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

Go to the source code of this file.

Classes

struct  UDATE
 
struct  NUMPARSE
 
struct  tagPARAMDATA
 
struct  tagMETHODDATA
 
struct  tagINTERFACEDATA
 

Macros

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

Typedefs

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

Enumerations

enum  tagREGKIND { REGKIND_DEFAULT, REGKIND_REGISTER, REGKIND_NONE }
 

Functions

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

Variables

UINT ui
 

Macro Definition Documentation

◆ ACTIVEOBJECT_STRONG

#define ACTIVEOBJECT_STRONG   0

Definition at line 181 of file oleauto.h.

◆ ACTIVEOBJECT_WEAK

#define ACTIVEOBJECT_WEAK   1

Definition at line 182 of file oleauto.h.

◆ DISPATCH_METHOD

#define DISPATCH_METHOD   0x1

Definition at line 1006 of file oleauto.h.

◆ DISPATCH_PROPERTYGET

#define DISPATCH_PROPERTYGET   0x2

Definition at line 1007 of file oleauto.h.

◆ DISPATCH_PROPERTYPUT

#define DISPATCH_PROPERTYPUT   0x4

Definition at line 1008 of file oleauto.h.

◆ DISPATCH_PROPERTYPUTREF

#define DISPATCH_PROPERTYPUTREF   0x8

Definition at line 1009 of file oleauto.h.

◆ ID_DEFAULTINST

#define ID_DEFAULTINST   -2

Definition at line 1004 of file oleauto.h.

◆ IsHashValCompatible

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

Definition at line 1001 of file oleauto.h.

◆ LHashValOfName

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

Definition at line 999 of file oleauto.h.

◆ LOAD_TLB_AS_32BIT

#define LOAD_TLB_AS_32BIT   0x20

Definition at line 1011 of file oleauto.h.

◆ LOAD_TLB_AS_64BIT

#define LOAD_TLB_AS_64BIT   0x40

Definition at line 1012 of file oleauto.h.

◆ LOCALE_USE_NLS

#define LOCALE_USE_NLS   0x10000000

Definition at line 338 of file oleauto.h.

◆ MASK_TO_RESET_TLB_BITS

#define MASK_TO_RESET_TLB_BITS   ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)

Definition at line 1013 of file oleauto.h.

◆ MEMBERID_NIL

#define MEMBERID_NIL   DISPID_UNKNOWN

Definition at line 1003 of file oleauto.h.

◆ NUMPRS_CURRENCY

#define NUMPRS_CURRENCY   0x00400 /* Currency symbol */

Definition at line 745 of file oleauto.h.

◆ NUMPRS_DECIMAL

#define NUMPRS_DECIMAL   0x00100 /* Decimal separator */

Definition at line 743 of file oleauto.h.

◆ NUMPRS_EXPONENT

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

Definition at line 746 of file oleauto.h.

◆ NUMPRS_HEX_OCT

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

Definition at line 741 of file oleauto.h.

◆ NUMPRS_INEXACT

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

Definition at line 750 of file oleauto.h.

◆ NUMPRS_LEADING_MINUS

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

Definition at line 739 of file oleauto.h.

◆ NUMPRS_LEADING_PLUS

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

Definition at line 737 of file oleauto.h.

◆ NUMPRS_LEADING_WHITE

#define NUMPRS_LEADING_WHITE   0x00001 /* Leading whitespace */

Definition at line 735 of file oleauto.h.

◆ NUMPRS_NEG

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

Definition at line 749 of file oleauto.h.

◆ NUMPRS_PARENS

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

Definition at line 742 of file oleauto.h.

◆ NUMPRS_STD

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

Definition at line 748 of file oleauto.h.

◆ NUMPRS_THOUSANDS

#define NUMPRS_THOUSANDS   0x00200 /* Thousands separator */

Definition at line 744 of file oleauto.h.

◆ NUMPRS_TRAILING_MINUS

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

Definition at line 740 of file oleauto.h.

◆ NUMPRS_TRAILING_PLUS

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

Definition at line 738 of file oleauto.h.

◆ NUMPRS_TRAILING_WHITE

#define NUMPRS_TRAILING_WHITE   0x00002 /* Trailing whitespace */

Definition at line 736 of file oleauto.h.

◆ NUMPRS_USE_ALL

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

Definition at line 747 of file oleauto.h.

◆ STDOLE2_LCID

#define STDOLE2_LCID   0

Definition at line 36 of file oleauto.h.

◆ STDOLE2_MAJORVERNUM

#define STDOLE2_MAJORVERNUM   2

Definition at line 34 of file oleauto.h.

◆ STDOLE2_MINORVERNUM

#define STDOLE2_MINORVERNUM   0

Definition at line 35 of file oleauto.h.

◆ STDOLE_LCID

#define STDOLE_LCID   0

Definition at line 32 of file oleauto.h.

◆ STDOLE_MAJORVERNUM

#define STDOLE_MAJORVERNUM   1

Definition at line 30 of file oleauto.h.

◆ STDOLE_MINORVERNUM

#define STDOLE_MINORVERNUM   0

Definition at line 31 of file oleauto.h.

◆ V_ARRAY

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

Definition at line 222 of file oleauto.h.

◆ V_ARRAYREF

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

Definition at line 223 of file oleauto.h.

◆ V_BOOL

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

Definition at line 224 of file oleauto.h.

◆ V_BOOLREF

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

Definition at line 225 of file oleauto.h.

◆ V_BSTR

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

Definition at line 226 of file oleauto.h.

◆ V_BSTRREF

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

Definition at line 227 of file oleauto.h.

◆ V_BYREF

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

Definition at line 228 of file oleauto.h.

◆ V_CY

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

Definition at line 229 of file oleauto.h.

◆ V_CYREF

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

Definition at line 230 of file oleauto.h.

◆ V_DATE

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

Definition at line 231 of file oleauto.h.

◆ V_DATEREF

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

Definition at line 232 of file oleauto.h.

◆ V_DECIMAL

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

Definition at line 236 of file oleauto.h.

◆ V_DECIMALREF

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

Definition at line 238 of file oleauto.h.

◆ V_DISPATCH

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

Definition at line 239 of file oleauto.h.

◆ V_DISPATCHREF

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

Definition at line 240 of file oleauto.h.

◆ V_ERROR

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

Definition at line 241 of file oleauto.h.

◆ V_ERRORREF

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

Definition at line 242 of file oleauto.h.

◆ V_I1

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

Definition at line 243 of file oleauto.h.

◆ V_I1REF

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

Definition at line 244 of file oleauto.h.

◆ V_I2

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

Definition at line 245 of file oleauto.h.

◆ V_I2REF

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

Definition at line 246 of file oleauto.h.

◆ V_I4

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

Definition at line 247 of file oleauto.h.

◆ V_I4REF

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

Definition at line 248 of file oleauto.h.

◆ V_I8

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

Definition at line 249 of file oleauto.h.

◆ V_I8REF

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

Definition at line 250 of file oleauto.h.

◆ V_INT

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

Definition at line 251 of file oleauto.h.

◆ V_INT_PTR

#define V_INT_PTR (   A)    V_I4(A)

Definition at line 257 of file oleauto.h.

◆ V_INT_PTRREF

#define V_INT_PTRREF (   A)    V_I4REF(A)

Definition at line 258 of file oleauto.h.

◆ V_INTREF

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

Definition at line 252 of file oleauto.h.

◆ V_ISARRAY

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

Definition at line 218 of file oleauto.h.

◆ V_ISBYREF

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

Definition at line 217 of file oleauto.h.

◆ V_ISVECTOR

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

Definition at line 219 of file oleauto.h.

◆ V_NONE

#define V_NONE (   A)    V_I2(A)

Definition at line 220 of file oleauto.h.

◆ V_R4

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

Definition at line 260 of file oleauto.h.

◆ V_R4REF

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

Definition at line 261 of file oleauto.h.

◆ V_R8

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

Definition at line 262 of file oleauto.h.

◆ V_R8REF

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

Definition at line 263 of file oleauto.h.

◆ V_RECORD

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

Definition at line 213 of file oleauto.h.

◆ V_RECORDINFO

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

Definition at line 214 of file oleauto.h.

◆ V_UI1

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

Definition at line 266 of file oleauto.h.

◆ V_UI1REF

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

Definition at line 267 of file oleauto.h.

◆ V_UI2

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

Definition at line 268 of file oleauto.h.

◆ V_UI2REF

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

Definition at line 269 of file oleauto.h.

◆ V_UI4

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

Definition at line 270 of file oleauto.h.

◆ V_UI4REF

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

Definition at line 271 of file oleauto.h.

◆ V_UI8

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

Definition at line 272 of file oleauto.h.

◆ V_UI8REF

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

Definition at line 273 of file oleauto.h.

◆ V_UINT

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

Definition at line 264 of file oleauto.h.

◆ V_UINT_PTR

#define V_UINT_PTR (   A)    V_UI4(A)

Definition at line 278 of file oleauto.h.

◆ V_UINT_PTRREF

#define V_UINT_PTRREF (   A)    V_UI4REF(A)

Definition at line 279 of file oleauto.h.

◆ V_UINTREF

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

Definition at line 265 of file oleauto.h.

◆ V_UNION

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

Definition at line 212 of file oleauto.h.

◆ V_UNKNOWN

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

Definition at line 281 of file oleauto.h.

◆ V_UNKNOWNREF

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

Definition at line 282 of file oleauto.h.

◆ V_VARIANTREF

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

Definition at line 283 of file oleauto.h.

◆ V_VT

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

Definition at line 211 of file oleauto.h.

◆ VAR_CALENDAR_GREGORIAN

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

Definition at line 334 of file oleauto.h.

◆ VAR_CALENDAR_HIJRI

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

Definition at line 329 of file oleauto.h.

◆ VAR_CALENDAR_THAI

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

Definition at line 333 of file oleauto.h.

◆ VAR_DATEVALUEONLY

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

Definition at line 327 of file oleauto.h.

◆ VAR_FORMAT_NOSUBSTITUTE

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

Definition at line 331 of file oleauto.h.

◆ VAR_FOURDIGITYEARS

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

Definition at line 332 of file oleauto.h.

◆ VAR_LOCALBOOL

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

Definition at line 330 of file oleauto.h.

◆ VAR_TIMEVALUEONLY

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

Definition at line 326 of file oleauto.h.

◆ VAR_VALIDDATE

#define VAR_VALIDDATE   0x004

Definition at line 328 of file oleauto.h.

◆ VarBoolFromInt

#define VarBoolFromInt   VarBoolFromI4

Definition at line 607 of file oleauto.h.

◆ VarBoolFromUint

#define VarBoolFromUint   VarBoolFromUI4

Definition at line 608 of file oleauto.h.

◆ VarBstrFromInt

#define VarBstrFromInt   VarBstrFromI4

Definition at line 605 of file oleauto.h.

◆ VarBstrFromUint

#define VarBstrFromUint   VarBstrFromUI4

Definition at line 606 of file oleauto.h.

◆ VARCMP_EQ

#define VARCMP_EQ   1

Definition at line 658 of file oleauto.h.

◆ VARCMP_GT

#define VARCMP_GT   2

Definition at line 659 of file oleauto.h.

◆ VARCMP_LT

#define VARCMP_LT   0

Definition at line 657 of file oleauto.h.

◆ VARCMP_NULL

#define VARCMP_NULL   3

Definition at line 660 of file oleauto.h.

◆ VarCyFromInt

#define VarCyFromInt   VarCyFromI4

Definition at line 603 of file oleauto.h.

◆ VarCyFromUint

#define VarCyFromUint   VarCyFromUI4

Definition at line 604 of file oleauto.h.

◆ VarDateFromInt

#define VarDateFromInt   VarDateFromI4

Definition at line 601 of file oleauto.h.

◆ VarDateFromUint

#define VarDateFromUint   VarDateFromUI4

Definition at line 602 of file oleauto.h.

◆ VarDecFromInt

#define VarDecFromInt   VarDecFromI4

Definition at line 617 of file oleauto.h.

◆ VarDecFromUint

#define VarDecFromUint   VarDecFromUI4

Definition at line 618 of file oleauto.h.

◆ VarI1FromInt

#define VarI1FromInt   VarI1FromI4

Definition at line 609 of file oleauto.h.

◆ VarI1FromUint

#define VarI1FromUint   VarI1FromUI4

Definition at line 610 of file oleauto.h.

◆ VarI2FromInt

#define VarI2FromInt   VarI2FromI4

Definition at line 591 of file oleauto.h.

◆ VarI2FromUint

#define VarI2FromUint   VarI2FromUI4

Definition at line 592 of file oleauto.h.

◆ VarI4FromI4

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

Definition at line 587 of file oleauto.h.

◆ VarI4FromInt

#define VarI4FromInt   VarI4FromI4

Definition at line 593 of file oleauto.h.

◆ VarI4FromUint

#define VarI4FromUint   VarI4FromUI4

Definition at line 594 of file oleauto.h.

◆ VarI8FromInt

#define VarI8FromInt   VarI8FromI4

Definition at line 595 of file oleauto.h.

◆ VarI8FromUint

#define VarI8FromUint   VarI8FromUI4

Definition at line 596 of file oleauto.h.

◆ VARIANT_ALPHABOOL

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

Definition at line 311 of file oleauto.h.

◆ VARIANT_CALENDAR_GREGORIAN

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

Definition at line 316 of file oleauto.h.

◆ VARIANT_CALENDAR_HIJRI

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

Definition at line 313 of file oleauto.h.

◆ VARIANT_CALENDAR_THAI

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

Definition at line 315 of file oleauto.h.

◆ VARIANT_LOCALBOOL

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

Definition at line 314 of file oleauto.h.

◆ VARIANT_NOUSEROVERRIDE

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

Definition at line 312 of file oleauto.h.

◆ VARIANT_NOVALUEPROP

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

Definition at line 310 of file oleauto.h.

◆ VARIANT_USE_NLS

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

Definition at line 317 of file oleauto.h.

◆ VarIntFromBool

#define VarIntFromBool   VarI4FromBool

Definition at line 629 of file oleauto.h.

◆ VarIntFromCy

#define VarIntFromCy   VarI4FromCy

Definition at line 626 of file oleauto.h.

◆ VarIntFromDate

#define VarIntFromDate   VarI4FromDate

Definition at line 625 of file oleauto.h.

◆ VarIntFromDec

#define VarIntFromDec   VarI4FromDec

Definition at line 634 of file oleauto.h.

◆ VarIntFromDisp

#define VarIntFromDisp   VarI4FromDisp

Definition at line 628 of file oleauto.h.

◆ VarIntFromI1

#define VarIntFromI1   VarI4FromI1

Definition at line 630 of file oleauto.h.

◆ VarIntFromI2

#define VarIntFromI2   VarI4FromI2

Definition at line 620 of file oleauto.h.

◆ VarIntFromI4

#define VarIntFromI4   VarI4FromI4

Definition at line 621 of file oleauto.h.

◆ VarIntFromI8

#define VarIntFromI8   VarI4FromI8

Definition at line 622 of file oleauto.h.

◆ VarIntFromR4

#define VarIntFromR4   VarI4FromR4

Definition at line 623 of file oleauto.h.

◆ VarIntFromR8

#define VarIntFromR8   VarI4FromR8

Definition at line 624 of file oleauto.h.

◆ VarIntFromStr

#define VarIntFromStr   VarI4FromStr

Definition at line 627 of file oleauto.h.

◆ VarIntFromUI1

#define VarIntFromUI1   VarI4FromUI1

Definition at line 619 of file oleauto.h.

◆ VarIntFromUI2

#define VarIntFromUI2   VarI4FromUI2

Definition at line 631 of file oleauto.h.

◆ VarIntFromUI4

#define VarIntFromUI4   VarI4FromUI4

Definition at line 632 of file oleauto.h.

◆ VarIntFromUI8

#define VarIntFromUI8   VarI4FromUI8

Definition at line 633 of file oleauto.h.

◆ VarIntFromUint

#define VarIntFromUint   VarI4FromUI4

Definition at line 635 of file oleauto.h.

◆ VarR4FromInt

#define VarR4FromInt   VarR4FromI4

Definition at line 597 of file oleauto.h.

◆ VarR4FromUint

#define VarR4FromUint   VarR4FromUI4

Definition at line 598 of file oleauto.h.

◆ VarR8FromInt

#define VarR8FromInt   VarR8FromI4

Definition at line 599 of file oleauto.h.

◆ VarR8FromUint

#define VarR8FromUint   VarR8FromUI4

Definition at line 600 of file oleauto.h.

◆ VarUI1FromInt

#define VarUI1FromInt   VarUI1FromI4

Definition at line 589 of file oleauto.h.

◆ VarUI1FromUint

#define VarUI1FromUint   VarUI1FromUI4

Definition at line 590 of file oleauto.h.

◆ VarUI2FromInt

#define VarUI2FromInt   VarUI2FromI4

Definition at line 611 of file oleauto.h.

◆ VarUI2FromUint

#define VarUI2FromUint   VarUI2FromUI4

Definition at line 612 of file oleauto.h.

◆ VarUI4FromInt

#define VarUI4FromInt   VarUI4FromI4

Definition at line 613 of file oleauto.h.

◆ VarUI4FromUI4

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

Definition at line 586 of file oleauto.h.

◆ VarUI4FromUint

#define VarUI4FromUint   VarUI4FromUI4

Definition at line 614 of file oleauto.h.

◆ VarUI8FromInt

#define VarUI8FromInt   VarUI8FromI4

Definition at line 615 of file oleauto.h.

◆ VarUI8FromUint

#define VarUI8FromUint   VarUI8FromUI4

Definition at line 616 of file oleauto.h.

◆ VarUintFromBool

#define VarUintFromBool   VarUI4FromBool

Definition at line 646 of file oleauto.h.

◆ VarUintFromCy

#define VarUintFromCy   VarUI4FromCy

Definition at line 643 of file oleauto.h.

◆ VarUintFromDate

#define VarUintFromDate   VarUI4FromDate

Definition at line 642 of file oleauto.h.

◆ VarUintFromDec

#define VarUintFromDec   VarUI4FromDec

Definition at line 651 of file oleauto.h.

◆ VarUintFromDisp

#define VarUintFromDisp   VarUI4FromDisp

Definition at line 645 of file oleauto.h.

◆ VarUintFromI1

#define VarUintFromI1   VarUI4FromI1

Definition at line 647 of file oleauto.h.

◆ VarUintFromI2

#define VarUintFromI2   VarUI4FromI2

Definition at line 637 of file oleauto.h.

◆ VarUintFromI4

#define VarUintFromI4   VarUI4FromI4

Definition at line 638 of file oleauto.h.

◆ VarUintFromI8

#define VarUintFromI8   VarUI4FromI8

Definition at line 639 of file oleauto.h.

◆ VarUintFromInt

#define VarUintFromInt   VarUI4FromI4

Definition at line 652 of file oleauto.h.

◆ VarUintFromR4

#define VarUintFromR4   VarUI4FromR4

Definition at line 640 of file oleauto.h.

◆ VarUintFromR8

#define VarUintFromR8   VarUI4FromR8

Definition at line 641 of file oleauto.h.

◆ VarUintFromStr

#define VarUintFromStr   VarUI4FromStr

Definition at line 644 of file oleauto.h.

◆ VarUintFromUI1

#define VarUintFromUI1   VarUI4FromUI1

Definition at line 636 of file oleauto.h.

◆ VarUintFromUI2

#define VarUintFromUI2   VarUI4FromUI2

Definition at line 648 of file oleauto.h.

◆ VarUintFromUI4

#define VarUintFromUI4   VarUI4FromUI4

Definition at line 649 of file oleauto.h.

◆ VarUintFromUI8

#define VarUintFromUI8   VarUI4FromUI8

Definition at line 650 of file oleauto.h.

◆ VT_HARDTYPE

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

Definition at line 323 of file oleauto.h.

◆ VTBIT_CY

#define VTBIT_CY   (1 << VT_CY)

Definition at line 762 of file oleauto.h.

◆ VTBIT_DECIMAL

#define VTBIT_DECIMAL   (1 << VT_DECIMAL)

Definition at line 763 of file oleauto.h.

◆ VTBIT_I1

#define VTBIT_I1   (1 << VT_I1)

Definition at line 752 of file oleauto.h.

◆ VTBIT_I2

#define VTBIT_I2   (1 << VT_I2)

Definition at line 754 of file oleauto.h.

◆ VTBIT_I4

#define VTBIT_I4   (1 << VT_I4)

Definition at line 756 of file oleauto.h.

◆ VTBIT_I8

#define VTBIT_I8   (1 << VT_I8)

Definition at line 758 of file oleauto.h.

◆ VTBIT_R4

#define VTBIT_R4   (1 << VT_R4)

Definition at line 760 of file oleauto.h.

◆ VTBIT_R8

#define VTBIT_R8   (1 << VT_R8)

Definition at line 761 of file oleauto.h.

◆ VTBIT_UI1

#define VTBIT_UI1   (1 << VT_UI1)

Definition at line 753 of file oleauto.h.

◆ VTBIT_UI2

#define VTBIT_UI2   (1 << VT_UI2)

Definition at line 755 of file oleauto.h.

◆ VTBIT_UI4

#define VTBIT_UI4   (1 << VT_UI4)

Definition at line 757 of file oleauto.h.

◆ VTBIT_UI8

#define VTBIT_UI8   (1 << VT_UI8)

Definition at line 759 of file oleauto.h.

◆ VTDATEGRE_MAX

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

Definition at line 342 of file oleauto.h.

◆ VTDATEGRE_MIN

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

Definition at line 341 of file oleauto.h.

◆ WHashValOfLHashVal

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

Definition at line 1000 of file oleauto.h.

Typedef Documentation

◆ INTERFACEDATA

◆ LPINTERFACEDATA

◆ LPMETHODDATA

◆ LPPARAMDATA

◆ METHODDATA

◆ PARAMDATA

◆ REGKIND

Enumeration Type Documentation

◆ tagREGKIND

Enumerator
REGKIND_DEFAULT 
REGKIND_REGISTER 
REGKIND_NONE 

Definition at line 923 of file oleauto.h.

924 {
928 } REGKIND;
enum tagREGKIND REGKIND

Function Documentation

◆ _Post_equal_to_() [1/2]

_Post_equal_to_ ( _String_length_(bstr) *sizeof(OLECHAR )

◆ _Post_equal_to_() [2/2]

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

◆ _Ret_writes_maybenull_z_()

_Ret_writes_maybenull_z_ ( ui 1) const

◆ BstrFromVector()

_Check_return_ HRESULT WINAPI BstrFromVector ( _In_ SAFEARRAY ,
_Out_ BSTR  
)

◆ ClearCustData()

VOID WINAPI ClearCustData ( LPCUSTDATA  )

◆ CreateDispTypeInfo()

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

Definition at line 8659 of file typelib.c.

8663 {
8664  ITypeInfoImpl *pTIClass, *pTIIface;
8665  ITypeLibImpl *pTypeLibImpl;
8666  unsigned int param, func;
8667  TLBFuncDesc *pFuncDesc;
8668  TLBRefType *ref;
8669 
8670  TRACE("\n");
8671  pTypeLibImpl = TypeLibImpl_Constructor();
8672  if (!pTypeLibImpl) return E_FAIL;
8673 
8674  pTypeLibImpl->TypeInfoCount = 2;
8675  pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
8676 
8677  pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
8678  pTIIface->pTypeLib = pTypeLibImpl;
8679  pTIIface->index = 0;
8680  pTIIface->Name = NULL;
8681  pTIIface->dwHelpContext = -1;
8682  pTIIface->guid = NULL;
8683  pTIIface->typeattr.lcid = lcid;
8684  pTIIface->typeattr.typekind = TKIND_INTERFACE;
8685  pTIIface->typeattr.wMajorVerNum = 0;
8686  pTIIface->typeattr.wMinorVerNum = 0;
8687  pTIIface->typeattr.cbAlignment = 2;
8688  pTIIface->typeattr.cbSizeInstance = -1;
8689  pTIIface->typeattr.cbSizeVft = -1;
8690  pTIIface->typeattr.cFuncs = 0;
8691  pTIIface->typeattr.cImplTypes = 0;
8692  pTIIface->typeattr.cVars = 0;
8693  pTIIface->typeattr.wTypeFlags = 0;
8694  pTIIface->hreftype = 0;
8695 
8696  pTIIface->funcdescs = TLBFuncDesc_Alloc(pidata->cMembers);
8697  pFuncDesc = pTIIface->funcdescs;
8698  for(func = 0; func < pidata->cMembers; func++) {
8699  METHODDATA *md = pidata->pmethdata + func;
8700  pFuncDesc->Name = TLB_append_str(&pTypeLibImpl->name_list, md->szName);
8701  pFuncDesc->funcdesc.memid = md->dispid;
8702  pFuncDesc->funcdesc.lprgscode = NULL;
8703  pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
8704  pFuncDesc->funcdesc.invkind = md->wFlags;
8705  pFuncDesc->funcdesc.callconv = md->cc;
8706  pFuncDesc->funcdesc.cParams = md->cArgs;
8707  pFuncDesc->funcdesc.cParamsOpt = 0;
8708  pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
8709  pFuncDesc->funcdesc.cScodes = 0;
8710  pFuncDesc->funcdesc.wFuncFlags = 0;
8711  pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
8712  pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
8713  pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
8714  pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
8715  md->cArgs * sizeof(ELEMDESC));
8716  pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
8717  for(param = 0; param < md->cArgs; param++) {
8718  pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
8719  pFuncDesc->pParamDesc[param].Name = TLB_append_str(&pTypeLibImpl->name_list, md->ppdata[param].szName);
8720  }
8721  pFuncDesc->helpcontext = 0;
8722  pFuncDesc->HelpStringContext = 0;
8723  pFuncDesc->HelpString = NULL;
8724  pFuncDesc->Entry = NULL;
8725  list_init(&pFuncDesc->custdata_list);
8726  pTIIface->typeattr.cFuncs++;
8727  ++pFuncDesc;
8728  }
8729 
8730  dump_TypeInfo(pTIIface);
8731 
8732  pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
8733  pTIClass->pTypeLib = pTypeLibImpl;
8734  pTIClass->index = 1;
8735  pTIClass->Name = NULL;
8736  pTIClass->dwHelpContext = -1;
8737  pTIClass->guid = NULL;
8738  pTIClass->typeattr.lcid = lcid;
8739  pTIClass->typeattr.typekind = TKIND_COCLASS;
8740  pTIClass->typeattr.wMajorVerNum = 0;
8741  pTIClass->typeattr.wMinorVerNum = 0;
8742  pTIClass->typeattr.cbAlignment = 2;
8743  pTIClass->typeattr.cbSizeInstance = -1;
8744  pTIClass->typeattr.cbSizeVft = -1;
8745  pTIClass->typeattr.cFuncs = 0;
8746  pTIClass->typeattr.cImplTypes = 1;
8747  pTIClass->typeattr.cVars = 0;
8748  pTIClass->typeattr.wTypeFlags = 0;
8749  pTIClass->hreftype = sizeof(MSFT_TypeInfoBase);
8750 
8751  pTIClass->impltypes = TLBImplType_Alloc(1);
8752 
8753  ref = heap_alloc_zero(sizeof(*ref));
8754  ref->pImpTLInfo = TLB_REF_INTERNAL;
8755  list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
8756 
8757  dump_TypeInfo(pTIClass);
8758 
8759  *pptinfo = (ITypeInfo *)&pTIClass->ITypeInfo2_iface;
8760 
8761  ITypeInfo_AddRef(*pptinfo);
8762  ITypeLib2_Release(&pTypeLibImpl->ITypeLib2_iface);
8763 
8764  return S_OK;
8765 
8766 }
struct list ref_list
Definition: typelib.c:1135
GLenum func
Definition: glext.h:6028
ITypeLib2 ITypeLib2_iface
Definition: typelib.c:1102
HREFTYPE hreftype
Definition: typelib.c:1255
static TLBString * TLB_append_str(struct list *string_list, BSTR new_str)
Definition: typelib.c:1884
static void dump_TypeInfo(const ITypeInfoImpl *pty)
Definition: typelib.c:1573
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
struct tagITypeInfoImpl ** typeinfos
Definition: typelib.c:1128
TYPEATTR typeattr
Definition: typelib.c:1250
#define E_FAIL
Definition: ddrawi.h:102
Definition: send.c:47
struct list custdata_list
Definition: typelib.c:1216
struct list name_list
Definition: typelib.c:1119
static ITypeInfoImpl * ITypeInfoImpl_Constructor(void)
Definition: typelib.c:5623
GLenum GLint ref
Definition: glext.h:6028
const TLBString * Entry
Definition: typelib.c:1215
smooth NULL
Definition: ftsmooth.c:416
const TLBString * Name
Definition: typelib.c:1210
TLBParDesc * pParamDesc
Definition: typelib.c:1211
ITypeInfo2 ITypeInfo2_iface
Definition: typelib.c:1242
TLBFuncDesc * funcdescs
Definition: typelib.c:1267
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLfloat param
Definition: glext.h:5796
FUNCDESC funcdesc
Definition: typelib.c:1209
static TLBParDesc * TLBParDesc_Constructor(UINT n)
Definition: typelib.c:1770
ITypeLibImpl * pTypeLib
Definition: typelib.c:1253
int HelpStringContext
Definition: typelib.c:1213
static TLBImplType * TLBImplType_Alloc(UINT n)
Definition: typelib.c:1812
DWORD dwHelpContext
Definition: typelib.c:1263
#define S_OK
Definition: intsafe.h:59
#define TLB_REF_INTERNAL
Definition: typelib.c:1196
static TLBFuncDesc * TLBFuncDesc_Alloc(UINT n)
Definition: typelib.c:1791
struct tagMSFT_TypeInfoBase MSFT_TypeInfoBase
TLBImplType * impltypes
Definition: typelib.c:1273
TLBGuid * guid
Definition: typelib.c:1249
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
const TLBString * Name
Definition: typelib.c:1259
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
const TLBString * Name
Definition: typelib.c:1202
#define md
Definition: compat-1.3.h:1983
static ITypeLibImpl * TypeLibImpl_Constructor(void)
Definition: typelib.c:3429
const TLBString * HelpString
Definition: typelib.c:1214

Referenced by test_CreateDispTypeInfo().

◆ CreateErrorInfo()

◆ CreateStdDispatch()

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

Definition at line 436 of file dispatch.c.

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

Referenced by test_CreateStdDispatch(), and Widget_Create().

◆ CreateTypeLib()

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

◆ CreateTypeLib2()

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

Definition at line 8910 of file typelib.c.

8912 {
8913  ITypeLibImpl *This;
8914  HRESULT hres;
8915 
8916  TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
8917 
8918  if (!szFile) return E_INVALIDARG;
8919 
8921  if (!This)
8922  return E_OUTOFMEMORY;
8923 
8924  This->lcid = GetSystemDefaultLCID();
8925  This->syskind = syskind;
8926  This->ptr_size = get_ptr_size(syskind);
8927 
8928  This->path = heap_alloc((lstrlenW(szFile) + 1) * sizeof(WCHAR));
8929  if (!This->path) {
8930  ITypeLib2_Release(&This->ITypeLib2_iface);
8931  return E_OUTOFMEMORY;
8932  }
8933  lstrcpyW(This->path, szFile);
8934 
8935  hres = ITypeLib2_QueryInterface(&This->ITypeLib2_iface, &IID_ICreateTypeLib2, (LPVOID*)ppctlib);
8936  ITypeLib2_Release(&This->ITypeLib2_iface);
8937  return hres;
8938 }
#define lstrlenW
Definition: compat.h:407
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define debugstr_w
Definition: kernel32.h:32
#define E_INVALIDARG
Definition: ddrawi.h:101
LCID WINAPI GetSystemDefaultLCID(void)
Definition: lang.c:784
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT hres
Definition: protocol.c:465
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
#define lstrcpyW
Definition: compat.h:406
static int get_ptr_size(SYSKIND syskind)
Definition: typelib.c:1339
static ITypeLibImpl * TypeLibImpl_Constructor(void)
Definition: typelib.c:3429

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

◆ DEFINE_OLEGUID()

DEFINE_OLEGUID ( IID_StdOle  ,
0x00020430  ,
,
 
)

◆ DispCallFunc()

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

Definition at line 6760 of file typelib.c.

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

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

◆ DispGetIDsOfNames()

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

◆ DispGetParam()

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

◆ DispInvoke()

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

Definition at line 65 of file dispatch.c.

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

Referenced by StdDispatch_Invoke().

◆ DosDateTimeToVariantTime()

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

◆ GetActiveObject()

HRESULT WINAPI GetActiveObject ( REFCLSID  ,
LPVOID  ,
LPUNKNOWN  
)

Definition at line 595 of file oleaut.c.

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

Referenced by ITypeInfo_fnCreateInstance().

◆ GetAltMonthNames()

◆ GetErrorInfo()

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

◆ GetRecordInfoFromGuids()

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

Definition at line 595 of file recinfo.c.

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

◆ GetRecordInfoFromTypeInfo()

HRESULT WINAPI GetRecordInfoFromTypeInfo ( ITypeInfo ,
IRecordInfo **   
)

Definition at line 626 of file recinfo.c.

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

Referenced by GetRecordInfoFromGuids(), and test_recinfo().

◆ LHashValOfNameSys()

ULONG WINAPI LHashValOfNameSys ( SYSKIND  ,
LCID  ,
LPCOLESTR   
)

Definition at line 628 of file hash.c.

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

Referenced by test_TypeComp().

◆ LHashValOfNameSysA()

ULONG WINAPI LHashValOfNameSysA ( SYSKIND  ,
LCID  ,
LPCSTR   
)

Definition at line 506 of file hash.c.

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

Referenced by LHashValOfNameSys(), and WMSFT_compile_names().

◆ LoadRegTypeLib()

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

Definition at line 534 of file typelib.c.

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

Referenced by BaseDispatch_Init(), ATL::IDispatchImpl< IShellFolderViewDual2, &IID_IShellFolderViewDual2 >::EnsureTILoaded(), get_type_info(), get_typeinfo(), GetRecordInfoFromGuids(), load_typelib(), NonOleAutomation_GetTypeInfo(), test_libattr(), and test_LoadRegTypeLib().