Skip to content

W
wine-winehq
Commit 3de15569 authored by Alexandre Julliard's avatar Alexandre Julliard
Browse files
Options

include: Use proper dllimports for OLE functions.

parent 9fc9c91b
Hide whitespace changes
Inline Side-by-side
Showing with 606 additions and 615 deletions
dlls/combase/Makefile.in
View file @ 3de15569
EXTRADEFS = -DWINOLE32API=
MODULE = combase.dll
IMPORTLIB = combase
IMPORTS = advapi32 ole32 user32 gdi32 uuid rpcrt4
......
dlls/combase/errorinfo.c
View file @ 3de15569
......@@ -19,6 +19,7 @@
*/
#define COBJMACROS
#define WINOLEAUTAPI
#include "oleauto.h"
......
dlls/ole32/Makefile.in
View file @ 3de15569
EXTRADEFS = -D_OLE32_
MODULE = ole32.dll
IMPORTLIB = ole32
IMPORTS = uuid advapi32 user32 gdi32 combase rpcrt4 kernelbase
......
dlls/oleaut32/Makefile.in
View file @ 3de15569
EXTRADEFS = -D_OLEAUT32_
MODULE = oleaut32.dll
IMPORTLIB = oleaut32
IMPORTS = uuid ole32 rpcrt4 user32 gdi32 advapi32
......
include/objbase.h
View file @ 3de15569
......@@ -178,6 +178,14 @@
#undef DECLARE_INTERFACE
#undef DECLARE_INTERFACE_
#ifndef WINOLE32API
#ifdef _OLE32_
#define WINOLE32API
#else
#define WINOLE32API DECLSPEC_IMPORT
#endif
#endif
#if defined(__cplusplus) && !defined(CINTERFACE)
#ifdef COM_STDMETHOD_CAN_THROW
......@@ -276,7 +284,7 @@ extern "C" {
/*****************************************************************************
* Standard API
*/
DWORD WINAPI CoBuildVersion(void);
WINOLE32API DWORD WINAPI CoBuildVersion(void);
typedef enum tagCOINIT
{
......@@ -288,43 +296,36 @@ typedef enum tagCOINIT
DECLARE_HANDLE(CO_MTA_USAGE_COOKIE);
HRESULT WINAPI CoInitialize(LPVOID lpReserved);
HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit);
void WINAPI CoUninitialize(void);
DWORD WINAPI CoGetCurrentProcess(void);
HRESULT WINAPI CoGetCurrentLogicalThreadId(GUID *id);
HRESULT WINAPI CoGetApartmentType(APTTYPE *type, APTTYPEQUALIFIER *qualifier);
HRESULT WINAPI CoIncrementMTAUsage(CO_MTA_USAGE_COOKIE *cookie);
HRESULT WINAPI CoDecrementMTAUsage(CO_MTA_USAGE_COOKIE cookie);
HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
void WINAPI CoFreeAllLibraries(void);
void WINAPI CoFreeLibrary(HINSTANCE hLibrary);
void WINAPI CoFreeUnusedLibraries(void);
void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved);
HRESULT WINAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv);
HRESULT WINAPI CoCreateInstanceEx(REFCLSID rclsid,
LPUNKNOWN pUnkOuter,
DWORD dwClsContext,
COSERVERINFO* pServerInfo,
ULONG cmq,
MULTI_QI* pResults);
HRESULT WINAPI CoCreateInstanceFromApp(REFCLSID clsid, IUnknown *outer, DWORD clscontext, void *reserved,
DWORD count, MULTI_QI *results);
HRESULT WINAPI CoGetInstanceFromFile(COSERVERINFO* pServerInfo, CLSID* pClsid, IUnknown* punkOuter, DWORD dwClsCtx, DWORD grfMode, OLECHAR* pwszName, DWORD dwCount, MULTI_QI* pResults);
HRESULT WINAPI CoGetInstanceFromIStorage(COSERVERINFO* pServerInfo, CLSID* pClsid, IUnknown* punkOuter, DWORD dwClsCtx, IStorage* pstg, DWORD dwCount, MULTI_QI* pResults);
HRESULT WINAPI CoGetMalloc(DWORD dwMemContext, LPMALLOC* lpMalloc);
void WINAPI CoTaskMemFree(LPVOID ptr);
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(CoTaskMemFree) __WINE_MALLOC;
LPVOID WINAPI CoTaskMemRealloc(LPVOID ptr, SIZE_T size) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(CoTaskMemFree);
HRESULT WINAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy);
HRESULT WINAPI CoRevokeMallocSpy(void);
HRESULT WINAPI CoGetContextToken( ULONG_PTR *token );
WINOLE32API HRESULT WINAPI CoInitialize(LPVOID lpReserved);
WINOLE32API HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit);
WINOLE32API void WINAPI CoUninitialize(void);
WINOLE32API DWORD WINAPI CoGetCurrentProcess(void);
WINOLE32API HRESULT WINAPI CoGetCurrentLogicalThreadId(GUID *id);
WINOLE32API HRESULT WINAPI CoGetApartmentType(APTTYPE *type, APTTYPEQUALIFIER *qualifier);
WINOLE32API HRESULT WINAPI CoIncrementMTAUsage(CO_MTA_USAGE_COOKIE *cookie);
WINOLE32API HRESULT WINAPI CoDecrementMTAUsage(CO_MTA_USAGE_COOKIE cookie);
WINOLE32API HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
WINOLE32API void WINAPI CoFreeAllLibraries(void);
WINOLE32API void WINAPI CoFreeLibrary(HINSTANCE hLibrary);
WINOLE32API void WINAPI CoFreeUnusedLibraries(void);
WINOLE32API void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved);
WINOLE32API HRESULT WINAPI CoCreateInstance(REFCLSID,LPUNKNOWN,DWORD,REFIID,LPVOID*);
WINOLE32API HRESULT WINAPI CoCreateInstanceEx(REFCLSID,LPUNKNOWN,DWORD,COSERVERINFO*,ULONG,MULTI_QI*);
WINOLE32API HRESULT WINAPI CoCreateInstanceFromApp(REFCLSID,IUnknown*,DWORD,void*,DWORD,MULTI_QI*);
WINOLE32API HRESULT WINAPI CoGetInstanceFromFile(COSERVERINFO*, CLSID*,IUnknown*,DWORD,DWORD,OLECHAR*,DWORD,MULTI_QI*);
WINOLE32API HRESULT WINAPI CoGetInstanceFromIStorage(COSERVERINFO*,CLSID*,IUnknown*,DWORD,IStorage*,DWORD,MULTI_QI*);
WINOLE32API HRESULT WINAPI CoGetMalloc(DWORD dwMemContext, LPMALLOC* lpMalloc);
WINOLE32API void WINAPI CoTaskMemFree(LPVOID ptr);
WINOLE32API LPVOID WINAPI CoTaskMemAlloc(SIZE_T size) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(CoTaskMemFree) __WINE_MALLOC;
WINOLE32API LPVOID WINAPI CoTaskMemRealloc(LPVOID ptr, SIZE_T size) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(CoTaskMemFree);
WINOLE32API HRESULT WINAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy);
WINOLE32API HRESULT WINAPI CoRevokeMallocSpy(void);
WINOLE32API HRESULT WINAPI CoGetContextToken( ULONG_PTR *token );
/* class registration flags; passed to CoRegisterClassObject */
typedef enum tagREGCLS
......@@ -336,64 +337,64 @@ typedef enum tagREGCLS
REGCLS_SURROGATE = 8
} REGCLS;
HRESULT WINAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo, REFIID iid, LPVOID *ppv);
HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid,LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags,LPDWORD lpdwRegister);
HRESULT WINAPI CoRevokeClassObject(DWORD dwRegister);
HRESULT WINAPI CoGetPSClsid(REFIID riid,CLSID *pclsid);
HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid);
HRESULT WINAPI CoRegisterSurrogate(LPSURROGATE pSurrogate);
HRESULT WINAPI CoSuspendClassObjects(void);
HRESULT WINAPI CoResumeClassObjects(void);
ULONG WINAPI CoAddRefServerProcess(void);
ULONG WINAPI CoReleaseServerProcess(void);
WINOLE32API HRESULT WINAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo, REFIID iid, LPVOID *ppv);
WINOLE32API HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid,LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags,LPDWORD lpdwRegister);
WINOLE32API HRESULT WINAPI CoRevokeClassObject(DWORD dwRegister);
WINOLE32API HRESULT WINAPI CoGetPSClsid(REFIID riid,CLSID *pclsid);
WINOLE32API HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid);
WINOLE32API HRESULT WINAPI CoRegisterSurrogate(LPSURROGATE pSurrogate);
WINOLE32API HRESULT WINAPI CoSuspendClassObjects(void);
WINOLE32API HRESULT WINAPI CoResumeClassObjects(void);
WINOLE32API ULONG WINAPI CoAddRefServerProcess(void);
WINOLE32API ULONG WINAPI CoReleaseServerProcess(void);
/* marshalling */
HRESULT WINAPI CoCreateFreeThreadedMarshaler(LPUNKNOWN punkOuter, LPUNKNOWN* ppunkMarshal);
HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid, LPVOID* ppv);
HRESULT WINAPI CoGetMarshalSizeMax(ULONG* pulSize, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
HRESULT WINAPI CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, LPMARSHAL* ppMarshal);
HRESULT WINAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult);
HRESULT WINAPI CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM* ppStm);
HRESULT WINAPI CoReleaseMarshalData(LPSTREAM pStm);
HRESULT WINAPI CoDisconnectObject(LPUNKNOWN lpUnk, DWORD reserved);
HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT* phresult);
HRESULT WINAPI CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID* ppv);
HRESULT WINAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
BOOL WINAPI CoIsHandlerConnected(LPUNKNOWN pUnk);
HRESULT WINAPI CoDisableCallCancellation(void *reserved);
HRESULT WINAPI CoEnableCallCancellation(void *reserved);
WINOLE32API HRESULT WINAPI CoCreateFreeThreadedMarshaler(LPUNKNOWN punkOuter, LPUNKNOWN* ppunkMarshal);
WINOLE32API HRESULT WINAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid, LPVOID* ppv);
WINOLE32API HRESULT WINAPI CoGetMarshalSizeMax(ULONG* pulSize, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
WINOLE32API HRESULT WINAPI CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, LPMARSHAL* ppMarshal);
WINOLE32API HRESULT WINAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult);
WINOLE32API HRESULT WINAPI CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
WINOLE32API HRESULT WINAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM* ppStm);
WINOLE32API HRESULT WINAPI CoReleaseMarshalData(LPSTREAM pStm);
WINOLE32API HRESULT WINAPI CoDisconnectObject(LPUNKNOWN lpUnk, DWORD reserved);
WINOLE32API HRESULT WINAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT* phresult);
WINOLE32API HRESULT WINAPI CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID* ppv);
WINOLE32API HRESULT WINAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
WINOLE32API BOOL WINAPI CoIsHandlerConnected(LPUNKNOWN pUnk);
WINOLE32API HRESULT WINAPI CoDisableCallCancellation(void *reserved);
WINOLE32API HRESULT WINAPI CoEnableCallCancellation(void *reserved);
/* security */
HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc, SOLE_AUTHENTICATION_SERVICE* asAuthSvc, void* pReserved1, DWORD dwAuthnLevel, DWORD dwImpLevel, void* pReserved2, DWORD dwCapabilities, void* pReserved3);
HRESULT WINAPI CoGetCallContext(REFIID riid, void** ppInterface);
HRESULT WINAPI CoSwitchCallContext(IUnknown *pContext, IUnknown **ppOldContext);
HRESULT WINAPI CoQueryAuthenticationServices(DWORD* pcAuthSvc, SOLE_AUTHENTICATION_SERVICE** asAuthSvc);
WINOLE32API HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc, SOLE_AUTHENTICATION_SERVICE* asAuthSvc, void* pReserved1, DWORD dwAuthnLevel, DWORD dwImpLevel, void* pReserved2, DWORD dwCapabilities, void* pReserved3);
WINOLE32API HRESULT WINAPI CoGetCallContext(REFIID riid, void** ppInterface);
WINOLE32API HRESULT WINAPI CoSwitchCallContext(IUnknown *pContext, IUnknown **ppOldContext);
WINOLE32API HRESULT WINAPI CoQueryAuthenticationServices(DWORD* pcAuthSvc, SOLE_AUTHENTICATION_SERVICE** asAuthSvc);
HRESULT WINAPI CoQueryProxyBlanket(IUnknown* pProxy, DWORD* pwAuthnSvc, DWORD* pAuthzSvc, OLECHAR** pServerPrincName, DWORD* pAuthnLevel, DWORD* pImpLevel, RPC_AUTH_IDENTITY_HANDLE* pAuthInfo, DWORD* pCapabilities);
HRESULT WINAPI CoSetProxyBlanket(IUnknown* pProxy, DWORD dwAuthnSvc, DWORD dwAuthzSvc, OLECHAR* pServerPrincName, DWORD dwAuthnLevel, DWORD dwImpLevel, RPC_AUTH_IDENTITY_HANDLE pAuthInfo, DWORD dwCapabilities);
HRESULT WINAPI CoCopyProxy(IUnknown* pProxy, IUnknown** ppCopy);
WINOLE32API HRESULT WINAPI CoQueryProxyBlanket(IUnknown* pProxy, DWORD* pwAuthnSvc, DWORD* pAuthzSvc, OLECHAR** pServerPrincName, DWORD* pAuthnLevel, DWORD* pImpLevel, RPC_AUTH_IDENTITY_HANDLE* pAuthInfo, DWORD* pCapabilities);
WINOLE32API HRESULT WINAPI CoSetProxyBlanket(IUnknown* pProxy, DWORD dwAuthnSvc, DWORD dwAuthzSvc, OLECHAR* pServerPrincName, DWORD dwAuthnLevel, DWORD dwImpLevel, RPC_AUTH_IDENTITY_HANDLE pAuthInfo, DWORD dwCapabilities);
WINOLE32API HRESULT WINAPI CoCopyProxy(IUnknown* pProxy, IUnknown** ppCopy);
HRESULT WINAPI CoImpersonateClient(void);
HRESULT WINAPI CoQueryClientBlanket(DWORD* pAuthnSvc, DWORD* pAuthzSvc, OLECHAR** pServerPrincName, DWORD* pAuthnLevel, DWORD* pImpLevel, RPC_AUTHZ_HANDLE* pPrivs, DWORD* pCapabilities);
HRESULT WINAPI CoRevertToSelf(void);
WINOLE32API HRESULT WINAPI CoImpersonateClient(void);
WINOLE32API HRESULT WINAPI CoQueryClientBlanket(DWORD* pAuthnSvc, DWORD* pAuthzSvc, OLECHAR** pServerPrincName, DWORD* pAuthnLevel, DWORD* pImpLevel, RPC_AUTHZ_HANDLE* pPrivs, DWORD* pCapabilities);
WINOLE32API HRESULT WINAPI CoRevertToSelf(void);
/* misc */
HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pClsidNew);
HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew);
HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, LPVOID lpvReserved);
HRESULT WINAPI CoGetObjectContext(REFIID riid, LPVOID *ppv);
HRESULT WINAPI CoRegisterInitializeSpy(IInitializeSpy *spy, ULARGE_INTEGER *cookie);
HRESULT WINAPI CoRevokeInitializeSpy(ULARGE_INTEGER cookie);
HRESULT WINAPI CoCreateGuid(GUID* pguid);
BOOL WINAPI CoIsOle1Class(REFCLSID rclsid);
BOOL WINAPI CoDosDateTimeToFileTime(WORD nDosDate, WORD nDosTime, FILETIME* lpFileTime);
BOOL WINAPI CoFileTimeToDosDateTime(FILETIME* lpFileTime, WORD* lpDosDate, WORD* lpDosTime);
HRESULT WINAPI CoFileTimeNow(FILETIME* lpFileTime);
HRESULT WINAPI CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter,LPMESSAGEFILTER *lplpMessageFilter);
HRESULT WINAPI CoRegisterChannelHook(REFGUID ExtensionGuid, IChannelHook *pChannelHook);
WINOLE32API HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pClsidNew);
WINOLE32API HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew);
WINOLE32API HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, LPVOID lpvReserved);
WINOLE32API HRESULT WINAPI CoGetObjectContext(REFIID riid, LPVOID *ppv);
WINOLE32API HRESULT WINAPI CoRegisterInitializeSpy(IInitializeSpy *spy, ULARGE_INTEGER *cookie);
WINOLE32API HRESULT WINAPI CoRevokeInitializeSpy(ULARGE_INTEGER cookie);
WINOLE32API HRESULT WINAPI CoCreateGuid(GUID* pguid);
WINOLE32API BOOL WINAPI CoIsOle1Class(REFCLSID rclsid);
WINOLE32API BOOL WINAPI CoDosDateTimeToFileTime(WORD nDosDate, WORD nDosTime, FILETIME* lpFileTime);
WINOLE32API BOOL WINAPI CoFileTimeToDosDateTime(FILETIME* lpFileTime, WORD* lpDosDate, WORD* lpDosTime);
WINOLE32API HRESULT WINAPI CoFileTimeNow(FILETIME* lpFileTime);
WINOLE32API HRESULT WINAPI CoRegisterMessageFilter(LPMESSAGEFILTER lpMessageFilter,LPMESSAGEFILTER *lplpMessageFilter);
WINOLE32API HRESULT WINAPI CoRegisterChannelHook(REFGUID ExtensionGuid, IChannelHook *pChannelHook);
typedef enum tagCOWAIT_FLAGS
{
......@@ -403,18 +404,18 @@ typedef enum tagCOWAIT_FLAGS
COWAIT_INPUTAVAILABLE = 0x00000004
} COWAIT_FLAGS;
HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags,DWORD dwTimeout,ULONG cHandles,LPHANDLE pHandles,LPDWORD lpdwindex);
WINOLE32API HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags,DWORD dwTimeout,ULONG cHandles,LPHANDLE pHandles,LPDWORD lpdwindex);
/*****************************************************************************
* GUID API
*/
HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR*);
HRESULT WINAPI CLSIDFromString(LPCOLESTR, LPCLSID);
HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID riid);
HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *lplpszProgID);
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax);
HRESULT WINAPI IIDFromString(LPCOLESTR str, IID *iid);
HRESULT WINAPI StringFromIID(REFIID riid, LPOLESTR*);
WINOLE32API HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR*);
WINOLE32API HRESULT WINAPI CLSIDFromString(LPCOLESTR, LPCLSID);
WINOLE32API HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID riid);
WINOLE32API HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *lplpszProgID);
WINOLE32API INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax);
WINOLE32API HRESULT WINAPI IIDFromString(LPCOLESTR str, IID *iid);
WINOLE32API HRESULT WINAPI StringFromIID(REFIID riid, LPOLESTR*);
/*****************************************************************************
* COM Server dll - exports
......@@ -425,27 +426,27 @@ HRESULT WINAPI DllCanUnloadNow(void) DECLSPEC_HIDDEN;
/*****************************************************************************
* Data Object
*/
HRESULT WINAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER* ppDAHolder);
HRESULT WINAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid, REFIID iid, LPVOID* ppv);
WINOLE32API HRESULT WINAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER* ppDAHolder);
WINOLE32API HRESULT WINAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid, REFIID iid, LPVOID* ppv);
/*****************************************************************************
* Moniker API
*/
HRESULT WINAPI BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult, LPVOID* ppvResult);
HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, void **ppv);
HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk);
HRESULT WINAPI CreateBindCtx(DWORD reserved, LPBC* ppbc);
HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, LPMONIKER* ppmk);
HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER* ppmk);
HRESULT WINAPI CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite);
HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER* ppmk);
HRESULT WINAPI CreateObjrefMoniker(LPUNKNOWN punk, LPMONIKER * ppmk);
HRESULT WINAPI CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER * ppmk);
HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid);
HRESULT WINAPI GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot);
HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName, ULONG * pchEaten, LPMONIKER * ppmk);
HRESULT WINAPI MonikerCommonPrefixWith(IMoniker* pmkThis,IMoniker* pmkOther,IMoniker** ppmkCommon);
HRESULT WINAPI MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest, LPMONIKER * ppmkRelPath, BOOL dwReserved);
WINOLE32API HRESULT WINAPI BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult, LPVOID* ppvResult);
WINOLE32API HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, void **ppv);
WINOLE32API HRESULT WINAPI CreateAntiMoniker(LPMONIKER * ppmk);
WINOLE32API HRESULT WINAPI CreateBindCtx(DWORD reserved, LPBC* ppbc);
WINOLE32API HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, LPMONIKER* ppmk);
WINOLE32API HRESULT WINAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER* ppmk);
WINOLE32API HRESULT WINAPI CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER* ppmkComposite);
WINOLE32API HRESULT WINAPI CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER* ppmk);
WINOLE32API HRESULT WINAPI CreateObjrefMoniker(LPUNKNOWN punk, LPMONIKER * ppmk);
WINOLE32API HRESULT WINAPI CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER * ppmk);
WINOLE32API HRESULT WINAPI GetClassFile(LPCOLESTR filePathName,CLSID *pclsid);
WINOLE32API HRESULT WINAPI GetRunningObjectTable(DWORD reserved, LPRUNNINGOBJECTTABLE *pprot);
WINOLE32API HRESULT WINAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName, ULONG * pchEaten, LPMONIKER * ppmk);
WINOLE32API HRESULT WINAPI MonikerCommonPrefixWith(IMoniker* pmkThis,IMoniker* pmkOther,IMoniker** ppmkCommon);
WINOLE32API HRESULT WINAPI MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest, LPMONIKER * ppmkRelPath, BOOL dwReserved);
/*****************************************************************************
* Storage API
......@@ -482,16 +483,16 @@ typedef struct tagSTGOPTIONS
const WCHAR* pwcsTemplateFile;
} STGOPTIONS;
HRESULT WINAPI StgCreateDocfile(LPCOLESTR pwcsName,DWORD grfMode,DWORD reserved,IStorage **ppstgOpen);
HRESULT WINAPI StgCreateStorageEx(const WCHAR*,DWORD,DWORD,DWORD,STGOPTIONS*,void*,REFIID,void**);
HRESULT WINAPI StgIsStorageFile(LPCOLESTR fn);
HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt);
HRESULT WINAPI StgOpenStorage(const OLECHAR* pwcsName,IStorage* pstgPriority,DWORD grfMode,SNB snbExclude,DWORD reserved,IStorage**ppstgOpen);
HRESULT WINAPI StgOpenStorageEx(const WCHAR* pwcwName,DWORD grfMode,DWORD stgfmt,DWORD grfAttrs,STGOPTIONS *pStgOptions, void *reserved, REFIID riid, void **ppObjectOpen);
WINOLE32API HRESULT WINAPI StgCreateDocfile(LPCOLESTR pwcsName,DWORD grfMode,DWORD reserved,IStorage **ppstgOpen);
WINOLE32API HRESULT WINAPI StgCreateStorageEx(const WCHAR*,DWORD,DWORD,DWORD,STGOPTIONS*,void*,REFIID,void**);
WINOLE32API HRESULT WINAPI StgIsStorageFile(LPCOLESTR fn);
WINOLE32API HRESULT WINAPI StgIsStorageILockBytes(ILockBytes *plkbyt);
WINOLE32API HRESULT WINAPI StgOpenStorage(const OLECHAR* pwcsName,IStorage* pstgPriority,DWORD grfMode,SNB snbExclude,DWORD reserved,IStorage**ppstgOpen);
WINOLE32API HRESULT WINAPI StgOpenStorageEx(const WCHAR* pwcwName,DWORD grfMode,DWORD stgfmt,DWORD grfAttrs,STGOPTIONS *pStgOptions, void *reserved, REFIID riid, void **ppObjectOpen);
HRESULT WINAPI StgCreateDocfileOnILockBytes(ILockBytes *plkbyt,DWORD grfMode, DWORD reserved, IStorage** ppstgOpen);
HRESULT WINAPI StgOpenStorageOnILockBytes(ILockBytes *plkbyt, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstgOpen);
HRESULT WINAPI StgSetTimes( OLECHAR const *lpszName, FILETIME const *pctime, FILETIME const *patime, FILETIME const *pmtime);
WINOLE32API HRESULT WINAPI StgCreateDocfileOnILockBytes(ILockBytes *plkbyt,DWORD grfMode, DWORD reserved, IStorage** ppstgOpen);
WINOLE32API HRESULT WINAPI StgOpenStorageOnILockBytes(ILockBytes *plkbyt, IStorage *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage **ppstgOpen);
WINOLE32API HRESULT WINAPI StgSetTimes( OLECHAR const *lpszName, FILETIME const *pctime, FILETIME const *patime, FILETIME const *pmtime);
#ifdef __cplusplus
}
......
include/ole2.h
View file @ 3de15569
......@@ -52,97 +52,78 @@ extern "C" {
/*
* API declarations
*/
HRESULT WINAPI RegisterDragDrop(HWND,LPDROPTARGET);
HRESULT WINAPI RevokeDragDrop(HWND);
HRESULT WINAPI DoDragDrop(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
HRESULT WINAPI OleLoadFromStream(IStream *pStm,REFIID iidInterface,void** ppvObj);
HRESULT WINAPI OleSaveToStream(IPersistStream *pPStm,IStream *pStm);
HOLEMENU WINAPI OleCreateMenuDescriptor(HMENU hmenuCombined,LPOLEMENUGROUPWIDTHS lpMenuWidths);
HRESULT WINAPI OleDestroyMenuDescriptor(HOLEMENU hmenuDescriptor);
HRESULT WINAPI OleSetMenuDescriptor(HOLEMENU hmenuDescriptor,HWND hwndFrame,HWND hwndActiveObject,LPOLEINPLACEFRAME lpFrame,LPOLEINPLACEACTIVEOBJECT lpActiveObject);
HRESULT WINAPI WriteClassStg(IStorage *pstg, REFCLSID rclsid);
HRESULT WINAPI ReadClassStg(IStorage *pstg,CLSID *pclsid);
HRESULT WINAPI WriteClassStm(IStream *pStm,REFCLSID rclsid);
HRESULT WINAPI ReadClassStm(IStream *pStm,CLSID *pclsid);
HRESULT WINAPI OleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad);
HRESULT WINAPI OleRegGetUserType(REFCLSID clsid,
DWORD dwFormOfType,
LPOLESTR* pszUserType);
HRESULT WINAPI OleRegGetMiscStatus (REFCLSID clsid, DWORD dwAspect, DWORD* pdwStatus);
HRESULT WINAPI OleRegEnumFormatEtc (REFCLSID clsid,
DWORD dwDirection,
LPENUMFORMATETC* ppenumFormatetc);
HRESULT WINAPI CreateStreamOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM* ppstm);
HRESULT WINAPI GetHGlobalFromStream(LPSTREAM pstm, HGLOBAL* phglobal);
HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum);
BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject);
HRESULT WINAPI OleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid,
DWORD renderopt, LPFORMATETC pFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg,
LPVOID* ppvObj);
HRESULT WINAPI OleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained);
HRESULT WINAPI OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL fVisible);
HRESULT WINAPI OleQueryLinkFromData(IDataObject* pSrcDataObject);
HRESULT WINAPI OleQueryCreateFromData(LPDATAOBJECT pSrcDataObject);
HRESULT WINAPI OleRun(LPUNKNOWN pUnknown);
HRESULT WINAPI OleDraw(LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw, LPCRECT lprcBounds);
VOID WINAPI ReleaseStgMedium(LPSTGMEDIUM);
HRESULT WINAPI OleGetClipboard(IDataObject** ppDataObj);
HRESULT WINAPI OleIsCurrentClipboard(LPDATAOBJECT);
HRESULT WINAPI OleSetClipboard(LPDATAOBJECT);
HRESULT WINAPI OleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID iid,
DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite,
LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI ReadFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT* pcf, LPOLESTR* lplpszUserType);
HRESULT WINAPI OleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID* ppvObj);
HRESULT WINAPI GetHGlobalFromILockBytes(LPLOCKBYTES plkbyt, HGLOBAL* phglobal);
HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES* pplkbyt);
HRESULT WINAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER* ppDAHolder);
HGLOBAL WINAPI OleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel);
HGLOBAL WINAPI OleGetIconOfFile(LPOLESTR lpszPath, BOOL fUseFileAsLabel);
HGLOBAL WINAPI OleMetafilePictFromIconAndLabel(HICON hIcon, LPOLESTR lpszLabel, LPOLESTR lpszSourceFile, UINT iIconIndex);
HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses);
HRESULT WINAPI OleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid,
DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI OleCreateFromFileEx(REFCLSID clsid, LPCOLESTR filename, REFIID iid, DWORD flags,
DWORD renderopt, ULONG num_fmts, DWORD *adv_flags, LPFORMATETC fmts, IAdviseSink *sink,
DWORD *conns, LPOLECLIENTSITE client_site, LPSTORAGE storage, LPVOID* obj);
HRESULT WINAPI OleCreateLink(LPMONIKER pmkLinkSrc, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI OleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite,
LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI OleFlushClipboard(void);
HRESULT WINAPI GetConvertStg(LPSTORAGE pStg);
HRESULT WINAPI SetConvertStg(LPSTORAGE pStg, BOOL fConvert);
BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, struct tagMSG* lpMsg, WORD* lpwCmd);
HRESULT WINAPI OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags);
HRESULT WINAPI WriteFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType);
HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, struct tagMSG* lpmsg);
HRESULT WINAPI OleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI OleCreateFromDataEx(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD dwFlags, DWORD renderopt, ULONG num_formats,
DWORD *adv_flags, LPFORMATETC fmts, IAdviseSink *sink, DWORD *conns,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
HRESULT WINAPI OleCreateDefaultHandler(REFCLSID clsid,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID* ppvObj);
HRESULT WINAPI OleCreateEmbeddingHelper(REFCLSID clsid,
LPUNKNOWN pUnkOuter,
DWORD flags,
IClassFactory *pCF,
REFIID riid,
LPVOID* ppvObj);
HRESULT WINAPI CreateOleAdviseHolder (LPOLEADVISEHOLDER *ppOAHolder);
HRESULT WINAPI OleInitialize(LPVOID pvReserved);
void WINAPI OleUninitialize(void);
BOOL WINAPI IsValidInterface(LPUNKNOWN punk);
DWORD WINAPI OleBuildVersion(VOID);
WINOLE32API HRESULT WINAPI RegisterDragDrop(HWND,LPDROPTARGET);
WINOLE32API HRESULT WINAPI RevokeDragDrop(HWND);
WINOLE32API HRESULT WINAPI DoDragDrop(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
WINOLE32API HRESULT WINAPI OleLoadFromStream(IStream *pStm,REFIID iidInterface,void** ppvObj);
WINOLE32API HRESULT WINAPI OleSaveToStream(IPersistStream *pPStm,IStream *pStm);
WINOLE32API HOLEMENU WINAPI OleCreateMenuDescriptor(HMENU hmenuCombined,LPOLEMENUGROUPWIDTHS lpMenuWidths);
WINOLE32API HRESULT WINAPI OleDestroyMenuDescriptor(HOLEMENU hmenuDescriptor);
WINOLE32API HRESULT WINAPI OleSetMenuDescriptor(HOLEMENU hmenuDescriptor,HWND hwndFrame,HWND hwndActiveObject,LPOLEINPLACEFRAME lpFrame,LPOLEINPLACEACTIVEOBJECT lpActiveObject);
WINOLE32API HRESULT WINAPI WriteClassStg(IStorage *pstg, REFCLSID rclsid);
WINOLE32API HRESULT WINAPI ReadClassStg(IStorage *pstg,CLSID *pclsid);
WINOLE32API HRESULT WINAPI WriteClassStm(IStream *pStm,REFCLSID rclsid);
WINOLE32API HRESULT WINAPI ReadClassStm(IStream *pStm,CLSID *pclsid);
WINOLE32API HRESULT WINAPI OleSave(LPPERSISTSTORAGE pPS, LPSTORAGE pStg, BOOL fSameAsLoad);
WINOLE32API HRESULT WINAPI OleRegGetUserType(REFCLSID clsid, DWORD dwFormOfType, LPOLESTR* pszUserType);
WINOLE32API HRESULT WINAPI OleRegGetMiscStatus (REFCLSID clsid, DWORD dwAspect, DWORD* pdwStatus);
WINOLE32API HRESULT WINAPI OleRegEnumFormatEtc (REFCLSID clsid, DWORD dwDirection, LPENUMFORMATETC* ppenumFormatetc);
WINOLE32API HRESULT WINAPI CreateStreamOnHGlobal (HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM* ppstm);
WINOLE32API HRESULT WINAPI GetHGlobalFromStream(LPSTREAM pstm, HGLOBAL* phglobal);
WINOLE32API HRESULT WINAPI OleRegEnumVerbs (REFCLSID clsid, LPENUMOLEVERB* ppenum);
WINOLE32API BOOL WINAPI OleIsRunning(LPOLEOBJECT pObject);
WINOLE32API HRESULT WINAPI OleCreateLinkFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleSetContainedObject(LPUNKNOWN pUnknown, BOOL fContained);
WINOLE32API HRESULT WINAPI OleNoteObjectVisible(LPUNKNOWN pUnknown, BOOL fVisible);
WINOLE32API HRESULT WINAPI OleQueryLinkFromData(IDataObject* pSrcDataObject);
WINOLE32API HRESULT WINAPI OleQueryCreateFromData(LPDATAOBJECT pSrcDataObject);
WINOLE32API HRESULT WINAPI OleRun(LPUNKNOWN pUnknown);
WINOLE32API HRESULT WINAPI OleDraw(LPUNKNOWN pUnknown, DWORD dwAspect, HDC hdcDraw, LPCRECT lprcBounds);
WINOLE32API VOID WINAPI ReleaseStgMedium(LPSTGMEDIUM);
WINOLE32API HRESULT WINAPI OleGetClipboard(IDataObject** ppDataObj);
WINOLE32API HRESULT WINAPI OleIsCurrentClipboard(LPDATAOBJECT);
WINOLE32API HRESULT WINAPI OleSetClipboard(LPDATAOBJECT);
WINOLE32API HRESULT WINAPI OleCreateStaticFromData(LPDATAOBJECT pSrcDataObj, REFIID iid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI ReadFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT* pcf, LPOLESTR* lplpszUserType);
WINOLE32API HRESULT WINAPI OleLoad(LPSTORAGE pStg, REFIID riid, LPOLECLIENTSITE pClientSite, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI GetHGlobalFromILockBytes(LPLOCKBYTES plkbyt, HGLOBAL* phglobal);
WINOLE32API HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPLOCKBYTES* pplkbyt);
WINOLE32API HRESULT WINAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER* ppDAHolder);
WINOLE32API HGLOBAL WINAPI OleGetIconOfClass(REFCLSID rclsid, LPOLESTR lpszLabel, BOOL fUseTypeAsLabel);
WINOLE32API HGLOBAL WINAPI OleGetIconOfFile(LPOLESTR lpszPath, BOOL fUseFileAsLabel);
WINOLE32API HGLOBAL WINAPI OleMetafilePictFromIconAndLabel(HICON hIcon, LPOLESTR lpszLabel, LPOLESTR lpszSourceFile, UINT iIconIndex);
WINOLE32API HRESULT WINAPI OleLockRunning(LPUNKNOWN pUnknown, BOOL fLock, BOOL fLastUnlockCloses);
WINOLE32API HRESULT WINAPI OleCreateFromFile(REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID riid,
DWORD renderopt, LPFORMATETC lpFormatEtc, LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleCreateFromFileEx(REFCLSID clsid, LPCOLESTR filename, REFIID iid, DWORD flags,
DWORD renderopt, ULONG num_fmts, DWORD *adv_flags, LPFORMATETC fmts, IAdviseSink *sink,
DWORD *conns, LPOLECLIENTSITE client_site, LPSTORAGE storage, LPVOID* obj);
WINOLE32API HRESULT WINAPI OleCreateLink(LPMONIKER pmkLinkSrc, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc,LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleCreate(REFCLSID rclsid, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc, LPOLECLIENTSITE pClientSite,LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleFlushClipboard(void);
WINOLE32API HRESULT WINAPI GetConvertStg(LPSTORAGE pStg);
WINOLE32API HRESULT WINAPI SetConvertStg(LPSTORAGE pStg, BOOL fConvert);
WINOLE32API BOOL WINAPI IsAccelerator(HACCEL hAccel, int cAccelEntries, struct tagMSG* lpMsg, WORD* lpwCmd);
WINOLE32API HRESULT WINAPI OleCreateLinkToFile(LPCOLESTR lpszFileName, REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HANDLE WINAPI OleDuplicateData(HANDLE hSrc, CLIPFORMAT cfFormat, UINT uiFlags);
WINOLE32API HRESULT WINAPI WriteFmtUserTypeStg(LPSTORAGE pstg, CLIPFORMAT cf, LPOLESTR lpszUserType);
WINOLE32API HRESULT WINAPI OleTranslateAccelerator (LPOLEINPLACEFRAME lpFrame, LPOLEINPLACEFRAMEINFO lpFrameInfo, struct tagMSG* lpmsg);
WINOLE32API HRESULT WINAPI OleCreateFromData(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD renderopt, LPFORMATETC pFormatEtc,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleCreateFromDataEx(LPDATAOBJECT pSrcDataObj, REFIID riid, DWORD dwFlags, DWORD renderopt, ULONG num_formats,
DWORD *adv_flags, LPFORMATETC fmts, IAdviseSink *sink, DWORD *conns,
LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleCreateDefaultHandler(REFCLSID clsid, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI OleCreateEmbeddingHelper(REFCLSID clsid, LPUNKNOWN pUnkOuter, DWORD flags, IClassFactory *pCF, REFIID riid, LPVOID* ppvObj);
WINOLE32API HRESULT WINAPI CreateOleAdviseHolder (LPOLEADVISEHOLDER *ppOAHolder);
WINOLE32API HRESULT WINAPI OleInitialize(LPVOID pvReserved);
WINOLE32API void WINAPI OleUninitialize(void);
WINOLE32API BOOL WINAPI IsValidInterface(LPUNKNOWN punk);
WINOLE32API DWORD WINAPI OleBuildVersion(VOID);
/*
* OLE version conversion declarations
......@@ -159,14 +140,13 @@ typedef struct _OLESTREAM {
LPOLESTREAMVTBL lpstbl;
} OLESTREAM;
HRESULT WINAPI OleConvertOLESTREAMToIStorage( LPOLESTREAM lpolestream, LPSTORAGE pstg, const DVTARGETDEVICE* ptd);
HRESULT WINAPI OleConvertIStorageToOLESTREAM( LPSTORAGE pstg, LPOLESTREAM lpolestream);
HRESULT WINAPI OleConvertIStorageToOLESTREAMEx( LPSTORAGE stg, CLIPFORMAT cf, LONG width, LONG height,
DWORD size, LPSTGMEDIUM medium, LPOLESTREAM olestream );
HRESULT WINAPI OleDoAutoConvert( LPSTORAGE pStg, LPCLSID pClsidNew );
HRESULT WINAPI OleGetAutoConvert( REFCLSID clsidOld, LPCLSID pClsidNew );
HRESULT WINAPI OleSetAutoConvert( REFCLSID clsidOld, REFCLSID clsidNew );
WINOLE32API HRESULT WINAPI OleConvertOLESTREAMToIStorage( LPOLESTREAM lpolestream, LPSTORAGE pstg, const DVTARGETDEVICE* ptd);
WINOLE32API HRESULT WINAPI OleConvertIStorageToOLESTREAM( LPSTORAGE pstg, LPOLESTREAM lpolestream);
WINOLE32API HRESULT WINAPI OleConvertIStorageToOLESTREAMEx( LPSTORAGE stg, CLIPFORMAT cf, LONG width, LONG height,
DWORD size, LPSTGMEDIUM medium, LPOLESTREAM olestream );
WINOLE32API HRESULT WINAPI OleDoAutoConvert( LPSTORAGE pStg, LPCLSID pClsidNew );
WINOLE32API HRESULT WINAPI OleGetAutoConvert( REFCLSID clsidOld, LPCLSID pClsidNew );
WINOLE32API HRESULT WINAPI OleSetAutoConvert( REFCLSID clsidOld, REFCLSID clsidNew );
#ifdef __cplusplus
} /* extern "C" */
......
include/oleauto.h
View file @ 3de15569
......@@ -35,69 +35,77 @@ DEFINE_OLEGUID(IID_StdOle, 0x00020430,0,0);
#define STDOLE2_MINORVERNUM 0
#define STDOLE2_LCID 0
ULONG WINAPI OaBuildVersion(void);
#ifndef WINOLEAUTAPI
#ifdef _OLEAUT32_
#define WINOLEAUTAPI
#else
#define WINOLEAUTAPI DECLSPEC_IMPORT
#endif
#endif
WINOLEAUTAPI ULONG WINAPI OaBuildVersion(void);
/* BSTR functions */
void WINAPI SysFreeString(BSTR);
BSTR WINAPI SysAllocString(const OLECHAR*) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
BSTR WINAPI SysAllocStringByteLen(LPCSTR,UINT) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
BSTR WINAPI SysAllocStringLen(const OLECHAR*,UINT) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
INT WINAPI SysReAllocString(LPBSTR,const OLECHAR*);
int WINAPI SysReAllocStringLen(BSTR*,const OLECHAR*,UINT);
UINT WINAPI SysStringByteLen(BSTR);
UINT WINAPI SysStringLen(BSTR);
WINOLEAUTAPI void WINAPI SysFreeString(BSTR);
WINOLEAUTAPI BSTR WINAPI SysAllocString(const OLECHAR*) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
WINOLEAUTAPI BSTR WINAPI SysAllocStringByteLen(LPCSTR,UINT) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
WINOLEAUTAPI BSTR WINAPI SysAllocStringLen(const OLECHAR*,UINT) __WINE_DEALLOC(SysFreeString) __WINE_MALLOC;
WINOLEAUTAPI INT WINAPI SysReAllocString(LPBSTR,const OLECHAR*);
WINOLEAUTAPI int WINAPI SysReAllocStringLen(BSTR*,const OLECHAR*,UINT);
WINOLEAUTAPI UINT WINAPI SysStringByteLen(BSTR);
WINOLEAUTAPI UINT WINAPI SysStringLen(BSTR);
/* IErrorInfo helpers */
HRESULT WINAPI SetErrorInfo(ULONG,IErrorInfo*);
HRESULT WINAPI GetErrorInfo(ULONG,IErrorInfo**);
HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo**);
WINOLEAUTAPI HRESULT WINAPI SetErrorInfo(ULONG,IErrorInfo*);
WINOLEAUTAPI HRESULT WINAPI GetErrorInfo(ULONG,IErrorInfo**);
WINOLEAUTAPI HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo**);
/* SafeArray functions */
SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE,UINT,SAFEARRAYBOUND*);
SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE,UINT,SAFEARRAYBOUND*,LPVOID);
SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE,LONG,ULONG);
SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE,LONG,ULONG,LPVOID);
HRESULT WINAPI SafeArrayAllocDescriptor(UINT,SAFEARRAY**);
HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE,UINT,SAFEARRAY**);
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY*);
HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY*);
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY*,LONG*,void*);
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY*,LONG*,void*);
HRESULT WINAPI SafeArrayLock(SAFEARRAY*);
HRESULT WINAPI SafeArrayUnlock(SAFEARRAY*);
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY*,UINT,LONG*);
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY*,UINT,LONG*);
UINT WINAPI SafeArrayGetDim(SAFEARRAY*);
UINT WINAPI SafeArrayGetElemsize(SAFEARRAY*);
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY*,VARTYPE*);
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY*,void**);
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY*);
HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY*,LONG*,void **);
HRESULT WINAPI SafeArrayCopyData(SAFEARRAY*,SAFEARRAY*);
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY*);
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY*);
HRESULT WINAPI SafeArrayCopy(SAFEARRAY*,SAFEARRAY**);
HRESULT WINAPI SafeArrayRedim(SAFEARRAY*,SAFEARRAYBOUND*);
HRESULT WINAPI SafeArraySetRecordInfo(SAFEARRAY*,IRecordInfo*);
HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY*,IRecordInfo**);
HRESULT WINAPI SafeArraySetIID(SAFEARRAY*,REFGUID);
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY*,GUID*);
HRESULT WINAPI VectorFromBstr(BSTR,SAFEARRAY**);
HRESULT WINAPI BstrFromVector(SAFEARRAY*,BSTR*);
WINOLEAUTAPI SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE,UINT,SAFEARRAYBOUND*);
WINOLEAUTAPI SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE,UINT,SAFEARRAYBOUND*,LPVOID);
WINOLEAUTAPI SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE,LONG,ULONG);
WINOLEAUTAPI SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE,LONG,ULONG,LPVOID);
WINOLEAUTAPI HRESULT WINAPI SafeArrayAllocDescriptor(UINT,SAFEARRAY**);
WINOLEAUTAPI HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE,UINT,SAFEARRAY**);
WINOLEAUTAPI HRESULT WINAPI SafeArrayAllocData(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayPutElement(SAFEARRAY*,LONG*,void*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetElement(SAFEARRAY*,LONG*,void*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayLock(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayUnlock(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY*,UINT,LONG*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY*,UINT,LONG*);
WINOLEAUTAPI UINT WINAPI SafeArrayGetDim(SAFEARRAY*);
WINOLEAUTAPI UINT WINAPI SafeArrayGetElemsize(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY*,VARTYPE*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayAccessData(SAFEARRAY*,void**);
WINOLEAUTAPI HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY*,LONG*,void **);
WINOLEAUTAPI HRESULT WINAPI SafeArrayCopyData(SAFEARRAY*,SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayDestroy(SAFEARRAY*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayCopy(SAFEARRAY*,SAFEARRAY**);
WINOLEAUTAPI HRESULT WINAPI SafeArrayRedim(SAFEARRAY*,SAFEARRAYBOUND*);
WINOLEAUTAPI HRESULT WINAPI SafeArraySetRecordInfo(SAFEARRAY*,IRecordInfo*);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY*,IRecordInfo**);
WINOLEAUTAPI HRESULT WINAPI SafeArraySetIID(SAFEARRAY*,REFGUID);
WINOLEAUTAPI HRESULT WINAPI SafeArrayGetIID(SAFEARRAY*,GUID*);
WINOLEAUTAPI HRESULT WINAPI VectorFromBstr(BSTR,SAFEARRAY**);
WINOLEAUTAPI HRESULT WINAPI BstrFromVector(SAFEARRAY*,BSTR*);
/* Object registration helpers */
#define ACTIVEOBJECT_STRONG 0
#define ACTIVEOBJECT_WEAK 1
HRESULT WINAPI RegisterActiveObject(LPUNKNOWN,REFCLSID,DWORD,LPDWORD);
HRESULT WINAPI RevokeActiveObject(DWORD,LPVOID);
HRESULT WINAPI GetActiveObject(REFCLSID,LPVOID,LPUNKNOWN*);
WINOLEAUTAPI HRESULT WINAPI RegisterActiveObject(LPUNKNOWN,REFCLSID,DWORD,LPDWORD);
WINOLEAUTAPI HRESULT WINAPI RevokeActiveObject(DWORD,LPVOID);
WINOLEAUTAPI HRESULT WINAPI GetActiveObject(REFCLSID,LPVOID,LPUNKNOWN*);
/* IRecordInfo helpers */
HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo*,IRecordInfo**);
HRESULT WINAPI GetRecordInfoFromGuids(REFGUID,ULONG,ULONG,LCID,REFGUID,IRecordInfo**);
WINOLEAUTAPI HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo*,IRecordInfo**);
WINOLEAUTAPI HRESULT WINAPI GetRecordInfoFromGuids(REFGUID,ULONG,ULONG,LCID,REFGUID,IRecordInfo**);
/*
* Variants
......@@ -184,12 +192,12 @@ HRESULT WINAPI GetRecordInfoFromGuids(REFGUID,ULONG,ULONG,LCID,REFGUID,IRecordIn
#define V_UNKNOWNREF(A) V_UNION(A,ppunkVal)
#define V_VARIANTREF(A) V_UNION(A,pvarVal)
void WINAPI VariantInit(VARIANT*);
HRESULT WINAPI VariantClear(VARIANT*);
HRESULT WINAPI VariantCopy(VARIANTARG *dst, const VARIANTARG *src);
HRESULT WINAPI VariantCopyInd(VARIANT *dst, const VARIANTARG *src);
HRESULT WINAPI VariantChangeType(VARIANTARG *dst, const VARIANTARG *src, USHORT flags, VARTYPE vt);
HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *dst, const VARIANTARG *src, LCID lcid, USHORT flags, VARTYPE vt);
WINOLEAUTAPI void WINAPI VariantInit(VARIANT*);
WINOLEAUTAPI HRESULT WINAPI VariantClear(VARIANT*);
WINOLEAUTAPI HRESULT WINAPI VariantCopy(VARIANTARG *dst, const VARIANTARG *src);
WINOLEAUTAPI HRESULT WINAPI VariantCopyInd(VARIANT *dst, const VARIANTARG *src);
WINOLEAUTAPI HRESULT WINAPI VariantChangeType(VARIANTARG *dst, const VARIANTARG *src, USHORT flags, VARTYPE vt);
WINOLEAUTAPI HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *dst, const VARIANTARG *src, LCID lcid, USHORT flags, VARTYPE vt);
/* VariantChangeType/VariantChangeTypeEx flags */
#define VARIANT_NOVALUEPROP 0x01 /* Don't get the default value property from IDispatch */
......@@ -226,247 +234,247 @@ HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *dst, const VARIANTARG *src, LCID
#define VTDATEGRE_MIN -657434 /* Minimum possible Gregorian date: 1/1/100 */
#define VTDATEGRE_MAX 2958465 /* Maximum possible Gregorian date: 31/12/9999 */
HRESULT WINAPI VarUI1FromI2(SHORT,BYTE*);
HRESULT WINAPI VarUI1FromI4(LONG,BYTE*);
HRESULT WINAPI VarUI1FromI8(LONG64,BYTE*);
HRESULT WINAPI VarUI1FromR4(FLOAT,BYTE*);
HRESULT WINAPI VarUI1FromR8(DOUBLE,BYTE*);
HRESULT WINAPI VarUI1FromDate(DATE,BYTE*);
HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL,BYTE*);
HRESULT WINAPI VarUI1FromI1(signed char,BYTE*);
HRESULT WINAPI VarUI1FromUI2(USHORT,BYTE*);
HRESULT WINAPI VarUI1FromUI4(ULONG,BYTE*);
HRESULT WINAPI VarUI1FromUI8(ULONG64,BYTE*);
HRESULT WINAPI VarUI1FromStr(const OLECHAR*,LCID,ULONG,BYTE*);
HRESULT WINAPI VarUI1FromCy(CY,BYTE*);
HRESULT WINAPI VarUI1FromDec(const DECIMAL*,BYTE*);
HRESULT WINAPI VarUI1FromDisp(IDispatch*,LCID,BYTE*);
HRESULT WINAPI VarI2FromUI1(BYTE,SHORT*);
HRESULT WINAPI VarI2FromI4(LONG,SHORT*);
HRESULT WINAPI VarI2FromI8(LONG64,SHORT*);
HRESULT WINAPI VarI2FromR4(FLOAT,SHORT*);
HRESULT WINAPI VarI2FromR8(DOUBLE,SHORT*);
HRESULT WINAPI VarI2FromDate(DATE,SHORT*);
HRESULT WINAPI VarI2FromBool(VARIANT_BOOL,SHORT*);
HRESULT WINAPI VarI2FromI1(signed char,SHORT*);
HRESULT WINAPI VarI2FromUI2(USHORT,SHORT*);
HRESULT WINAPI VarI2FromUI4(ULONG,SHORT*);
HRESULT WINAPI VarI2FromUI8(ULONG64,SHORT*);
HRESULT WINAPI VarI2FromStr(const OLECHAR*,LCID,ULONG,SHORT*);
HRESULT WINAPI VarI2FromCy(CY,SHORT*);
HRESULT WINAPI VarI2FromDec(const DECIMAL*,SHORT*);
HRESULT WINAPI VarI2FromDisp(IDispatch*,LCID,SHORT*);
HRESULT WINAPI VarI4FromUI1(BYTE,LONG*);
HRESULT WINAPI VarI4FromI2(SHORT,LONG*);
HRESULT WINAPI VarI4FromI8(LONG64,LONG*);
HRESULT WINAPI VarI4FromR4(FLOAT,LONG*);
HRESULT WINAPI VarI4FromR8(DOUBLE,LONG*);
HRESULT WINAPI VarI4FromDate(DATE,LONG*);
HRESULT WINAPI VarI4FromBool(VARIANT_BOOL,LONG*);
HRESULT WINAPI VarI4FromI1(signed char,LONG*);
HRESULT WINAPI VarI4FromUI2(USHORT,LONG*);
HRESULT WINAPI VarI4FromUI4(ULONG,LONG*);
HRESULT WINAPI VarI4FromUI8(ULONG64,LONG*);
HRESULT WINAPI VarI4FromStr(const OLECHAR*,LCID,ULONG,LONG*);
HRESULT WINAPI VarI4FromCy(CY,LONG*);
HRESULT WINAPI VarI4FromDec(const DECIMAL*,LONG*);
HRESULT WINAPI VarI4FromDisp(IDispatch*,LCID,LONG*);
HRESULT WINAPI VarI8FromUI1(BYTE,LONG64*);
HRESULT WINAPI VarI8FromI2(SHORT,LONG64*);
HRESULT WINAPI VarI8FromI4(LONG,LONG64*);
HRESULT WINAPI VarI8FromR4(FLOAT,LONG64*);
HRESULT WINAPI VarI8FromR8(DOUBLE,LONG64*);
HRESULT WINAPI VarI8FromDate(DATE,LONG64*);
HRESULT WINAPI VarI8FromStr(const OLECHAR*,LCID,ULONG,LONG64*);
HRESULT WINAPI VarI8FromBool(VARIANT_BOOL,LONG64*);
HRESULT WINAPI VarI8FromI1(signed char,LONG64*);
HRESULT WINAPI VarI8FromUI2(USHORT,LONG64*);
HRESULT WINAPI VarI8FromUI4(ULONG,LONG64*);
HRESULT WINAPI VarI8FromUI8(ULONG64,LONG64*);
HRESULT WINAPI VarI8FromDec(const DECIMAL *pdecIn,LONG64*);
HRESULT WINAPI VarI8FromInt(INT intIn,LONG64*);
HRESULT WINAPI VarI8FromCy(CY,LONG64*);
HRESULT WINAPI VarI8FromDisp(IDispatch*,LCID,LONG64*);
HRESULT WINAPI VarR4FromUI1(BYTE,FLOAT*);
HRESULT WINAPI VarR4FromI2(SHORT,FLOAT*);
HRESULT WINAPI VarR4FromI4(LONG,FLOAT*);
HRESULT WINAPI VarR4FromI8(LONG64,FLOAT*);
HRESULT WINAPI VarR4FromR8(DOUBLE,FLOAT*);
HRESULT WINAPI VarR4FromDate(DATE,FLOAT*);
HRESULT WINAPI VarR4FromBool(VARIANT_BOOL,FLOAT*);
HRESULT WINAPI VarR4FromI1(signed char,FLOAT*);
HRESULT WINAPI VarR4FromUI2(USHORT,FLOAT*);
HRESULT WINAPI VarR4FromUI4(ULONG,FLOAT*);
HRESULT WINAPI VarR4FromUI8(ULONG64,FLOAT*);
HRESULT WINAPI VarR4FromStr(const OLECHAR*,LCID,ULONG,FLOAT*);
HRESULT WINAPI VarR4FromCy(CY,FLOAT*);
HRESULT WINAPI VarR4FromDec(const DECIMAL*,FLOAT*);
HRESULT WINAPI VarR4FromDisp(IDispatch*,LCID,FLOAT*);
HRESULT WINAPI VarR8FromUI1(BYTE,double*);
HRESULT WINAPI VarR8FromI2(SHORT,double*);
HRESULT WINAPI VarR8FromI4(LONG,double*);
HRESULT WINAPI VarR8FromI8(LONG64,double*);
HRESULT WINAPI VarR8FromR4(FLOAT,double*);
HRESULT WINAPI VarR8FromDate(DATE,double*);
HRESULT WINAPI VarR8FromBool(VARIANT_BOOL,double*);
HRESULT WINAPI VarR8FromI1(signed char,double*);
HRESULT WINAPI VarR8FromUI2(USHORT,double*);
HRESULT WINAPI VarR8FromUI4(ULONG,double*);
HRESULT WINAPI VarR8FromUI8(ULONG64,double*);
HRESULT WINAPI VarR8FromStr(const OLECHAR*,LCID,ULONG,double*);
HRESULT WINAPI VarR8FromCy(CY,double*);
HRESULT WINAPI VarR8FromDec(const DECIMAL*,double*);
HRESULT WINAPI VarR8FromDisp(IDispatch*,LCID,double*);
HRESULT WINAPI VarDateFromUI1(BYTE,DATE*);
HRESULT WINAPI VarDateFromI2(SHORT,DATE*);
HRESULT WINAPI VarDateFromI4(LONG,DATE*);
HRESULT WINAPI VarDateFromI8(LONG64,DATE*);
HRESULT WINAPI VarDateFromR4(FLOAT,DATE*);
HRESULT WINAPI VarDateFromR8(DOUBLE,DATE*);
HRESULT WINAPI VarDateFromStr(const OLECHAR*,LCID,ULONG,DATE*);
HRESULT WINAPI VarDateFromI1(signed char,DATE*);
HRESULT WINAPI VarDateFromUI2(USHORT,DATE*);
HRESULT WINAPI VarDateFromUI4(ULONG,DATE*);
HRESULT WINAPI VarDateFromUI8(ULONG64,DATE*);
HRESULT WINAPI VarDateFromBool(VARIANT_BOOL,DATE*);
HRESULT WINAPI VarDateFromCy(CY,DATE*);
HRESULT WINAPI VarDateFromDec(const DECIMAL*,DATE*);
HRESULT WINAPI VarDateFromDisp(IDispatch*,LCID,DATE*);
HRESULT WINAPI VarCyFromUI1(BYTE,CY*);
HRESULT WINAPI VarCyFromI2(SHORT sIn,CY*);
HRESULT WINAPI VarCyFromI4(LONG,CY*);
HRESULT WINAPI VarCyFromI8(LONG64,CY*);
HRESULT WINAPI VarCyFromR4(FLOAT,CY*);
HRESULT WINAPI VarCyFromR8(DOUBLE,CY*);
HRESULT WINAPI VarCyFromDate(DATE,CY*);
HRESULT WINAPI VarCyFromStr(const OLECHAR*,LCID,ULONG,CY*);
HRESULT WINAPI VarCyFromBool(VARIANT_BOOL,CY*);
HRESULT WINAPI VarCyFromI1(signed char,CY*);
HRESULT WINAPI VarCyFromUI2(USHORT,CY*);
HRESULT WINAPI VarCyFromUI4(ULONG,CY*);
HRESULT WINAPI VarCyFromUI8(ULONG64,CY*);
HRESULT WINAPI VarCyFromDec(const DECIMAL*,CY*);
HRESULT WINAPI VarCyFromDisp(IDispatch*,LCID,CY*);
HRESULT WINAPI VarBstrFromUI1(BYTE,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromI2(SHORT,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromI4(LONG,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromI8(LONG64,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromR4(FLOAT,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromR8(DOUBLE,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromDate(DATE,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromI1(signed char,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromUI2(USHORT,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromUI8(ULONG64,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromUI4(ULONG,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromCy(CY,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromDec(const DECIMAL*,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBstrFromDisp(IDispatch*,LCID,ULONG,BSTR*);
HRESULT WINAPI VarBoolFromUI1(BYTE,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromI2(SHORT,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromI4(LONG,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromI8(LONG64,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromR4(FLOAT,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromR8(DOUBLE,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromDate(DATE,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromStr(const OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromI1(signed char,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromUI2(USHORT,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromUI4(ULONG,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromUI8(ULONG64,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromCy(CY,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromDec(const DECIMAL*,VARIANT_BOOL*);
HRESULT WINAPI VarBoolFromDisp(IDispatch*,LCID,VARIANT_BOOL*);
HRESULT WINAPI VarI1FromUI1(BYTE,signed char*);
HRESULT WINAPI VarI1FromI2(SHORT,signed char*);
HRESULT WINAPI VarI1FromI4(LONG,signed char*);
HRESULT WINAPI VarI1FromI8(LONG64,signed char*);
HRESULT WINAPI VarI1FromR4(FLOAT,signed char*);
HRESULT WINAPI VarI1FromR8(DOUBLE,signed char*);
HRESULT WINAPI VarI1FromDate(DATE,signed char*);
HRESULT WINAPI VarI1FromStr(const OLECHAR*,LCID,ULONG,signed char*);
HRESULT WINAPI VarI1FromBool(VARIANT_BOOL,signed char*);
HRESULT WINAPI VarI1FromUI2(USHORT,signed char*);
HRESULT WINAPI VarI1FromUI4(ULONG,signed char*);
HRESULT WINAPI VarI1FromUI8(ULONG64,signed char*);
HRESULT WINAPI VarI1FromCy(CY,signed char*);
HRESULT WINAPI VarI1FromDec(const DECIMAL*,signed char*);
HRESULT WINAPI VarI1FromDisp(IDispatch*,LCID,signed char*);
HRESULT WINAPI VarUI2FromUI1(BYTE,USHORT*);
HRESULT WINAPI VarUI2FromI2(SHORT,USHORT*);
HRESULT WINAPI VarUI2FromI4(LONG,USHORT*);
HRESULT WINAPI VarUI2FromI8(LONG64,USHORT*);
HRESULT WINAPI VarUI2FromR4(FLOAT,USHORT*);
HRESULT WINAPI VarUI2FromR8(DOUBLE,USHORT*);
HRESULT WINAPI VarUI2FromDate(DATE,USHORT*);
HRESULT WINAPI VarUI2FromStr(const OLECHAR*,LCID,ULONG,USHORT*);
HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL,USHORT*);
HRESULT WINAPI VarUI2FromI1(signed char,USHORT*);
HRESULT WINAPI VarUI2FromUI4(ULONG,USHORT*);
HRESULT WINAPI VarUI2FromUI8(ULONG64,USHORT*);
HRESULT WINAPI VarUI2FromCy(CY,USHORT*);
HRESULT WINAPI VarUI2FromDec(const DECIMAL*,USHORT*);
HRESULT WINAPI VarUI2FromDisp(IDispatch*,LCID,USHORT*);
HRESULT WINAPI VarUI4FromStr(const OLECHAR*,LCID,ULONG,ULONG*);
HRESULT WINAPI VarUI4FromUI1(BYTE,ULONG*);
HRESULT WINAPI VarUI4FromI2(SHORT,ULONG*);
HRESULT WINAPI VarUI4FromI4(LONG,ULONG*);
HRESULT WINAPI VarUI4FromI8(LONG64,ULONG*);
HRESULT WINAPI VarUI4FromR4(FLOAT,ULONG*);
HRESULT WINAPI VarUI4FromR8(DOUBLE,ULONG*);
HRESULT WINAPI VarUI4FromDate(DATE,ULONG*);
HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL,ULONG*);
HRESULT WINAPI VarUI4FromI1(signed char,ULONG*);
HRESULT WINAPI VarUI4FromUI2(USHORT,ULONG*);
HRESULT WINAPI VarUI4FromUI8(ULONG64,ULONG*);
HRESULT WINAPI VarUI4FromCy(CY,ULONG*);
HRESULT WINAPI VarUI4FromDec(const DECIMAL*,ULONG*);
HRESULT WINAPI VarUI4FromDisp(IDispatch*,LCID,ULONG*);
HRESULT WINAPI VarUI8FromUI1(BYTE,ULONG64*);
HRESULT WINAPI VarUI8FromI2(SHORT,ULONG64*);
HRESULT WINAPI VarUI8FromI4(LONG,ULONG64*);
HRESULT WINAPI VarUI8FromI8(LONG64,ULONG64*);
HRESULT WINAPI VarUI8FromR4(FLOAT,ULONG64*);
HRESULT WINAPI VarUI8FromR8(DOUBLE,ULONG64*);
HRESULT WINAPI VarUI8FromDate(DATE,ULONG64*);
HRESULT WINAPI VarUI8FromStr(const OLECHAR*,LCID,ULONG,ULONG64*);
HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL,ULONG64*);
HRESULT WINAPI VarUI8FromI1(signed char,ULONG64*);
HRESULT WINAPI VarUI8FromUI2(USHORT,ULONG64*);
HRESULT WINAPI VarUI8FromUI4(ULONG,ULONG64*);
HRESULT WINAPI VarUI8FromDec(const DECIMAL*,ULONG64*);
HRESULT WINAPI VarUI8FromInt(INT,ULONG64*);
HRESULT WINAPI VarUI8FromCy(CY,ULONG64*);
HRESULT WINAPI VarUI8FromDisp(IDispatch*,LCID,ULONG64*);
HRESULT WINAPI VarDecFromUI1(BYTE,DECIMAL*);
HRESULT WINAPI VarDecFromI2(SHORT,DECIMAL*);
HRESULT WINAPI VarDecFromI4(LONG,DECIMAL*);
HRESULT WINAPI VarDecFromI8(LONG64,DECIMAL*);
HRESULT WINAPI VarDecFromR4(FLOAT,DECIMAL*);
HRESULT WINAPI VarDecFromR8(DOUBLE,DECIMAL*);
HRESULT WINAPI VarDecFromDate(DATE,DECIMAL*);
HRESULT WINAPI VarDecFromStr(const OLECHAR*,LCID,ULONG,DECIMAL*);
HRESULT WINAPI VarDecFromBool(VARIANT_BOOL,DECIMAL*);
HRESULT WINAPI VarDecFromI1(signed char,DECIMAL*);
HRESULT WINAPI VarDecFromUI2(USHORT,DECIMAL*);
HRESULT WINAPI VarDecFromUI4(ULONG,DECIMAL*);
HRESULT WINAPI VarDecFromUI8(ULONG64,DECIMAL*);
HRESULT WINAPI VarDecFromCy(CY,DECIMAL*);
HRESULT WINAPI VarDecFromDisp(IDispatch*,LCID,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromI2(SHORT,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromI4(LONG,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromI8(LONG64,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromR4(FLOAT,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromR8(DOUBLE,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromDate(DATE,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromI1(signed char,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromUI2(USHORT,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromUI4(ULONG,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromUI8(ULONG64,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromStr(const OLECHAR*,LCID,ULONG,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromCy(CY,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromDec(const DECIMAL*,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarUI1FromDisp(IDispatch*,LCID,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromUI1(BYTE,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromI4(LONG,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromI8(LONG64,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromR4(FLOAT,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromR8(DOUBLE,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromDate(DATE,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromBool(VARIANT_BOOL,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromI1(signed char,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromUI2(USHORT,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromUI4(ULONG,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromUI8(ULONG64,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromStr(const OLECHAR*,LCID,ULONG,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromCy(CY,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromDec(const DECIMAL*,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI2FromDisp(IDispatch*,LCID,SHORT*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromUI1(BYTE,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromI2(SHORT,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromI8(LONG64,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromR4(FLOAT,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromR8(DOUBLE,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromDate(DATE,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromBool(VARIANT_BOOL,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromI1(signed char,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromUI2(USHORT,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromUI4(ULONG,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromUI8(ULONG64,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromStr(const OLECHAR*,LCID,ULONG,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromCy(CY,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromDec(const DECIMAL*,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI4FromDisp(IDispatch*,LCID,LONG*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromUI1(BYTE,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromI2(SHORT,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromI4(LONG,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromR4(FLOAT,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromR8(DOUBLE,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromDate(DATE,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromStr(const OLECHAR*,LCID,ULONG,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromBool(VARIANT_BOOL,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromI1(signed char,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromUI2(USHORT,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromUI4(ULONG,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromUI8(ULONG64,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromDec(const DECIMAL *pdecIn,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromInt(INT intIn,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromCy(CY,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarI8FromDisp(IDispatch*,LCID,LONG64*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromUI1(BYTE,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromI2(SHORT,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromI4(LONG,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromI8(LONG64,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromR8(DOUBLE,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromDate(DATE,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromBool(VARIANT_BOOL,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromI1(signed char,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromUI2(USHORT,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromUI4(ULONG,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromUI8(ULONG64,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromStr(const OLECHAR*,LCID,ULONG,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromCy(CY,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromDec(const DECIMAL*,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR4FromDisp(IDispatch*,LCID,FLOAT*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromUI1(BYTE,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromI2(SHORT,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromI4(LONG,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromI8(LONG64,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromR4(FLOAT,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromDate(DATE,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromBool(VARIANT_BOOL,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromI1(signed char,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromUI2(USHORT,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromUI4(ULONG,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromUI8(ULONG64,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromStr(const OLECHAR*,LCID,ULONG,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromCy(CY,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromDec(const DECIMAL*,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8FromDisp(IDispatch*,LCID,double*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUI1(BYTE,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromI2(SHORT,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromI4(LONG,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromI8(LONG64,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromR4(FLOAT,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromR8(DOUBLE,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromStr(const OLECHAR*,LCID,ULONG,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromI1(signed char,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUI2(USHORT,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUI4(ULONG,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUI8(ULONG64,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromBool(VARIANT_BOOL,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromCy(CY,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromDec(const DECIMAL*,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromDisp(IDispatch*,LCID,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromUI1(BYTE,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromI2(SHORT sIn,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromI4(LONG,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromI8(LONG64,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromR4(FLOAT,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromR8(DOUBLE,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromDate(DATE,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromStr(const OLECHAR*,LCID,ULONG,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromBool(VARIANT_BOOL,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromI1(signed char,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromUI2(USHORT,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromUI4(ULONG,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromUI8(ULONG64,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromDec(const DECIMAL*,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyFromDisp(IDispatch*,LCID,CY*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromUI1(BYTE,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromI2(SHORT,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromI4(LONG,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromI8(LONG64,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromR4(FLOAT,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromR8(DOUBLE,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromDate(DATE,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromI1(signed char,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromUI2(USHORT,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromUI8(ULONG64,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromUI4(ULONG,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromCy(CY,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromDec(const DECIMAL*,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBstrFromDisp(IDispatch*,LCID,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromUI1(BYTE,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromI2(SHORT,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromI4(LONG,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromI8(LONG64,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromR4(FLOAT,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromR8(DOUBLE,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromDate(DATE,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromStr(const OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromI1(signed char,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromUI2(USHORT,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromUI4(ULONG,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromUI8(ULONG64,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromCy(CY,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromDec(const DECIMAL*,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarBoolFromDisp(IDispatch*,LCID,VARIANT_BOOL*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromUI1(BYTE,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromI2(SHORT,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromI4(LONG,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromI8(LONG64,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromR4(FLOAT,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromR8(DOUBLE,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromDate(DATE,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromStr(const OLECHAR*,LCID,ULONG,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromBool(VARIANT_BOOL,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromUI2(USHORT,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromUI4(ULONG,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromUI8(ULONG64,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromCy(CY,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromDec(const DECIMAL*,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarI1FromDisp(IDispatch*,LCID,signed char*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromUI1(BYTE,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromI2(SHORT,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromI4(LONG,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromI8(LONG64,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromR4(FLOAT,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromR8(DOUBLE,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromDate(DATE,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromStr(const OLECHAR*,LCID,ULONG,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromI1(signed char,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromUI4(ULONG,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromUI8(ULONG64,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromCy(CY,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromDec(const DECIMAL*,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI2FromDisp(IDispatch*,LCID,USHORT*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromStr(const OLECHAR*,LCID,ULONG,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromUI1(BYTE,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromI2(SHORT,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromI4(LONG,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromI8(LONG64,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromR4(FLOAT,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromR8(DOUBLE,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromDate(DATE,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromI1(signed char,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromUI2(USHORT,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromUI8(ULONG64,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromCy(CY,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromDec(const DECIMAL*,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI4FromDisp(IDispatch*,LCID,ULONG*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromUI1(BYTE,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromI2(SHORT,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromI4(LONG,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromI8(LONG64,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromR4(FLOAT,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromR8(DOUBLE,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromDate(DATE,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromStr(const OLECHAR*,LCID,ULONG,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromI1(signed char,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromUI2(USHORT,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromUI4(ULONG,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromDec(const DECIMAL*,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromInt(INT,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromCy(CY,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarUI8FromDisp(IDispatch*,LCID,ULONG64*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromUI1(BYTE,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromI2(SHORT,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromI4(LONG,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromI8(LONG64,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromR4(FLOAT,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromR8(DOUBLE,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromDate(DATE,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromStr(const OLECHAR*,LCID,ULONG,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromBool(VARIANT_BOOL,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromI1(signed char,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromUI2(USHORT,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromUI4(ULONG,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromUI8(ULONG64,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromCy(CY,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFromDisp(IDispatch*,LCID,DECIMAL*);
#define VarUI4FromUI4( in,pOut ) ( *(pOut) = (in) )
#define VarI4FromI4( in,pOut ) ( *(pOut) = (in) )
......@@ -544,62 +552,62 @@ HRESULT WINAPI VarDecFromDisp(IDispatch*,LCID,DECIMAL*);
#define VARCMP_GT 2
#define VARCMP_NULL 3
HRESULT WINAPI VarR4CmpR8(float,double);
HRESULT WINAPI VarR8Pow(double,double,double*);
HRESULT WINAPI VarR8Round(double,int,double*);
HRESULT WINAPI VarDecAbs(const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecAdd(const DECIMAL*,const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecCmp(const DECIMAL*,const DECIMAL*);
HRESULT WINAPI VarDecCmpR8(const DECIMAL*,DOUBLE);
HRESULT WINAPI VarDecDiv(const DECIMAL*,const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecFix(const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecInt(const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecMul(const DECIMAL*,const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecNeg(const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarDecRound(const DECIMAL*,int,DECIMAL*);
HRESULT WINAPI VarDecSub(const DECIMAL*,const DECIMAL*,DECIMAL*);
HRESULT WINAPI VarCyAbs(CY,CY*);
HRESULT WINAPI VarCyAdd(CY,CY,CY*);
HRESULT WINAPI VarCyCmp(CY,CY);
HRESULT WINAPI VarCyCmpR8(CY,DOUBLE);
HRESULT WINAPI VarCyFix(CY,CY*);
HRESULT WINAPI VarCyInt(CY,CY*);
HRESULT WINAPI VarCyMul(CY,CY,CY*);
HRESULT WINAPI VarCyMulI4(CY,LONG,CY*);
HRESULT WINAPI VarCyMulI8(CY,LONG64,CY*);
HRESULT WINAPI VarCyNeg(CY,CY*);
HRESULT WINAPI VarCyRound(CY,INT,CY*);
HRESULT WINAPI VarCySub(CY,CY,CY*);
HRESULT WINAPI VarAdd(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarAnd(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarCat(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarDiv(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarEqv(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarIdiv(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarImp(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarMod(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarMul(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarOr(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarPow(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarSub(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarXor(LPVARIANT,LPVARIANT,LPVARIANT);
HRESULT WINAPI VarAbs(LPVARIANT,LPVARIANT);
HRESULT WINAPI VarFix(LPVARIANT,LPVARIANT);
HRESULT WINAPI VarInt(LPVARIANT,LPVARIANT);
HRESULT WINAPI VarNeg(LPVARIANT,LPVARIANT);
HRESULT WINAPI VarNot(LPVARIANT,LPVARIANT);
HRESULT WINAPI VarRound(LPVARIANT,int,LPVARIANT);
HRESULT WINAPI VarCmp(LPVARIANT,LPVARIANT,LCID,ULONG);
HRESULT WINAPI VarBstrCmp(BSTR,BSTR,LCID,ULONG);
HRESULT WINAPI VarBstrCat(BSTR,BSTR,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarR4CmpR8(float,double);
WINOLEAUTAPI HRESULT WINAPI VarR8Pow(double,double,double*);
WINOLEAUTAPI HRESULT WINAPI VarR8Round(double,int,double*);
WINOLEAUTAPI HRESULT WINAPI VarDecAbs(const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecAdd(const DECIMAL*,const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecCmp(const DECIMAL*,const DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecCmpR8(const DECIMAL*,DOUBLE);
WINOLEAUTAPI HRESULT WINAPI VarDecDiv(const DECIMAL*,const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecFix(const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecInt(const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecMul(const DECIMAL*,const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecNeg(const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecRound(const DECIMAL*,int,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarDecSub(const DECIMAL*,const DECIMAL*,DECIMAL*);
WINOLEAUTAPI HRESULT WINAPI VarCyAbs(CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyAdd(CY,CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyCmp(CY,CY);
WINOLEAUTAPI HRESULT WINAPI VarCyCmpR8(CY,DOUBLE);
WINOLEAUTAPI HRESULT WINAPI VarCyFix(CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyInt(CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyMul(CY,CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyMulI4(CY,LONG,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyMulI8(CY,LONG64,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyNeg(CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCyRound(CY,INT,CY*);
WINOLEAUTAPI HRESULT WINAPI VarCySub(CY,CY,CY*);
WINOLEAUTAPI HRESULT WINAPI VarAdd(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarAnd(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarCat(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarDiv(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarEqv(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarIdiv(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarImp(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarMod(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarMul(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarOr(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarPow(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarSub(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarXor(LPVARIANT,LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarAbs(LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarFix(LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarInt(LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarNeg(LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarNot(LPVARIANT,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarRound(LPVARIANT,int,LPVARIANT);
WINOLEAUTAPI HRESULT WINAPI VarCmp(LPVARIANT,LPVARIANT,LCID,ULONG);
WINOLEAUTAPI HRESULT WINAPI VarBstrCmp(BSTR,BSTR,LCID,ULONG);
WINOLEAUTAPI HRESULT WINAPI VarBstrCat(BSTR,BSTR,BSTR*);
typedef struct {
......@@ -647,32 +655,32 @@ typedef struct
#define VTBIT_CY (1 << VT_CY)
#define VTBIT_DECIMAL (1 << VT_DECIMAL)
HRESULT WINAPI VarParseNumFromStr(const OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
HRESULT WINAPI VarNumFromParseNum(NUMPARSE*,BYTE*,ULONG,VARIANT*);
WINOLEAUTAPI HRESULT WINAPI VarParseNumFromStr(const OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
WINOLEAUTAPI HRESULT WINAPI VarNumFromParseNum(NUMPARSE*,BYTE*,ULONG,VARIANT*);
INT WINAPI DosDateTimeToVariantTime(USHORT,USHORT,double*);
INT WINAPI VariantTimeToDosDateTime(double,USHORT*,USHORT*);
WINOLEAUTAPI INT WINAPI DosDateTimeToVariantTime(USHORT,USHORT,double*);
WINOLEAUTAPI INT WINAPI VariantTimeToDosDateTime(double,USHORT*,USHORT*);
INT WINAPI VariantTimeToSystemTime(DOUBLE,LPSYSTEMTIME);
INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME,double*);
WINOLEAUTAPI INT WINAPI VariantTimeToSystemTime(DOUBLE,LPSYSTEMTIME);
WINOLEAUTAPI INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME,double*);
HRESULT WINAPI VarDateFromUdate(UDATE*,ULONG,DATE*);
HRESULT WINAPI VarDateFromUdateEx(UDATE*,LCID,ULONG,DATE*);
HRESULT WINAPI VarUdateFromDate(DATE,ULONG,UDATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUdate(UDATE*,ULONG,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarDateFromUdateEx(UDATE*,LCID,ULONG,DATE*);
WINOLEAUTAPI HRESULT WINAPI VarUdateFromDate(DATE,ULONG,UDATE*);
/* Variant formatting */
HRESULT WINAPI VarWeekdayName(int,int,int,ULONG,BSTR*);
HRESULT WINAPI VarMonthName(int,int,ULONG,BSTR*);
HRESULT WINAPI GetAltMonthNames(LCID,LPOLESTR**);
WINOLEAUTAPI HRESULT WINAPI VarWeekdayName(int,int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarMonthName(int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI GetAltMonthNames(LCID,LPOLESTR**);
HRESULT WINAPI VarFormat(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
HRESULT WINAPI VarFormatCurrency(LPVARIANT,int,int,int,int,ULONG,BSTR*);
HRESULT WINAPI VarFormatDateTime(LPVARIANT,int,ULONG,BSTR*);
HRESULT WINAPI VarFormatNumber(LPVARIANT,int,int,int,int,ULONG,BSTR*);
HRESULT WINAPI VarFormatPercent(LPVARIANT,int,int,int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarFormat(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarFormatCurrency(LPVARIANT,int,int,int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarFormatDateTime(LPVARIANT,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarFormatNumber(LPVARIANT,int,int,int,int,ULONG,BSTR*);
WINOLEAUTAPI HRESULT WINAPI VarFormatPercent(LPVARIANT,int,int,int,int,ULONG,BSTR*);
HRESULT WINAPI VarFormatFromTokens(LPVARIANT,LPOLESTR,LPBYTE,ULONG,BSTR*,LCID);
HRESULT WINAPI VarTokenizeFormatString(LPOLESTR,LPBYTE,int,int,int,LCID,int*);
WINOLEAUTAPI HRESULT WINAPI VarFormatFromTokens(LPVARIANT,LPOLESTR,LPBYTE,ULONG,BSTR*,LCID);
WINOLEAUTAPI HRESULT WINAPI VarTokenizeFormatString(LPOLESTR,LPBYTE,int,int,int,LCID,int*);
/*
......@@ -713,22 +721,20 @@ typedef enum tagREGKIND
REGKIND_NONE
} REGKIND;
HRESULT WINAPI DispGetParam(DISPPARAMS*,UINT,VARTYPE,VARIANT*,UINT*);
HRESULT WINAPI DispGetIDsOfNames(ITypeInfo*,OLECHAR**,UINT,DISPID*);
HRESULT WINAPI DispInvoke(void*,ITypeInfo*,DISPID,WORD,DISPPARAMS*,VARIANT*,
EXCEPINFO*,UINT*);
HRESULT WINAPI CreateDispTypeInfo(INTERFACEDATA*,LCID,ITypeInfo**);
HRESULT WINAPI CreateStdDispatch(IUnknown*,void*,ITypeInfo*,IUnknown**);
HRESULT WINAPI DispCallFunc(void*,ULONG_PTR,CALLCONV,VARTYPE,UINT,VARTYPE*,
VARIANTARG**,VARIANT*);
WINOLEAUTAPI HRESULT WINAPI DispGetParam(DISPPARAMS*,UINT,VARTYPE,VARIANT*,UINT*);
WINOLEAUTAPI HRESULT WINAPI DispGetIDsOfNames(ITypeInfo*,OLECHAR**,UINT,DISPID*);
WINOLEAUTAPI HRESULT WINAPI DispInvoke(void*,ITypeInfo*,DISPID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
WINOLEAUTAPI HRESULT WINAPI CreateDispTypeInfo(INTERFACEDATA*,LCID,ITypeInfo**);
WINOLEAUTAPI HRESULT WINAPI CreateStdDispatch(IUnknown*,void*,ITypeInfo*,IUnknown**);
WINOLEAUTAPI HRESULT WINAPI DispCallFunc(void*,ULONG_PTR,CALLCONV,VARTYPE,UINT,VARTYPE*,VARIANTARG**,VARIANT*);
/*
* TypeLib API
*/
ULONG WINAPI LHashValOfNameSysA(SYSKIND,LCID,LPCSTR);
ULONG WINAPI LHashValOfNameSys(SYSKIND,LCID,LPCOLESTR);
WINOLEAUTAPI ULONG WINAPI LHashValOfNameSysA(SYSKIND,LCID,LPCSTR);
WINOLEAUTAPI ULONG WINAPI LHashValOfNameSys(SYSKIND,LCID,LPCOLESTR);
#define LHashValOfName(lcid,name) LHashValOfNameSys(SYS_WIN32,lcid,name)
#define WHashValOfLHashVal(hash) ((USHORT)((hash) & 0xffff))
......@@ -746,18 +752,18 @@ ULONG WINAPI LHashValOfNameSys(SYSKIND,LCID,LPCOLESTR);
#define LOAD_TLB_AS_64BIT 0x40
#define MASK_TO_RESET_TLB_BITS ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)
HRESULT WINAPI CreateTypeLib(SYSKIND,const OLECHAR*,ICreateTypeLib**);
HRESULT WINAPI CreateTypeLib2(SYSKIND,LPCOLESTR,ICreateTypeLib2**);
HRESULT WINAPI LoadRegTypeLib(REFGUID,WORD,WORD,LCID,ITypeLib**);
HRESULT WINAPI LoadTypeLib(const OLECHAR*,ITypeLib**);
HRESULT WINAPI LoadTypeLibEx(LPCOLESTR,REGKIND,ITypeLib**);
HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID,WORD,WORD,LCID,LPBSTR);
HRESULT WINAPI RegisterTypeLib(ITypeLib*,LPCOLESTR,LPCOLESTR);
HRESULT WINAPI UnRegisterTypeLib(REFGUID,WORD,WORD,LCID,SYSKIND);
HRESULT WINAPI RegisterTypeLibForUser(ITypeLib*,OLECHAR*,OLECHAR*);
HRESULT WINAPI UnRegisterTypeLibForUser(REFGUID,WORD,WORD,LCID,SYSKIND);
VOID WINAPI ClearCustData(LPCUSTDATA);
WINOLEAUTAPI HRESULT WINAPI CreateTypeLib(SYSKIND,const OLECHAR*,ICreateTypeLib**);
WINOLEAUTAPI HRESULT WINAPI CreateTypeLib2(SYSKIND,LPCOLESTR,ICreateTypeLib2**);
WINOLEAUTAPI HRESULT WINAPI LoadRegTypeLib(REFGUID,WORD,WORD,LCID,ITypeLib**);
WINOLEAUTAPI HRESULT WINAPI LoadTypeLib(const OLECHAR*,ITypeLib**);
WINOLEAUTAPI HRESULT WINAPI LoadTypeLibEx(LPCOLESTR,REGKIND,ITypeLib**);
WINOLEAUTAPI HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID,WORD,WORD,LCID,LPBSTR);
WINOLEAUTAPI HRESULT WINAPI RegisterTypeLib(ITypeLib*,LPCOLESTR,LPCOLESTR);
WINOLEAUTAPI HRESULT WINAPI UnRegisterTypeLib(REFGUID,WORD,WORD,LCID,SYSKIND);
WINOLEAUTAPI HRESULT WINAPI RegisterTypeLibForUser(ITypeLib*,OLECHAR*,OLECHAR*);
WINOLEAUTAPI HRESULT WINAPI UnRegisterTypeLibForUser(REFGUID,WORD,WORD,LCID,SYSKIND);
WINOLEAUTAPI void WINAPI ClearCustData(LPCUSTDATA);
#ifdef __cplusplus
} /* extern "C" */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment