ReactOS  0.4.12-dev-409-g9f418243
oleauto.h File Reference
#include <oaidl.h>
Include dependency graph for oleauto.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  UDATE
 
struct  NUMPARSE
 
struct  tagPARAMDATA
 
struct  tagMETHODDATA
 
struct  tagINTERFACEDATA
 

Macros

#define STDOLE_MAJORVERNUM   1
 
#define STDOLE_MINORVERNUM   0
 
#define STDOLE_LCID   0
 
#define STDOLE2_MAJORVERNUM   2
 
#define STDOLE2_MINORVERNUM   0
 
#define STDOLE2_LCID   0
 
#define ACTIVEOBJECT_STRONG   0
 
#define ACTIVEOBJECT_WEAK   1
 
#define V_VT(A)   ((A)->vt)
 
#define V_UNION(A, B)   ((A)->B)
 
#define V_RECORD(A)   ((A)->pvRecord)
 
#define V_RECORDINFO(A)   ((A)->pRecInfo)
 
#define V_ISBYREF(A)   (V_VT(A) & VT_BYREF)
 
#define V_ISARRAY(A)   (V_VT(A) & VT_ARRAY)
 
#define V_ISVECTOR(A)   (V_VT(A) & VT_VECTOR)
 
#define V_NONE(A)   V_I2(A)
 
#define V_ARRAY(A)   V_UNION(A,parray)
 
#define V_ARRAYREF(A)   V_UNION(A,pparray)
 
#define V_BOOL(A)   V_UNION(A,boolVal)
 
#define V_BOOLREF(A)   V_UNION(A,pboolVal)
 
#define V_BSTR(A)   V_UNION(A,bstrVal)
 
#define V_BSTRREF(A)   V_UNION(A,pbstrVal)
 
#define V_BYREF(A)   V_UNION(A,byref)
 
#define V_CY(A)   V_UNION(A,cyVal)
 
#define V_CYREF(A)   V_UNION(A,pcyVal)
 
#define V_DATE(A)   V_UNION(A,date)
 
#define V_DATEREF(A)   V_UNION(A,pdate)
 
#define V_DECIMAL(A)   ((A)->decVal)
 
#define V_DECIMALREF(A)   V_UNION(A,pdecVal)
 
#define V_DISPATCH(A)   V_UNION(A,pdispVal)
 
#define V_DISPATCHREF(A)   V_UNION(A,ppdispVal)
 
#define V_ERROR(A)   V_UNION(A,scode)
 
#define V_ERRORREF(A)   V_UNION(A,pscode)
 
#define V_I1(A)   V_UNION(A,cVal)
 
#define V_I1REF(A)   V_UNION(A,pcVal)
 
#define V_I2(A)   V_UNION(A,iVal)
 
#define V_I2REF(A)   V_UNION(A,piVal)
 
#define V_I4(A)   V_UNION(A,lVal)
 
#define V_I4REF(A)   V_UNION(A,plVal)
 
#define V_I8(A)   V_UNION(A,llVal)
 
#define V_I8REF(A)   V_UNION(A,pllVal)
 
#define V_INT(A)   V_UNION(A,intVal)
 
#define V_INTREF(A)   V_UNION(A,pintVal)
 
#define V_INT_PTR(A)   V_I4(A)
 
#define V_INT_PTRREF(A)   V_I4REF(A)
 
#define V_R4(A)   V_UNION(A,fltVal)
 
#define V_R4REF(A)   V_UNION(A,pfltVal)
 
#define V_R8(A)   V_UNION(A,dblVal)
 
#define V_R8REF(A)   V_UNION(A,pdblVal)
 
#define V_UINT(A)   V_UNION(A,uintVal)
 
#define V_UINTREF(A)   V_UNION(A,puintVal)
 
#define V_UI1(A)   V_UNION(A,bVal)
 
#define V_UI1REF(A)   V_UNION(A,pbVal)
 
#define V_UI2(A)   V_UNION(A,uiVal)
 
#define V_UI2REF(A)   V_UNION(A,puiVal)
 
#define V_UI4(A)   V_UNION(A,ulVal)
 
#define V_UI4REF(A)   V_UNION(A,pulVal)
 
#define V_UI8(A)   V_UNION(A,ullVal)
 
#define V_UI8REF(A)   V_UNION(A,pullVal)
 
#define V_UINT_PTR(A)   V_UI4(A)
 
#define V_UINT_PTRREF(A)   V_UI4REF(A)
 
#define V_UNKNOWN(A)   V_UNION(A,punkVal)
 
#define V_UNKNOWNREF(A)   V_UNION(A,ppunkVal)
 
#define V_VARIANTREF(A)   V_UNION(A,pvarVal)
 
#define VARIANT_NOVALUEPROP   0x01 /* Don't get the default value property from IDispatch */
 
#define VARIANT_ALPHABOOL   0x02 /* Coerce to "True"|"False" instead of "-1"|"0" */
 
#define VARIANT_NOUSEROVERRIDE   0x04 /* Pass LOCALE_NOUSEROVERRIDE to low level conversions */
 
#define VARIANT_CALENDAR_HIJRI   0x08 /* Use the Hijri calendar */
 
#define VARIANT_LOCALBOOL   0x10 /* Like VARIANT_ALPHABOOL, but use localised text */
 
#define VARIANT_CALENDAR_THAI   0x20 /* Use the Thai buddhist calendar */
 
#define VARIANT_CALENDAR_GREGORIAN   0x40 /* Use the Gregorian calendar */
 
#define VARIANT_USE_NLS   0x80 /* Format result using NLS calls */
 
#define VT_HARDTYPE   VT_RESERVED /* Don't coerce this variant when comparing it to others */
 
#define VAR_TIMEVALUEONLY   0x001 /* Ignore date portion of VT_DATE */
 
#define VAR_DATEVALUEONLY   0x002 /* Ignore time portion of VT_DATE */
 
#define VAR_VALIDDATE   0x004
 
#define VAR_CALENDAR_HIJRI   0x008 /* Use the Hijri calendar */
 
#define VAR_LOCALBOOL   0x010 /* VT_BOOL<->VT_BSTR: Use localised boolean text */
 
#define VAR_FORMAT_NOSUBSTITUTE   0x020 /* Don't change format strings for un-coercable types */
 
#define VAR_FOURDIGITYEARS   0x040 /* Always print years with 4 digits */
 
#define VAR_CALENDAR_THAI   0x080 /* Use the Thai buddhist calendar */
 
#define VAR_CALENDAR_GREGORIAN   0x100 /* Use the Gregorian calendar */
 
#define LOCALE_USE_NLS   0x10000000
 
#define VTDATEGRE_MIN   -657434 /* Minimum possible Gregorian date: 1/1/100 */
 
#define VTDATEGRE_MAX   2958465 /* Maximum possible Gregorian date: 31/12/9999 */
 
#define VarUI4FromUI4(in, pOut)   ( *(pOut) = (in) )
 
#define VarI4FromI4(in, pOut)   ( *(pOut) = (in) )
 
#define VarUI1FromInt   VarUI1FromI4
 
#define VarUI1FromUint   VarUI1FromUI4
 
#define VarI2FromInt   VarI2FromI4
 
#define VarI2FromUint   VarI2FromUI4
 
#define VarI4FromInt   VarI4FromI4
 
#define VarI4FromUint   VarI4FromUI4
 
#define VarI8FromInt   VarI8FromI4
 
#define VarI8FromUint   VarI8FromUI4
 
#define VarR4FromInt   VarR4FromI4
 
#define VarR4FromUint   VarR4FromUI4
 
#define VarR8FromInt   VarR8FromI4
 
#define VarR8FromUint   VarR8FromUI4
 
#define VarDateFromInt   VarDateFromI4
 
#define VarDateFromUint   VarDateFromUI4
 
#define VarCyFromInt   VarCyFromI4
 
#define VarCyFromUint   VarCyFromUI4
 
#define VarBstrFromInt   VarBstrFromI4
 
#define VarBstrFromUint   VarBstrFromUI4
 
#define VarBoolFromInt   VarBoolFromI4
 
#define VarBoolFromUint   VarBoolFromUI4
 
#define VarI1FromInt   VarI1FromI4
 
#define VarI1FromUint   VarI1FromUI4
 
#define VarUI2FromInt   VarUI2FromI4
 
#define VarUI2FromUint   VarUI2FromUI4
 
#define VarUI4FromInt   VarUI4FromI4
 
#define VarUI4FromUint   VarUI4FromUI4
 
#define VarUI8FromInt   VarUI8FromI4
 
#define VarUI8FromUint   VarUI8FromUI4
 
#define VarDecFromInt   VarDecFromI4
 
#define VarDecFromUint   VarDecFromUI4
 
#define VarIntFromUI1   VarI4FromUI1
 
#define VarIntFromI2   VarI4FromI2
 
#define VarIntFromI4   VarI4FromI4
 
#define VarIntFromI8   VarI4FromI8
 
#define VarIntFromR4   VarI4FromR4
 
#define VarIntFromR8   VarI4FromR8
 
#define VarIntFromDate   VarI4FromDate
 
#define VarIntFromCy   VarI4FromCy
 
#define VarIntFromStr   VarI4FromStr
 
#define VarIntFromDisp   VarI4FromDisp
 
#define VarIntFromBool   VarI4FromBool
 
#define VarIntFromI1   VarI4FromI1
 
#define VarIntFromUI2   VarI4FromUI2
 
#define VarIntFromUI4   VarI4FromUI4
 
#define VarIntFromUI8   VarI4FromUI8
 
#define VarIntFromDec   VarI4FromDec
 
#define VarIntFromUint   VarI4FromUI4
 
#define VarUintFromUI1   VarUI4FromUI1
 
#define VarUintFromI2   VarUI4FromI2
 
#define VarUintFromI4   VarUI4FromI4
 
#define VarUintFromI8   VarUI4FromI8
 
#define VarUintFromR4   VarUI4FromR4
 
#define VarUintFromR8   VarUI4FromR8
 
#define VarUintFromDate   VarUI4FromDate
 
#define VarUintFromCy   VarUI4FromCy
 
#define VarUintFromStr   VarUI4FromStr
 
#define VarUintFromDisp   VarUI4FromDisp
 
#define VarUintFromBool   VarUI4FromBool
 
#define VarUintFromI1   VarUI4FromI1
 
#define VarUintFromUI2   VarUI4FromUI2
 
#define VarUintFromUI4   VarUI4FromUI4
 
#define VarUintFromUI8   VarUI4FromUI8
 
#define VarUintFromDec   VarUI4FromDec
 
#define VarUintFromInt   VarUI4FromI4
 
#define VARCMP_LT   0
 
#define VARCMP_EQ   1
 
#define VARCMP_GT   2
 
#define VARCMP_NULL   3
 
#define NUMPRS_LEADING_WHITE   0x00001 /* Leading whitespace */
 
#define NUMPRS_TRAILING_WHITE   0x00002 /* Trailing whitespace */
 
#define NUMPRS_LEADING_PLUS   0x00004 /* Leading '+' sign */
 
#define NUMPRS_TRAILING_PLUS   0x00008 /* Trailing '+' sign */
 
#define NUMPRS_LEADING_MINUS   0x00010 /* Leading '-' sign */
 
#define NUMPRS_TRAILING_MINUS   0x00020 /* Trailing '-' sign */
 
#define NUMPRS_HEX_OCT   0x00040 /* Octal number (with a leading 0) */
 
#define NUMPRS_PARENS   0x00080 /* Parentheses for negative numbers */
 
#define NUMPRS_DECIMAL   0x00100 /* Decimal separator */
 
#define NUMPRS_THOUSANDS   0x00200 /* Thousands separator */
 
#define NUMPRS_CURRENCY   0x00400 /* Currency symbol */
 
#define NUMPRS_EXPONENT   0x00800 /* Exponent (e.g. "e-14") */
 
#define NUMPRS_USE_ALL   0x01000 /* Parse the entire string */
 
#define NUMPRS_STD   0x01FFF /* Standard flags for internal coercions (All of the above) */
 
#define NUMPRS_NEG   0x10000 /* Number is negative (dwOutFlags only) */
 
#define NUMPRS_INEXACT   0x20000 /* Number is represented inexactly (dwOutFlags only) */
 
#define VTBIT_I1   (1 << VT_I1)
 
#define VTBIT_UI1   (1 << VT_UI1)
 
#define VTBIT_I2   (1 << VT_I2)
 
#define VTBIT_UI2   (1 << VT_UI2)
 
#define VTBIT_I4   (1 << VT_I4)
 
#define VTBIT_UI4   (1 << VT_UI4)
 
#define VTBIT_I8   (1 << VT_I8)
 
#define VTBIT_UI8   (1 << VT_UI8)
 
#define VTBIT_R4   (1 << VT_R4)
 
#define VTBIT_R8   (1 << VT_R8)
 
#define VTBIT_CY   (1 << VT_CY)
 
#define VTBIT_DECIMAL   (1 << VT_DECIMAL)
 
#define LHashValOfName(lcid, name)   LHashValOfNameSys(SYS_WIN32,lcid,name)
 
#define WHashValOfLHashVal(hash)   ((USHORT)((hash) & 0xffff))
 
#define IsHashValCompatible(hash1, hash2)   ((hash1) & 0xff0000 == (hash2) & 0xff0000)
 
#define MEMBERID_NIL   DISPID_UNKNOWN
 
#define ID_DEFAULTINST   -2
 
#define DISPATCH_METHOD   0x1
 
#define DISPATCH_PROPERTYGET   0x2
 
#define DISPATCH_PROPERTYPUT   0x4
 
#define DISPATCH_PROPERTYPUTREF   0x8
 
#define LOAD_TLB_AS_32BIT   0x20
 
#define LOAD_TLB_AS_64BIT   0x40
 
#define MASK_TO_RESET_TLB_BITS   ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)
 

Typedefs

typedef struct tagPARAMDATA PARAMDATA
 
typedef struct tagPARAMDATALPPARAMDATA
 
typedef struct tagMETHODDATA METHODDATA
 
typedef struct tagMETHODDATALPMETHODDATA
 
typedef struct tagINTERFACEDATA INTERFACEDATA
 
typedef struct tagINTERFACEDATALPINTERFACEDATA
 
typedef enum tagREGKIND REGKIND
 

Enumerations

enum  tagREGKIND { REGKIND_DEFAULT, REGKIND_REGISTER, REGKIND_NONE }
 

Functions

 DEFINE_OLEGUID (IID_StdOle, 0x00020430, 0, 0)
 
ULONG WINAPI OaBuildVersion (void)
 
BSTR WINAPI SysAllocString (_In_opt_z_ const OLECHAR *)
 
BSTR WINAPI SysAllocStringByteLen (_In_opt_z_ LPCSTR, _In_ UINT)
 
 _Ret_writes_maybenull_z_ (ui+1) BSTR WINAPI SysAllocStringLen(_In_reads_opt_(ui) const OLECHAR *
 
void WINAPI SysFreeString (_In_opt_ BSTR)
 
INT WINAPI SysReAllocString (_Inout_ _At_(*pbstr, _Pre_z_ _Post_z_ _Post_readable_size_(_String_length_(psz)+1)) LPBSTR pbstr, _In_opt_z_ const OLECHAR *psz)
 
_Check_return_ int WINAPI SysReAllocStringLen (_Inout_ _At_(*pbstr, _Pre_z_ _Post_z_ _Post_readable_size_(len+1)) BSTR *pbstr, _In_opt_z_ const OLECHAR *, _In_ UINT len)
 
 _Post_equal_to_ (_String_length_(bstr) *sizeof(OLECHAR)) UINT WINAPI SysStringByteLen(_In_opt_ BSTR bstr)
 
 _Post_equal_to_ (pbstr==NULL ? 0 :_String_length_(pbstr)) UINT WINAPI SysStringLen(_In_opt_ BSTR pbstr)
 
HRESULT WINAPI SetErrorInfo (_In_ ULONG, _In_opt_ IErrorInfo *)
 
_Check_return_ HRESULT WINAPI GetErrorInfo (_In_ ULONG, _Outptr_ IErrorInfo **)
 
_Check_return_ HRESULT WINAPI CreateErrorInfo (_Outptr_ ICreateErrorInfo **)
 
SAFEARRAY *WINAPI SafeArrayCreate (_In_ VARTYPE, _In_ UINT, _In_ SAFEARRAYBOUND *)
 
SAFEARRAY *WINAPI SafeArrayCreateEx (_In_ VARTYPE, _In_ UINT, _In_ SAFEARRAYBOUND *, _In_ LPVOID)
 
SAFEARRAY *WINAPI SafeArrayCreateVector (_In_ VARTYPE, _In_ LONG, _In_ ULONG)
 
SAFEARRAY *WINAPI SafeArrayCreateVectorEx (_In_ VARTYPE, _In_ LONG, _In_ ULONG, _In_ LPVOID)
 
HRESULT WINAPI SafeArrayAllocDescriptor (_In_ UINT, _Outptr_ SAFEARRAY **)
 
HRESULT WINAPI SafeArrayAllocDescriptorEx (_In_ VARTYPE, _In_ UINT, _Outptr_ SAFEARRAY **)
 
HRESULT WINAPI SafeArrayAllocData (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayDestroyDescriptor (_In_ SAFEARRAY *)
 
_Check_return_ HRESULT WINAPI SafeArrayPutElement (_In_ SAFEARRAY *, LONG *, _In_ void *)
 
HRESULT WINAPI SafeArrayGetElement (_In_ SAFEARRAY *, LONG *, _Out_ void *)
 
HRESULT WINAPI SafeArrayLock (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayUnlock (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayGetUBound (_In_ SAFEARRAY *, _In_ UINT, _Out_ LONG *)
 
HRESULT WINAPI SafeArrayGetLBound (_In_ SAFEARRAY *, _In_ UINT, _Out_ LONG *)
 
UINT WINAPI SafeArrayGetDim (_In_ SAFEARRAY *)
 
UINT WINAPI SafeArrayGetElemsize (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayGetVartype (_In_ SAFEARRAY *, _Out_ VARTYPE *)
 
HRESULT WINAPI SafeArrayAccessData (_In_ SAFEARRAY *, void **)
 
HRESULT WINAPI SafeArrayUnaccessData (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayPtrOfIndex (_In_ SAFEARRAY *psa, _In_reads_(psa->cDims) LONG *, _Outptr_result_bytebuffer_(psa->cbElements) void **)
 
_Check_return_ HRESULT WINAPI SafeArrayCopyData (_In_ SAFEARRAY *, _In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayDestroyData (_In_ SAFEARRAY *)
 
HRESULT WINAPI SafeArrayDestroy (_In_ SAFEARRAY *)
 
_Check_return_ HRESULT WINAPI SafeArrayCopy (_In_ SAFEARRAY *, _Outptr_ SAFEARRAY **)
 
HRESULT WINAPI SafeArrayRedim (_Inout_ SAFEARRAY *, _In_ SAFEARRAYBOUND *)
 
HRESULT WINAPI SafeArraySetRecordInfo (_In_ SAFEARRAY *, _In_ IRecordInfo *)
 
HRESULT WINAPI SafeArrayGetRecordInfo (_In_ SAFEARRAY *, _Outptr_ IRecordInfo **)
 
HRESULT WINAPI SafeArraySetIID (_In_ SAFEARRAY *, _In_ REFGUID)
 
HRESULT WINAPI SafeArrayGetIID (_In_ SAFEARRAY *, _Out_ GUID *)
 
_Check_return_ HRESULT WINAPI VectorFromBstr (_In_ BSTR, _Outptr_ SAFEARRAY **)
 
_Check_return_ HRESULT WINAPI BstrFromVector (_In_ SAFEARRAY *, _Out_ BSTR *)
 
_Check_return_ HRESULT WINAPI RegisterActiveObject (LPUNKNOWN, REFCLSID, DWORD, LPDWORD)
 
HRESULT WINAPI RevokeActiveObject (DWORD, LPVOID)
 
HRESULT WINAPI GetActiveObject (REFCLSID, LPVOID, LPUNKNOWN *)
 
HRESULT WINAPI GetRecordInfoFromTypeInfo (ITypeInfo *, IRecordInfo **)
 
HRESULT WINAPI GetRecordInfoFromGuids (REFGUID, ULONG, ULONG, LCID, REFGUID, IRecordInfo **)
 
void WINAPI VariantInit (_Out_ VARIANT *)
 
HRESULT WINAPI VariantClear (_Inout_ VARIANT *)
 
_Check_return_ HRESULT WINAPI VariantCopy (_Inout_ VARIANT *, _In_ VARIANT *)
 
_Check_return_ HRESULT WINAPI VariantCopyInd (_Inout_ VARIANT *, _In_ VARIANT *)
 
_Check_return_ HRESULT WINAPI VariantChangeType (_Inout_ VARIANT *, _In_ VARIANT *, _In_ USHORT, _In_ VARTYPE)
 
_Check_return_ HRESULT WINAPI VariantChangeTypeEx (_Inout_ VARIANT *, _In_ VARIANT *, _In_ LCID, _In_ USHORT, _In_ VARTYPE)
 
HRESULT WINAPI VarUI1FromI2 (SHORT, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromI4 (LONG, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromI8 (LONG64, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromR4 (FLOAT, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromR8 (DOUBLE, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromDate (DATE, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromBool (VARIANT_BOOL, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromI1 (signed char, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromUI2 (USHORT, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromUI4 (ULONG, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromUI8 (ULONG64, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromCy (CY, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromDec (_In_ DECIMAL *, _Out_ BYTE *)
 
HRESULT WINAPI VarUI1FromDisp (IDispatch *, LCID, _Out_ BYTE *)
 
HRESULT WINAPI VarI2FromUI1 (BYTE, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromI4 (LONG, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromI8 (LONG64, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromR4 (FLOAT, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromR8 (DOUBLE, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromDate (DATE, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromBool (VARIANT_BOOL, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromI1 (signed char, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromUI2 (USHORT, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromUI4 (ULONG, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromUI8 (ULONG64, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromCy (CY, SHORT *)
 
HRESULT WINAPI VarI2FromDec (_In_ DECIMAL *, _Out_ SHORT *)
 
HRESULT WINAPI VarI2FromDisp (IDispatch *, LCID, _Out_ SHORT *)
 
HRESULT WINAPI VarI4FromUI1 (BYTE, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromI2 (SHORT, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromI8 (LONG64, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromR4 (FLOAT, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromR8 (DOUBLE, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromDate (DATE, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromBool (VARIANT_BOOL, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromI1 (signed char, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromUI2 (USHORT, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromUI4 (ULONG, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromUI8 (ULONG64, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromCy (CY, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromDec (_In_ DECIMAL *, _Out_ LONG *)
 
HRESULT WINAPI VarI4FromDisp (IDispatch *, _In_ LCID, _Out_ LONG *)
 
HRESULT WINAPI VarI8FromUI1 (BYTE, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromI2 (SHORT, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromI4 (LONG, LONG64 *)
 
HRESULT WINAPI VarI8FromR4 (FLOAT, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromR8 (DOUBLE, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromDate (DATE, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromBool (VARIANT_BOOL, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromI1 (signed char, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromUI2 (USHORT, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromUI4 (ULONG, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromUI8 (ULONG64, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromDec (_In_ DECIMAL *pdecIn, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromInt (INT intIn, LONG64 *)
 
HRESULT WINAPI VarI8FromCy (_In_ CY, _Out_ LONG64 *)
 
HRESULT WINAPI VarI8FromDisp (IDispatch *, _In_ LCID, _Out_ LONG64 *)
 
HRESULT WINAPI VarR4FromUI1 (BYTE, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromI2 (SHORT, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromI4 (LONG, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromI8 (LONG64, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromR8 (DOUBLE, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromDate (DATE, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromBool (VARIANT_BOOL, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromI1 (signed char, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromUI2 (USHORT, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromUI4 (ULONG, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromUI8 (ULONG64, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromCy (CY, FLOAT *)
 
HRESULT WINAPI VarR4FromDec (_In_ DECIMAL *, _Out_ FLOAT *)
 
HRESULT WINAPI VarR4FromDisp (IDispatch *, LCID, _Out_ FLOAT *)
 
HRESULT WINAPI VarR8FromUI1 (BYTE, _Out_ double *)
 
HRESULT WINAPI VarR8FromI2 (SHORT, _Out_ double *)
 
HRESULT WINAPI VarR8FromI4 (LONG, _Out_ double *)
 
HRESULT WINAPI VarR8FromI8 (LONG64, _Out_ double *)
 
HRESULT WINAPI VarR8FromR4 (FLOAT, _Out_ double *)
 
HRESULT WINAPI VarR8FromDate (DATE, _Out_ double *)
 
HRESULT WINAPI VarR8FromBool (VARIANT_BOOL, _Out_ double *)
 
HRESULT WINAPI VarR8FromI1 (signed char, double *)
 
HRESULT WINAPI VarR8FromUI2 (USHORT, _Out_ double *)
 
HRESULT WINAPI VarR8FromUI4 (ULONG, _Out_ double *)
 
HRESULT WINAPI VarR8FromUI8 (ULONG64, _Out_ double *)
 
HRESULT WINAPI VarR8FromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ double *)
 
HRESULT WINAPI VarR8FromCy (CY, double *)
 
HRESULT WINAPI VarR8FromDec (_In_ const DECIMAL *, _Out_ double *)
 
HRESULT WINAPI VarR8FromDisp (IDispatch *, LCID, _Out_ double *)
 
HRESULT WINAPI VarDateFromUI1 (BYTE, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromI2 (SHORT, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromI4 (LONG, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromI8 (LONG64, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromR4 (FLOAT, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromR8 (DOUBLE, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromI1 (signed char, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromUI2 (USHORT, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromUI4 (ULONG, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromUI8 (ULONG64, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromBool (VARIANT_BOOL, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromCy (CY, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromDec (_In_ DECIMAL *, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromDisp (IDispatch *, LCID, _Out_ DATE *)
 
HRESULT WINAPI VarCyFromUI1 (BYTE, _Out_ CY *)
 
HRESULT WINAPI VarCyFromI2 (SHORT sIn, _Out_ CY *)
 
HRESULT WINAPI VarCyFromI4 (LONG, _Out_ CY *)
 
HRESULT WINAPI VarCyFromI8 (LONG64, _Out_ CY *)
 
HRESULT WINAPI VarCyFromR4 (FLOAT, _Out_ CY *)
 
HRESULT WINAPI VarCyFromR8 (DOUBLE, _Out_ CY *)
 
HRESULT WINAPI VarCyFromDate (DATE, _Out_ CY *)
 
HRESULT WINAPI VarCyFromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ CY *)
 
HRESULT WINAPI VarCyFromBool (VARIANT_BOOL, _Out_ CY *)
 
HRESULT WINAPI VarCyFromI1 (signed char, _Out_ CY *)
 
HRESULT WINAPI VarCyFromUI2 (USHORT, _Out_ CY *)
 
HRESULT WINAPI VarCyFromUI4 (ULONG, _Out_ CY *)
 
HRESULT WINAPI VarCyFromUI8 (ULONG64, _Out_ CY *)
 
HRESULT WINAPI VarCyFromDec (_In_ DECIMAL *, _Out_ CY *)
 
HRESULT WINAPI VarCyFromDisp (_In_ IDispatch *, LCID, _Out_ CY *)
 
HRESULT WINAPI VarBstrFromUI1 (BYTE, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromI2 (SHORT, LCID, ULONG, BSTR *)
 
HRESULT WINAPI VarBstrFromI4 (LONG, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromI8 (LONG64, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromR4 (FLOAT, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromR8 (DOUBLE, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromDate (_In_ DATE, _In_ LCID, _In_ ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromBool (VARIANT_BOOL, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromI1 (signed char, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromUI2 (USHORT, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromUI8 (ULONG64, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromUI4 (ULONG, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromCy (CY, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromDec (_In_ DECIMAL *, _In_ LCID, _In_ ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBstrFromDisp (IDispatch *, LCID, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarBoolFromUI1 (BYTE, _Out_ VARIANT_BOOL *)
 
_Check_return_ HRESULT WINAPI VarBoolFromI2 (_In_ SHORT, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromI4 (LONG, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromI8 (LONG64, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromR4 (FLOAT, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromR8 (DOUBLE, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromDate (DATE, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromStr (_In_ OLECHAR *, LCID, ULONG, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromI1 (signed char, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromUI2 (USHORT, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromUI4 (ULONG, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromUI8 (ULONG64, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromCy (CY, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromDec (_In_ DECIMAL *, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarBoolFromDisp (IDispatch *, LCID, _Out_ VARIANT_BOOL *)
 
HRESULT WINAPI VarI1FromUI1 (_In_ BYTE, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromI2 (_In_ SHORT, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromI4 (_In_ LONG, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromI8 (_In_ LONG64, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromR4 (_In_ FLOAT, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromR8 (_In_ DOUBLE, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromDate (_In_ DATE, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromBool (_In_ VARIANT_BOOL, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromUI2 (_In_ USHORT, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromUI4 (_In_ ULONG, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromUI8 (_In_ ULONG64, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromCy (_In_ CY, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromDec (_In_ DECIMAL *, _Out_ signed char *)
 
HRESULT WINAPI VarI1FromDisp (_In_ IDispatch *, _In_ LCID, _Out_ signed char *)
 
HRESULT WINAPI VarUI2FromUI1 (BYTE, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromI2 (SHORT, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromI4 (LONG, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromI8 (LONG64, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromR4 (FLOAT, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromR8 (DOUBLE, USHORT *)
 
HRESULT WINAPI VarUI2FromDate (DATE, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromBool (VARIANT_BOOL, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromI1 (signed char, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromUI4 (ULONG, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromUI8 (ULONG64, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromCy (CY, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromDec (_In_ DECIMAL *, _Out_ USHORT *)
 
HRESULT WINAPI VarUI2FromDisp (_In_ IDispatch *, LCID, _Out_ USHORT *)
 
HRESULT WINAPI VarUI4FromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromUI1 (BYTE, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromI2 (_In_ SHORT, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromI4 (LONG, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromI8 (LONG64, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromR4 (FLOAT, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromR8 (DOUBLE, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromDate (DATE, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromBool (VARIANT_BOOL, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromI1 (signed char, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromUI2 (USHORT, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromUI8 (ULONG64, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromCy (CY, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromDec (_In_ DECIMAL *, _Out_ ULONG *)
 
HRESULT WINAPI VarUI4FromDisp (_In_ IDispatch *, LCID, _Out_ ULONG *)
 
HRESULT WINAPI VarUI8FromUI1 (BYTE, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromI2 (SHORT, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromI4 (LONG, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromI8 (LONG64, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromR4 (FLOAT, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromR8 (DOUBLE, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromDate (DATE, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromBool (VARIANT_BOOL, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromI1 (signed char, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromUI2 (USHORT, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromUI4 (ULONG, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromDec (_In_ DECIMAL *, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromInt (INT, ULONG64 *)
 
HRESULT WINAPI VarUI8FromCy (CY, _Out_ ULONG64 *)
 
HRESULT WINAPI VarUI8FromDisp (_In_ IDispatch *, LCID, _Out_ ULONG64 *)
 
HRESULT WINAPI VarDecFromUI1 (_In_ BYTE, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromI2 (_In_ SHORT, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromI4 (_In_ LONG, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromI8 (LONG64, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromR4 (_In_ FLOAT, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromR8 (_In_ DOUBLE, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromDate (_In_ DATE, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromBool (_In_ VARIANT_BOOL, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromI1 (_In_ signed char, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromUI2 (_In_ USHORT, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromUI4 (_In_ ULONG, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromUI8 (ULONG64, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromCy (_In_ CY, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFromDisp (_In_ IDispatch *, _In_ LCID, _Out_ DECIMAL *)
 
HRESULT WINAPI VarR4CmpR8 (_In_ float, _In_ double)
 
HRESULT WINAPI VarR8Pow (_In_ double, _In_ double, _Out_ double *)
 
HRESULT WINAPI VarR8Round (_In_ double, _In_ int, _Out_ double *)
 
HRESULT WINAPI VarDecAbs (_In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecAdd (_In_ const DECIMAL *, _In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecCmp (_In_ const DECIMAL *, _In_ const DECIMAL *)
 
HRESULT WINAPI VarDecCmpR8 (_In_ const DECIMAL *, _In_ DOUBLE)
 
HRESULT WINAPI VarDecDiv (_In_ const DECIMAL *, _In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecFix (_In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecInt (_In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecMul (_In_ const DECIMAL *, _In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecNeg (_In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecRound (_In_ const DECIMAL *, int, _Out_ DECIMAL *)
 
HRESULT WINAPI VarDecSub (_In_ const DECIMAL *, _In_ const DECIMAL *, _Out_ DECIMAL *)
 
HRESULT WINAPI VarCyAbs (_In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarCyAdd (_In_ const CY, _In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarCyCmp (_In_ const CY, _In_ const CY)
 
HRESULT WINAPI VarCyCmpR8 (_In_ const CY, _In_ DOUBLE)
 
HRESULT WINAPI VarCyFix (_In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarCyInt (_In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarCyMul (_In_ const CY, _In_ CY, _Out_ CY *)
 
HRESULT WINAPI VarCyMulI4 (_In_ const CY, _In_ LONG, _Out_ CY *)
 
HRESULT WINAPI VarCyMulI8 (_In_ const CY, _In_ LONG64, _Out_ CY *)
 
HRESULT WINAPI VarCyNeg (_In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarCyRound (_In_ const CY, _In_ INT, _Out_ CY *)
 
HRESULT WINAPI VarCySub (_In_ const CY, _In_ const CY, _Out_ CY *)
 
HRESULT WINAPI VarAdd (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarAnd (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarCat (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarDiv (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarEqv (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarIdiv (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarImp (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarMod (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarMul (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarOr (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarPow (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarSub (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarXor (_In_ LPVARIANT, _In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarAbs (_In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarFix (_In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarInt (_In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarNeg (_In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarNot (_In_ LPVARIANT, _Out_ LPVARIANT)
 
HRESULT WINAPI VarRound (_In_ LPVARIANT, _In_ int, _Out_ LPVARIANT)
 
HRESULT WINAPI VarCmp (_In_ LPVARIANT, _In_ LPVARIANT, _In_ LCID, _In_ ULONG)
 
HRESULT WINAPI VarBstrCmp (_In_ BSTR, _In_ BSTR, _In_ LCID, _In_ ULONG)
 
HRESULT WINAPI VarBstrCat (_In_ BSTR, _In_ BSTR, _Out_ BSTR *)
 
_Check_return_ HRESULT WINAPI VarParseNumFromStr (_In_ OLECHAR *, _In_ LCID, _In_ ULONG, _Out_ NUMPARSE *, _Out_ BYTE *)
 
_Check_return_ HRESULT WINAPI VarNumFromParseNum (_In_ NUMPARSE *, _In_ BYTE *, _In_ ULONG, _Out_ VARIANT *)
 
INT WINAPI DosDateTimeToVariantTime (_In_ USHORT, _In_ USHORT, _Out_ double *)
 
INT WINAPI VariantTimeToDosDateTime (_In_ double, _Out_ USHORT *, _Out_ USHORT *)
 
INT WINAPI VariantTimeToSystemTime (_In_ DOUBLE, _Out_ LPSYSTEMTIME)
 
INT WINAPI SystemTimeToVariantTime (_In_ LPSYSTEMTIME, _Out_ double *)
 
_Check_return_ HRESULT WINAPI VarDateFromUdate (_In_ UDATE *, _In_ ULONG, _Out_ DATE *)
 
HRESULT WINAPI VarDateFromUdateEx (_In_ UDATE *, _In_ LCID, _In_ ULONG, _Out_ DATE *)
 
_Check_return_ HRESULT WINAPI VarUdateFromDate (_In_ DATE, _In_ ULONG, _Out_ UDATE *)
 
HRESULT WINAPI VarWeekdayName (int, int, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarMonthName (int, int, ULONG, _Out_ BSTR *)
 
_Check_return_ HRESULT WINAPI GetAltMonthNames (LCID, _Outptr_result_buffer_maybenull_(13) LPOLESTR **)
 
HRESULT WINAPI VarFormat (_In_ LPVARIANT, _In_opt_ LPOLESTR, int, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarFormatCurrency (_In_ LPVARIANT, int, int, int, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarFormatDateTime (_In_ LPVARIANT, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarFormatNumber (_In_ LPVARIANT, int, int, int, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarFormatPercent (_In_ LPVARIANT, int, int, int, int, ULONG, _Out_ BSTR *)
 
HRESULT WINAPI VarFormatFromTokens (_In_ LPVARIANT, _In_opt_ LPOLESTR, LPBYTE, ULONG, _Out_ BSTR *, LCID)
 
HRESULT WINAPI VarTokenizeFormatString (_In_opt_ LPOLESTR, _Inout_ LPBYTE, int, int, int, LCID, _In_opt_ int *)
 
_Check_return_ HRESULT WINAPI DispGetParam (_In_ DISPPARAMS *, UINT, VARTYPE, _Out_ VARIANT *, _Out_opt_ UINT *)
 
_Check_return_ HRESULT WINAPI DispGetIDsOfNames (ITypeInfo *, _In_reads_(cNames) OLECHAR **, UINT cNames, _Out_writes_(cNames) DISPID *)
 
_Check_return_ HRESULT WINAPI DispInvoke (void *, ITypeInfo *, DISPID, WORD, DISPPARAMS *, VARIANT *, EXCEPINFO *, UINT *)
 
_Check_return_ HRESULT WINAPI CreateDispTypeInfo (INTERFACEDATA *, LCID, ITypeInfo **)
 
_Check_return_ HRESULT WINAPI CreateStdDispatch (IUnknown *, void *, ITypeInfo *, IUnknown **)
 
HRESULT WINAPI DispCallFunc (void *, ULONG_PTR, CALLCONV, VARTYPE, UINT, VARTYPE *, VARIANTARG **, VARIANT *)
 
ULONG WINAPI LHashValOfNameSysA (SYSKIND, LCID, LPCSTR)
 
ULONG WINAPI LHashValOfNameSys (SYSKIND, LCID, LPCOLESTR)
 
_Check_return_ HRESULT WINAPI CreateTypeLib (SYSKIND, const OLECHAR *, ICreateTypeLib **)
 
_Check_return_ HRESULT WINAPI CreateTypeLib2 (SYSKIND, LPCOLESTR, ICreateTypeLib2 **)
 
_Check_return_ HRESULT WINAPI LoadRegTypeLib (REFGUID, WORD, WORD, LCID, ITypeLib **)
 
HRESULT WINAPI LoadTypeLib (_In_z_ const OLECHAR *, ITypeLib **)
 
_Check_return_ HRESULT WINAPI LoadTypeLibEx (LPCOLESTR, REGKIND, ITypeLib **)
 
HRESULT WINAPI QueryPathOfRegTypeLib (REFGUID, WORD, WORD, LCID, LPBSTR)
 
_Check_return_ HRESULT WINAPI RegisterTypeLib (ITypeLib *, _In_ OLECHAR *, _In_opt_ OLECHAR *)
 
_Check_return_ HRESULT WINAPI UnRegisterTypeLib (REFGUID, WORD, WORD, LCID, SYSKIND)
 
HRESULT WINAPI RegisterTypeLibForUser (ITypeLib *, _In_ OLECHAR *, _In_opt_ OLECHAR *)
 
HRESULT WINAPI UnRegisterTypeLibForUser (REFGUID, WORD, WORD, LCID, SYSKIND)
 
VOID WINAPI ClearCustData (LPCUSTDATA)
 

Variables

UINT ui
 

Macro Definition Documentation

◆ ACTIVEOBJECT_STRONG

#define ACTIVEOBJECT_STRONG   0

Definition at line 181 of file oleauto.h.

◆ ACTIVEOBJECT_WEAK

#define ACTIVEOBJECT_WEAK   1

Definition at line 182 of file oleauto.h.

◆ DISPATCH_METHOD

#define DISPATCH_METHOD   0x1

Definition at line 1006 of file oleauto.h.

◆ DISPATCH_PROPERTYGET

#define DISPATCH_PROPERTYGET   0x2

Definition at line 1007 of file oleauto.h.

◆ DISPATCH_PROPERTYPUT

#define DISPATCH_PROPERTYPUT   0x4

Definition at line 1008 of file oleauto.h.

◆ DISPATCH_PROPERTYPUTREF

#define DISPATCH_PROPERTYPUTREF   0x8

Definition at line 1009 of file oleauto.h.

◆ ID_DEFAULTINST

#define ID_DEFAULTINST   -2

Definition at line 1004 of file oleauto.h.

◆ IsHashValCompatible

#define IsHashValCompatible (   hash1,
  hash2 
)    ((hash1) & 0xff0000 == (hash2) & 0xff0000)

Definition at line 1001 of file oleauto.h.

◆ LHashValOfName

#define LHashValOfName (   lcid,
  name 
)    LHashValOfNameSys(SYS_WIN32,lcid,name)

Definition at line 999 of file oleauto.h.

◆ LOAD_TLB_AS_32BIT

#define LOAD_TLB_AS_32BIT   0x20

Definition at line 1011 of file oleauto.h.

◆ LOAD_TLB_AS_64BIT

#define LOAD_TLB_AS_64BIT   0x40

Definition at line 1012 of file oleauto.h.

◆ LOCALE_USE_NLS

#define LOCALE_USE_NLS   0x10000000

Definition at line 338 of file oleauto.h.

◆ MASK_TO_RESET_TLB_BITS

#define MASK_TO_RESET_TLB_BITS   ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)

Definition at line 1013 of file oleauto.h.

◆ MEMBERID_NIL

#define MEMBERID_NIL   DISPID_UNKNOWN

Definition at line 1003 of file oleauto.h.

◆ NUMPRS_CURRENCY

#define NUMPRS_CURRENCY   0x00400 /* Currency symbol */

Definition at line 745 of file oleauto.h.

◆ NUMPRS_DECIMAL

#define NUMPRS_DECIMAL   0x00100 /* Decimal separator */

Definition at line 743 of file oleauto.h.

◆ NUMPRS_EXPONENT

#define NUMPRS_EXPONENT   0x00800 /* Exponent (e.g. "e-14") */

Definition at line 746 of file oleauto.h.

◆ NUMPRS_HEX_OCT

#define NUMPRS_HEX_OCT   0x00040 /* Octal number (with a leading 0) */

Definition at line 741 of file oleauto.h.

◆ NUMPRS_INEXACT

#define NUMPRS_INEXACT   0x20000 /* Number is represented inexactly (dwOutFlags only) */

Definition at line 750 of file oleauto.h.

◆ NUMPRS_LEADING_MINUS

#define NUMPRS_LEADING_MINUS   0x00010 /* Leading '-' sign */

Definition at line 739 of file oleauto.h.

◆ NUMPRS_LEADING_PLUS

#define NUMPRS_LEADING_PLUS   0x00004 /* Leading '+' sign */

Definition at line 737 of file oleauto.h.

◆ NUMPRS_LEADING_WHITE

#define NUMPRS_LEADING_WHITE   0x00001 /* Leading whitespace */

Definition at line 735 of file oleauto.h.

◆ NUMPRS_NEG

#define NUMPRS_NEG   0x10000 /* Number is negative (dwOutFlags only) */

Definition at line 749 of file oleauto.h.

◆ NUMPRS_PARENS

#define NUMPRS_PARENS   0x00080 /* Parentheses for negative numbers */

Definition at line 742 of file oleauto.h.

◆ NUMPRS_STD

#define NUMPRS_STD   0x01FFF /* Standard flags for internal coercions (All of the above) */

Definition at line 748 of file oleauto.h.

◆ NUMPRS_THOUSANDS

#define NUMPRS_THOUSANDS   0x00200 /* Thousands separator */

Definition at line 744 of file oleauto.h.

◆ NUMPRS_TRAILING_MINUS

#define NUMPRS_TRAILING_MINUS   0x00020 /* Trailing '-' sign */

Definition at line 740 of file oleauto.h.

◆ NUMPRS_TRAILING_PLUS

#define NUMPRS_TRAILING_PLUS   0x00008 /* Trailing '+' sign */

Definition at line 738 of file oleauto.h.

◆ NUMPRS_TRAILING_WHITE

#define NUMPRS_TRAILING_WHITE   0x00002 /* Trailing whitespace */

Definition at line 736 of file oleauto.h.

◆ NUMPRS_USE_ALL

#define NUMPRS_USE_ALL   0x01000 /* Parse the entire string */

Definition at line 747 of file oleauto.h.

◆ STDOLE2_LCID

#define STDOLE2_LCID   0

Definition at line 36 of file oleauto.h.

◆ STDOLE2_MAJORVERNUM

#define STDOLE2_MAJORVERNUM   2

Definition at line 34 of file oleauto.h.

◆ STDOLE2_MINORVERNUM

#define STDOLE2_MINORVERNUM   0

Definition at line 35 of file oleauto.h.

◆ STDOLE_LCID

#define STDOLE_LCID   0

Definition at line 32 of file oleauto.h.

◆ STDOLE_MAJORVERNUM

#define STDOLE_MAJORVERNUM   1

Definition at line 30 of file oleauto.h.

◆ STDOLE_MINORVERNUM

#define STDOLE_MINORVERNUM   0

Definition at line 31 of file oleauto.h.

◆ V_ARRAY

#define V_ARRAY (   A)    V_UNION(A,parray)

Definition at line 222 of file oleauto.h.

◆ V_ARRAYREF

#define V_ARRAYREF (   A)    V_UNION(A,pparray)

Definition at line 223 of file oleauto.h.

◆ V_BOOL

#define V_BOOL (   A)    V_UNION(A,boolVal)

Definition at line 224 of file oleauto.h.

◆ V_BOOLREF

#define V_BOOLREF (   A)    V_UNION(A,pboolVal)

Definition at line 225 of file oleauto.h.

◆ V_BSTR

#define V_BSTR (   A)    V_UNION(A,bstrVal)

Definition at line 226 of file oleauto.h.

◆ V_BSTRREF

#define V_BSTRREF (   A)    V_UNION(A,pbstrVal)

Definition at line 227 of file oleauto.h.

◆ V_BYREF

#define V_BYREF (   A)    V_UNION(A,byref)

Definition at line 228 of file oleauto.h.

◆ V_CY

#define V_CY (   A)    V_UNION(A,cyVal)

Definition at line 229 of file oleauto.h.

◆ V_CYREF

#define V_CYREF (   A)    V_UNION(A,pcyVal)

Definition at line 230 of file oleauto.h.

◆ V_DATE

#define V_DATE (   A)    V_UNION(A,date)

Definition at line 231 of file oleauto.h.

◆ V_DATEREF

#define V_DATEREF (   A)    V_UNION(A,pdate)

Definition at line 232 of file oleauto.h.

◆ V_DECIMAL

#define V_DECIMAL (   A)    ((A)->decVal)

Definition at line 236 of file oleauto.h.

◆ V_DECIMALREF

#define V_DECIMALREF (   A)    V_UNION(A,pdecVal)

Definition at line 238 of file oleauto.h.

◆ V_DISPATCH

#define V_DISPATCH (   A)    V_UNION(A,pdispVal)

Definition at line 239 of file oleauto.h.

◆ V_DISPATCHREF

#define V_DISPATCHREF (   A)    V_UNION(A,ppdispVal)

Definition at line 240 of file oleauto.h.

◆ V_ERROR

#define V_ERROR (   A)    V_UNION(A,scode)

Definition at line 241 of file oleauto.h.

◆ V_ERRORREF

#define V_ERRORREF (   A)    V_UNION(A,pscode)

Definition at line 242 of file oleauto.h.

◆ V_I1

#define V_I1 (   A)    V_UNION(A,cVal)

Definition at line 243 of file oleauto.h.

◆ V_I1REF

#define V_I1REF (   A)    V_UNION(A,pcVal)

Definition at line 244 of file oleauto.h.

◆ V_I2

#define V_I2 (   A)    V_UNION(A,iVal)

Definition at line 245 of file oleauto.h.

◆ V_I2REF

#define V_I2REF (   A)    V_UNION(A,piVal)

Definition at line 246 of file oleauto.h.

◆ V_I4

#define V_I4 (   A)    V_UNION(A,lVal)

Definition at line 247 of file oleauto.h.

◆ V_I4REF

#define V_I4REF (   A)    V_UNION(A,plVal)

Definition at line 248 of file oleauto.h.

◆ V_I8

#define V_I8 (   A)    V_UNION(A,llVal)

Definition at line 249 of file oleauto.h.

◆ V_I8REF

#define V_I8REF (   A)    V_UNION(A,pllVal)

Definition at line 250 of file oleauto.h.

◆ V_INT

#define V_INT (   A)    V_UNION(A,intVal)

Definition at line 251 of file oleauto.h.

◆ V_INT_PTR

#define V_INT_PTR (   A)    V_I4(A)

Definition at line 257 of file oleauto.h.

◆ V_INT_PTRREF

#define V_INT_PTRREF (   A)    V_I4REF(A)

Definition at line 258 of file oleauto.h.

◆ V_INTREF

#define V_INTREF (   A)    V_UNION(A,pintVal)

Definition at line 252 of file oleauto.h.

◆ V_ISARRAY

#define V_ISARRAY (   A)    (V_VT(A) & VT_ARRAY)

Definition at line 218 of file oleauto.h.

◆ V_ISBYREF

#define V_ISBYREF (   A)    (V_VT(A) & VT_BYREF)

Definition at line 217 of file oleauto.h.

◆ V_ISVECTOR

#define V_ISVECTOR (   A)    (V_VT(A) & VT_VECTOR)

Definition at line 219 of file oleauto.h.

◆ V_NONE

#define V_NONE (   A)    V_I2(A)

Definition at line 220 of file oleauto.h.

◆ V_R4

#define V_R4 (   A)    V_UNION(A,fltVal)

Definition at line 260 of file oleauto.h.

◆ V_R4REF

#define V_R4REF (   A)    V_UNION(A,pfltVal)

Definition at line 261 of file oleauto.h.

◆ V_R8

#define V_R8 (   A)    V_UNION(A,dblVal)

Definition at line 262 of file oleauto.h.

◆ V_R8REF

#define V_R8REF (   A)    V_UNION(A,pdblVal)

Definition at line 263 of file oleauto.h.

◆ V_RECORD

#define V_RECORD (   A)    ((A)->pvRecord)

Definition at line 213 of file oleauto.h.

◆ V_RECORDINFO

#define V_RECORDINFO (   A)    ((A)->pRecInfo)

Definition at line 214 of file oleauto.h.

◆ V_UI1

#define V_UI1 (   A)    V_UNION(A,bVal)

Definition at line 266 of file oleauto.h.

◆ V_UI1REF

#define V_UI1REF (   A)    V_UNION(A,pbVal)

Definition at line 267 of file oleauto.h.

◆ V_UI2

#define V_UI2 (   A)    V_UNION(A,uiVal)

Definition at line 268 of file oleauto.h.

◆ V_UI2REF

#define V_UI2REF (   A)    V_UNION(A,puiVal)

Definition at line 269 of file oleauto.h.

◆ V_UI4

#define V_UI4 (   A)    V_UNION(A,ulVal)

Definition at line 270 of file oleauto.h.

◆ V_UI4REF

#define V_UI4REF (   A)    V_UNION(A,pulVal)

Definition at line 271 of file oleauto.h.

◆ V_UI8

#define V_UI8 (   A)    V_UNION(A,ullVal)

Definition at line 272 of file oleauto.h.

◆ V_UI8REF

#define V_UI8REF (   A)    V_UNION(A,pullVal)

Definition at line 273 of file oleauto.h.

◆ V_UINT

#define V_UINT (   A)    V_UNION(A,uintVal)

Definition at line 264 of file oleauto.h.

◆ V_UINT_PTR

#define V_UINT_PTR (   A)    V_UI4(A)

Definition at line 278 of file oleauto.h.

◆ V_UINT_PTRREF

#define V_UINT_PTRREF (   A)    V_UI4REF(A)

Definition at line 279 of file oleauto.h.

◆ V_UINTREF

#define V_UINTREF (   A)    V_UNION(A,puintVal)

Definition at line 265 of file oleauto.h.

◆ V_UNION

#define V_UNION (   A,
  B 
)    ((A)->B)

Definition at line 212 of file oleauto.h.

◆ V_UNKNOWN

#define V_UNKNOWN (   A)    V_UNION(A,punkVal)

Definition at line 281 of file oleauto.h.

◆ V_UNKNOWNREF

#define V_UNKNOWNREF (   A)    V_UNION(A,ppunkVal)

Definition at line 282 of file oleauto.h.

◆ V_VARIANTREF

#define V_VARIANTREF (   A)    V_UNION(A,pvarVal)

Definition at line 283 of file oleauto.h.

◆ V_VT

#define V_VT (   A)    ((A)->vt)

Definition at line 211 of file oleauto.h.

◆ VAR_CALENDAR_GREGORIAN

#define VAR_CALENDAR_GREGORIAN   0x100 /* Use the Gregorian calendar */

Definition at line 334 of file oleauto.h.

◆ VAR_CALENDAR_HIJRI

#define VAR_CALENDAR_HIJRI   0x008 /* Use the Hijri calendar */

Definition at line 329 of file oleauto.h.

◆ VAR_CALENDAR_THAI

#define VAR_CALENDAR_THAI   0x080 /* Use the Thai buddhist calendar */

Definition at line 333 of file oleauto.h.

◆ VAR_DATEVALUEONLY

#define VAR_DATEVALUEONLY   0x002 /* Ignore time portion of VT_DATE */

Definition at line 327 of file oleauto.h.

◆ VAR_FORMAT_NOSUBSTITUTE

#define VAR_FORMAT_NOSUBSTITUTE   0x020 /* Don't change format strings for un-coercable types */

Definition at line 331 of file oleauto.h.

◆ VAR_FOURDIGITYEARS

#define VAR_FOURDIGITYEARS   0x040 /* Always print years with 4 digits */

Definition at line 332 of file oleauto.h.

◆ VAR_LOCALBOOL

#define VAR_LOCALBOOL   0x010 /* VT_BOOL<->VT_BSTR: Use localised boolean text */

Definition at line 330 of file oleauto.h.

◆ VAR_TIMEVALUEONLY

#define VAR_TIMEVALUEONLY   0x001 /* Ignore date portion of VT_DATE */

Definition at line 326 of file oleauto.h.

◆ VAR_VALIDDATE

#define VAR_VALIDDATE   0x004

Definition at line 328 of file oleauto.h.

◆ VarBoolFromInt

#define VarBoolFromInt   VarBoolFromI4

Definition at line 607 of file oleauto.h.

◆ VarBoolFromUint

#define VarBoolFromUint   VarBoolFromUI4

Definition at line 608 of file oleauto.h.

◆ VarBstrFromInt

#define VarBstrFromInt   VarBstrFromI4

Definition at line 605 of file oleauto.h.

◆ VarBstrFromUint

#define VarBstrFromUint   VarBstrFromUI4

Definition at line 606 of file oleauto.h.

◆ VARCMP_EQ

#define VARCMP_EQ   1

Definition at line 658 of file oleauto.h.

◆ VARCMP_GT

#define VARCMP_GT   2

Definition at line 659 of file oleauto.h.

◆ VARCMP_LT

#define VARCMP_LT   0

Definition at line 657 of file oleauto.h.

◆ VARCMP_NULL

#define VARCMP_NULL   3

Definition at line 660 of file oleauto.h.

◆ VarCyFromInt

#define VarCyFromInt   VarCyFromI4

Definition at line 603 of file oleauto.h.

◆ VarCyFromUint

#define VarCyFromUint   VarCyFromUI4

Definition at line 604 of file oleauto.h.

◆ VarDateFromInt

#define VarDateFromInt   VarDateFromI4

Definition at line 601 of file oleauto.h.

◆ VarDateFromUint

#define VarDateFromUint   VarDateFromUI4

Definition at line 602 of file oleauto.h.

◆ VarDecFromInt

#define VarDecFromInt   VarDecFromI4

Definition at line 617 of file oleauto.h.

◆ VarDecFromUint

#define VarDecFromUint   VarDecFromUI4

Definition at line 618 of file oleauto.h.

◆ VarI1FromInt

#define VarI1FromInt   VarI1FromI4

Definition at line 609 of file oleauto.h.

◆ VarI1FromUint

#define VarI1FromUint   VarI1FromUI4

Definition at line 610 of file oleauto.h.

◆ VarI2FromInt

#define VarI2FromInt   VarI2FromI4

Definition at line 591 of file oleauto.h.

◆ VarI2FromUint

#define VarI2FromUint   VarI2FromUI4

Definition at line 592 of file oleauto.h.

◆ VarI4FromI4

#define VarI4FromI4 (   in,
  pOut 
)    ( *(pOut) = (in) )

Definition at line 587 of file oleauto.h.

◆ VarI4FromInt

#define VarI4FromInt   VarI4FromI4

Definition at line 593 of file oleauto.h.

◆ VarI4FromUint

#define VarI4FromUint   VarI4FromUI4

Definition at line 594 of file oleauto.h.

◆ VarI8FromInt

#define VarI8FromInt   VarI8FromI4

Definition at line 595 of file oleauto.h.

◆ VarI8FromUint

#define VarI8FromUint   VarI8FromUI4

Definition at line 596 of file oleauto.h.

◆ VARIANT_ALPHABOOL

#define VARIANT_ALPHABOOL   0x02 /* Coerce to "True"|"False" instead of "-1"|"0" */

Definition at line 311 of file oleauto.h.

◆ VARIANT_CALENDAR_GREGORIAN

#define VARIANT_CALENDAR_GREGORIAN   0x40 /* Use the Gregorian calendar */

Definition at line 316 of file oleauto.h.

◆ VARIANT_CALENDAR_HIJRI

#define VARIANT_CALENDAR_HIJRI   0x08 /* Use the Hijri calendar */

Definition at line 313 of file oleauto.h.

◆ VARIANT_CALENDAR_THAI

#define VARIANT_CALENDAR_THAI   0x20 /* Use the Thai buddhist calendar */

Definition at line 315 of file oleauto.h.

◆ VARIANT_LOCALBOOL

#define VARIANT_LOCALBOOL   0x10 /* Like VARIANT_ALPHABOOL, but use localised text */

Definition at line 314 of file oleauto.h.

◆ VARIANT_NOUSEROVERRIDE

#define VARIANT_NOUSEROVERRIDE   0x04 /* Pass LOCALE_NOUSEROVERRIDE to low level conversions */

Definition at line 312 of file oleauto.h.

◆ VARIANT_NOVALUEPROP

#define VARIANT_NOVALUEPROP   0x01 /* Don't get the default value property from IDispatch */

Definition at line 310 of file oleauto.h.

◆ VARIANT_USE_NLS

#define VARIANT_USE_NLS   0x80 /* Format result using NLS calls */

Definition at line 317 of file oleauto.h.

◆ VarIntFromBool

#define VarIntFromBool   VarI4FromBool

Definition at line 629 of file oleauto.h.

◆ VarIntFromCy

#define VarIntFromCy   VarI4FromCy

Definition at line 626 of file oleauto.h.

◆ VarIntFromDate

#define VarIntFromDate   VarI4FromDate

Definition at line 625 of file oleauto.h.

◆ VarIntFromDec

#define VarIntFromDec   VarI4FromDec

Definition at line 634 of file oleauto.h.

◆ VarIntFromDisp

#define VarIntFromDisp   VarI4FromDisp

Definition at line 628 of file oleauto.h.

◆ VarIntFromI1

#define VarIntFromI1   VarI4FromI1

Definition at line 630 of file oleauto.h.

◆ VarIntFromI2

#define VarIntFromI2   VarI4FromI2

Definition at line 620 of file oleauto.h.

◆ VarIntFromI4

#define VarIntFromI4   VarI4FromI4

Definition at line 621 of file oleauto.h.

◆ VarIntFromI8

#define VarIntFromI8   VarI4FromI8

Definition at line 622 of file oleauto.h.

◆ VarIntFromR4

#define VarIntFromR4   VarI4FromR4

Definition at line 623 of file oleauto.h.

◆ VarIntFromR8

#define VarIntFromR8   VarI4FromR8

Definition at line 624 of file oleauto.h.

◆ VarIntFromStr

#define VarIntFromStr   VarI4FromStr

Definition at line 627 of file oleauto.h.

◆ VarIntFromUI1

#define VarIntFromUI1   VarI4FromUI1

Definition at line 619 of file oleauto.h.

◆ VarIntFromUI2

#define VarIntFromUI2   VarI4FromUI2

Definition at line 631 of file oleauto.h.

◆ VarIntFromUI4

#define VarIntFromUI4   VarI4FromUI4

Definition at line 632 of file oleauto.h.

◆ VarIntFromUI8

#define VarIntFromUI8   VarI4FromUI8

Definition at line 633 of file oleauto.h.

◆ VarIntFromUint

#define VarIntFromUint   VarI4FromUI4

Definition at line 635 of file oleauto.h.

◆ VarR4FromInt

#define VarR4FromInt   VarR4FromI4

Definition at line 597 of file oleauto.h.

◆ VarR4FromUint

#define VarR4FromUint   VarR4FromUI4

Definition at line 598 of file oleauto.h.

◆ VarR8FromInt

#define VarR8FromInt   VarR8FromI4

Definition at line 599 of file oleauto.h.

◆ VarR8FromUint

#define VarR8FromUint   VarR8FromUI4

Definition at line 600 of file oleauto.h.

◆ VarUI1FromInt

#define VarUI1FromInt   VarUI1FromI4

Definition at line 589 of file oleauto.h.

◆ VarUI1FromUint

#define VarUI1FromUint   VarUI1FromUI4

Definition at line 590 of file oleauto.h.

◆ VarUI2FromInt

#define VarUI2FromInt   VarUI2FromI4

Definition at line 611 of file oleauto.h.

◆ VarUI2FromUint

#define VarUI2FromUint   VarUI2FromUI4

Definition at line 612 of file oleauto.h.

◆ VarUI4FromInt

#define VarUI4FromInt   VarUI4FromI4

Definition at line 613 of file oleauto.h.

◆ VarUI4FromUI4

#define VarUI4FromUI4 (   in,
  pOut 
)    ( *(pOut) = (in) )

Definition at line 586 of file oleauto.h.

◆ VarUI4FromUint

#define VarUI4FromUint   VarUI4FromUI4

Definition at line 614 of file oleauto.h.

◆ VarUI8FromInt

#define VarUI8FromInt   VarUI8FromI4

Definition at line 615 of file oleauto.h.

◆ VarUI8FromUint

#define VarUI8FromUint   VarUI8FromUI4

Definition at line 616 of file oleauto.h.

◆ VarUintFromBool

#define VarUintFromBool   VarUI4FromBool

Definition at line 646 of file oleauto.h.

◆ VarUintFromCy

#define VarUintFromCy   VarUI4FromCy

Definition at line 643 of file oleauto.h.

◆ VarUintFromDate

#define VarUintFromDate   VarUI4FromDate

Definition at line 642 of file oleauto.h.

◆ VarUintFromDec

#define VarUintFromDec   VarUI4FromDec

Definition at line 651 of file oleauto.h.

◆ VarUintFromDisp

#define VarUintFromDisp   VarUI4FromDisp

Definition at line 645 of file oleauto.h.

◆ VarUintFromI1

#define VarUintFromI1   VarUI4FromI1

Definition at line 647 of file oleauto.h.

◆ VarUintFromI2

#define VarUintFromI2   VarUI4FromI2

Definition at line 637 of file oleauto.h.

◆ VarUintFromI4

#define VarUintFromI4   VarUI4FromI4

Definition at line 638 of file oleauto.h.

◆ VarUintFromI8

#define VarUintFromI8   VarUI4FromI8

Definition at line 639 of file oleauto.h.

◆ VarUintFromInt

#define VarUintFromInt   VarUI4FromI4

Definition at line 652 of file oleauto.h.

◆ VarUintFromR4

#define VarUintFromR4   VarUI4FromR4

Definition at line 640 of file oleauto.h.

◆ VarUintFromR8

#define VarUintFromR8   VarUI4FromR8

Definition at line 641 of file oleauto.h.

◆ VarUintFromStr

#define VarUintFromStr   VarUI4FromStr

Definition at line 644 of file oleauto.h.

◆ VarUintFromUI1

#define VarUintFromUI1   VarUI4FromUI1

Definition at line 636 of file oleauto.h.

◆ VarUintFromUI2

#define VarUintFromUI2   VarUI4FromUI2

Definition at line 648 of file oleauto.h.

◆ VarUintFromUI4

#define VarUintFromUI4   VarUI4FromUI4

Definition at line 649 of file oleauto.h.

◆ VarUintFromUI8

#define VarUintFromUI8   VarUI4FromUI8

Definition at line 650 of file oleauto.h.

◆ VT_HARDTYPE

#define VT_HARDTYPE   VT_RESERVED /* Don't coerce this variant when comparing it to others */

Definition at line 323 of file oleauto.h.

◆ VTBIT_CY

#define VTBIT_CY   (1 << VT_CY)

Definition at line 762 of file oleauto.h.

◆ VTBIT_DECIMAL

#define VTBIT_DECIMAL   (1 << VT_DECIMAL)

Definition at line 763 of file oleauto.h.

◆ VTBIT_I1

#define VTBIT_I1   (1 << VT_I1)

Definition at line 752 of file oleauto.h.

◆ VTBIT_I2

#define VTBIT_I2   (1 << VT_I2)

Definition at line 754 of file oleauto.h.

◆ VTBIT_I4

#define VTBIT_I4   (1 << VT_I4)

Definition at line 756 of file oleauto.h.

◆ VTBIT_I8

#define VTBIT_I8   (1 << VT_I8)

Definition at line 758 of file oleauto.h.

◆ VTBIT_R4

#define VTBIT_R4   (1 << VT_R4)

Definition at line 760 of file oleauto.h.

◆ VTBIT_R8

#define VTBIT_R8   (1 << VT_R8)

Definition at line 761 of file oleauto.h.

◆ VTBIT_UI1

#define VTBIT_UI1   (1 << VT_UI1)

Definition at line 753 of file oleauto.h.

◆ VTBIT_UI2

#define VTBIT_UI2   (1 << VT_UI2)

Definition at line 755 of file oleauto.h.

◆ VTBIT_UI4

#define VTBIT_UI4   (1 << VT_UI4)

Definition at line 757 of file oleauto.h.

◆ VTBIT_UI8

#define VTBIT_UI8   (1 << VT_UI8)

Definition at line 759 of file oleauto.h.

◆ VTDATEGRE_MAX

#define VTDATEGRE_MAX   2958465 /* Maximum possible Gregorian date: 31/12/9999 */

Definition at line 342 of file oleauto.h.

◆ VTDATEGRE_MIN

#define VTDATEGRE_MIN   -657434 /* Minimum possible Gregorian date: 1/1/100 */

Definition at line 341 of file oleauto.h.

◆ WHashValOfLHashVal

#define WHashValOfLHashVal (   hash)    ((USHORT)((hash) & 0xffff))

Definition at line 1000 of file oleauto.h.

Typedef Documentation

◆ INTERFACEDATA

◆ LPINTERFACEDATA

◆ LPMETHODDATA

◆ LPPARAMDATA

◆ METHODDATA

◆ PARAMDATA

◆ REGKIND

Enumeration Type Documentation

◆ tagREGKIND

Enumerator
REGKIND_DEFAULT 
REGKIND_REGISTER 
REGKIND_NONE 

Definition at line 923 of file oleauto.h.

924 {
928 } REGKIND;
enum tagREGKIND REGKIND

Function Documentation

◆ _Post_equal_to_() [1/2]

_Post_equal_to_ ( _String_length_(bstr) *sizeof(OLECHAR )

◆ _Post_equal_to_() [2/2]

_Post_equal_to_ ( pbstr  = =NULL ? 0 :_String_length_(pbstr))

◆ _Ret_writes_maybenull_z_()

_Ret_writes_maybenull_z_ ( ui 1) const

◆ BstrFromVector()

_Check_return_ HRESULT WINAPI BstrFromVector ( _In_ SAFEARRAY ,
_Out_ BSTR  
)

◆ ClearCustData()

VOID WINAPI ClearCustData ( LPCUSTDATA  )

◆ CreateDispTypeInfo()

_Check_return_ HRESULT WINAPI CreateDispTypeInfo ( INTERFACEDATA ,
LCID  ,
ITypeInfo **   
)

Definition at line 8721 of file typelib.c.

8725 {
8726  ITypeInfoImpl *pTIClass, *pTIIface;
8727  ITypeLibImpl *pTypeLibImpl;
8728  unsigned int param, func;
8729  TLBFuncDesc *pFuncDesc;
8730  TLBRefType *ref;
8731 
8732  TRACE("\n");
8733  pTypeLibImpl = TypeLibImpl_Constructor();
8734  if (!pTypeLibImpl) return E_FAIL;
8735 
8736  pTypeLibImpl->TypeInfoCount = 2;
8737  pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
8738 
8739  pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
8740  pTIIface->pTypeLib = pTypeLibImpl;
8741  pTIIface->index = 0;
8742  pTIIface->Name = NULL;
8743  pTIIface->dwHelpContext = -1;
8744  pTIIface->guid = NULL;
8745  pTIIface->typeattr.lcid = lcid;
8746  pTIIface->typeattr.typekind = TKIND_INTERFACE;
8747  pTIIface->typeattr.wMajorVerNum = 0;
8748  pTIIface->typeattr.wMinorVerNum = 0;
8749  pTIIface->typeattr.cbAlignment = 2;
8750  pTIIface->typeattr.cbSizeInstance = -1;
8751  pTIIface->typeattr.cbSizeVft = -1;
8752  pTIIface->typeattr.cFuncs = 0;
8753  pTIIface->typeattr.cImplTypes = 0;
8754  pTIIface->typeattr.cVars = 0;
8755  pTIIface->typeattr.wTypeFlags = 0;
8756  pTIIface->hreftype = 0;
8757 
8758  pTIIface->funcdescs = TLBFuncDesc_Alloc(pidata->cMembers);
8759  pFuncDesc = pTIIface->funcdescs;
8760  for(func = 0; func < pidata->cMembers; func++) {
8761  METHODDATA *md = pidata->pmethdata + func;
8762  pFuncDesc->Name = TLB_append_str(&pTypeLibImpl->name_list, md->szName);
8763  pFuncDesc->funcdesc.memid = md->dispid;
8764  pFuncDesc->funcdesc.lprgscode = NULL;
8765  pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
8766  pFuncDesc->funcdesc.invkind = md->wFlags;
8767  pFuncDesc->funcdesc.callconv = md->cc;
8768  pFuncDesc->funcdesc.cParams = md->cArgs;
8769  pFuncDesc->funcdesc.cParamsOpt = 0;
8770  pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
8771  pFuncDesc->funcdesc.cScodes = 0;
8772  pFuncDesc->funcdesc.wFuncFlags = 0;
8773  pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
8774  pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
8775  pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
8776  pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
8777  md->cArgs * sizeof(ELEMDESC));
8778  pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
8779  for(param = 0; param < md->cArgs; param++) {
8780  pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
8781  pFuncDesc->pParamDesc[param].Name = TLB_append_str(&pTypeLibImpl->name_list, md->ppdata[param].szName);
8782  }
8783  pFuncDesc->helpcontext = 0;
8784  pFuncDesc->HelpStringContext = 0;
8785  pFuncDesc->HelpString = NULL;
8786  pFuncDesc->Entry = NULL;
8787  list_init(&pFuncDesc->custdata_list);
8788  pTIIface->typeattr.cFuncs++;
8789  ++pFuncDesc;
8790  }
8791 
8792  dump_TypeInfo(pTIIface);
8793 
8794  pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
8795  pTIClass->pTypeLib = pTypeLibImpl;
8796  pTIClass->index = 1;
8797  pTIClass->Name = NULL;
8798  pTIClass->dwHelpContext = -1;
8799  pTIClass->guid = NULL;
8800  pTIClass->typeattr.lcid = lcid;
8801  pTIClass->typeattr.typekind = TKIND_COCLASS;
8802  pTIClass->typeattr.wMajorVerNum = 0;
8803  pTIClass->typeattr.wMinorVerNum = 0;
8804  pTIClass->typeattr.cbAlignment = 2;
8805  pTIClass->typeattr.cbSizeInstance = -1;
8806  pTIClass->typeattr.cbSizeVft = -1;
8807  pTIClass->typeattr.cFuncs = 0;
8808  pTIClass->typeattr.cImplTypes = 1;
8809  pTIClass->typeattr.cVars = 0;
8810  pTIClass->typeattr.wTypeFlags = 0;
8811  pTIClass->hreftype = sizeof(MSFT_TypeInfoBase);
8812 
8813  pTIClass->impltypes = TLBImplType_Alloc(1);
8814 
8815  ref = heap_alloc_zero(sizeof(*ref));
8816  ref->pImpTLInfo = TLB_REF_INTERNAL;
8817  list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
8818 
8819  dump_TypeInfo(pTIClass);
8820 
8821  *pptinfo = (ITypeInfo *)&pTIClass->ITypeInfo2_iface;
8822 
8823  ITypeInfo_AddRef(*pptinfo);
8824  ITypeLib2_Release(&pTypeLibImpl->ITypeLib2_iface);
8825 
8826  return S_OK;
8827 
8828 }
struct list ref_list
Definition: typelib.c:1135
GLenum func
Definition: glext.h:6028
ITypeLib2 ITypeLib2_iface
Definition: typelib.c:1102
HREFTYPE hreftype
Definition: typelib.c:1255
static TLBString * TLB_append_str(struct list *string_list, BSTR new_str)
Definition: typelib.c:1884
static void dump_TypeInfo(const ITypeInfoImpl *pty)
Definition: typelib.c:1573
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
struct tagITypeInfoImpl ** typeinfos
Definition: typelib.c:1128
TYPEATTR typeattr
Definition: typelib.c:1250
#define E_FAIL
Definition: ddrawi.h:102
Definition: send.c:47
struct list custdata_list
Definition: typelib.c:1216
struct list name_list
Definition: typelib.c:1119
static ITypeInfoImpl * ITypeInfoImpl_Constructor(void)
Definition: typelib.c:5623
GLenum GLint ref
Definition: glext.h:6028
const TLBString * Entry
Definition: typelib.c:1215
smooth NULL
Definition: ftsmooth.c:416
const TLBString * Name
Definition: typelib.c:1210
TLBParDesc * pParamDesc
Definition: typelib.c:1211
ITypeInfo2 ITypeInfo2_iface
Definition: typelib.c:1242
TLBFuncDesc * funcdescs
Definition: typelib.c:1267
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLfloat param
Definition: glext.h:5796
FUNCDESC funcdesc
Definition: typelib.c:1209
static TLBParDesc * TLBParDesc_Constructor(UINT n)
Definition: typelib.c:1770
ITypeLibImpl * pTypeLib
Definition: typelib.c:1253
int HelpStringContext
Definition: typelib.c:1213
static TLBImplType * TLBImplType_Alloc(UINT n)
Definition: typelib.c:1812
DWORD dwHelpContext
Definition: typelib.c:1263
#define S_OK
Definition: intsafe.h:59
#define TLB_REF_INTERNAL
Definition: typelib.c:1196
static TLBFuncDesc * TLBFuncDesc_Alloc(UINT n)
Definition: typelib.c:1791
struct tagMSFT_TypeInfoBase MSFT_TypeInfoBase
TLBImplType * impltypes
Definition: typelib.c:1273
TLBGuid * guid
Definition: typelib.c:1249
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
const TLBString * Name
Definition: typelib.c:1259
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
const TLBString * Name
Definition: typelib.c:1202
#define md
Definition: compat-1.3.h:1983
static ITypeLibImpl * TypeLibImpl_Constructor(void)
Definition: typelib.c:3429
const TLBString * HelpString
Definition: typelib.c:1214

Referenced by test_CreateDispTypeInfo().

◆ CreateErrorInfo()

◆ CreateStdDispatch()

_Check_return_ HRESULT WINAPI CreateStdDispatch ( IUnknown ,
void ,
ITypeInfo ,
IUnknown **   
)

Definition at line 436 of file dispatch.c.

441 {
442  StdDispatch *pStdDispatch;
443 
444  TRACE("(%p, %p, %p, %p)\n", punkOuter, pvThis, ptinfo, stddisp);
445 
446  if (!pvThis || !ptinfo || !stddisp)
447  return E_INVALIDARG;
448 
449  pStdDispatch = CoTaskMemAlloc(sizeof(StdDispatch));
450  if (!pStdDispatch)
451  return E_OUTOFMEMORY;
452 
453  pStdDispatch->IDispatch_iface.lpVtbl = &StdDispatch_VTable;
454  pStdDispatch->pvThis = pvThis;
455  pStdDispatch->pTypeInfo = ptinfo;
456  pStdDispatch->ref = 1;
457 
458  /* we keep a reference to the type info so prevent it from
459  * being destroyed until we are done with it */
460  ITypeInfo_AddRef(ptinfo);
461  *stddisp = (IUnknown*)&pStdDispatch->IDispatch_iface;
462 
463  return S_OK;
464 }
IDispatch IDispatch_iface
Definition: dispatch.c:207
ITypeInfo * pTypeInfo
Definition: dispatch.c:209
void * pvThis
Definition: dispatch.c:208
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
static const IDispatchVtbl StdDispatch_VTable
Definition: dispatch.c:413
#define TRACE(s)
Definition: solgame.cpp:4
#define S_OK
Definition: intsafe.h:59
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:406
LONG ref
Definition: dispatch.c:210

Referenced by test_CreateStdDispatch(), and Widget_Create().

◆ CreateTypeLib()

_Check_return_ HRESULT WINAPI CreateTypeLib ( SYSKIND  ,
const OLECHAR ,
ICreateTypeLib **   
)

◆ CreateTypeLib2()

_Check_return_ HRESULT WINAPI CreateTypeLib2 ( SYSKIND  ,
LPCOLESTR  ,
ICreateTypeLib2 **   
)

Definition at line 8972 of file typelib.c.

8974 {
8975  ITypeLibImpl *This;
8976  HRESULT hres;
8977 
8978  TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
8979 
8980  if (!szFile) return E_INVALIDARG;
8981 
8983  if (!This)
8984  return E_OUTOFMEMORY;
8985 
8986  This->lcid = GetSystemDefaultLCID();
8987  This->syskind = syskind;
8988  This->ptr_size = get_ptr_size(syskind);
8989 
8990  This->path = heap_alloc((lstrlenW(szFile) + 1) * sizeof(WCHAR));
8991  if (!This->path) {
8992  ITypeLib2_Release(&This->ITypeLib2_iface);
8993  return E_OUTOFMEMORY;
8994  }
8995  lstrcpyW(This->path, szFile);
8996 
8997  hres = ITypeLib2_QueryInterface(&This->ITypeLib2_iface, &IID_ICreateTypeLib2, (LPVOID*)ppctlib);
8998  ITypeLib2_Release(&This->ITypeLib2_iface);
8999  return hres;
9000 }
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define lstrlenW
Definition: compat.h:407
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define debugstr_w
Definition: kernel32.h:32
#define E_INVALIDARG
Definition: ddrawi.h:101
LCID WINAPI GetSystemDefaultLCID(void)
Definition: lang.c:784
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT hres
Definition: protocol.c:465
LONG HRESULT
Definition: typedefs.h:77
#define lstrcpyW
Definition: compat.h:406
static int get_ptr_size(SYSKIND syskind)
Definition: typelib.c:1339
static ITypeLibImpl * TypeLibImpl_Constructor(void)
Definition: typelib.c:3429

Referenced by CreateTypeLib(), test_create_typelib_lcid(), test_CreateTypeLib(), test_dep(), test_SetDocString(), test_SetFuncAndParamNames(), test_SetTypeDescAlias(), test_SetVarHelpContext(), test_stub(), and test_TypeInfo2_GetContainingTypeLib().

◆ DEFINE_OLEGUID()

DEFINE_OLEGUID ( IID_StdOle  ,
0x00020430  ,
,
 
)

◆ DispCallFunc()

HRESULT WINAPI DispCallFunc ( void ,
ULONG_PTR  ,
CALLCONV  ,
VARTYPE  ,
UINT  ,
VARTYPE ,
VARIANTARG **  ,
VARIANT  
)

Definition at line 6816 of file typelib.c.

6819 {
6820 #ifdef __i386__
6821  int argspos, stack_offset;
6822  void *func;
6823  UINT i;
6824  DWORD *args;
6825 
6826  TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6827  pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6828  pvargResult, V_VT(pvargResult));
6829 
6830  if (cc != CC_STDCALL && cc != CC_CDECL)
6831  {
6832  FIXME("unsupported calling convention %d\n",cc);
6833  return E_INVALIDARG;
6834  }
6835 
6836  /* maximum size for an argument is sizeof(VARIANT) */
6837  args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 );
6838 
6839  /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6840  argspos = 1;
6841  if (pvInstance)
6842  {
6843  const FARPROC *vtable = *(FARPROC **)pvInstance;
6844  func = vtable[oVft/sizeof(void *)];
6845  args[argspos++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
6846  }
6847  else func = (void *)oVft;
6848 
6849  for (i = 0; i < cActuals; i++)
6850  {
6851  VARIANT *arg = prgpvarg[i];
6852 
6853  switch (prgvt[i])
6854  {
6855  case VT_EMPTY:
6856  break;
6857  case VT_I8:
6858  case VT_UI8:
6859  case VT_R8:
6860  case VT_DATE:
6861  case VT_CY:
6862  memcpy( &args[argspos], &V_I8(arg), sizeof(V_I8(arg)) );
6863  argspos += sizeof(V_I8(arg)) / sizeof(DWORD);
6864  break;
6865  case VT_DECIMAL:
6866  case VT_VARIANT:
6867  memcpy( &args[argspos], arg, sizeof(*arg) );
6868  argspos += sizeof(*arg) / sizeof(DWORD);
6869  break;
6870  case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6871  args[argspos++] = V_BOOL(arg);
6872  break;
6873  default:
6874  args[argspos++] = V_UI4(arg);
6875  break;
6876  }
6877  TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
6878  }
6879 
6880  switch (vtReturn)
6881  {
6882  case VT_EMPTY:
6883  call_method( func, argspos - 1, args + 1, &stack_offset );
6884  break;
6885  case VT_R4:
6886  V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6887  break;
6888  case VT_R8:
6889  case VT_DATE:
6890  V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6891  break;
6892  case VT_DECIMAL:
6893  case VT_VARIANT:
6894  if (pvInstance)
6895  {
6896  args[0] = (DWORD)pvInstance; /* arg 0 is a pointer to the instance */
6897  args[1] = (DWORD)pvargResult; /* arg 1 is a pointer to the result */
6898  call_method( func, argspos, args, &stack_offset );
6899  }
6900  else
6901  {
6902  args[0] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */
6903  call_method( func, argspos, args, &stack_offset );
6904  }
6905  break;
6906  case VT_I8:
6907  case VT_UI8:
6908  case VT_CY:
6909  V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6910  break;
6911  case VT_HRESULT:
6912  WARN("invalid return type %u\n", vtReturn);
6913  heap_free( args );
6914  return E_INVALIDARG;
6915  default:
6916  V_UI4(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6917  break;
6918  }
6919  heap_free( args );
6920  if (stack_offset && cc == CC_STDCALL)
6921  {
6922  WARN( "stack pointer off by %d\n", stack_offset );
6923  return DISP_E_BADCALLEE;
6924  }
6925  if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
6926  TRACE("retval: %s\n", debugstr_variant(pvargResult));
6927  return S_OK;
6928 
6929 #elif defined(__x86_64__)
6930  int argspos;
6931  UINT i;
6932  DWORD_PTR *args;
6933  void *func;
6934 
6935  TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6936  pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6937  pvargResult, V_VT(pvargResult));
6938 
6939  if (cc != CC_STDCALL && cc != CC_CDECL)
6940  {
6941  FIXME("unsupported calling convention %d\n",cc);
6942  return E_INVALIDARG;
6943  }
6944 
6945  /* maximum size for an argument is sizeof(DWORD_PTR) */
6946  args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) );
6947 
6948  /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6949  argspos = 1;
6950  if (pvInstance)
6951  {
6952  const FARPROC *vtable = *(FARPROC **)pvInstance;
6953  func = vtable[oVft/sizeof(void *)];
6954  args[argspos++] = (DWORD_PTR)pvInstance; /* the This pointer is always the first parameter */
6955  }
6956  else func = (void *)oVft;
6957 
6958  for (i = 0; i < cActuals; i++)
6959  {
6960  VARIANT *arg = prgpvarg[i];
6961 
6962  switch (prgvt[i])
6963  {
6964  case VT_DECIMAL:
6965  case VT_VARIANT:
6966  args[argspos++] = (ULONG_PTR)arg;
6967  break;
6968  case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6969  args[argspos++] = V_BOOL(arg);
6970  break;
6971  default:
6972  args[argspos++] = V_UI8(arg);
6973  break;
6974  }
6975  TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
6976  }
6977 
6978  switch (vtReturn)
6979  {
6980  case VT_R4:
6981  V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6982  break;
6983  case VT_R8:
6984  case VT_DATE:
6985  V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6986  break;
6987  case VT_DECIMAL:
6988  case VT_VARIANT:
6989  if (pvInstance)
6990  {
6991  args[0] = (DWORD_PTR)pvInstance; /* arg 0 is a pointer to the instance */
6992  args[1] = (DWORD_PTR)pvargResult; /* arg 1 is a pointer to the result */
6993  call_method( func, argspos, args );
6994  }
6995  else
6996  {
6997  args[0] = (DWORD_PTR)pvargResult; /* arg 0 is a pointer to the result */
6998  call_method( func, argspos, args );
6999  }
7000  break;
7001  case VT_HRESULT:
7002  WARN("invalid return type %u\n", vtReturn);
7003  heap_free( args );
7004  return E_INVALIDARG;
7005  default:
7006  V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1 );
7007  break;
7008  }
7009  heap_free( args );
7010  if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
7011  TRACE("retval: %s\n", debugstr_variant(pvargResult));
7012  return S_OK;
7013 
7014 #elif defined(__arm__)
7015  int argspos;
7016  void *func;
7017  UINT i;
7018  DWORD *args;
7019  struct {
7020 #ifndef __SOFTFP__
7021  union {
7022  float s[16];
7023  double d[8];
7024  } sd;
7025 #endif
7026  DWORD r[4];
7027  } regs;
7028  int rcount; /* 32-bit register index count */
7029 #ifndef __SOFTFP__
7030  int scount = 0; /* single-precision float register index count */
7031  int dcount = 0; /* double-precision float register index count */
7032 #endif
7033 
7034  TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
7035  pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
7036 
7037  if (cc != CC_STDCALL && cc != CC_CDECL)
7038  {
7039  FIXME("unsupported calling convention %d\n",cc);
7040  return E_INVALIDARG;
7041  }
7042 
7043  argspos = 0;
7044  rcount = 0;
7045 
7046  /* Determine if we need to pass a pointer for the return value as arg 0. If so, do that */
7047  /* first as it will need to be in the 'r' registers: */
7048  switch (vtReturn)
7049  {
7050  case VT_DECIMAL:
7051  case VT_VARIANT:
7052  regs.r[rcount++] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */
7053  break;
7054  case VT_HRESULT:
7055  WARN("invalid return type %u\n", vtReturn);
7056  return E_INVALIDARG;
7057  default: /* And all others are in 'r', 's', or 'd' registers or have no return value */
7058  break;
7059  }
7060 
7061  if (pvInstance)
7062  {
7063  const FARPROC *vtable = *(FARPROC **)pvInstance;
7064  func = vtable[oVft/sizeof(void *)];
7065  regs.r[rcount++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
7066  }
7067  else func = (void *)oVft;
7068 
7069  /* maximum size for an argument is sizeof(VARIANT). Also allow for return pointer and stack alignment. */
7070  args = heap_alloc( sizeof(VARIANT) * cActuals + sizeof(DWORD) * 4 );
7071 
7072  for (i = 0; i < cActuals; i++)
7073  {
7074  VARIANT *arg = prgpvarg[i];
7075  DWORD *pdwarg = (DWORD *)(arg); /* a reinterpret_cast of the variant, used for copying structures when they are split between registers and stack */
7076  int ntemp; /* Used for counting words split between registers and stack */
7077 
7078  switch (prgvt[i])
7079  {
7080  case VT_EMPTY:
7081  break;
7082  case VT_R8: /* these must be 8-byte aligned, and put in 'd' regs or stack, as they are double-floats */
7083  case VT_DATE:
7084 #ifndef __SOFTFP__
7085  dcount = max( (scount + 1) / 2, dcount );
7086  if (dcount < 8)
7087  {
7088  regs.sd.d[dcount++] = V_R8(arg);
7089  }
7090  else
7091  {
7092  argspos += (argspos % 2); /* align argspos to 8-bytes */
7093  memcpy( &args[argspos], &V_R8(arg), sizeof(V_R8(arg)) );
7094  argspos += sizeof(V_R8(arg)) / sizeof(DWORD);
7095  }
7096  break;
7097 #endif
7098  case VT_I8: /* these must be 8-byte aligned, and put in 'r' regs or stack, as they are long-longs */
7099  case VT_UI8:
7100  case VT_CY:
7101  if (rcount < 3)
7102  {
7103  rcount += (rcount % 2); /* align rcount to 8-byte register pair */
7104  memcpy( &regs.r[rcount], &V_UI8(arg), sizeof(V_UI8(arg)) );
7105  rcount += sizeof(V_UI8(arg)) / sizeof(DWORD);
7106  }
7107  else
7108  {
7109  rcount = 4; /* Make sure we flag that all 'r' regs are full */
7110  argspos += (argspos % 2); /* align argspos to 8-bytes */
7111  memcpy( &args[argspos], &V_UI8(arg), sizeof(V_UI8(arg)) );
7112  argspos += sizeof(V_UI8(arg)) / sizeof(DWORD);
7113  }
7114  break;
7115  case VT_DECIMAL: /* these structures are 8-byte aligned, and put in 'r' regs or stack, can be split between the two */
7116  case VT_VARIANT:
7117  /* 8-byte align 'r' and/or stack: */
7118  if (rcount < 3)
7119  rcount += (rcount % 2);
7120  else
7121  {
7122  rcount = 4;
7123  argspos += (argspos % 2);
7124  }
7125  ntemp = sizeof(*arg) / sizeof(DWORD);
7126  while (ntemp > 0)
7127  {
7128  if (rcount < 4)
7129  regs.r[rcount++] = *pdwarg++;
7130  else
7131  args[argspos++] = *pdwarg++;
7132  --ntemp;
7133  }
7134  break;
7135  case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
7136  if (rcount < 4)
7137  regs.r[rcount++] = V_BOOL(arg);
7138  else
7139  args[argspos++] = V_BOOL(arg);
7140  break;
7141  case VT_R4: /* these must be 4-byte aligned, and put in 's' regs or stack, as they are single-floats */
7142 #ifndef __SOFTFP__
7143  if (!(scount % 2)) scount = max( scount, dcount * 2 );
7144  if (scount < 16)
7145  regs.sd.s[scount++] = V_R4(arg);
7146  else
7147  args[argspos++] = V_UI4(arg);
7148  break;
7149 #endif
7150  default:
7151  if (rcount < 4)
7152  regs.r[rcount++] = V_UI4(arg);
7153  else
7154  args[argspos++] = V_UI4(arg);
7155  break;
7156  }
7157  TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
7158  }
7159 
7160  argspos += (argspos % 2); /* Make sure stack function alignment is 8-byte */
7161 
7162  switch (vtReturn)
7163  {
7164  case VT_EMPTY: /* EMPTY = no return value */
7165  case VT_DECIMAL: /* DECIMAL and VARIANT already have a pointer argument passed (see above) */
7166  case VT_VARIANT:
7167  call_method( func, argspos, args, (DWORD*)&regs );
7168  break;
7169  case VT_R4:
7170  V_R4(pvargResult) = call_float_method( func, argspos, args, (DWORD*)&regs );
7171  break;
7172  case VT_R8:
7173  case VT_DATE:
7174  V_R8(pvargResult) = call_double_method( func, argspos, args, (DWORD*)&regs );
7175  break;
7176  case VT_I8:
7177  case VT_UI8:
7178  case VT_CY:
7179  V_UI8(pvargResult) = call_method( func, argspos, args, (DWORD*)&regs );
7180  break;
7181  default:
7182  V_UI4(pvargResult) = call_method( func, argspos, args, (DWORD*)&regs );
7183  break;
7184  }
7185  heap_free( args );
7186  if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
7187  TRACE("retval: %s\n", debugstr_variant(pvargResult));
7188  return S_OK;
7189 
7190 #else
7191  FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n",
7192  pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
7193  return E_NOTIMPL;
7194 #endif
7195 }
GLenum func
Definition: glext.h:6028
#define max(a, b)
Definition: svc.c:63
static void * vtable[]
Definition: typelib.c:1231
#define DWORD_PTR
Definition: treelist.c:76
Definition: compat.h:1948
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define V_R8(A)
Definition: oleauto.h:262
#define WARN(fmt,...)
Definition: debug.h:111
Definition: match.c:390
#define V_UI8(A)
Definition: oleauto.h:272
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define FIXME(fmt,...)
Definition: debug.h:110
#define E_INVALIDARG
Definition: ddrawi.h:101
#define DISP_E_BADCALLEE
Definition: winerror.h:2525
#define V_I8(A)
Definition: oleauto.h:249
#define V_R4(A)
Definition: oleauto.h:260
#define TRACE(s)
Definition: solgame.cpp:4
#define d
Definition: ke_i.h:81
static unsigned stack_offset(compile_ctx_t *ctx)
Definition: compile.c:349
unsigned int UINT
Definition: ndis.h:50
#define V_BOOL(A)
Definition: oleauto.h:224
unsigned long DWORD
Definition: ntddk_ex.h:95
static ULONG_PTR
Definition: typelib.c:84
#define V_UI4(A)
Definition: oleauto.h:270
struct @3999 regs[]
static const WCHAR sd[]
Definition: suminfo.c:287
Definition: compat.h:1933
#define V_VT(A)
Definition: oleauto.h:211
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
Definition: compat.h:1935
uint32_t DWORD_PTR
Definition: typedefs.h:63
uint32_t cc
Definition: isohybrid.c:75
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
#define S_OK
Definition: intsafe.h:59
#define E_NOTIMPL
Definition: ddrawi.h:99
#define args
Definition: format.c:66
int(* FARPROC)()
Definition: compat.h:28
static DWORD
Definition: typelib.c:87
Definition: compat.h:1934
static BOOL heap_free(void *mem)
Definition: appwiz.h:75

Referenced by invoke_builtin_function(), ITypeInfo_fnInvoke(), and test_DispCallFunc().

◆ DispGetIDsOfNames()

_Check_return_ HRESULT WINAPI DispGetIDsOfNames ( ITypeInfo ,
_In_reads_(cNames) OLECHAR **  ,
UINT  cNames,
_Out_writes_(cNames) DISPID  
)

◆ DispGetParam()

_Check_return_ HRESULT WINAPI DispGetParam ( _In_ DISPPARAMS *  ,
UINT  ,
VARTYPE  ,
_Out_ VARIANT ,
_Out_opt_ UINT  
)

◆ DispInvoke()

_Check_return_ HRESULT WINAPI DispInvoke ( void ,
ITypeInfo ,
DISPID  ,
WORD  ,
DISPPARAMS *  ,
VARIANT ,
EXCEPINFO *  ,
UINT  
)

Definition at line 65 of file dispatch.c.

74 {
75  TRACE("\n");
76 
77  return ITypeInfo_Invoke(ptinfo, _this, dispidMember, wFlags,
78  pparams, pvarResult, pexcepinfo, puArgErr);
79 }
#define TRACE(s)
Definition: solgame.cpp:4
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:519

Referenced by StdDispatch_Invoke().

◆ DosDateTimeToVariantTime()

INT WINAPI DosDateTimeToVariantTime ( _In_  USHORT,
_In_  USHORT,
_Out_ double  
)

◆ GetActiveObject()

HRESULT WINAPI GetActiveObject ( REFCLSID  ,
LPVOID  ,
LPUNKNOWN  
)

Definition at line 596 of file oleaut.c.

597 {
598  WCHAR guidbuf[80];
599  HRESULT ret;
600  LPRUNNINGOBJECTTABLE runobtable;
602 
603  StringFromGUID2(rcid,guidbuf,39);
605  if (FAILED(ret))
606  return ret;
607  ret = GetRunningObjectTable(0,&runobtable);
608  if (FAILED(ret)) {
609  IMoniker_Release(moniker);
610  return ret;
611  }
612  ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
613  IRunningObjectTable_Release(runobtable);
614  IMoniker_Release(moniker);
615  return ret;
616 }
interface IRunningObjectTable * LPRUNNINGOBJECTTABLE
Definition: objfwd.h:17
__wchar_t WCHAR
Definition: xmlstorage.h:180
HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, IMoniker **ppmk)
Definition: itemmoniker.c:936
LONG HRESULT
Definition: typedefs.h:77
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2346
int ret
interface IMoniker * LPMONIKER
Definition: objfwd.h:9
static const WCHAR * pdelimiter
Definition: oleaut.c:513
HRESULT WINAPI GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot)
Definition: moniker.c:1039
Definition: main.c:41

Referenced by ITypeInfo_fnCreateInstance().

◆ GetAltMonthNames()

◆ GetErrorInfo()

_Check_return_ HRESULT WINAPI GetErrorInfo ( _In_  ULONG,
_Outptr_ IErrorInfo **   
)

◆ GetRecordInfoFromGuids()

HRESULT WINAPI GetRecordInfoFromGuids ( REFGUID  ,
ULONG  ,
ULONG  ,
LCID  ,
REFGUID  ,
IRecordInfo **   
)

Definition at line 595 of file recinfo.c.

597 {
598  ITypeInfo *pTypeInfo;
599  ITypeLib *pTypeLib;
600  HRESULT hres;
601 
602  TRACE("(%p,%d,%d,%d,%s,%p)\n", rGuidTypeLib, uVerMajor, uVerMinor,
603  lcid, debugstr_guid(rGuidTypeInfo), ppRecInfo);
604 
605  hres = LoadRegTypeLib(rGuidTypeLib, uVerMajor, uVerMinor, lcid, &pTypeLib);
606  if(FAILED(hres)) {
607  WARN("LoadRegTypeLib failed!\n");
608  return hres;
609  }
610 
611  hres = ITypeLib_GetTypeInfoOfGuid(pTypeLib, rGuidTypeInfo, &pTypeInfo);
612  ITypeLib_Release(pTypeLib);
613  if(FAILED(hres)) {
614  WARN("GetTypeInfoOfGuid failed!\n");
615  return hres;
616  }
617 
618  hres = GetRecordInfoFromTypeInfo(pTypeInfo, ppRecInfo);
619  ITypeInfo_Release(pTypeInfo);
620  return hres;
621 }
#define WARN(fmt,...)
Definition: debug.h:111
#define debugstr_guid
Definition: kernel32.h:35
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT hres
Definition: protocol.c:465
LONG HRESULT
Definition: typedefs.h:77
HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo *pTI, IRecordInfo **ppRecInfo)
Definition: recinfo.c:626
HRESULT WINAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib **ppTLib)
Definition: typelib.c:534

◆ GetRecordInfoFromTypeInfo()

HRESULT WINAPI GetRecordInfoFromTypeInfo ( ITypeInfo ,
IRecordInfo **   
)

Definition at line 626 of file recinfo.c.

626  {
627  HRESULT hres;
628  TYPEATTR *typeattr;
630  ITypeInfo *pTypeInfo;
631  int i;
632  GUID guid;
633 
634  TRACE("(%p %p)\n", pTI, ppRecInfo);
635 
636  if(!pTI || !ppRecInfo)
637  return E_INVALIDARG;
638 
639  hres = ITypeInfo_GetTypeAttr(pTI, &typeattr);
640  if(FAILED(hres) || !typeattr) {
641  WARN("GetTypeAttr failed: %08x\n", hres);
642  return hres;
643  }
644 
645  if(typeattr->typekind == TKIND_ALIAS) {
646  hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
647  guid = typeattr->guid;
648  ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
649  if(FAILED(hres)) {
650  WARN("GetRefTypeInfo failed: %08x\n", hres);
651  return hres;
652  }
653  hres = ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr);
654  if(FAILED(hres)) {
655  ITypeInfo_Release(pTypeInfo);
656  WARN("GetTypeAttr failed for referenced type: %08x\n", hres);
657  return hres;
658  }
659  }else {
660  pTypeInfo = pTI;
661  ITypeInfo_AddRef(pTypeInfo);
662  guid = typeattr->guid;
663  }
664 
665  if(typeattr->typekind != TKIND_RECORD) {
666  WARN("typekind != TKIND_RECORD\n");
667  ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
668  ITypeInfo_Release(pTypeInfo);
669  return E_INVALIDARG;
670  }
671 
672  ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
673  ret->IRecordInfo_iface.lpVtbl = &IRecordInfoImplVtbl;
674  ret->ref = 1;
675  ret->pTypeInfo = pTypeInfo;
676  ret->n_vars = typeattr->cVars;
677  ret->size = typeattr->cbSizeInstance;
678  ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
679 
680  ret->guid = guid;
681 
682  /* NOTE: Windows implementation calls ITypeInfo::GetCantainingTypeLib and
683  * ITypeLib::GetLibAttr, but we currently don't need this.
684  */
685 
686  hres = ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &ret->name, NULL, NULL, NULL);
687  if(FAILED(hres)) {
688  WARN("ITypeInfo::GetDocumentation failed\n");
689  ret->name = NULL;
690  }
691 
692  ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(fieldstr));
693  for(i = 0; i<ret->n_vars; i++) {
694  VARDESC *vardesc;
695  hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc);
696  if(FAILED(hres)) {
697  WARN("GetVarDesc failed\n");
698  continue;
699  }
700  ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
701  ret->fields[i].varkind = vardesc->varkind;
702  ret->fields[i].offset = vardesc->u.oInst;
703  hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
704  NULL, NULL, NULL);
705  if(FAILED(hres))
706  WARN("GetDocumentation failed: %08x\n", hres);
707  TRACE("field=%s, offset=%d\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
708  ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc);
709  }
710 
711  *ppRecInfo = &ret->IRecordInfo_iface;
712 
713  return S_OK;
714 }
static const IRecordInfoVtbl IRecordInfoImplVtbl
Definition: recinfo.c:566
#define WARN(fmt,...)
Definition: debug.h:111
#define MEMBERID_NIL
Definition: oleauto.h:1003
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const GUID * guid
#define debugstr_w
Definition: kernel32.h:32
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT hres
Definition: protocol.c:465
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG HRESULT
Definition: typedefs.h:77
int ret
#define S_OK
Definition: intsafe.h:59

Referenced by GetRecordInfoFromGuids(), and test_recinfo().

◆ LHashValOfNameSys()

ULONG WINAPI LHashValOfNameSys ( SYSKIND  ,
LCID  ,
LPCOLESTR   
)

Definition at line 628 of file hash.c.

629 {
630  LPSTR strA;
631  ULONG res;
632  INT len;
633 
634  if (!str) return 0;
635  len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
636  strA = HeapAlloc( GetProcessHeap(), 0, len );
637  WideCharToMultiByte( CP_ACP, 0, str, -1, strA, len, NULL, NULL );
638  res = LHashValOfNameSysA(skind, lcid, strA);
640  return res;
641 }
char strA[12]
Definition: clipboard.c:2028
#define WideCharToMultiByte
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:99
char * LPSTR
Definition: xmlstorage.h:182
int32_t INT
Definition: typedefs.h:56
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLenum GLsizei len
Definition: glext.h:6722
ULONG WINAPI LHashValOfNameSysA(SYSKIND skind, LCID lcid, LPCSTR lpStr)
Definition: hash.c:506
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by test_TypeComp().

◆ LHashValOfNameSysA()

ULONG WINAPI LHashValOfNameSysA ( SYSKIND  ,
LCID  ,
LPCSTR   
)

Definition at line 506 of file hash.c.

507 {
508  ULONG nOffset, nMask = skind == SYS_MAC ? 1 : 0;
509  ULONG nHiWord, nLoWord = 0x0deadbee;
510  const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
511 
512  TRACE("(%d, 0x%x, %s) %s\n", skind, lcid, debugstr_a(lpStr),
513  (skind == SYS_WIN16) ? "SYS_WIN16" : (skind == SYS_WIN32) ? "SYS_WIN32" : "");
514 
515  if (!str)
516  return 0;
517 
518  lcid = ConvertDefaultLocale(lcid);
519 
520  switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
521  {
522  default:
523  ERR("Unknown lcid %x, treating as latin-based, please report\n", lcid);
524  /* .. Fall Through .. */
525  case LANG_AFRIKAANS: case LANG_ALBANIAN: case LANG_ARMENIAN:
526  case LANG_ASSAMESE: case LANG_AZERI: case LANG_BASQUE:
528  case LANG_CATALAN: case LANG_DANISH: case LANG_DIVEHI:
529  case LANG_DUTCH: case LANG_ENGLISH: case LANG_ESTONIAN:
530  case LANG_FAEROESE: case LANG_FINNISH: case LANG_FRENCH:
531  case LANG_GALICIAN: case LANG_GEORGIAN: case LANG_GERMAN:
532  case LANG_GUJARATI: case LANG_HINDI: case LANG_INDONESIAN:
533  case LANG_ITALIAN: case LANG_KANNADA: case LANG_KASHMIRI:
534  case LANG_KAZAK: case LANG_KONKANI: case LANG_KYRGYZ:
536  case LANG_MALAY: case LANG_MALAYALAM: case LANG_MANIPURI:
537  case LANG_MARATHI: case LANG_MONGOLIAN: case LANG_NEPALI:
538  case LANG_ORIYA: case LANG_PORTUGUESE: case LANG_PUNJABI:
539  case LANG_ROMANIAN: case LANG_SANSKRIT: case LANG_SERBIAN:
540  case LANG_SINDHI: case LANG_SLOVENIAN: case LANG_SWAHILI:
541  case LANG_SWEDISH: case LANG_SYRIAC: case LANG_TAMIL:
542  case LANG_TATAR: case LANG_TELUGU: case LANG_THAI:
543  case LANG_UKRAINIAN: case LANG_URDU: case LANG_UZBEK:
545  case LANG_MAORI: case LANG_ROMANSH: case LANG_IRISH:
546  case LANG_SAMI: case LANG_UPPER_SORBIAN: case LANG_SUTU:
547  case LANG_TSONGA: case LANG_TSWANA: case LANG_VENDA:
548  case LANG_XHOSA: case LANG_ZULU: case LANG_ESPERANTO:
549  case LANG_WALON: case LANG_CORNISH: case LANG_WELSH:
550  case LANG_BRETON: case LANG_MANX_GAELIC:
551  nOffset = 16;
552  pnLookup = Lookup_16;
553  break;
554  case LANG_CZECH: case LANG_HUNGARIAN: case LANG_POLISH:
555  case LANG_SLOVAK: case LANG_SPANISH:
556  nOffset = 32;
557  pnLookup = Lookup_32;
558  break;
559  case LANG_HEBREW:
560  nOffset = 48;
561  pnLookup = Lookup_48;
562  break;
563  case LANG_JAPANESE:
564  nOffset = 64;
565  pnLookup = Lookup_64;
566  break;
567  case LANG_KOREAN:
568  nOffset = 80;
569  pnLookup = Lookup_80;
570  break;
571  case LANG_CHINESE:
572  nOffset = 112;
573  pnLookup = Lookup_112;
574  break;
575  case LANG_GREEK:
576  nOffset = 128;
577  pnLookup = Lookup_128;
578  break;
579  case LANG_ICELANDIC:
580  nOffset = 144;
581  pnLookup = Lookup_144;
582  break;
583  case LANG_TURKISH:
584  nOffset = 160;
585  pnLookup = Lookup_160;
586  break;
587  case LANG_NORWEGIAN:
589  {
590  nOffset = 176;
591  pnLookup = Lookup_176;
592  }
593  else
594  {
595  nOffset = 16;
596  pnLookup = Lookup_16;
597  }
598  break;
599  case LANG_ARABIC:
600  case LANG_FARSI:
601  nOffset = 208;
602  pnLookup = Lookup_208;
603  break;
604  case LANG_RUSSIAN:
605  nOffset = 224;
606  pnLookup = Lookup_224;
607  break;
608  }
609 
610  nHiWord = (nOffset | nMask) << 16;
611 
612  while (*str)
613  {
614  nLoWord = 37 * nLoWord + pnLookup[*str > 0x7f && nMask ? *str + 0x80 : *str];
615  str++;
616  }
617  /* Constrain to a prime modulo and sizeof(WORD) */
618  nLoWord = (nLoWord % 65599) & 0xffff;
619 
620  return nHiWord | nLoWord;
621 }
#define LANG_UZBEK
Definition: nls.h:142
#define LANG_BELARUSIAN
Definition: nls.h:35
#define LANG_SYRIAC
Definition: nls.h:126
#define LANG_BASQUE
Definition: nls.h:34
static const unsigned char Lookup_80[128 *3]
Definition: hash.c:183
#define LANG_SWAHILI
Definition: nls.h:124
#define LANG_TSONGA
Definition: nls.h:157
static const unsigned char Lookup_144[128 *3]
Definition: hash.c:297
#define LANG_ESTONIAN
Definition: nls.h:53
#define LANG_LITHUANIAN
Definition: nls.h:88
#define LANG_THAI
Definition: nls.h:132
#define LANG_HINDI
Definition: nls.h:68
#define LANG_HUNGARIAN
Definition: nls.h:69
static const unsigned char Lookup_128[128 *3]
Definition: hash.c:259
#define LANG_SINDHI
Definition: nls.h:118
#define LANG_DIVEHI
Definition: nls.h:50
#define LANG_SCOTTISH_GAELIC
#define LANG_AZERI
Definition: nls.h:32
#define LANG_DUTCH
Definition: nls.h:51
static const unsigned char Lookup_176[128 *3]
Definition: hash.c:373
#define LANG_CZECH
Definition: nls.h:47
#define LANG_ARABIC
Definition: nls.h:29
#define LANG_MALAYALAM
Definition: nls.h:93
#define LANG_ORIYA
Definition: nls.h:104
#define LANG_KASHMIRI
Definition: nls.h:78
#define LANG_ROMANIAN
Definition: nls.h:111
#define LANG_BENGALI
Definition: nls.h:36
#define LANG_HEBREW
Definition: nls.h:67
#define LANG_BRETON
Definition: nls.h:39
#define LANG_SAMI
Definition: nls.h:114
#define LANG_SERBIAN
Definition: nls.h:116
#define LANG_MACEDONIAN
Definition: nls.h:91
#define LANG_SLOVAK
Definition: nls.h:120
#define LANG_BULGARIAN
Definition: nls.h:40
#define LANG_MALAY
Definition: nls.h:92
#define LANG_AFRIKAANS
Definition: nls.h:25
#define LANG_JAPANESE
Definition: nls.h:76
LCID WINAPI ConvertDefaultLocale(LCID lcid)
Definition: lang.c:1499
static const unsigned char Lookup_48[128 *3]
Definition: hash.c:108
#define LANG_TURKISH
Definition: nls.h:136
#define LANG_NORWEGIAN
Definition: nls.h:102
#define LANG_XHOSA
Definition: nls.h:146
static const unsigned char Lookup_208[128 *3]
Definition: hash.c:411
#define LANG_GALICIAN
Definition: nls.h:60
#define LANG_ITALIAN
Definition: nls.h:75
const WCHAR * str
#define LANG_MONGOLIAN
Definition: nls.h:100
#define LANG_VENDA
Definition: nls.h:158
#define LANG_KONKANI
Definition: nls.h:83
smooth NULL
Definition: ftsmooth.c:416
#define LANG_MALTESE
Definition: nls.h:94
#define LANG_KYRGYZ
Definition: nls.h:85
#define LANG_MANX_GAELIC
Definition: winnt_old.h:419
#define LANG_UPPER_SORBIAN
Definition: nls.h:140
#define LANG_INDONESIAN
Definition: nls.h:72
#define LANG_TELUGU
Definition: nls.h:131
#define LANG_SLOVENIAN
Definition: nls.h:121
#define LANG_TATAR
Definition: nls.h:130
#define LANG_CORNISH
Definition: nls.h:163
#define SUBLANG_NORWEGIAN_NYNORSK
Definition: nls.h:301
static const unsigned char Lookup_224[128 *3]
Definition: hash.c:449
#define LANG_PORTUGUESE
Definition: nls.h:108
#define LANG_FAEROESE
Definition: nls.h:54
#define TRACE(s)
Definition: solgame.cpp:4
#define debugstr_a
Definition: kernel32.h:31
#define LANG_SANSKRIT
Definition: nls.h:115
#define LANG_LATVIAN
Definition: nls.h:87
#define LANG_URDU
Definition: nls.h:141
static const unsigned char Lookup_64[128 *3]
Definition: hash.c:146
#define LANG_DANISH
Definition: nls.h:48
#define LANG_RUSSIAN
Definition: nls.h:113
#define LANG_ROMANSH
Definition: nls.h:112
#define LANG_ENGLISH
Definition: nls.h:52
#define LANG_NEPALI
Definition: nls.h:101
#define LANG_KANNADA
Definition: nls.h:77
#define LANG_IRISH
Definition: nls.h:74
#define LANGIDFROMLCID(l)
Definition: nls.h:18
static const unsigned char Lookup_112[128 *3]
Definition: hash.c:221
#define LANG_FRENCH
Definition: nls.h:58
#define LANG_VIETNAMESE
Definition: nls.h:143
static const unsigned char Lookup_32[128 *3]
Definition: hash.c:70
#define LANG_MARATHI
Definition: nls.h:98
#define LANG_GERMAN
Definition: nls.h:62
#define LANG_TSWANA
Definition: nls.h:135
#define ERR(fmt,...)
Definition: debug.h:109
#define LANG_PUNJABI
Definition: nls.h:109
#define LANG_ASSAMESE
Definition: nls.h:31
#define LANG_ALBANIAN
Definition: nls.h:26
#define LANG_SUTU
Definition: nls.h:156
#define LANG_UKRAINIAN
Definition: nls.h:139
#define LANG_FARSI
Definition: nls.h:55
#define LANG_WALON
Definition: nls.h:162
#define LANG_CHINESE
Definition: nls.h:42
unsigned int ULONG
Definition: retypes.h:1
#define LANG_SWEDISH
Definition: nls.h:125
#define LANG_ARMENIAN
Definition: nls.h:30
#define LANG_KOREAN
Definition: nls.h:84
#define LANG_MANIPURI
Definition: nls.h:95
#define LANG_POLISH
Definition: nls.h:107
#define LANG_ESPERANTO
Definition: nls.h:161
#define LANG_TAMIL
Definition: nls.h:129
#define LANG_GEORGIAN
Definition: nls.h:61
#define LANG_KAZAK
Definition: nls.h:79
static const unsigned char Lookup_160[128 *3]
Definition: hash.c:335
#define LANG_ZULU
Definition: nls.h:150
#define LANG_FINNISH
Definition: nls.h:57
#define LANG_ICELANDIC
Definition: nls.h:70
#define LANG_MAORI
Definition: nls.h:96
#define LANG_SPANISH
Definition: nls.h:123
#define LANG_GREEK
Definition: nls.h:63
#define LANG_CATALAN
Definition: nls.h:41
#define LANG_GUJARATI
Definition: nls.h:65
#define PRIMARYLANGID(l)
Definition: nls.h:16
static const unsigned char Lookup_16[128 *3]
Definition: hash.c:32
#define LANG_WELSH
Definition: nls.h:144
#define SUBLANGID(l)
Definition: nls.h:17

Referenced by LHashValOfNameSys(), and WMSFT_compile_names().

◆ LoadRegTypeLib()

_Check_return_ HRESULT WINAPI LoadRegTypeLib ( REFGUID  ,
WORD  ,
WORD  ,
LCID  ,
ITypeLib **   
)

Definition at line 534 of file typelib.c.

540 {
541  BSTR bstr=NULL;
542  HRESULT res;
543 
544  *ppTLib = NULL;
545 
546  res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
547 
548  if(SUCCEEDED(res))
549  {
550  res= LoadTypeLib(bstr, ppTLib);
551  SysFreeString(bstr);
552 
553  if ((wVerMajor!=0xffff || wVerMinor!=0xffff) && *ppTLib)
554  {
555  TLIBATTR *attr;
556 
557  res = ITypeLib_GetLibAttr(*ppTLib, &attr);
558  if (res == S_OK)
559  {
560  BOOL mismatch = attr->wMajorVerNum != wVerMajor || attr->wMinorVerNum < wVerMinor;
561  ITypeLib_ReleaseTLibAttr(*ppTLib, attr);
562 
563  if (mismatch)
564  {
565  ITypeLib_Release(*ppTLib);
566  *ppTLib = NULL;
568  }
569  }
570  }
571  }
572 
573  TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
574 
575  return res;
576 }
void WINAPI SysFreeString(BSTR str)
Definition: oleaut.c:275
HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib **pptLib)
Definition: typelib.c:461
HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID guid, WORD wMaj, WORD wMin, LCID lcid, LPBSTR path)
Definition: typelib.c:409
OLECHAR * BSTR
Definition: compat.h:1927
_STLP_INLINE_LOOP _STLP_STD::pair< _InputIter1, _InputIter2 > mismatch(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2)
Definition: _algobase.h:522
smooth NULL
Definition: ftsmooth.c:416
#define debugstr_guid
Definition: kernel32.h:35
#define TRACE(s)
Definition: solgame.cpp:4
unsigned int BOOL
Definition: ntddk_ex.h:94