home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / msinc.pak / VARIANT.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-24  |  10.9 KB  |  319 lines
  1. /***
  2. *variant.h
  3. *
  4. *Purpose:
  5. *  This file declares VARIANT, and related data types.
  6. *
  7. *Implementation Notes:
  8. *  This file requires ole2.h
  9. *
  10. *****************************************************************************/
  11.  
  12. /*
  13.  *      C/C++ Run Time Library - Version 6.5
  14.  *
  15.  *      Copyright (c) 1994 by Borland International
  16.  *      All Rights Reserved.
  17.  *
  18.  */
  19.  
  20. #if !defined(__FLAT__)
  21. /***
  22. *variant.h
  23. *
  24. *Purpose:
  25. *  This file declares VARIANT, and related data types.
  26. *
  27. *Implementation Notes:
  28. *  This file requires ole2.h
  29. *
  30. *****************************************************************************/
  31.  
  32. /*
  33.  *      C/C++ Run Time Library - Version 6.5
  34.  *
  35.  *      Copyright (c) 1994 by Borland International
  36.  *      All Rights Reserved.
  37.  *
  38.  */
  39.  
  40. #ifndef _VARIANT_H_
  41. #define _VARIANT_H_
  42. #define __VARIANT_H
  43.  
  44. #ifndef HUGEP
  45. # ifdef _MAC
  46. #  define HUGEP FAR
  47. # else
  48. #  if WIN32
  49. #   define HUGEP
  50. #  else
  51. #   define HUGEP _huge
  52. #  endif
  53. # endif
  54. #endif
  55.  
  56. #ifndef FAR
  57. # ifdef _MAC
  58. #  define FAR
  59. # else
  60. #  ifdef WIN32
  61. #   define FAR
  62. #  else
  63. #   define FAR _far
  64. #  endif
  65. # endif
  66. #endif
  67.  
  68.  
  69. /* Forward Declarations */
  70.  
  71. #ifdef __cplusplus
  72. interface IDispatch;
  73. #else
  74. typedef interface IDispatch IDispatch;
  75. #endif
  76.  
  77.  
  78. #ifndef OLESTR
  79. #if defined(WIN32)
  80. typedef WCHAR OLECHAR;
  81. typedef LPWSTR LPOLESTR;
  82. typedef LPCWSTR LPCOLESTR;
  83. #define OLESTR(str) L##str
  84. #else
  85. typedef char OLECHAR;
  86. typedef OLECHAR FAR* LPOLESTR;
  87. typedef const OLECHAR FAR* LPCOLESTR;
  88. #define OLESTR(str) str
  89. #endif
  90. #endif
  91.  
  92. typedef OLECHAR FAR* BSTR;
  93. typedef BSTR FAR* LPBSTR;
  94.  
  95.  
  96. typedef struct FARSTRUCT tagSAFEARRAYBOUND {
  97.     unsigned long cElements;
  98.     long lLbound;
  99. } SAFEARRAYBOUND, FAR* LPSAFEARRAYBOUND;
  100.  
  101. typedef struct FARSTRUCT tagSAFEARRAY {
  102.     unsigned short cDims;
  103.     unsigned short fFeatures;
  104. #if defined(WIN32)
  105.     unsigned long cbElements;
  106.     unsigned long cLocks;
  107. #else
  108.     unsigned short cbElements;
  109.     unsigned short cLocks;
  110. #ifdef _MAC
  111.     Handle handle;
  112. #else
  113.     unsigned long handle;
  114. #endif
  115. #endif
  116.     void HUGEP* pvData;
  117.     SAFEARRAYBOUND rgsabound[1];
  118. } SAFEARRAY, FAR* LPSAFEARRAY;
  119.  
  120. #define FADF_AUTO       0x0001  /* array is allocated on the stack         */
  121. #define FADF_STATIC     0x0002  /* array is staticly allocated             */
  122. #define FADF_EMBEDDED   0x0004  /* array is embedded in a structure        */
  123. #define FADF_FIXEDSIZE  0x0010  /* array may not be resized or reallocated */
  124. #define FADF_BSTR       0x0100  /* an array of BSTRs                       */
  125. #define FADF_UNKNOWN    0x0200  /* an array of IUnknown*                   */
  126. #define FADF_DISPATCH   0x0400  /* an array of IDispatch*                  */
  127. #define FADF_VARIANT    0x0800  /* an array of VARIANTs                    */
  128. #define FADF_RESERVED   0xF0E8  /* bits reserved for future use            */
  129.  
  130.  
  131. /* 0 == FALSE, -1 == TRUE */
  132. typedef short VARIANT_BOOL;
  133.  
  134.  
  135. typedef double DATE;
  136.  
  137.  
  138. /* This is a helper struct for use in handling currency. */
  139. typedef struct FARSTRUCT tagCY {
  140. #ifdef _MAC
  141.     long          Hi;
  142.     unsigned long Lo;
  143. #else
  144.     unsigned long Lo;
  145.     long          Hi;
  146. #endif
  147. } CY;
  148.  
  149.  
  150. /*
  151.  * VARENUM usage key,
  152.  *
  153.  *   [V] - may appear in a VARIANT
  154.  *   [T] - may appear in a TYPEDESC
  155.  *   [P] - may appear in an OLE property set
  156.  *   [S] - may appear in a Safe Array
  157.  *
  158.  */
  159. enum VARENUM
  160. {
  161.     VT_EMPTY           = 0,   /* [V]   [P]     nothing                     */
  162.     VT_NULL            = 1,   /* [V]           SQL style Null              */
  163.     VT_I2              = 2,   /* [V][T][P][S]  2 byte signed int           */
  164.     VT_I4              = 3,   /* [V][T][P][S]  4 byte signed int           */
  165.     VT_R4              = 4,   /* [V][T][P][S]  4 byte real                 */
  166.     VT_R8              = 5,   /* [V][T][P][S]  8 byte real                 */
  167.     VT_CY              = 6,   /* [V][T][P][S]  currency                    */
  168.     VT_DATE            = 7,   /* [V][T][P][S]  date                        */
  169.     VT_BSTR            = 8,   /* [V][T][P][S]  binary string               */
  170.     VT_DISPATCH        = 9,   /* [V][T]   [S]  IDispatch FAR*              */
  171.     VT_ERROR           = 10,  /* [V][T]   [S]  SCODE                       */
  172.     VT_BOOL            = 11,  /* [V][T][P][S]  True=-1, False=0            */
  173.     VT_VARIANT         = 12,  /* [V][T][P][S]  VARIANT FAR*                */
  174.     VT_UNKNOWN         = 13,  /* [V][T]   [S]  IUnknown FAR*               */
  175.  
  176.     VT_I1              = 16,  /*    [T]        signed char                 */
  177.     VT_UI1             = 17,  /* [V][T]   [S]  unsigned char               */
  178.     VT_UI2             = 18,  /*    [T]        unsigned short              */
  179.     VT_UI4             = 19,  /*    [T]        unsigned short              */
  180.     VT_I8              = 20,  /*    [T][P]     signed 64-bit int           */
  181.     VT_UI8             = 21,  /*    [T]        unsigned 64-bit int         */
  182.     VT_INT             = 22,  /*    [T]        signed machine int          */
  183.     VT_UINT            = 23,  /*    [T]        unsigned machine int        */
  184.     VT_VOID            = 24,  /*    [T]        C style void                */
  185.     VT_HRESULT         = 25,  /*    [T]                                    */
  186.     VT_PTR             = 26,  /*    [T]        pointer type                */
  187.     VT_SAFEARRAY       = 27,  /*    [T]        (use VT_ARRAY in VARIANT)   */
  188.     VT_CARRAY          = 28,  /*    [T]        C style array               */
  189.     VT_USERDEFINED     = 29,  /*    [T]        user defined type           */
  190.     VT_LPSTR           = 30,  /*    [T][P]     null terminated string      */
  191.     VT_LPWSTR          = 31,  /*    [T][P]     wide null terminated string */
  192.  
  193.     VT_FILETIME        = 64,  /*       [P]     FILETIME                    */
  194.     VT_BLOB            = 65,  /*       [P]     Length prefixed bytes       */
  195.     VT_STREAM          = 66,  /*       [P]     Name of the stream follows  */
  196.     VT_STORAGE         = 67,  /*       [P]     Name of the storage follows */
  197.     VT_STREAMED_OBJECT = 68,  /*       [P]     Stream contains an object   */
  198.     VT_STORED_OBJECT   = 69,  /*       [P]     Storage contains an object  */
  199.     VT_BLOB_OBJECT     = 70,  /*       [P]     Blob contains an object     */
  200.     VT_CF              = 71,  /*       [P]     Clipboard format            */
  201.     VT_CLSID           = 72   /*       [P]     A Class ID                  */
  202. };
  203.  
  204. #define VT_VECTOR      0x1000 /*       [P]     simple counted array        */
  205. #define VT_ARRAY       0x2000 /* [V]           SAFEARRAY*                  */
  206. #define VT_BYREF       0x4000 /* [V]                                       */
  207. #define VT_RESERVED    0x8000
  208.  
  209.  
  210. typedef unsigned short VARTYPE;
  211.  
  212. typedef struct FARSTRUCT tagVARIANT VARIANT;
  213. typedef struct FARSTRUCT tagVARIANT FAR* LPVARIANT;
  214. typedef struct FARSTRUCT tagVARIANT VARIANTARG;
  215. typedef struct FARSTRUCT tagVARIANT FAR* LPVARIANTARG;
  216.  
  217. struct FARSTRUCT tagVARIANT{
  218.     VARTYPE vt;
  219.     unsigned short wReserved1;
  220.     unsigned short wReserved2;
  221.     unsigned short wReserved3;
  222.     union {
  223.       unsigned char bVal;            /* VT_UI1               */
  224.       short        iVal;             /* VT_I2                */
  225.       long         lVal;             /* VT_I4                */
  226.       float        fltVal;           /* VT_R4                */
  227.       double       dblVal;           /* VT_R8                */
  228. #if defined(__cplusplus) && defined(__BORLANDC__)
  229.       VARIANT_BOOL boolVal;          /* VT_BOOL              */
  230. #else
  231.       VARIANT_BOOL bool;             /* VT_BOOL              */
  232. #endif
  233.       SCODE        scode;            /* VT_ERROR             */
  234.       CY           cyVal;            /* VT_CY                */
  235.       DATE         date;             /* VT_DATE              */
  236.       BSTR         bstrVal;          /* VT_BSTR              */
  237.       IUnknown     FAR* punkVal;     /* VT_UNKNOWN           */
  238.       IDispatch    FAR* pdispVal;    /* VT_DISPATCH          */
  239.       SAFEARRAY    FAR* parray;      /* VT_ARRAY|*           */
  240.  
  241.       unsigned char FAR *pbVal;      /* VT_BYREF|VT_UI1      */
  242.       short        FAR* piVal;       /* VT_BYREF|VT_I2       */
  243.       long         FAR* plVal;       /* VT_BYREF|VT_I4       */
  244.       float        FAR* pfltVal;     /* VT_BYREF|VT_R4       */
  245.       double       FAR* pdblVal;     /* VT_BYREF|VT_R8       */
  246.       VARIANT_BOOL FAR* pbool;       /* VT_BYREF|VT_BOOL     */
  247.       SCODE        FAR* pscode;      /* VT_BYREF|VT_ERROR    */
  248.       CY           FAR* pcyVal;      /* VT_BYREF|VT_CY       */
  249.       DATE         FAR* pdate;       /* VT_BYREF|VT_DATE     */
  250.       BSTR         FAR* pbstrVal;    /* VT_BYREF|VT_BSTR     */
  251.       IUnknown  FAR* FAR* ppunkVal;  /* VT_BYREF|VT_UNKNOWN  */
  252.       IDispatch FAR* FAR* ppdispVal; /* VT_BYREF|VT_DISPATCH */
  253.       SAFEARRAY FAR* FAR* pparray;   /* VT_BYREF|VT_ARRAY|*  */
  254.       VARIANT      FAR* pvarVal;     /* VT_BYREF|VT_VARIANT  */
  255.  
  256.       void         FAR* byref;       /* Generic ByRef        */
  257.     } _UNION_NAME(u);
  258. };
  259.  
  260. #if defined(NONAMELESSUNION) || (defined(_MAC) && !defined(__cplusplus) && !defined(_MSC_VER))
  261. # define V_UNION(X, Y) ((X)->u.Y)
  262. #else
  263. # define V_UNION(X, Y) ((X)->Y)
  264. #endif
  265.  
  266. /* Variant access macros */
  267. #define V_VT(X)          ((X)->vt)
  268. #define V_ISBYREF(X)     (V_VT(X)&VT_BYREF)
  269. #define V_ISARRAY(X)     (V_VT(X)&VT_ARRAY)
  270. #define V_ISVECTOR(X)    (V_VT(X)&VT_VECTOR)
  271.  
  272. #define V_NONE(X)        V_I2(X)
  273. #define V_UI1(X)         V_UNION(X, bVal)
  274. #define V_UI1REF(X)      V_UNION(X, pbVal)
  275. #define V_I2(X)          V_UNION(X, iVal)
  276. #define V_I2REF(X)       V_UNION(X, piVal)
  277. #define V_I4(X)          V_UNION(X, lVal)
  278. #define V_I4REF(X)       V_UNION(X, plVal)
  279. #define V_R4(X)          V_UNION(X, fltVal)
  280. #define V_R4REF(X)       V_UNION(X, pfltVal)
  281. #define V_R8(X)          V_UNION(X, dblVal)
  282. #define V_R8REF(X)       V_UNION(X, pdblVal)
  283.  
  284. #if defined(__cplusplus) && defined(__BORLANDC__)
  285.         #define V_BOOL(X)        V_UNION(X, boolVal)
  286. #else
  287.         #define V_BOOL(X)        V_UNION(X, bool)
  288. #endif
  289.  
  290. #define V_BOOLREF(X)     V_UNION(X, pbool)
  291. #define V_ERROR(X)       V_UNION(X, scode)
  292. #define V_ERRORREF(X)    V_UNION(X, pscode)
  293. #define V_CY(X)          V_UNION(X, cyVal)
  294. #define V_CYREF(X)       V_UNION(X, pcyVal)
  295. #define V_DATE(X)        V_UNION(X, date)
  296. #define V_DATEREF(X)     V_UNION(X, pdate)
  297. #define V_BSTR(X)        V_UNION(X, bstrVal)
  298. #define V_BSTRREF(X)     V_UNION(X, pbstrVal)
  299. #define V_UNKNOWN(X)     V_UNION(X, punkVal)
  300. #define V_UNKNOWNREF(X)  V_UNION(X, ppunkVal)
  301. #define V_DISPATCH(X)    V_UNION(X, pdispVal)
  302. #define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
  303. #define V_VARIANTREF(X)  V_UNION(X, pvarVal)
  304. #define V_ARRAY(X)       V_UNION(X, parray)
  305. #define V_ARRAYREF(X)    V_UNION(X, pparray)
  306. #define V_BYREF(X)       V_UNION(X, byref)
  307.  
  308. #endif /* _VARIANT_H_ */
  309.  
  310. #else  /* !__FLAT__ */
  311. #ifndef RC_INVOKED
  312. #pragma message("WARNING: your code should #include oleauto.h instead of variant.h")
  313. #endif /* !RC_INVOKED */
  314.  
  315. #include <oleauto.h>
  316.  
  317. #endif  /* __FLAT__ */
  318.  
  319.