home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / mfc / database / daoview / crack.cpp next >
Encoding:
C/C++ Source or Header  |  1998-03-27  |  6.8 KB  |  334 lines
  1. // crack.cpp
  2. //
  3. // This is a part of the Microsoft Foundation Classes C++ library.
  4. // Copyright (C) 1992-1998 Microsoft Corporation
  5. // All rights reserved.
  6. //
  7. // This source code is only intended as a supplement to the
  8. // Microsoft Foundation Classes Reference and related
  9. // electronic documentation provided with the library.
  10. // See these sources for detailed information regarding the
  11. // Microsoft Foundation Classes product.
  12.  
  13.  
  14. #include "stdafx.h"
  15. #include "crack.h"
  16.  
  17. LPCTSTR CCrack::strFieldType(short sType)
  18. {
  19.     switch(sType){
  20.         case (dbBoolean):
  21.             return _T("Bool");
  22.         case (dbByte):
  23.             return _T("Byte");
  24.         case (dbInteger):
  25.             return _T("Integer");
  26.         case (dbLong):
  27.             return _T("Long");
  28.         case (dbCurrency):
  29.             return _T("Currency");
  30.         case (dbSingle):
  31.             return _T("Single");
  32.         case (dbDouble):
  33.             return _T("Double");
  34.         case (dbDate):
  35.             return _T("Date");
  36.         case (dbText):
  37.             return _T("Text");
  38.         case (dbLongBinary):
  39.             return _T("Long Binary");
  40.         case (dbMemo):
  41.             return _T("Memo");
  42.         case (dbGUID):
  43.             return _T("GUID");
  44.     }
  45.     return _T("Unknown");
  46. }
  47.  
  48. LPCTSTR CCrack::strQueryDefType(short sType)
  49. {
  50.     switch(sType){
  51.         case (dbQSelect):
  52.             return _T("Select");
  53.         case (dbQAction):
  54.             return _T("Action");
  55.         case (dbQCrosstab):
  56.             return _T("Crosstab");
  57.         case (dbQDelete):
  58.             return _T("Delete");
  59.         case (dbQUpdate):
  60.             return _T("Update");
  61.         case (dbQAppend):
  62.             return _T("Append");
  63.         case (dbQMakeTable):
  64.             return _T("MakeTable");
  65.         case (dbQDDL):
  66.             return _T("DDL");
  67.         case (dbQSQLPassThrough):
  68.             return _T("SQLPassThrough");
  69.         case (dbQSetOperation):
  70.             return _T("Set Operation");
  71.         case (dbQSPTBulk):
  72.             return _T("SPTBulk");
  73.     }
  74.     return _T("Unknown");
  75. }
  76.  
  77. LPCTSTR CCrack::strBOOL(BOOL bFlag)
  78. {
  79.     return bFlag ? _T("TRUE") : _T("FALSE");
  80. }
  81.  
  82. CString CCrack::strVARIANT(const COleVariant& var)
  83. {
  84.     CString strRet;
  85.     strRet = _T("Fish");
  86.     switch(var.vt){
  87.         case VT_EMPTY:
  88.         case VT_NULL:
  89.             strRet = _T("NULL");
  90.             break;
  91.         case VT_I2:
  92.             strRet.Format(_T("%hd"),V_I2(&var));
  93.             break;
  94.         case VT_I4:
  95.             strRet.Format(_T("%d"),V_I4(&var));
  96.             break;
  97.         case VT_R4:
  98.             strRet.Format(_T("%e"),(double)V_R4(&var));
  99.             break;
  100.         case VT_R8:
  101.             strRet.Format(_T("%e"),V_R8(&var));
  102.             break;
  103.         case VT_CY:
  104.             strRet = COleCurrency(var).Format();
  105.             break;
  106.         case VT_DATE:
  107.             strRet = COleDateTime(var).Format(_T("%m %d %y"));
  108.             break;
  109.         case VT_BSTR:
  110.             strRet = V_BSTRT(&var);
  111.             break;
  112.         case VT_DISPATCH:
  113.             strRet = _T("VT_DISPATCH");
  114.             break;
  115.         case VT_ERROR:
  116.             strRet = _T("VT_ERROR");
  117.             break;
  118.         case VT_BOOL:
  119.             return strBOOL(V_BOOL(&var));
  120.         case VT_VARIANT:
  121.             strRet = _T("VT_VARIANT");
  122.             break;
  123.         case VT_UNKNOWN:
  124.             strRet = _T("VT_UNKNOWN");
  125.             break;
  126.         case VT_I1:
  127.             strRet = _T("VT_I1");
  128.             break;
  129.         case VT_UI1:
  130.             strRet.Format(_T("0x%02hX"),(unsigned short)V_UI1(&var));
  131.             break;
  132.         case VT_UI2:
  133.             strRet = _T("VT_UI2");
  134.             break;
  135.         case VT_UI4:
  136.             strRet = _T("VT_UI4");
  137.             break;
  138.         case VT_I8:
  139.             strRet = _T("VT_I8");
  140.             break;
  141.         case VT_UI8:
  142.             strRet = _T("VT_UI8");
  143.             break;
  144.         case VT_INT:
  145.             strRet = _T("VT_INT");
  146.             break;
  147.         case VT_UINT:
  148.             strRet = _T("VT_UINT");
  149.             break;
  150.         case VT_VOID:
  151.             strRet = _T("VT_VOID");
  152.             break;
  153.         case VT_HRESULT:
  154.             strRet = _T("VT_HRESULT");
  155.             break;
  156.         case VT_PTR:
  157.             strRet = _T("VT_PTR");
  158.             break;
  159.         case VT_SAFEARRAY:
  160.             strRet = _T("VT_SAFEARRAY");
  161.             break;
  162.         case VT_CARRAY:
  163.             strRet = _T("VT_CARRAY");
  164.             break;
  165.         case VT_USERDEFINED:
  166.             strRet = _T("VT_USERDEFINED");
  167.             break;
  168.         case VT_LPSTR:
  169.             strRet = _T("VT_LPSTR");
  170.             break;
  171.         case VT_LPWSTR:
  172.             strRet = _T("VT_LPWSTR");
  173.             break;
  174.         case VT_FILETIME:
  175.             strRet = _T("VT_FILETIME");
  176.             break;
  177.         case VT_BLOB:
  178.             strRet = _T("VT_BLOB");
  179.             break;
  180.         case VT_STREAM:
  181.             strRet = _T("VT_STREAM");
  182.             break;
  183.         case VT_STORAGE:
  184.             strRet = _T("VT_STORAGE");
  185.             break;
  186.         case VT_STREAMED_OBJECT:
  187.             strRet = _T("VT_STREAMED_OBJECT");
  188.             break;
  189.         case VT_STORED_OBJECT:
  190.             strRet = _T("VT_STORED_OBJECT");
  191.             break;
  192.         case VT_BLOB_OBJECT:
  193.             strRet = _T("VT_BLOB_OBJECT");
  194.             break;
  195.         case VT_CF:
  196.             strRet = _T("VT_CF");
  197.             break;
  198.         case VT_CLSID:
  199.             strRet = _T("VT_CLSID");
  200.             break;
  201.     }
  202.     WORD vt = var.vt;
  203.     if(vt & VT_ARRAY){
  204.         vt = vt & ~VT_ARRAY;
  205.         strRet = _T("Array of ");
  206.     }
  207.     if(vt & VT_BYREF){
  208.         vt = vt & ~VT_BYREF;
  209.         strRet += _T("Pointer to ");
  210.     }
  211.     if(vt != var.vt){
  212.         switch(vt){
  213.             case VT_EMPTY:
  214.                 strRet += _T("VT_EMPTY");
  215.                 break;
  216.             case VT_NULL:
  217.                 strRet += _T("VT_NULL");
  218.                 break;
  219.             case VT_I2:
  220.                 strRet += _T("VT_I2");
  221.                 break;
  222.             case VT_I4:
  223.                 strRet += _T("VT_I4");
  224.                 break;
  225.             case VT_R4:
  226.                 strRet += _T("VT_R4");
  227.                 break;
  228.             case VT_R8:
  229.                 strRet += _T("VT_R8");
  230.                 break;
  231.             case VT_CY:
  232.                 strRet += _T("VT_CY");
  233.                 break;
  234.             case VT_DATE:
  235.                 strRet += _T("VT_DATE");
  236.                 break;
  237.             case VT_BSTR:
  238.                 strRet += _T("VT_BSTR");
  239.                 break;
  240.             case VT_DISPATCH:
  241.                 strRet += _T("VT_DISPATCH");
  242.                 break;
  243.             case VT_ERROR:
  244.                 strRet += _T("VT_ERROR");
  245.                 break;
  246.             case VT_BOOL:
  247.                 strRet += _T("VT_BOOL");
  248.                 break;
  249.             case VT_VARIANT:
  250.                 strRet += _T("VT_VARIANT");
  251.                 break;
  252.             case VT_UNKNOWN:
  253.                 strRet += _T("VT_UNKNOWN");
  254.                 break;
  255.             case VT_I1:
  256.                 strRet += _T("VT_I1");
  257.                 break;
  258.             case VT_UI1:
  259.                 strRet += _T("VT_UI1");
  260.                 break;
  261.             case VT_UI2:
  262.                 strRet += _T("VT_UI2");
  263.                 break;
  264.             case VT_UI4:
  265.                 strRet += _T("VT_UI4");
  266.                 break;
  267.             case VT_I8:
  268.                 strRet += _T("VT_I8");
  269.                 break;
  270.             case VT_UI8:
  271.                 strRet += _T("VT_UI8");
  272.                 break;
  273.             case VT_INT:
  274.                 strRet += _T("VT_INT");
  275.                 break;
  276.             case VT_UINT:
  277.                 strRet += _T("VT_UINT");
  278.                 break;
  279.             case VT_VOID:
  280.                 strRet += _T("VT_VOID");
  281.                 break;
  282.             case VT_HRESULT:
  283.                 strRet += _T("VT_HRESULT");
  284.                 break;
  285.             case VT_PTR:
  286.                 strRet += _T("VT_PTR");
  287.                 break;
  288.             case VT_SAFEARRAY:
  289.                 strRet += _T("VT_SAFEARRAY");
  290.                 break;
  291.             case VT_CARRAY:
  292.                 strRet += _T("VT_CARRAY");
  293.                 break;
  294.             case VT_USERDEFINED:
  295.                 strRet += _T("VT_USERDEFINED");
  296.                 break;
  297.             case VT_LPSTR:
  298.                 strRet += _T("VT_LPSTR");
  299.                 break;
  300.             case VT_LPWSTR:
  301.                 strRet += _T("VT_LPWSTR");
  302.                 break;
  303.             case VT_FILETIME:
  304.                 strRet += _T("VT_FILETIME");
  305.                 break;
  306.             case VT_BLOB:
  307.                 strRet += _T("VT_BLOB");
  308.                 break;
  309.             case VT_STREAM:
  310.                 strRet += _T("VT_STREAM");
  311.                 break;
  312.             case VT_STORAGE:
  313.                 strRet += _T("VT_STORAGE");
  314.                 break;
  315.             case VT_STREAMED_OBJECT:
  316.                 strRet += _T("VT_STREAMED_OBJECT");
  317.                 break;
  318.             case VT_STORED_OBJECT:
  319.                 strRet += _T("VT_STORED_OBJECT");
  320.                 break;
  321.             case VT_BLOB_OBJECT:
  322.                 strRet += _T("VT_BLOB_OBJECT");
  323.                 break;
  324.             case VT_CF:
  325.                 strRet += _T("VT_CF");
  326.                 break;
  327.             case VT_CLSID:
  328.                 strRet += _T("VT_CLSID");
  329.                 break;
  330.         }
  331.     }
  332.     return strRet;
  333. }
  334.