Return to variant.h CVS log

Up to [WindowsNT SDKs] / mstools / ole20 / h / i386

Annotation of mstools/ole20/h/i386/variant.h, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.