#include <oaidl.h>

Include dependency graph for oleauto.h:

This graph shows which files directly or indirectly include 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 tagPARAMDATA *	LPPARAMDATA

typedef struct tagMETHODDATA	METHODDATA

typedef struct tagMETHODDATA *	LPMETHODDATA

typedef struct tagINTERFACEDATA	INTERFACEDATA

typedef struct tagINTERFACEDATA *	LPINTERFACEDATA

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_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyAdd (_In_ CY, _In_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyCmp (_In_ CY, _In_ CY)

HRESULT WINAPI	VarCyCmpR8 (_In_ CY, _In_ DOUBLE)

HRESULT WINAPI	VarCyFix (_In_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyInt (_In_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyMul (_In_ CY, _In_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyMulI4 (_In_ CY, _In_ LONG, _Out_ CY *)

HRESULT WINAPI	VarCyMulI8 (_In_ CY, _In_ LONG64, _Out_ CY *)

HRESULT WINAPI	VarCyNeg (_In_ CY, _Out_ CY *)

HRESULT WINAPI	VarCyRound (_In_ CY, _In_ INT, _Out_ CY *)

HRESULT WINAPI	VarCySub (_In_ CY, _In_ 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_ LPCOLESTR, _In_opt_ LPCOLESTR)

_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

typedef struct tagINTERFACEDATA INTERFACEDATA

◆ LPINTERFACEDATA

typedef struct tagINTERFACEDATA * LPINTERFACEDATA

◆ LPMETHODDATA

typedef struct tagMETHODDATA * LPMETHODDATA

◆ LPPARAMDATA

typedef struct tagPARAMDATA * LPPARAMDATA

◆ METHODDATA

typedef struct tagMETHODDATA METHODDATA

◆ PARAMDATA

typedef struct tagPARAMDATA PARAMDATA

◆ REGKIND

typedef enum tagREGKIND REGKIND

Enumeration Type Documentation

◆ tagREGKIND

enum tagREGKIND

Enumerator
REGKIND_DEFAULT
REGKIND_REGISTER
REGKIND_NONE

Definition at line 923 of file oleauto.h.

{
    REGKIND_DEFAULT,
    REGKIND_REGISTER,
    REGKIND_NONE
} 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 *	pidata,
		LCID	lcid,
		ITypeInfo **	pptinfo
	)

Definition at line 8792 of file typelib.c.

{
    ITypeInfoImpl *pTIClass, *pTIIface;
    ITypeLibImpl *pTypeLibImpl;
    unsigned int param, func;
    TLBFuncDesc *pFuncDesc;
    TLBRefType *ref;
 
    TRACE("\n");
    pTypeLibImpl = TypeLibImpl_Constructor();
    if (!pTypeLibImpl) return E_FAIL;
 
    pTypeLibImpl->TypeInfoCount = 2;
    pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
 
    pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
    pTIIface->pTypeLib = pTypeLibImpl;
    pTIIface->index = 0;
    pTIIface->Name = NULL;
    pTIIface->dwHelpContext = -1;
    pTIIface->guid = NULL;
    pTIIface->typeattr.lcid = lcid;
    pTIIface->typeattr.typekind = TKIND_INTERFACE;
    pTIIface->typeattr.wMajorVerNum = 0;
    pTIIface->typeattr.wMinorVerNum = 0;
    pTIIface->typeattr.cbAlignment = 2;
    pTIIface->typeattr.cbSizeInstance = -1;
    pTIIface->typeattr.cbSizeVft = -1;
    pTIIface->typeattr.cFuncs = 0;
    pTIIface->typeattr.cImplTypes = 0;
    pTIIface->typeattr.cVars = 0;
    pTIIface->typeattr.wTypeFlags = 0;
    pTIIface->hreftype = 0;
 
    pTIIface->funcdescs = TLBFuncDesc_Alloc(pidata->cMembers);
    pFuncDesc = pTIIface->funcdescs;
    for(func = 0; func < pidata->cMembers; func++) {
        METHODDATA *md = pidata->pmethdata + func;
        pFuncDesc->Name = TLB_append_str(&pTypeLibImpl->name_list, md->szName);
        pFuncDesc->funcdesc.memid = md->dispid;
        pFuncDesc->funcdesc.lprgscode = NULL;
        pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
        pFuncDesc->funcdesc.invkind = md->wFlags;
        pFuncDesc->funcdesc.callconv = md->cc;
        pFuncDesc->funcdesc.cParams = md->cArgs;
        pFuncDesc->funcdesc.cParamsOpt = 0;
        pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
        pFuncDesc->funcdesc.cScodes = 0;
        pFuncDesc->funcdesc.wFuncFlags = 0;
        pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
        pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
        pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                                              md->cArgs * sizeof(ELEMDESC));
        pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
        for(param = 0; param < md->cArgs; param++) {
            pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
            pFuncDesc->pParamDesc[param].Name = TLB_append_str(&pTypeLibImpl->name_list, md->ppdata[param].szName);
        }
        pFuncDesc->helpcontext = 0;
        pFuncDesc->HelpStringContext = 0;
        pFuncDesc->HelpString = NULL;
        pFuncDesc->Entry = NULL;
        list_init(&pFuncDesc->custdata_list);
        pTIIface->typeattr.cFuncs++;
        ++pFuncDesc;
    }
 
    dump_TypeInfo(pTIIface);
 
    pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
    pTIClass->pTypeLib = pTypeLibImpl;
    pTIClass->index = 1;
    pTIClass->Name = NULL;
    pTIClass->dwHelpContext = -1;
    pTIClass->guid = NULL;
    pTIClass->typeattr.lcid = lcid;
    pTIClass->typeattr.typekind = TKIND_COCLASS;
    pTIClass->typeattr.wMajorVerNum = 0;
    pTIClass->typeattr.wMinorVerNum = 0;
    pTIClass->typeattr.cbAlignment = 2;
    pTIClass->typeattr.cbSizeInstance = -1;
    pTIClass->typeattr.cbSizeVft = -1;
    pTIClass->typeattr.cFuncs = 0;
    pTIClass->typeattr.cImplTypes = 1;
    pTIClass->typeattr.cVars = 0;
    pTIClass->typeattr.wTypeFlags = 0;
    pTIClass->hreftype = sizeof(MSFT_TypeInfoBase);
 
    pTIClass->impltypes = TLBImplType_Alloc(1);
 
    ref = heap_alloc_zero(sizeof(*ref));
    ref->pImpTLInfo = TLB_REF_INTERNAL;
    list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
 
    dump_TypeInfo(pTIClass);
 
    *pptinfo = (ITypeInfo *)&pTIClass->ITypeInfo2_iface;
 
    ITypeInfo_AddRef(*pptinfo);
    ITypeLib2_Release(&pTypeLibImpl->ITypeLib2_iface);
 
    return S_OK;
 
}

Referenced by test_CreateDispTypeInfo().

◆ CreateErrorInfo()

_Check_return_ HRESULT WINAPI CreateErrorInfo ( _Outptr_ ICreateErrorInfo ** )

◆ CreateStdDispatch()

_Check_return_ HRESULT WINAPI CreateStdDispatch	(	IUnknown *	punkOuter,
		void *	pvThis,
		ITypeInfo *	ptinfo,
		IUnknown **	stddisp
	)

Definition at line 434 of file dispatch.c.

{
    StdDispatch *pStdDispatch;
 
    TRACE("(%p, %p, %p, %p)\n", punkOuter, pvThis, ptinfo, stddisp);
 
    if (!pvThis || !ptinfo || !stddisp)
        return E_INVALIDARG;
 
    pStdDispatch = CoTaskMemAlloc(sizeof(StdDispatch));
    if (!pStdDispatch)
        return E_OUTOFMEMORY;
 
    pStdDispatch->IDispatch_iface.lpVtbl = &StdDispatch_VTable;
    pStdDispatch->pvThis = pvThis;
    pStdDispatch->pTypeInfo = ptinfo;
    pStdDispatch->ref = 1;
 
    /* we keep a reference to the type info so prevent it from
     * being destroyed until we are done with it */
    ITypeInfo_AddRef(ptinfo);
    *stddisp = (IUnknown*)&pStdDispatch->IDispatch_iface;
 
    return S_OK;
}

Referenced by test_CreateStdDispatch(), and Widget_Create().

◆ CreateTypeLib()

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

◆ CreateTypeLib2()

_Check_return_ HRESULT WINAPI CreateTypeLib2	(	SYSKIND	syskind,
		LPCOLESTR	szFile,
		ICreateTypeLib2 **	ppctlib
	)

Definition at line 9043 of file typelib.c.

{
    ITypeLibImpl *This;
    HRESULT hres;
 
    TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
 
    if (!szFile) return E_INVALIDARG;
 
    This = TypeLibImpl_Constructor();
    if (!This)
        return E_OUTOFMEMORY;
 
    This->lcid = GetSystemDefaultLCID();
    This->syskind = syskind;
    This->ptr_size = get_ptr_size(syskind);
 
    This->path = heap_alloc((lstrlenW(szFile) + 1) * sizeof(WCHAR));
    if (!This->path) {
        ITypeLib2_Release(&This->ITypeLib2_iface);
        return E_OUTOFMEMORY;
    }
    lstrcpyW(This->path, szFile);
 
    hres = ITypeLib2_QueryInterface(&This->ITypeLib2_iface, &IID_ICreateTypeLib2, (LPVOID*)ppctlib);
    ITypeLib2_Release(&This->ITypeLib2_iface);
    return hres;
}

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	,
		0	,
		0
	)

◆ DispCallFunc()

HRESULT WINAPI DispCallFunc	(	void *	pvInstance,
		ULONG_PTR	oVft,
		CALLCONV	cc,
		VARTYPE	vtReturn,
		UINT	cActuals,
		VARTYPE *	prgvt,
		VARIANTARG **	prgpvarg,
		VARIANT *	pvargResult
	)

Definition at line 7071 of file typelib.c.

{
    FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n",
           pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
    return E_NOTIMPL;
}

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 *	_this,
		ITypeInfo *	ptinfo,
		DISPID	dispidMember,
		WORD	wFlags,
		DISPPARAMS *	pparams,
		VARIANT *	pvarResult,
		EXCEPINFO *	pexcepinfo,
		UINT *	puArgErr
	)

Definition at line 63 of file dispatch.c.

{
    TRACE("\n");
 
    return ITypeInfo_Invoke(ptinfo, _this, dispidMember, wFlags,
                            pparams, pvarResult, pexcepinfo, puArgErr);
}

Referenced by StdDispatch_Invoke().

◆ DosDateTimeToVariantTime()

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

◆ GetActiveObject()

HRESULT WINAPI GetActiveObject	(	REFCLSID	rcid,
		LPVOID	preserved,
		LPUNKNOWN *	ppunk
	)

Definition at line 592 of file oleaut.c.

{
    WCHAR           guidbuf[80];
    HRESULT         ret;
    LPRUNNINGOBJECTTABLE    runobtable;
    LPMONIKER       moniker;
 
    StringFromGUID2(rcid,guidbuf,39);
    ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
    if (FAILED(ret))
        return ret;
    ret = GetRunningObjectTable(0,&runobtable);
    if (FAILED(ret)) {
        IMoniker_Release(moniker);
        return ret;
    }
    ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
    IRunningObjectTable_Release(runobtable);
    IMoniker_Release(moniker);
    return ret;
}

Referenced by ITypeInfo_fnCreateInstance().

◆ GetAltMonthNames()

_Check_return_ HRESULT WINAPI GetAltMonthNames	(	LCID	,
		_Outptr_result_buffer_maybenull_(13) LPOLESTR **
	)

◆ GetErrorInfo()

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

◆ GetRecordInfoFromGuids()

HRESULT WINAPI GetRecordInfoFromGuids	(	REFGUID	rGuidTypeLib,
		ULONG	uVerMajor,
		ULONG	uVerMinor,
		LCID	lcid,
		REFGUID	rGuidTypeInfo,
		IRecordInfo **	ppRecInfo
	)

Definition at line 594 of file recinfo.c.

{
    ITypeInfo *pTypeInfo;
    ITypeLib *pTypeLib;
    HRESULT hres;
    
    TRACE("(%p,%d,%d,%d,%s,%p)\n", rGuidTypeLib, uVerMajor, uVerMinor,
            lcid, debugstr_guid(rGuidTypeInfo), ppRecInfo);
 
    hres = LoadRegTypeLib(rGuidTypeLib, uVerMajor, uVerMinor, lcid, &pTypeLib);
    if(FAILED(hres)) {
        WARN("LoadRegTypeLib failed!\n");
        return hres;
    }
 
    hres = ITypeLib_GetTypeInfoOfGuid(pTypeLib, rGuidTypeInfo, &pTypeInfo);
    ITypeLib_Release(pTypeLib);
    if(FAILED(hres)) {
        WARN("GetTypeInfoOfGuid failed!\n");
        return hres;
    }
 
    hres = GetRecordInfoFromTypeInfo(pTypeInfo, ppRecInfo);
    ITypeInfo_Release(pTypeInfo);
    return hres;
}

◆ GetRecordInfoFromTypeInfo()

HRESULT WINAPI GetRecordInfoFromTypeInfo	(	ITypeInfo *	pTI,
		IRecordInfo **	ppRecInfo
	)

Definition at line 625 of file recinfo.c.

                                                                                  {
    HRESULT hres;
    TYPEATTR *typeattr;
    IRecordInfoImpl *ret;
    ITypeInfo *pTypeInfo;
    int i;
    GUID guid;
 
    TRACE("(%p %p)\n", pTI, ppRecInfo);
 
    if(!pTI || !ppRecInfo)
        return E_INVALIDARG;
    
    hres = ITypeInfo_GetTypeAttr(pTI, &typeattr);
    if(FAILED(hres) || !typeattr) {
        WARN("GetTypeAttr failed: %08x\n", hres);
        return hres;
    }
 
    if(typeattr->typekind == TKIND_ALIAS) {
        hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
        guid = typeattr->guid;
        ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
        if(FAILED(hres)) {
            WARN("GetRefTypeInfo failed: %08x\n", hres);
            return hres;
        }
        hres = ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr);
        if(FAILED(hres)) {
            ITypeInfo_Release(pTypeInfo);
            WARN("GetTypeAttr failed for referenced type: %08x\n", hres);
            return hres;
        }
    }else  {
        pTypeInfo = pTI;
        ITypeInfo_AddRef(pTypeInfo);
        guid = typeattr->guid;
    }
 
    if(typeattr->typekind != TKIND_RECORD) {
        WARN("typekind != TKIND_RECORD\n");
        ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
        ITypeInfo_Release(pTypeInfo);
        return E_INVALIDARG;
    }
 
    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
    ret->IRecordInfo_iface.lpVtbl = &IRecordInfoImplVtbl;
    ret->ref = 1;
    ret->pTypeInfo = pTypeInfo;
    ret->n_vars = typeattr->cVars;
    ret->size = typeattr->cbSizeInstance;
    ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
 
    ret->guid = guid;
 
    /* NOTE: Windows implementation calls ITypeInfo::GetCantainingTypeLib and
     *       ITypeLib::GetLibAttr, but we currently don't need this.
     */
 
    hres = ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &ret->name, NULL, NULL, NULL);
    if(FAILED(hres)) {
        WARN("ITypeInfo::GetDocumentation failed\n");
        ret->name = NULL;
    }
 
    ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(fieldstr));
    for(i = 0; i<ret->n_vars; i++) {
        VARDESC *vardesc;
        hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc);
        if(FAILED(hres)) {
            WARN("GetVarDesc failed\n");
            continue;
        }
        ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
        ret->fields[i].varkind = vardesc->varkind;
        ret->fields[i].offset = vardesc->u.oInst;
        hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
                NULL, NULL, NULL);
        if(FAILED(hres))
            WARN("GetDocumentation failed: %08x\n", hres);
        TRACE("field=%s, offset=%d\n", debugstr_w(ret->fields[i].name), ret->fields[i].offset);
        ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc);
    }
 
    *ppRecInfo = &ret->IRecordInfo_iface;
 
    return S_OK;
}

Referenced by GetRecordInfoFromGuids(), and test_recinfo().

◆ LHashValOfNameSys()

ULONG WINAPI LHashValOfNameSys	(	SYSKIND	skind,
		LCID	lcid,
		LPCOLESTR	str
	)

Definition at line 628 of file hash.c.

{
    LPSTR   strA;
    ULONG   res;
    INT len;
 
    if (!str) return 0;
    len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
    strA = HeapAlloc( GetProcessHeap(), 0, len );
    WideCharToMultiByte( CP_ACP, 0, str, -1, strA, len, NULL, NULL );
    res = LHashValOfNameSysA(skind, lcid, strA);
    HeapFree(GetProcessHeap(), 0, strA);
    return res;
}

Referenced by test_TypeComp().

◆ LHashValOfNameSysA()

ULONG WINAPI LHashValOfNameSysA	(	SYSKIND	skind,
		LCID	lcid,
		LPCSTR	lpStr
	)

Definition at line 506 of file hash.c.

{
  ULONG nOffset, nMask = skind == SYS_MAC ? 1 : 0;
  ULONG nHiWord, nLoWord = 0x0deadbee;
  const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
 
  TRACE("(%d, 0x%x, %s) %s\n", skind, lcid, debugstr_a(lpStr),
    (skind == SYS_WIN16) ? "SYS_WIN16" : (skind == SYS_WIN32) ? "SYS_WIN32" : "");
 
  if (!str)
    return 0;
 
  lcid = ConvertDefaultLocale(lcid);
 
  switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
  {
  default:
    ERR("Unknown lcid %x, treating as latin-based, please report\n", lcid);
    /* .. Fall Through .. */
  case LANG_AFRIKAANS:  case LANG_ALBANIAN:   case LANG_ARMENIAN:
  case LANG_ASSAMESE:   case LANG_AZERI:      case LANG_BASQUE:
  case LANG_BELARUSIAN: case LANG_BENGALI:    case LANG_BULGARIAN:
  case LANG_CATALAN:    case LANG_DANISH:     case LANG_DIVEHI:
  case LANG_DUTCH:      case LANG_ENGLISH:    case LANG_ESTONIAN:
  case LANG_FAEROESE:   case LANG_FINNISH:    case LANG_FRENCH:
  case LANG_GALICIAN:   case LANG_GEORGIAN:   case LANG_GERMAN:
  case LANG_GUJARATI:   case LANG_HINDI:      case LANG_INDONESIAN:
  case LANG_ITALIAN:    case LANG_KANNADA:    case LANG_KASHMIRI:
  case LANG_KAZAK:      case LANG_KONKANI:    case LANG_KYRGYZ:
  case LANG_LATVIAN:    case LANG_LITHUANIAN: case LANG_MACEDONIAN:
  case LANG_MALAY:      case LANG_MALAYALAM:  case LANG_MANIPURI:
  case LANG_MARATHI:    case LANG_MONGOLIAN:  case LANG_NEPALI:
  case LANG_ORIYA:      case LANG_PORTUGUESE: case LANG_PUNJABI:
  case LANG_ROMANIAN:   case LANG_SANSKRIT:   case LANG_SERBIAN:
  case LANG_SINDHI:     case LANG_SLOVENIAN:  case LANG_SWAHILI:
  case LANG_SWEDISH:    case LANG_SYRIAC:     case LANG_TAMIL:
  case LANG_TATAR:      case LANG_TELUGU:     case LANG_THAI:
  case LANG_UKRAINIAN:  case LANG_URDU:       case LANG_UZBEK:
  case LANG_VIETNAMESE: case LANG_SCOTTISH_GAELIC: case LANG_MALTESE:
  case LANG_MAORI:      case LANG_ROMANSH:    case LANG_IRISH:
  case LANG_SAMI:       case LANG_UPPER_SORBIAN: case LANG_SUTU:
  case LANG_TSONGA:     case LANG_TSWANA:     case LANG_VENDA:
  case LANG_XHOSA:      case LANG_ZULU:       case LANG_ESPERANTO:
  case LANG_WALON:      case LANG_CORNISH:    case LANG_WELSH:
  case LANG_BRETON:     case LANG_MANX_GAELIC:
    nOffset = 16;
    pnLookup = Lookup_16;
    break;
  case LANG_CZECH:  case LANG_HUNGARIAN:  case LANG_POLISH:
  case LANG_SLOVAK: case LANG_SPANISH:
    nOffset = 32;
    pnLookup = Lookup_32;
    break;
  case LANG_HEBREW:
    nOffset = 48;
    pnLookup = Lookup_48;
    break;
  case LANG_JAPANESE:
    nOffset = 64;
    pnLookup = Lookup_64;
    break;
  case LANG_KOREAN:
    nOffset = 80;
    pnLookup = Lookup_80;
    break;
  case LANG_CHINESE:
    nOffset = 112;
    pnLookup = Lookup_112;
    break;
  case LANG_GREEK:
    nOffset = 128;
    pnLookup = Lookup_128;
    break;
  case LANG_ICELANDIC:
    nOffset = 144;
    pnLookup = Lookup_144;
    break;
  case LANG_TURKISH:
    nOffset = 160;
    pnLookup = Lookup_160;
    break;
  case LANG_NORWEGIAN:
    if (SUBLANGID(LANGIDFROMLCID(lcid)) == SUBLANG_NORWEGIAN_NYNORSK)
    {
      nOffset = 176;
      pnLookup = Lookup_176;
    }
    else
    {
      nOffset = 16;
      pnLookup = Lookup_16;
    }
    break;
  case LANG_ARABIC:
  case LANG_FARSI:
    nOffset = 208;
    pnLookup = Lookup_208;
    break;
  case LANG_RUSSIAN:
    nOffset = 224;
    pnLookup = Lookup_224;
    break;
  }
 
  nHiWord = (nOffset | nMask) << 16;
 
  while (*str)
  {
    nLoWord = 37 * nLoWord + pnLookup[*str > 0x7f && nMask ? *str + 0x80 : *str];
    str++;
  }
  /* Constrain to a prime modulo and sizeof(WORD) */
  nLoWord = (nLoWord % 65599) & 0xffff;
 
  return nHiWord | nLoWord;
}

Referenced by LHashValOfNameSys(), and WMSFT_compile_names().

◆ LoadRegTypeLib()

_Check_return_ HRESULT WINAPI LoadRegTypeLib	(	REFGUID	rguid,
		WORD	wVerMajor,
		WORD	wVerMinor,
		LCID	lcid,
		ITypeLib **	ppTLib
	)

Definition at line 531 of file typelib.c.

{
    BSTR bstr=NULL;
    HRESULT res;
 
    *ppTLib = NULL;
 
    res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
 
    if(SUCCEEDED(res))
    {
        res= LoadTypeLib(bstr, ppTLib);
        SysFreeString(bstr);
 
        if ((wVerMajor!=0xffff || wVerMinor!=0xffff) && *ppTLib)
        {
            TLIBATTR *attr;
 
            res = ITypeLib_GetLibAttr(*ppTLib, &attr);
            if (res == S_OK)
            {
                BOOL mismatch = attr->wMajorVerNum != wVerMajor || attr->wMinorVerNum < wVerMinor;
                ITypeLib_ReleaseTLibAttr(*ppTLib, attr);
 
                if (mismatch)
                {
                    ITypeLib_Release(*ppTLib);
                    *ppTLib = NULL;
                    res = TYPE_E_LIBNOTREGISTERED;
                }
            }
        }
    }
 
    TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
 
    return res;
}

Referenced by BaseDispatch_Init(), ATL::IDispatchImpl< T, piid, plibid, wMajor, wMinor >::EnsureTILoaded(), get_type_info(), get_typeinfo(), get_typelib(), GetRecordInfoFromGuids(), CTipbarAccessible::Initialize(), load_typelib(), NonOleAutomation_GetTypeInfo(), test_libattr(), test_LoadRegTypeLib(), test_register_typelib(), tl_absent(), and tl_present().

◆ LoadTypeLib()

HRESULT WINAPI LoadTypeLib	(	_In_z_ const OLECHAR *	,
		ITypeLib **
	)

◆ LoadTypeLibEx()

_Check_return_ HRESULT WINAPI LoadTypeLibEx	(	LPCOLESTR	szFile,
		REGKIND	regkind,
		ITypeLib **	pptLib
	)

Definition at line 473 of file typelib.c.

{
    WCHAR szPath[MAX_PATH+1];
    HRESULT res;
 
    TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
 
    if (!szFile || !pptLib)
        return E_INVALIDARG;
 
    *pptLib = NULL;
 
    res = TLB_ReadTypeLib(szFile, szPath, MAX_PATH + 1, (ITypeLib2**)pptLib);
 
    if (SUCCEEDED(res))
        switch(regkind)
        {
            case REGKIND_DEFAULT:
                /* don't register typelibs supplied with full path. Experimentation confirms the following */
                if (((szFile[0] == '\\') && (szFile[1] == '\\')) ||
                    (szFile[0] && (szFile[1] == ':'))) break;
                /* else fall-through */
 
            case REGKIND_REGISTER:
                if (FAILED(res = RegisterTypeLib(*pptLib, szPath, NULL)))
                {
                    ITypeLib_Release(*pptLib);
                    *pptLib = 0;
                }
                break;
            case REGKIND_NONE:
                break;
        }
 
    TRACE(" returns %08x\n",res);
    return res;
}

Referenced by load_typelib(), LoadTypeLib(), SEALED_::LoadTypeLibrary(), register_server(), search_res_tlb(), test_CreateTypeLib(), test_dep(), test_dump_typelib(), test_LoadTypeLib(), test_recinfo(), test_register_typelib(), test_SetTypeDescAlias(), and UnRegisterTypeLib().

◆ OaBuildVersion()

ULONG WINAPI OaBuildVersion ( void )

Definition at line 644 of file oleaut.c.

{
    switch(GetVersion() & 0x8000ffff)  /* mask off build number */
    {
    case 0x80000a03:  /* WIN31 */
        return MAKELONG(0xffff, 20);
    case 0x00003303:  /* NT351 */
        return MAKELONG(0xffff, 30);
    case 0x80000004:  /* WIN95; I'd like to use the "standard" w95 minor
                 version here (30), but as we still use w95
                 as default winver (which is good IMHO), I better
                 play safe and use the latest value for w95 for now.
                 Change this as soon as default winver gets changed
                 to something more recent */
    case 0x80000a04:  /* WIN98 */
    case 0x00000004:  /* NT40 */
    case 0x00000005:  /* W2K */
        return MAKELONG(0xffff, 40);
    case 0x00000105:  /* WinXP */
#ifdef __REACTOS__
    case 0x00000205:  /* Win2K3 */
#endif /* __REACTOS__ */
    case 0x00000006:  /* Vista */
    case 0x00000106:  /* Win7 */
        return MAKELONG(0xffff, 50);
    default:
        FIXME("Version value not known yet. Please investigate it !\n");
        return MAKELONG(0xffff, 40);  /* for now return the same value as for w2k */
    }
}

◆ QueryPathOfRegTypeLib()

HRESULT WINAPI QueryPathOfRegTypeLib	(	REFGUID	guid,
		WORD	wMaj,
		WORD	wMin,
		LCID	lcid,
		LPBSTR	path
	)

Definition at line 406 of file typelib.c.

{
    BOOL redir = TRUE;
#ifdef _WIN64
    HRESULT hres = query_typelib_path( guid, wMaj, wMin, SYS_WIN64, lcid, path, TRUE );
    if(SUCCEEDED(hres))
        return hres;
    redir = FALSE;
#endif
    return query_typelib_path( guid, wMaj, wMin, SYS_WIN32, lcid, path, redir );
}

Referenced by ICreateTypeInfo2_fnAddRefTypeInfo(), LoadRegTypeLib(), test_LoadRegTypeLib(), and test_QueryPathOfRegTypeLib().

◆ RegisterActiveObject()

_Check_return_ HRESULT WINAPI RegisterActiveObject	(	LPUNKNOWN	punk,
		REFCLSID	rcid,
		DWORD	dwFlags,
		LPDWORD	pdwRegister
	)

Definition at line 526 of file oleaut.c.

  {
    WCHAR           guidbuf[80];
    HRESULT         ret;
    LPRUNNINGOBJECTTABLE    runobtable;
    LPMONIKER       moniker;
        DWORD                   rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
 
    StringFromGUID2(rcid,guidbuf,39);
    ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
    if (FAILED(ret))
        return ret;
    ret = GetRunningObjectTable(0,&runobtable);
    if (FAILED(ret)) {
        IMoniker_Release(moniker);
        return ret;
    }
        if(dwFlags == ACTIVEOBJECT_WEAK)
          rot_flags = 0;
    ret = IRunningObjectTable_Register(runobtable,rot_flags,punk,moniker,pdwRegister);
    IRunningObjectTable_Release(runobtable);
    IMoniker_Release(moniker);
    return ret;
}

◆ RegisterTypeLib()

_Check_return_ HRESULT WINAPI RegisterTypeLib	(	ITypeLib *	,
		_In_	LPCOLESTR,
		_In_opt_	LPCOLESTR
	)

◆ RegisterTypeLibForUser()

HRESULT WINAPI RegisterTypeLibForUser	(	ITypeLib *	,
		_In_ OLECHAR *	,
		_In_opt_ OLECHAR *
	)

◆ RevokeActiveObject()

HRESULT WINAPI RevokeActiveObject	(	DWORD	xregister,
		LPVOID	reserved
	)

Definition at line 565 of file oleaut.c.

{
    LPRUNNINGOBJECTTABLE    runobtable;
    HRESULT         ret;
 
    ret = GetRunningObjectTable(0,&runobtable);
    if (FAILED(ret)) return ret;
    ret = IRunningObjectTable_Revoke(runobtable,xregister);
    if (SUCCEEDED(ret)) ret = S_OK;
    IRunningObjectTable_Release(runobtable);
    return ret;
}

◆ SafeArrayAccessData()

HRESULT WINAPI SafeArrayAccessData	(	_In_ SAFEARRAY *	,
		void **
	)

◆ SafeArrayAllocData()

HRESULT WINAPI SafeArrayAllocData ( _In_ SAFEARRAY * )

◆ SafeArrayAllocDescriptor()

HRESULT WINAPI SafeArrayAllocDescriptor	(	_In_	UINT,
		_Outptr_ SAFEARRAY **
	)

◆ SafeArrayAllocDescriptorEx()

HRESULT WINAPI SafeArrayAllocDescriptorEx	(	_In_	VARTYPE,
		_In_	UINT,
		_Outptr_ SAFEARRAY **
	)

◆ SafeArrayCopy()

_Check_return_ HRESULT WINAPI SafeArrayCopy	(	_In_ SAFEARRAY *	,
		_Outptr_ SAFEARRAY **
	)

◆ SafeArrayCopyData()

_Check_return_ HRESULT WINAPI SafeArrayCopyData	(	_In_ SAFEARRAY *	,
		_In_ SAFEARRAY *
	)

◆ SafeArrayCreate()

SAFEARRAY *WINAPI SafeArrayCreate	(	_In_	VARTYPE,
		_In_	UINT,
		_In_ SAFEARRAYBOUND *
	)

◆ SafeArrayCreateEx()

SAFEARRAY *WINAPI SafeArrayCreateEx	(	_In_	VARTYPE,
		_In_	UINT,
		_In_ SAFEARRAYBOUND *	,
		_In_	LPVOID
	)

◆ SafeArrayCreateVector()

SAFEARRAY *WINAPI SafeArrayCreateVector	(	_In_	VARTYPE,
		_In_	LONG,
		_In_	ULONG
	)

◆ SafeArrayCreateVectorEx()

SAFEARRAY *WINAPI SafeArrayCreateVectorEx	(	_In_	VARTYPE,
		_In_	LONG,
		_In_	ULONG,
		_In_	LPVOID
	)

◆ SafeArrayDestroy()

HRESULT WINAPI SafeArrayDestroy ( _In_ SAFEARRAY * )

◆ SafeArrayDestroyData()

HRESULT WINAPI SafeArrayDestroyData ( _In_ SAFEARRAY * )

◆ SafeArrayDestroyDescriptor()

HRESULT WINAPI SafeArrayDestroyDescriptor ( _In_ SAFEARRAY * )

◆ SafeArrayGetDim()

UINT WINAPI SafeArrayGetDim ( _In_ SAFEARRAY * )

◆ SafeArrayGetElement()

HRESULT WINAPI SafeArrayGetElement	(	_In_ SAFEARRAY *	,
		LONG *	,
		_Out_ void *
	)

◆ SafeArrayGetElemsize()

UINT WINAPI SafeArrayGetElemsize ( _In_ SAFEARRAY * )

◆ SafeArrayGetIID()

HRESULT WINAPI SafeArrayGetIID	(	_In_ SAFEARRAY *	,
		_Out_ GUID *
	)

◆ SafeArrayGetLBound()

HRESULT WINAPI SafeArrayGetLBound	(	_In_ SAFEARRAY *	,
		_In_	UINT,
		_Out_ LONG *
	)

◆ SafeArrayGetRecordInfo()

HRESULT WINAPI SafeArrayGetRecordInfo	(	_In_ SAFEARRAY *	,
		_Outptr_ IRecordInfo **
	)

◆ SafeArrayGetUBound()

HRESULT WINAPI SafeArrayGetUBound	(	_In_ SAFEARRAY *	,
		_In_	UINT,
		_Out_ LONG *
	)

◆ SafeArrayGetVartype()

HRESULT WINAPI SafeArrayGetVartype	(	_In_ SAFEARRAY *	,
		_Out_ VARTYPE *
	)

◆ SafeArrayLock()

HRESULT WINAPI SafeArrayLock ( _In_ SAFEARRAY * )

◆ SafeArrayPtrOfIndex()

HRESULT WINAPI SafeArrayPtrOfIndex	(	_In_ SAFEARRAY *	psa,
		_In_reads_(psa->cDims) LONG *	,
		_Outptr_result_bytebuffer_(psa->cbElements) void **
	)

◆ SafeArrayPutElement()

_Check_return_ HRESULT WINAPI SafeArrayPutElement	(	_In_ SAFEARRAY *	,
		LONG *	,
		_In_ void *
	)

◆ SafeArrayRedim()

HRESULT WINAPI SafeArrayRedim	(	_Inout_ SAFEARRAY *	,
		_In_ SAFEARRAYBOUND *
	)

◆ SafeArraySetIID()

HRESULT WINAPI SafeArraySetIID	(	_In_ SAFEARRAY *	,
		_In_	REFGUID
	)

◆ SafeArraySetRecordInfo()

HRESULT WINAPI SafeArraySetRecordInfo	(	_In_ SAFEARRAY *	,
		_In_ IRecordInfo *
	)

◆ SafeArrayUnaccessData()

HRESULT WINAPI SafeArrayUnaccessData ( _In_ SAFEARRAY * )

◆ SafeArrayUnlock()

HRESULT WINAPI SafeArrayUnlock ( _In_ SAFEARRAY * )

◆ SetErrorInfo()

HRESULT WINAPI SetErrorInfo	(	_In_	ULONG,
		_In_opt_ IErrorInfo *
	)

◆ SysAllocString()

BSTR WINAPI SysAllocString ( _In_opt_z_ const OLECHAR * )

◆ SysAllocStringByteLen()

BSTR WINAPI SysAllocStringByteLen	(	_In_opt_z_	LPCSTR,
		_In_	UINT
	)

◆ SysFreeString()

void WINAPI SysFreeString ( _In_opt_ BSTR )

◆ SysReAllocString()

INT WINAPI SysReAllocString ( _Inout_ _At_(*,(psz+ 1 ) const

◆ SysReAllocStringLen()

_Check_return_ int WINAPI SysReAllocStringLen ( _Inout_ _At_(*,+ 1len ) const

◆ SystemTimeToVariantTime()

INT WINAPI SystemTimeToVariantTime	(	_In_	LPSYSTEMTIME,
		_Out_ double *
	)

◆ UnRegisterTypeLib()

_Check_return_ HRESULT WINAPI UnRegisterTypeLib	(	REFGUID	libid,
		WORD	wVerMajor,
		WORD	wVerMinor,
		LCID	lcid,
		SYSKIND	syskind
	)

Definition at line 882 of file typelib.c.

{
    BSTR tlibPath = NULL;
    DWORD tmpLength;
    WCHAR keyName[60];
    WCHAR subKeyName[50];
    int result = S_OK;
    DWORD i = 0;
    BOOL deleteOtherStuff;
    HKEY key = NULL;
    TYPEATTR* typeAttr = NULL;
    TYPEKIND kind;
    ITypeInfo* typeInfo = NULL;
    ITypeLib* typeLib = NULL;
    int numTypes;
 
    TRACE("(IID: %s)\n",debugstr_guid(libid));
 
    /* Create the path to the key */
    get_typelib_key( libid, wVerMajor, wVerMinor, keyName );
 
    if (syskind != SYS_WIN16 && syskind != SYS_WIN32 && syskind != SYS_WIN64)
    {
        TRACE("Unsupported syskind %i\n", syskind);
        result = E_INVALIDARG;
        goto end;
    }
 
    /* get the path to the typelib on disk */
    if (query_typelib_path(libid, wVerMajor, wVerMinor, syskind, lcid, &tlibPath, FALSE) != S_OK) {
        result = E_INVALIDARG;
        goto end;
    }
 
    /* Try and open the key to the type library. */
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ | KEY_WRITE, &key) != ERROR_SUCCESS) {
        result = E_INVALIDARG;
        goto end;
    }
 
    /* Try and load the type library */
    if (LoadTypeLibEx(tlibPath, REGKIND_NONE, &typeLib) != S_OK) {
        result = TYPE_E_INVALIDSTATE;
        goto end;
    }
 
    /* remove any types registered with this typelib */
    numTypes = ITypeLib_GetTypeInfoCount(typeLib);
    for (i=0; i<numTypes; i++) {
        /* get the kind of type */
        if (ITypeLib_GetTypeInfoType(typeLib, i, &kind) != S_OK) {
            goto enddeleteloop;
        }
 
        /* skip non-interfaces, and get type info for the type */
        if ((kind != TKIND_INTERFACE) && (kind != TKIND_DISPATCH)) {
            goto enddeleteloop;
        }
        if (ITypeLib_GetTypeInfo(typeLib, i, &typeInfo) != S_OK) {
            goto enddeleteloop;
        }
        if (ITypeInfo_GetTypeAttr(typeInfo, &typeAttr) != S_OK) {
            goto enddeleteloop;
        }
 
        

Classes

Macros

Typedefs

Enumerations

Functions

Variables