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 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;
        }
 
        if ((kind == TKIND_INTERFACE && (typeAttr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
            kind == TKIND_DISPATCH)
        {
            BOOL is_wow64;
            REGSAM opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
 
            TLB_unregister_interface(&typeAttr->guid, 0);
 
            /* unregister TLBs into the opposite registry view, too */
            if(opposite == KEY_WOW64_32KEY ||
               (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)) {
                TLB_unregister_interface(&typeAttr->guid, opposite);
            }
        }
 
enddeleteloop:
        if (typeAttr) ITypeInfo_ReleaseTypeAttr(typeInfo, typeAttr);
        typeAttr = NULL;
        if (typeInfo) ITypeInfo_Release(typeInfo);
        typeInfo = NULL;
    }
 
    /* Now, delete the type library path subkey */
    get_lcid_subkey( lcid, syskind, subKeyName );
    RegDeleteKeyW(key, subKeyName);
    *wcsrchr( subKeyName, '\\' ) = 0;  /* remove last path component */
    RegDeleteKeyW(key, subKeyName);
 
    /* check if there is anything besides the FLAGS/HELPDIR keys.
       If there is, we don't delete them */
    tmpLength = ARRAY_SIZE(subKeyName);
    deleteOtherStuff = TRUE;
    i = 0;
    while(RegEnumKeyExW(key, i++, subKeyName, &tmpLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
        tmpLength = ARRAY_SIZE(subKeyName);
 
        /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
        if (!wcscmp(subKeyName, FLAGSW)) continue;
        if (!wcscmp(subKeyName, HELPDIRW)) continue;
        deleteOtherStuff = FALSE;
        break;
    }
 
    /* only delete the other parts of the key if we're absolutely sure */
    if (deleteOtherStuff) {
        RegDeleteKeyW(key, FLAGSW);
        RegDeleteKeyW(key, HELPDIRW);
        RegCloseKey(key);
        key = NULL;
 
        RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
        *wcsrchr( keyName, '\\' ) = 0;  /* remove last path component */
        RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
    }
 
end:
    SysFreeString(tlibPath);
    if (typeLib) ITypeLib_Release(typeLib);
    if (key) RegCloseKey(key);
    return result;
}

Referenced by ATL::AtlComModuleUnregisterServer(), ITERATE_UnregisterTypeLibraries(), register_server(), START_TEST(), test_register_typelib(), test_stub(), and UnRegisterTypeLibForUser().

UnRegisterTypeLibForUser()

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

Definition at line 1045 of file typelib.c.

{
    FIXME("(%s, %u, %u, %u, %u) unregistering the typelib system-wide\n",
          debugstr_guid(libid), wVerMajor, wVerMinor, lcid, syskind);
    return UnRegisterTypeLib(libid, wVerMajor, wVerMinor, lcid, syskind);
}

VarAbs()

HRESULT WINAPI VarAbs	(	_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarAdd()

HRESULT WINAPI VarAdd	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarAnd()

HRESULT WINAPI VarAnd	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarBoolFromCy()

HRESULT WINAPI VarBoolFromCy	(	CY	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromDate()

HRESULT WINAPI VarBoolFromDate	(	DATE	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromDec()

HRESULT WINAPI VarBoolFromDec	(	_In_ DECIMAL *	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromDisp()

HRESULT WINAPI VarBoolFromDisp	(	IDispatch *	,
		LCID	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromI1()

HRESULT WINAPI VarBoolFromI1	(	signed char	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromI2()

_Check_return_ HRESULT WINAPI VarBoolFromI2	(	_In_	SHORT,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromI4()

HRESULT WINAPI VarBoolFromI4	(	LONG	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromI8()

HRESULT WINAPI VarBoolFromI8	(	LONG64	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromR4()

HRESULT WINAPI VarBoolFromR4	(	FLOAT	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromR8()

HRESULT WINAPI VarBoolFromR8	(	DOUBLE	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromStr()

HRESULT WINAPI VarBoolFromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromUI1()

HRESULT WINAPI VarBoolFromUI1	(	BYTE	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromUI2()

HRESULT WINAPI VarBoolFromUI2	(	USHORT	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromUI4()

HRESULT WINAPI VarBoolFromUI4	(	ULONG	,
		_Out_ VARIANT_BOOL *
	)

VarBoolFromUI8()

HRESULT WINAPI VarBoolFromUI8	(	ULONG64	,
		_Out_ VARIANT_BOOL *
	)

VarBstrCat()

HRESULT WINAPI VarBstrCat	(	_In_	BSTR,
		_In_	BSTR,
		_Out_ BSTR *
	)

VarBstrCmp()

HRESULT WINAPI VarBstrCmp	(	_In_	BSTR,
		_In_	BSTR,
		_In_	LCID,
		_In_	ULONG
	)

VarBstrFromBool()

HRESULT WINAPI VarBstrFromBool	(	VARIANT_BOOL	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromCy()

HRESULT WINAPI VarBstrFromCy	(	CY	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromDate()

HRESULT WINAPI VarBstrFromDate	(	_In_	DATE,
		_In_	LCID,
		_In_	ULONG,
		_Out_ BSTR *
	)

VarBstrFromDec()

HRESULT WINAPI VarBstrFromDec	(	_In_ DECIMAL *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ BSTR *
	)

VarBstrFromDisp()

HRESULT WINAPI VarBstrFromDisp	(	IDispatch *	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromI1()

HRESULT WINAPI VarBstrFromI1	(	signed char	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromI2()

HRESULT WINAPI VarBstrFromI2	(	SHORT	sIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6417 of file vartype.c.

{
  ULONG64 ul64 = sIn;
 
  if (sIn < 0)
  {
    ul64 = -sIn;
    dwFlags |= VAR_NEGATIVE;
  }
  return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromI4()

HRESULT WINAPI VarBstrFromI4	(	LONG	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromI8()

HRESULT WINAPI VarBstrFromI8	(	LONG64	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromR4()

HRESULT WINAPI VarBstrFromR4	(	FLOAT	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromR8()

HRESULT WINAPI VarBstrFromR8	(	DOUBLE	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromUI1()

HRESULT WINAPI VarBstrFromUI1	(	BYTE	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromUI2()

HRESULT WINAPI VarBstrFromUI2	(	USHORT	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromUI4()

HRESULT WINAPI VarBstrFromUI4	(	ULONG	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarBstrFromUI8()

HRESULT WINAPI VarBstrFromUI8	(	ULONG64	,
		LCID	,
		ULONG	,
		_Out_ BSTR *
	)

VarCat()

HRESULT WINAPI VarCat	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarCmp()

HRESULT WINAPI VarCmp	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_In_	LCID,
		_In_	ULONG
	)

VarCyAbs()

HRESULT WINAPI VarCyAbs	(	_In_	CY,
		_Out_ CY *
	)

VarCyAdd()

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

VarCyCmp()

HRESULT WINAPI VarCyCmp	(	_In_	CY,
		_In_	CY
	)

VarCyCmpR8()

HRESULT WINAPI VarCyCmpR8	(	_In_	CY,
		_In_	DOUBLE
	)

VarCyFix()

HRESULT WINAPI VarCyFix	(	_In_	CY,
		_Out_ CY *
	)

VarCyFromBool()

HRESULT WINAPI VarCyFromBool	(	VARIANT_BOOL	,
		_Out_ CY *
	)

VarCyFromDate()

HRESULT WINAPI VarCyFromDate	(	DATE	,
		_Out_ CY *
	)

VarCyFromDec()

HRESULT WINAPI VarCyFromDec	(	_In_ DECIMAL *	,
		_Out_ CY *
	)

VarCyFromDisp()

HRESULT WINAPI VarCyFromDisp	(	_In_ IDispatch *	,
		LCID	,
		_Out_ CY *
	)

VarCyFromI1()

HRESULT WINAPI VarCyFromI1	(	signed char	,
		_Out_ CY *
	)

VarCyFromI2()

HRESULT WINAPI VarCyFromI2	(	SHORT	sIn,
		_Out_ CY *
	)

VarCyFromI4()

HRESULT WINAPI VarCyFromI4	(	LONG	,
		_Out_ CY *
	)

VarCyFromI8()

HRESULT WINAPI VarCyFromI8	(	LONG64	,
		_Out_ CY *
	)

VarCyFromR4()

HRESULT WINAPI VarCyFromR4	(	FLOAT	,
		_Out_ CY *
	)

VarCyFromR8()

HRESULT WINAPI VarCyFromR8	(	DOUBLE	,
		_Out_ CY *
	)

VarCyFromStr()

HRESULT WINAPI VarCyFromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ CY *
	)

VarCyFromUI1()

HRESULT WINAPI VarCyFromUI1	(	BYTE	,
		_Out_ CY *
	)

VarCyFromUI2()

HRESULT WINAPI VarCyFromUI2	(	USHORT	,
		_Out_ CY *
	)

VarCyFromUI4()

HRESULT WINAPI VarCyFromUI4	(	ULONG	,
		_Out_ CY *
	)

VarCyFromUI8()

HRESULT WINAPI VarCyFromUI8	(	ULONG64	,
		_Out_ CY *
	)

VarCyInt()

HRESULT WINAPI VarCyInt	(	_In_	CY,
		_Out_ CY *
	)

VarCyMul()

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

VarCyMulI4()

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

VarCyMulI8()

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

VarCyNeg()

HRESULT WINAPI VarCyNeg	(	_In_	CY,
		_Out_ CY *
	)

VarCyRound()

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

VarCySub()

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

VarDateFromBool()

HRESULT WINAPI VarDateFromBool	(	VARIANT_BOOL	,
		_Out_ DATE *
	)

VarDateFromCy()

HRESULT WINAPI VarDateFromCy	(	CY	,
		_Out_ DATE *
	)

VarDateFromDec()

HRESULT WINAPI VarDateFromDec	(	_In_ DECIMAL *	,
		_Out_ DATE *
	)

VarDateFromDisp()

HRESULT WINAPI VarDateFromDisp	(	IDispatch *	,
		LCID	,
		_Out_ DATE *
	)

VarDateFromI1()

HRESULT WINAPI VarDateFromI1	(	signed char	,
		_Out_ DATE *
	)

VarDateFromI2()

HRESULT WINAPI VarDateFromI2	(	SHORT	,
		_Out_ DATE *
	)

VarDateFromI4()

HRESULT WINAPI VarDateFromI4	(	LONG	,
		_Out_ DATE *
	)

VarDateFromI8()

HRESULT WINAPI VarDateFromI8	(	LONG64	,
		_Out_ DATE *
	)

VarDateFromR4()

HRESULT WINAPI VarDateFromR4	(	FLOAT	,
		_Out_ DATE *
	)

VarDateFromR8()

HRESULT WINAPI VarDateFromR8	(	DOUBLE	,
		_Out_ DATE *
	)

VarDateFromStr()

HRESULT WINAPI VarDateFromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ DATE *
	)

VarDateFromUdate()

_Check_return_ HRESULT WINAPI VarDateFromUdate	(	_In_ UDATE *	,
		_In_	ULONG,
		_Out_ DATE *
	)

VarDateFromUdateEx()

HRESULT WINAPI VarDateFromUdateEx	(	_In_ UDATE *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ DATE *
	)

VarDateFromUI1()

HRESULT WINAPI VarDateFromUI1	(	BYTE	,
		_Out_ DATE *
	)

VarDateFromUI2()

HRESULT WINAPI VarDateFromUI2	(	USHORT	,
		_Out_ DATE *
	)

VarDateFromUI4()

HRESULT WINAPI VarDateFromUI4	(	ULONG	,
		_Out_ DATE *
	)

VarDateFromUI8()

HRESULT WINAPI VarDateFromUI8	(	ULONG64	,
		_Out_ DATE *
	)

VarDecAbs()

HRESULT WINAPI VarDecAbs	(	_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecAdd()

HRESULT WINAPI VarDecAdd	(	_In_ const DECIMAL *	,
		_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecCmp()

HRESULT WINAPI VarDecCmp	(	_In_ const DECIMAL *	,
		_In_ const DECIMAL *
	)

VarDecCmpR8()

HRESULT WINAPI VarDecCmpR8	(	_In_ const DECIMAL *	,
		_In_	DOUBLE
	)

VarDecDiv()

HRESULT WINAPI VarDecDiv	(	_In_ const DECIMAL *	,
		_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecFix()

HRESULT WINAPI VarDecFix	(	_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecFromBool()

HRESULT WINAPI VarDecFromBool	(	_In_	VARIANT_BOOL,
		_Out_ DECIMAL *
	)

VarDecFromCy()

HRESULT WINAPI VarDecFromCy	(	_In_	CY,
		_Out_ DECIMAL *
	)

VarDecFromDate()

HRESULT WINAPI VarDecFromDate	(	_In_	DATE,
		_Out_ DECIMAL *
	)

VarDecFromDisp()

HRESULT WINAPI VarDecFromDisp	(	_In_ IDispatch *	,
		_In_	LCID,
		_Out_ DECIMAL *
	)

VarDecFromI1()

HRESULT WINAPI VarDecFromI1	(	_In_ signed char	,
		_Out_ DECIMAL *
	)

VarDecFromI2()

HRESULT WINAPI VarDecFromI2	(	_In_	SHORT,
		_Out_ DECIMAL *
	)

VarDecFromI4()

HRESULT WINAPI VarDecFromI4	(	_In_	LONG,
		_Out_ DECIMAL *
	)

VarDecFromI8()

HRESULT WINAPI VarDecFromI8	(	LONG64	,
		_Out_ DECIMAL *
	)

VarDecFromR4()

HRESULT WINAPI VarDecFromR4	(	_In_	FLOAT,
		_Out_ DECIMAL *
	)

VarDecFromR8()

HRESULT WINAPI VarDecFromR8	(	_In_	DOUBLE,
		_Out_ DECIMAL *
	)

VarDecFromStr()

HRESULT WINAPI VarDecFromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ DECIMAL *
	)

VarDecFromUI1()

HRESULT WINAPI VarDecFromUI1	(	_In_	BYTE,
		_Out_ DECIMAL *
	)

VarDecFromUI2()

HRESULT WINAPI VarDecFromUI2	(	_In_	USHORT,
		_Out_ DECIMAL *
	)

VarDecFromUI4()

HRESULT WINAPI VarDecFromUI4	(	_In_	ULONG,
		_Out_ DECIMAL *
	)

VarDecFromUI8()

HRESULT WINAPI VarDecFromUI8	(	ULONG64	,
		_Out_ DECIMAL *
	)

VarDecInt()

HRESULT WINAPI VarDecInt	(	_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecMul()

HRESULT WINAPI VarDecMul	(	_In_ const DECIMAL *	,
		_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecNeg()

HRESULT WINAPI VarDecNeg	(	_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDecRound()

HRESULT WINAPI VarDecRound	(	_In_ const DECIMAL *	,
		int	,
		_Out_ DECIMAL *
	)

VarDecSub()

HRESULT WINAPI VarDecSub	(	_In_ const DECIMAL *	,
		_In_ const DECIMAL *	,
		_Out_ DECIMAL *
	)

VarDiv()

HRESULT WINAPI VarDiv	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarEqv()

HRESULT WINAPI VarEqv	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarFix()

HRESULT WINAPI VarFix	(	_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarFormat()

HRESULT WINAPI VarFormat	(	_In_	LPVARIANT,
		_In_opt_	LPOLESTR,
		int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarFormatCurrency()

HRESULT WINAPI VarFormatCurrency	(	_In_	LPVARIANT,
		int	,
		int	,
		int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarFormatDateTime()

HRESULT WINAPI VarFormatDateTime	(	_In_	LPVARIANT,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarFormatFromTokens()

HRESULT WINAPI VarFormatFromTokens	(	_In_	LPVARIANT,
		_In_opt_	LPOLESTR,
		LPBYTE	,
		ULONG	,
		_Out_ BSTR *	,
		LCID
	)

VarFormatNumber()

HRESULT WINAPI VarFormatNumber	(	_In_	LPVARIANT,
		int	,
		int	,
		int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarFormatPercent()

HRESULT WINAPI VarFormatPercent	(	_In_	LPVARIANT,
		int	,
		int	,
		int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarI1FromBool()

HRESULT WINAPI VarI1FromBool	(	_In_	VARIANT_BOOL,
		_Out_ signed char *
	)

VarI1FromCy()

HRESULT WINAPI VarI1FromCy	(	_In_	CY,
		_Out_ signed char *
	)

VarI1FromDate()

HRESULT WINAPI VarI1FromDate	(	_In_	DATE,
		_Out_ signed char *
	)

VarI1FromDec()

HRESULT WINAPI VarI1FromDec	(	_In_ DECIMAL *	,
		_Out_ signed char *
	)

VarI1FromDisp()

HRESULT WINAPI VarI1FromDisp	(	_In_ IDispatch *	,
		_In_	LCID,
		_Out_ signed char *
	)

VarI1FromI2()

HRESULT WINAPI VarI1FromI2	(	_In_	SHORT,
		_Out_ signed char *
	)

VarI1FromI4()

HRESULT WINAPI VarI1FromI4	(	_In_	LONG,
		_Out_ signed char *
	)

VarI1FromI8()

HRESULT WINAPI VarI1FromI8	(	_In_	LONG64,
		_Out_ signed char *
	)

VarI1FromR4()

HRESULT WINAPI VarI1FromR4	(	_In_	FLOAT,
		_Out_ signed char *
	)

VarI1FromR8()

HRESULT WINAPI VarI1FromR8	(	_In_	DOUBLE,
		_Out_ signed char *
	)

VarI1FromStr()

HRESULT WINAPI VarI1FromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ signed char *
	)

VarI1FromUI1()

HRESULT WINAPI VarI1FromUI1	(	_In_	BYTE,
		_Out_ signed char *
	)

VarI1FromUI2()

HRESULT WINAPI VarI1FromUI2	(	_In_	USHORT,
		_Out_ signed char *
	)

VarI1FromUI4()

HRESULT WINAPI VarI1FromUI4	(	_In_	ULONG,
		_Out_ signed char *
	)

VarI1FromUI8()

HRESULT WINAPI VarI1FromUI8	(	_In_	ULONG64,
		_Out_ signed char *
	)

VarI2FromBool()

HRESULT WINAPI VarI2FromBool	(	VARIANT_BOOL	,
		_Out_ SHORT *
	)

VarI2FromCy()

HRESULT WINAPI VarI2FromCy	(	CY	cyIn,
		SHORT *	psOut
	)

Definition at line 978 of file vartype.c.

{
  LONG i = I2_MAX + 1;
 
  VarI4FromCy(cyIn, &i);
  return _VarI2FromI4(i, psOut);
}

Referenced by test_VarI2FromCy(), and VARIANT_Coerce().

VarI2FromDate()

HRESULT WINAPI VarI2FromDate	(	DATE	,
		_Out_ SHORT *
	)

VarI2FromDec()

HRESULT WINAPI VarI2FromDec	(	_In_ DECIMAL *	,
		_Out_ SHORT *
	)

VarI2FromDisp()

HRESULT WINAPI VarI2FromDisp	(	IDispatch *	,
		LCID	,
		_Out_ SHORT *
	)

VarI2FromI1()

HRESULT WINAPI VarI2FromI1	(	signed char	,
		_Out_ SHORT *
	)

VarI2FromI4()

HRESULT WINAPI VarI2FromI4	(	LONG	,
		_Out_ SHORT *
	)

VarI2FromI8()

HRESULT WINAPI VarI2FromI8	(	LONG64	,
		_Out_ SHORT *
	)

VarI2FromR4()

HRESULT WINAPI VarI2FromR4	(	FLOAT	,
		_Out_ SHORT *
	)

VarI2FromR8()

HRESULT WINAPI VarI2FromR8	(	DOUBLE	,
		_Out_ SHORT *
	)

VarI2FromStr()

HRESULT WINAPI VarI2FromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ SHORT *
	)

VarI2FromUI1()

HRESULT WINAPI VarI2FromUI1	(	BYTE	,
		_Out_ SHORT *
	)

VarI2FromUI2()

HRESULT WINAPI VarI2FromUI2	(	USHORT	,
		_Out_ SHORT *
	)

VarI2FromUI4()

HRESULT WINAPI VarI2FromUI4	(	ULONG	,
		_Out_ SHORT *
	)

VarI2FromUI8()

HRESULT WINAPI VarI2FromUI8	(	ULONG64	,
		_Out_ SHORT *
	)

VarI4FromBool()

HRESULT WINAPI VarI4FromBool	(	VARIANT_BOOL	,
		_Out_ LONG *
	)

VarI4FromCy()

HRESULT WINAPI VarI4FromCy	(	CY	,
		_Out_ LONG *
	)

VarI4FromDate()

HRESULT WINAPI VarI4FromDate	(	DATE	,
		_Out_ LONG *
	)

VarI4FromDec()

HRESULT WINAPI VarI4FromDec	(	_In_ DECIMAL *	,
		_Out_ LONG *
	)

VarI4FromDisp()

HRESULT WINAPI VarI4FromDisp	(	IDispatch *	,
		_In_	LCID,
		_Out_ LONG *
	)

VarI4FromI1()

HRESULT WINAPI VarI4FromI1	(	signed char	,
		_Out_ LONG *
	)

VarI4FromI2()

HRESULT WINAPI VarI4FromI2	(	SHORT	,
		_Out_ LONG *
	)

VarI4FromI8()

HRESULT WINAPI VarI4FromI8	(	LONG64	,
		_Out_ LONG *
	)

VarI4FromR4()

HRESULT WINAPI VarI4FromR4	(	FLOAT	,
		_Out_ LONG *
	)

VarI4FromR8()

HRESULT WINAPI VarI4FromR8	(	DOUBLE	,
		_Out_ LONG *
	)

VarI4FromStr()

HRESULT WINAPI VarI4FromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ LONG *
	)

VarI4FromUI1()

HRESULT WINAPI VarI4FromUI1	(	BYTE	,
		_Out_ LONG *
	)

VarI4FromUI2()

HRESULT WINAPI VarI4FromUI2	(	USHORT	,
		_Out_ LONG *
	)

VarI4FromUI4()

HRESULT WINAPI VarI4FromUI4	(	ULONG	,
		_Out_ LONG *
	)

VarI4FromUI8()

HRESULT WINAPI VarI4FromUI8	(	ULONG64	,
		_Out_ LONG *
	)

VarI8FromBool()

HRESULT WINAPI VarI8FromBool	(	VARIANT_BOOL	,
		_Out_ LONG64 *
	)

VarI8FromCy()

HRESULT WINAPI VarI8FromCy	(	_In_	CY,
		_Out_ LONG64 *
	)

VarI8FromDate()

HRESULT WINAPI VarI8FromDate	(	DATE	,
		_Out_ LONG64 *
	)

VarI8FromDec()

HRESULT WINAPI VarI8FromDec	(	_In_ DECIMAL *	pdecIn,
		_Out_ LONG64 *
	)

VarI8FromDisp()

HRESULT WINAPI VarI8FromDisp	(	IDispatch *	,
		_In_	LCID,
		_Out_ LONG64 *
	)

VarI8FromI1()

HRESULT WINAPI VarI8FromI1	(	signed char	,
		_Out_ LONG64 *
	)

VarI8FromI2()

HRESULT WINAPI VarI8FromI2	(	SHORT	,
		_Out_ LONG64 *
	)

VarI8FromI4()

HRESULT WINAPI VarI8FromI4	(	LONG	,
		LONG64 *
	)

VarI8FromInt()

HRESULT WINAPI VarI8FromInt	(	INT	intIn,
		LONG64 *
	)

VarI8FromR4()

HRESULT WINAPI VarI8FromR4	(	FLOAT	,
		_Out_ LONG64 *
	)

VarI8FromR8()

HRESULT WINAPI VarI8FromR8	(	DOUBLE	,
		_Out_ LONG64 *
	)

VarI8FromStr()

HRESULT WINAPI VarI8FromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ LONG64 *
	)

VarI8FromUI1()

HRESULT WINAPI VarI8FromUI1	(	BYTE	,
		_Out_ LONG64 *
	)

VarI8FromUI2()

HRESULT WINAPI VarI8FromUI2	(	USHORT	,
		_Out_ LONG64 *
	)

VarI8FromUI4()

HRESULT WINAPI VarI8FromUI4	(	ULONG	,
		_Out_ LONG64 *
	)

VarI8FromUI8()

HRESULT WINAPI VarI8FromUI8	(	ULONG64	,
		_Out_ LONG64 *
	)

VariantChangeType()

_Check_return_ HRESULT WINAPI VariantChangeType	(	_Inout_ VARIANT *	,
		_In_ VARIANT *	,
		_In_	USHORT,
		_In_	VARTYPE
	)

VariantChangeTypeEx()

_Check_return_ HRESULT WINAPI VariantChangeTypeEx	(	_Inout_ VARIANT *	,
		_In_ VARIANT *	,
		_In_	LCID,
		_In_	USHORT,
		_In_	VARTYPE
	)

VariantClear()

HRESULT WINAPI VariantClear

(

_Inout_ VARIANT *

)

VariantCopy()

_Check_return_ HRESULT WINAPI VariantCopy	(	_Inout_ VARIANT *	,
		_In_ VARIANT *
	)

VariantCopyInd()

_Check_return_ HRESULT WINAPI VariantCopyInd	(	_Inout_ VARIANT *	,
		_In_ VARIANT *
	)

VariantInit()

void WINAPI VariantInit

(

_Out_ VARIANT *

)

VariantTimeToDosDateTime()

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

VariantTimeToSystemTime()

INT WINAPI VariantTimeToSystemTime	(	_In_	DOUBLE,
		_Out_	LPSYSTEMTIME
	)

VarIdiv()

HRESULT WINAPI VarIdiv	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarImp()

HRESULT WINAPI VarImp	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarInt()

HRESULT WINAPI VarInt	(	_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarMod()

HRESULT WINAPI VarMod	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarMonthName()

HRESULT WINAPI VarMonthName	(	int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarMul()

HRESULT WINAPI VarMul	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarNeg()

HRESULT WINAPI VarNeg	(	_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarNot()

HRESULT WINAPI VarNot	(	_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarNumFromParseNum()

_Check_return_ HRESULT WINAPI VarNumFromParseNum	(	_In_ NUMPARSE *	,
		_In_ BYTE *	,
		_In_	ULONG,
		_Out_ VARIANT *
	)

VarOr()

HRESULT WINAPI VarOr	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarParseNumFromStr()

_Check_return_ HRESULT WINAPI VarParseNumFromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ NUMPARSE *	,
		_Out_ BYTE *
	)

VarPow()

HRESULT WINAPI VarPow	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarR4CmpR8()

HRESULT WINAPI VarR4CmpR8	(	_In_ float	,
		_In_ double
	)

VarR4FromBool()

HRESULT WINAPI VarR4FromBool	(	VARIANT_BOOL	,
		_Out_ FLOAT *
	)

VarR4FromCy()

HRESULT WINAPI VarR4FromCy	(	CY	cyIn,
		FLOAT *	pFltOut
	)

Definition at line 2790 of file vartype.c.

{
  *pFltOut = (double)cyIn.int64 / CY_MULTIPLIER_F;
  return S_OK;
}

Referenced by test_VarR4FromCy(), and VARIANT_Coerce().

VarR4FromDate()

HRESULT WINAPI VarR4FromDate	(	DATE	,
		_Out_ FLOAT *
	)

VarR4FromDec()

HRESULT WINAPI VarR4FromDec	(	_In_ DECIMAL *	,
		_Out_ FLOAT *
	)

VarR4FromDisp()

HRESULT WINAPI VarR4FromDisp	(	IDispatch *	,
		LCID	,
		_Out_ FLOAT *
	)

VarR4FromI1()

HRESULT WINAPI VarR4FromI1	(	signed char	,
		_Out_ FLOAT *
	)

VarR4FromI2()

HRESULT WINAPI VarR4FromI2	(	SHORT	,
		_Out_ FLOAT *
	)

VarR4FromI4()

HRESULT WINAPI VarR4FromI4	(	LONG	,
		_Out_ FLOAT *
	)

VarR4FromI8()

HRESULT WINAPI VarR4FromI8	(	LONG64	,
		_Out_ FLOAT *
	)

VarR4FromR8()

HRESULT WINAPI VarR4FromR8	(	DOUBLE	,
		_Out_ FLOAT *
	)

VarR4FromStr()

HRESULT WINAPI VarR4FromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ FLOAT *
	)

VarR4FromUI1()

HRESULT WINAPI VarR4FromUI1	(	BYTE	,
		_Out_ FLOAT *
	)

VarR4FromUI2()

HRESULT WINAPI VarR4FromUI2	(	USHORT	,
		_Out_ FLOAT *
	)

VarR4FromUI4()

HRESULT WINAPI VarR4FromUI4	(	ULONG	,
		_Out_ FLOAT *
	)

VarR4FromUI8()

HRESULT WINAPI VarR4FromUI8	(	ULONG64	,
		_Out_ FLOAT *
	)

VarR8FromBool()

HRESULT WINAPI VarR8FromBool	(	VARIANT_BOOL	,
		_Out_ double *
	)

VarR8FromCy()

HRESULT WINAPI VarR8FromCy	(	CY	cyIn,
		double *	pDblOut
	)

Definition at line 3113 of file vartype.c.

{
  return _VarR8FromCy(cyIn, pDblOut);
}

Referenced by test_VarAdd(), test_VarMul(), test_VarR8FromCy(), test_VarSub(), VarDateFromCy(), and VARIANT_Coerce().

VarR8FromDate()

HRESULT WINAPI VarR8FromDate	(	DATE	,
		_Out_ double *
	)

VarR8FromDec()

HRESULT WINAPI VarR8FromDec	(	_In_ const DECIMAL *	,
		_Out_ double *
	)

VarR8FromDisp()

HRESULT WINAPI VarR8FromDisp	(	IDispatch *	,
		LCID	,
		_Out_ double *
	)

VarR8FromI1()

HRESULT WINAPI VarR8FromI1	(	signed char	cIn,
		double *	pDblOut
	)

Definition at line 3209 of file vartype.c.

{
  return _VarR8FromI1(cIn, pDblOut);
}

Referenced by test_VarR8FromI1(), VarDateFromI1(), and VARIANT_Coerce().

VarR8FromI2()

HRESULT WINAPI VarR8FromI2	(	SHORT	,
		_Out_ double *
	)

VarR8FromI4()

HRESULT WINAPI VarR8FromI4	(	LONG	,
		_Out_ double *
	)

VarR8FromI8()

HRESULT WINAPI VarR8FromI8	(	LONG64	,
		_Out_ double *
	)

VarR8FromR4()

HRESULT WINAPI VarR8FromR4	(	FLOAT	,
		_Out_ double *
	)

VarR8FromStr()

HRESULT WINAPI VarR8FromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ double *
	)

VarR8FromUI1()

HRESULT WINAPI VarR8FromUI1	(	BYTE	,
		_Out_ double *
	)

VarR8FromUI2()

HRESULT WINAPI VarR8FromUI2	(	USHORT	,
		_Out_ double *
	)

VarR8FromUI4()

HRESULT WINAPI VarR8FromUI4	(	ULONG	,
		_Out_ double *
	)

VarR8FromUI8()

HRESULT WINAPI VarR8FromUI8	(	ULONG64	,
		_Out_ double *
	)

VarR8Pow()

HRESULT WINAPI VarR8Pow	(	_In_ double	,
		_In_ double	,
		_Out_ double *
	)

VarR8Round()

HRESULT WINAPI VarR8Round	(	_In_ double	,
		_In_ int	,
		_Out_ double *
	)

VarRound()

HRESULT WINAPI VarRound	(	_In_	LPVARIANT,
		_In_ int	,
		_Out_	LPVARIANT
	)

VarSub()

HRESULT WINAPI VarSub	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VarTokenizeFormatString()

HRESULT WINAPI VarTokenizeFormatString	(	_In_opt_	LPOLESTR,
		_Inout_	LPBYTE,
		int	,
		int	,
		int	,
		LCID	,
		_In_opt_ int *
	)

VarUdateFromDate()

_Check_return_ HRESULT WINAPI VarUdateFromDate	(	_In_	DATE,
		_In_	ULONG,
		_Out_ UDATE *
	)

VarUI1FromBool()

HRESULT WINAPI VarUI1FromBool	(	VARIANT_BOOL	,
		_Out_ BYTE *
	)

VarUI1FromCy()

HRESULT WINAPI VarUI1FromCy	(	CY	,
		_Out_ BYTE *
	)

VarUI1FromDate()

HRESULT WINAPI VarUI1FromDate	(	DATE	,
		_Out_ BYTE *
	)

VarUI1FromDec()

HRESULT WINAPI VarUI1FromDec	(	_In_ DECIMAL *	,
		_Out_ BYTE *
	)

VarUI1FromDisp()

HRESULT WINAPI VarUI1FromDisp	(	IDispatch *	,
		LCID	,
		_Out_ BYTE *
	)

VarUI1FromI1()

HRESULT WINAPI VarUI1FromI1	(	signed char	,
		_Out_ BYTE *
	)

VarUI1FromI2()

HRESULT WINAPI VarUI1FromI2	(	SHORT	,
		_Out_ BYTE *
	)

VarUI1FromI4()

HRESULT WINAPI VarUI1FromI4	(	LONG	,
		_Out_ BYTE *
	)

VarUI1FromI8()

HRESULT WINAPI VarUI1FromI8	(	LONG64	,
		_Out_ BYTE *
	)

VarUI1FromR4()

HRESULT WINAPI VarUI1FromR4	(	FLOAT	,
		_Out_ BYTE *
	)

VarUI1FromR8()

HRESULT WINAPI VarUI1FromR8	(	DOUBLE	,
		_Out_ BYTE *
	)

VarUI1FromStr()

HRESULT WINAPI VarUI1FromStr	(	_In_ OLECHAR *	,
		LCID	,
		ULONG	,
		_Out_ BYTE *
	)

VarUI1FromUI2()

HRESULT WINAPI VarUI1FromUI2	(	USHORT	,
		_Out_ BYTE *
	)

VarUI1FromUI4()

HRESULT WINAPI VarUI1FromUI4	(	ULONG	,
		_Out_ BYTE *
	)

VarUI1FromUI8()

HRESULT WINAPI VarUI1FromUI8	(	ULONG64	,
		_Out_ BYTE *
	)

VarUI2FromBool()

HRESULT WINAPI VarUI2FromBool	(	VARIANT_BOOL	,
		_Out_ USHORT *
	)

VarUI2FromCy()

HRESULT WINAPI VarUI2FromCy	(	CY	,
		_Out_ USHORT *
	)

VarUI2FromDate()

HRESULT WINAPI VarUI2FromDate	(	DATE	,
		_Out_ USHORT *
	)

VarUI2FromDec()

HRESULT WINAPI VarUI2FromDec	(	_In_ DECIMAL *	,
		_Out_ USHORT *
	)

VarUI2FromDisp()

HRESULT WINAPI VarUI2FromDisp	(	_In_ IDispatch *	,
		LCID	,
		_Out_ USHORT *
	)

VarUI2FromI1()

HRESULT WINAPI VarUI2FromI1	(	signed char	,
		_Out_ USHORT *
	)

VarUI2FromI2()

HRESULT WINAPI VarUI2FromI2	(	SHORT	,
		_Out_ USHORT *
	)

VarUI2FromI4()

HRESULT WINAPI VarUI2FromI4	(	LONG	,
		_Out_ USHORT *
	)

VarUI2FromI8()

HRESULT WINAPI VarUI2FromI8	(	LONG64	,
		_Out_ USHORT *
	)

VarUI2FromR4()

HRESULT WINAPI VarUI2FromR4	(	FLOAT	,
		_Out_ USHORT *
	)

VarUI2FromR8()

HRESULT WINAPI VarUI2FromR8	(	DOUBLE	dblIn,
		USHORT *	pusOut
	)

Definition at line 1269 of file vartype.c.

{
  if (dblIn < -0.5 || dblIn >= UI2_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(USHORT, dblIn, *pusOut);
  return S_OK;
}

Referenced by test_VarUI2FromR8(), VARIANT_Coerce(), VarUI2FromDate(), and VarUI2FromR4().

VarUI2FromStr()

HRESULT WINAPI VarUI2FromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ USHORT *
	)

VarUI2FromUI1()

HRESULT WINAPI VarUI2FromUI1	(	BYTE	,
		_Out_ USHORT *
	)

VarUI2FromUI4()

HRESULT WINAPI VarUI2FromUI4	(	ULONG	,
		_Out_ USHORT *
	)

VarUI2FromUI8()

HRESULT WINAPI VarUI2FromUI8	(	ULONG64	,
		_Out_ USHORT *
	)

VarUI4FromBool()

HRESULT WINAPI VarUI4FromBool	(	VARIANT_BOOL	,
		_Out_ ULONG *
	)

VarUI4FromCy()

HRESULT WINAPI VarUI4FromCy	(	CY	,
		_Out_ ULONG *
	)

VarUI4FromDate()

HRESULT WINAPI VarUI4FromDate	(	DATE	,
		_Out_ ULONG *
	)

VarUI4FromDec()

HRESULT WINAPI VarUI4FromDec	(	_In_ DECIMAL *	,
		_Out_ ULONG *
	)

VarUI4FromDisp()

HRESULT WINAPI VarUI4FromDisp	(	_In_ IDispatch *	,
		LCID	,
		_Out_ ULONG *
	)

VarUI4FromI1()

HRESULT WINAPI VarUI4FromI1	(	signed char	,
		_Out_ ULONG *
	)

VarUI4FromI2()

HRESULT WINAPI VarUI4FromI2	(	_In_	SHORT,
		_Out_ ULONG *
	)

VarUI4FromI4()

HRESULT WINAPI VarUI4FromI4	(	LONG	,
		_Out_ ULONG *
	)

VarUI4FromI8()

HRESULT WINAPI VarUI4FromI8	(	LONG64	,
		_Out_ ULONG *
	)

VarUI4FromR4()

HRESULT WINAPI VarUI4FromR4	(	FLOAT	,
		_Out_ ULONG *
	)

VarUI4FromR8()

HRESULT WINAPI VarUI4FromR8	(	DOUBLE	,
		_Out_ ULONG *
	)

VarUI4FromStr()

HRESULT WINAPI VarUI4FromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ ULONG *
	)

VarUI4FromUI1()

HRESULT WINAPI VarUI4FromUI1	(	BYTE	,
		_Out_ ULONG *
	)

VarUI4FromUI2()

HRESULT WINAPI VarUI4FromUI2	(	USHORT	,
		_Out_ ULONG *
	)

VarUI4FromUI8()

HRESULT WINAPI VarUI4FromUI8	(	ULONG64	,
		_Out_ ULONG *
	)

VarUI8FromBool()

HRESULT WINAPI VarUI8FromBool	(	VARIANT_BOOL	,
		_Out_ ULONG64 *
	)

VarUI8FromCy()

HRESULT WINAPI VarUI8FromCy	(	CY	,
		_Out_ ULONG64 *
	)

VarUI8FromDate()

HRESULT WINAPI VarUI8FromDate	(	DATE	,
		_Out_ ULONG64 *
	)

VarUI8FromDec()

HRESULT WINAPI VarUI8FromDec	(	_In_ DECIMAL *	,
		_Out_ ULONG64 *
	)

VarUI8FromDisp()

HRESULT WINAPI VarUI8FromDisp	(	_In_ IDispatch *	,
		LCID	,
		_Out_ ULONG64 *
	)

VarUI8FromI1()

HRESULT WINAPI VarUI8FromI1	(	signed char	,
		_Out_ ULONG64 *
	)

VarUI8FromI2()

HRESULT WINAPI VarUI8FromI2	(	SHORT	,
		_Out_ ULONG64 *
	)

VarUI8FromI4()

HRESULT WINAPI VarUI8FromI4	(	LONG	,
		_Out_ ULONG64 *
	)

VarUI8FromI8()

HRESULT WINAPI VarUI8FromI8	(	LONG64	,
		_Out_ ULONG64 *
	)

VarUI8FromInt()

HRESULT WINAPI VarUI8FromInt	(	INT	,
		ULONG64 *
	)

VarUI8FromR4()

HRESULT WINAPI VarUI8FromR4	(	FLOAT	,
		_Out_ ULONG64 *
	)

VarUI8FromR8()

HRESULT WINAPI VarUI8FromR8	(	DOUBLE	,
		_Out_ ULONG64 *
	)

VarUI8FromStr()

HRESULT WINAPI VarUI8FromStr	(	_In_ OLECHAR *	,
		_In_	LCID,
		_In_	ULONG,
		_Out_ ULONG64 *
	)

VarUI8FromUI1()

HRESULT WINAPI VarUI8FromUI1	(	BYTE	,
		_Out_ ULONG64 *
	)

VarUI8FromUI2()

HRESULT WINAPI VarUI8FromUI2	(	USHORT	,
		_Out_ ULONG64 *
	)

VarUI8FromUI4()

HRESULT WINAPI VarUI8FromUI4	(	ULONG	,
		_Out_ ULONG64 *
	)

VarWeekdayName()

HRESULT WINAPI VarWeekdayName	(	int	,
		int	,
		int	,
		ULONG	,
		_Out_ BSTR *
	)

VarXor()

HRESULT WINAPI VarXor	(	_In_	LPVARIANT,
		_In_	LPVARIANT,
		_Out_	LPVARIANT
	)

VectorFromBstr()

_Check_return_ HRESULT WINAPI VectorFromBstr	(	_In_	BSTR,
		_Outptr_ SAFEARRAY **
	)

Variable Documentation

ui

UINT ui

Definition at line 49 of file oleauto.h.

Referenced by _chm_parse_PMGL_entry(), CRegPropertyBag::_GetStreamSize(), atan2(), chm_enumerate_dir(), chm_resolve_object(), chm_retrieve_object(), execute_list(), InstallerImpl_UILevel(), ITSS_chm_enumerator(), ITSS_create_stream(), ITSS_IStorageImpl_OpenStream(), ntlm_InitializeSecurityContextW(), SystemFunction004(), SystemFunction005(), test_marshal_basetypes(), test_UninitializedUri(), CTaskSwitchWnd::UpdateButtonsSize(), Widget_basetypes_in(), Widget_basetypes_out(), and x86_64_fetch_minidump_module().