ReactOS 0.4.16-dev-1515-g853b446
usrmarshal.c File Reference
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "ole2.h"
#include "oleauto.h"
#include "typelib.h"
#include "ocidl.h"
#include "wine/debug.h"
Include dependency graph for usrmarshal.c:

Go to the source code of this file.

Classes

struct  bstr_wire_t
 
struct  variant_wire_t
 

Macros

#define COBJMACROS
 
#define NONAMELESSUNION
 
#define ALIGNED_LENGTH(_Len, _Align)   (((_Len)+(_Align))&~(_Align))
 
#define ALIGNED_POINTER(_Ptr, _Align)   ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
 
#define ALIGN_LENGTH(_Len, _Align)   _Len = ALIGNED_LENGTH(_Len, _Align)
 
#define ALIGN_POINTER(_Ptr, _Align)   _Ptr = ALIGNED_POINTER(_Ptr, _Align)
 
#define CLS_FUNCDESC   'f'
 
#define CLS_LIBATTR   'l'
 
#define CLS_TYPEATTR   't'
 
#define CLS_VARDESC   'v'
 
#define FADF_AUTOSETFLAGS
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (ole)
 
ULONG __RPC_USER WdtpInterfacePointer_UserSize (ULONG *, ULONG, ULONG, IUnknown *, REFIID)
 
unsigned char *__RPC_USER WdtpInterfacePointer_UserMarshal (ULONG *, ULONG, unsigned char *, IUnknown *, REFIID)
 
unsigned char *__RPC_USER WdtpInterfacePointer_UserUnmarshal (ULONG *, unsigned char *, IUnknown **, REFIID)
 
static void dump_user_flags (const ULONG *pFlags)
 
ULONG WINAPI CLEANLOCALSTORAGE_UserSize (ULONG *pFlags, ULONG Start, CLEANLOCALSTORAGE *pstg)
 
unsigned char *WINAPI CLEANLOCALSTORAGE_UserMarshal (ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg)
 
unsigned char *WINAPI CLEANLOCALSTORAGE_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstr)
 
void WINAPI CLEANLOCALSTORAGE_UserFree (ULONG *pFlags, CLEANLOCALSTORAGE *pstr)
 
ULONG WINAPI BSTR_UserSize (ULONG *pFlags, ULONG Start, BSTR *pstr)
 
unsigned char *WINAPI BSTR_UserMarshal (ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
 
unsigned char *WINAPI BSTR_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
 
void WINAPI BSTR_UserFree (ULONG *pFlags, BSTR *pstr)
 
unsigned int get_type_size (ULONG *pFlags, VARTYPE vt)
 
static unsigned int get_type_alignment (ULONG *pFlags, VARTYPE vt)
 
static unsigned interface_variant_size (ULONG *pFlags, REFIID riid, IUnknown *punk)
 
static ULONG wire_extra_user_size (ULONG *pFlags, ULONG Start, VARIANT *pvar)
 
static unsigned charinterface_variant_marshal (ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown *punk)
 
static unsigned charinterface_variant_unmarshal (ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown **ppunk)
 
ULONG WINAPI VARIANT_UserSize (ULONG *pFlags, ULONG Start, VARIANT *pvar)
 
unsigned char *WINAPI VARIANT_UserMarshal (ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
 
unsigned char *WINAPI VARIANT_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
 
void WINAPI VARIANT_UserFree (ULONG *pFlags, VARIANT *pvar)
 
static ULONG SAFEARRAY_GetCellCount (const SAFEARRAY *psa)
 
static SF_TYPE SAFEARRAY_GetUnionType (SAFEARRAY *psa)
 
static DWORD elem_wire_size (LPSAFEARRAY lpsa, SF_TYPE sftype)
 
static DWORD elem_mem_size (wireSAFEARRAY wiresa, SF_TYPE sftype)
 
ULONG WINAPI LPSAFEARRAY_UserSize (ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
 
unsigned char *WINAPI LPSAFEARRAY_UserMarshal (ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
 
unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
 
void WINAPI LPSAFEARRAY_UserFree (ULONG *pFlags, LPSAFEARRAY *ppsa)
 
ULONG WINAPI HFONT_UserSize (ULONG *pFlags, ULONG Start, HFONT *phfont)
 
unsigned char *WINAPI HFONT_UserMarshal (ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
 
unsigned char *WINAPI HFONT_UserUnmarshal (ULONG *pFlags, unsigned char *Buffer, HFONT *phfont)
 
void WINAPI HFONT_UserFree (ULONG *pFlags, HFONT *phfont)
 
HRESULT CALLBACK IDispatch_Invoke_Proxy (IDispatch *This, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
HRESULT __RPC_STUB IDispatch_Invoke_Stub (IDispatch *This, DISPID dispIdMember, REFIID riid, LCID lcid, DWORD dwFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *pArgErr, UINT cVarRef, UINT *rgVarRefIdx, VARIANTARG *rgVarRef)
 
HRESULT CALLBACK IEnumVARIANT_Next_Proxy (IEnumVARIANT *This, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 
HRESULT __RPC_STUB IEnumVARIANT_Next_Stub (IEnumVARIANT *This, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 
static void free_embedded_typedesc (TYPEDESC *tdesc)
 
static void free_embedded_arraydesc (ARRAYDESC *adesc)
 
static void free_embedded_elemdesc (ELEMDESC *edesc)
 
HRESULT CALLBACK ITypeComp_Bind_Proxy (ITypeComp *This, LPOLESTR name, ULONG lHashVal, WORD flags, ITypeInfo **ti, DESCKIND *desckind, BINDPTR *bindptr)
 
HRESULT __RPC_STUB ITypeComp_Bind_Stub (ITypeComp *This, LPOLESTR name, ULONG lHashVal, WORD flags, ITypeInfo **ti, DESCKIND *desckind, FUNCDESC **funcdesc, VARDESC **vardesc, ITypeComp **typecomp, CLEANLOCALSTORAGE *stg)
 
HRESULT CALLBACK ITypeComp_BindType_Proxy (ITypeComp *This, LPOLESTR name, ULONG lHashVal, ITypeInfo **ti, ITypeComp **typecomp)
 
HRESULT __RPC_STUB ITypeComp_BindType_Stub (ITypeComp *This, LPOLESTR name, ULONG lHashVal, ITypeInfo **ti)
 
HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy (ITypeInfo *This, TYPEATTR **ppTypeAttr)
 
HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub (ITypeInfo *This, LPTYPEATTR *ppTypeAttr, CLEANLOCALSTORAGE *pDummy)
 
HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy (ITypeInfo *This, UINT index, FUNCDESC **ppFuncDesc)
 
HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub (ITypeInfo *This, UINT index, LPFUNCDESC *ppFuncDesc, CLEANLOCALSTORAGE *pDummy)
 
HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy (ITypeInfo *This, UINT index, VARDESC **ppVarDesc)
 
HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub (ITypeInfo *This, UINT index, LPVARDESC *ppVarDesc, CLEANLOCALSTORAGE *pDummy)
 
HRESULT CALLBACK ITypeInfo_GetNames_Proxy (ITypeInfo *This, MEMBERID memid, BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
 
HRESULT __RPC_STUB ITypeInfo_GetNames_Stub (ITypeInfo *This, MEMBERID memid, BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
 
HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy (ITypeInfo *This, LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
 
HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub (ITypeInfo *This)
 
HRESULT CALLBACK ITypeInfo_Invoke_Proxy (ITypeInfo *This, PVOID pvInstance, MEMBERID memid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
HRESULT __RPC_STUB ITypeInfo_Invoke_Stub (ITypeInfo *This)
 
HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy (ITypeInfo *This, MEMBERID memid, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
 
HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub (ITypeInfo *This, MEMBERID memid, DWORD flags, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
 
HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy (ITypeInfo *This, MEMBERID memid, INVOKEKIND invkind, BSTR *dll_name, BSTR *name, WORD *ordinal)
 
HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub (ITypeInfo *This, MEMBERID memid, INVOKEKIND invkind, DWORD flags, BSTR *dll_name, BSTR *name, WORD *ordinal)
 
HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy (ITypeInfo *This, MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
 
HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub (ITypeInfo *This)
 
HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy (ITypeInfo *This, IUnknown *pUnkOuter, REFIID riid, PVOID *ppvObj)
 
HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub (ITypeInfo *This, REFIID riid, IUnknown **ppvObj)
 
HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy (ITypeInfo *This, ITypeLib **ppTLib, UINT *pIndex)
 
HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub (ITypeInfo *This, ITypeLib **ppTLib, UINT *pIndex)
 
void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy (ITypeInfo *This, TYPEATTR *pTypeAttr)
 
HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub (ITypeInfo *This)
 
void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy (ITypeInfo *This, FUNCDESC *pFuncDesc)
 
HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub (ITypeInfo *This)
 
void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy (ITypeInfo *This, VARDESC *pVarDesc)
 
HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub (ITypeInfo *This)
 
HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy (ITypeInfo2 *This, MEMBERID memid, LCID lcid, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
 
HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub (ITypeInfo2 *This, MEMBERID memid, LCID lcid, DWORD flags, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
 
UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy (ITypeLib *This)
 
HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub (ITypeLib *This, UINT *pcTInfo)
 
HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy (ITypeLib *This, TLIBATTR **ppTLibAttr)
 
HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub (ITypeLib *This, LPTLIBATTR *ppTLibAttr, CLEANLOCALSTORAGE *pDummy)
 
HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy (ITypeLib *This, INT index, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
 
HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub (ITypeLib *This, INT index, DWORD flags, BSTR *name, BSTR *doc_string, DWORD *help_context, BSTR *help_file)
 
HRESULT CALLBACK ITypeLib_IsName_Proxy (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, BOOL *pfName)
 
HRESULT __RPC_STUB ITypeLib_IsName_Stub (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, BOOL *pfName, BSTR *pBstrLibName)
 
HRESULT CALLBACK ITypeLib_FindName_Proxy (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, USHORT *pcFound)
 
HRESULT __RPC_STUB ITypeLib_FindName_Stub (ITypeLib *This, LPOLESTR szNameBuf, ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, USHORT *pcFound, BSTR *pBstrLibName)
 
void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy (ITypeLib *This, TLIBATTR *pTLibAttr)
 
HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub (ITypeLib *This)
 
HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy (ITypeLib2 *This, ULONG *pcUniqueNames, ULONG *pcchUniqueNames)
 
HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub (ITypeLib2 *This, ULONG *pcUniqueNames, ULONG *pcchUniqueNames)
 
HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy (ITypeLib2 *This, INT index, LCID lcid, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
 
HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub (ITypeLib2 *This, INT index, LCID lcid, DWORD flags, BSTR *help_string, DWORD *help_context, BSTR *help_dll)
 
HRESULT CALLBACK IPropertyBag_Read_Proxy (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog)
 
HRESULT __RPC_STUB IPropertyBag_Read_Stub (IPropertyBag *This, LPCOLESTR pszPropName, VARIANT *pVar, IErrorLog *pErrorLog, DWORD varType, IUnknown *pUnkObj)
 
HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy (IClassFactory2 *This, IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID riid, BSTR bstrKey, PVOID *ppvObj)
 
HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub (IClassFactory2 *This, REFIID riid, BSTR bstrKey, IUnknown **ppvObj)
 
HRESULT CALLBACK IEnumConnections_Next_Proxy (IEnumConnections *This, ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFetched)
 
HRESULT __RPC_STUB IEnumConnections_Next_Stub (IEnumConnections *This, ULONG cConnections, LPCONNECTDATA rgcd, ULONG *pcFetched)
 
HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy (IEnumConnectionPoints *This, ULONG cConnections, IConnectionPoint **ppCP, ULONG *pcFetched)
 
HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub (IEnumConnectionPoints *This, ULONG cConnections, IConnectionPoint **ppCP, ULONG *pcFetched)
 
HRESULT CALLBACK IPersistMemory_Load_Proxy (IPersistMemory *This, LPVOID pMem, ULONG cbSize)
 
HRESULT __RPC_STUB IPersistMemory_Load_Stub (IPersistMemory *This, BYTE *pMem, ULONG cbSize)
 
HRESULT CALLBACK IPersistMemory_Save_Proxy (IPersistMemory *This, LPVOID pMem, BOOL fClearDirty, ULONG cbSize)
 
HRESULT __RPC_STUB IPersistMemory_Save_Stub (IPersistMemory *This, BYTE *pMem, BOOL fClearDirty, ULONG cbSize)
 
void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy (IAdviseSinkEx *This, DWORD dwViewStatus)
 
HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub (IAdviseSinkEx *This, DWORD dwViewStatus)
 
HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy (IEnumOleUndoUnits *This, ULONG cElt, IOleUndoUnit **rgElt, ULONG *pcEltFetched)
 
HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub (IEnumOleUndoUnits *This, ULONG cElt, IOleUndoUnit **rgElt, ULONG *pcEltFetched)
 
HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy (IQuickActivate *This, QACONTAINER *pQaContainer, QACONTROL *pQaControl)
 
HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub (IQuickActivate *This, QACONTAINER *pQaContainer, QACONTROL *pQaControl)
 

Macro Definition Documentation

◆ ALIGN_LENGTH

#define ALIGN_LENGTH (   _Len,
  _Align 
)    _Len = ALIGNED_LENGTH(_Len, _Align)

Definition at line 44 of file usrmarshal.c.

◆ ALIGN_POINTER

#define ALIGN_POINTER (   _Ptr,
  _Align 
)    _Ptr = ALIGNED_POINTER(_Ptr, _Align)

Definition at line 45 of file usrmarshal.c.

◆ ALIGNED_LENGTH

#define ALIGNED_LENGTH (   _Len,
  _Align 
)    (((_Len)+(_Align))&~(_Align))

Definition at line 42 of file usrmarshal.c.

◆ ALIGNED_POINTER

#define ALIGNED_POINTER (   _Ptr,
  _Align 
)    ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))

Definition at line 43 of file usrmarshal.c.

◆ CLS_FUNCDESC

#define CLS_FUNCDESC   'f'

Definition at line 70 of file usrmarshal.c.

◆ CLS_LIBATTR

#define CLS_LIBATTR   'l'

Definition at line 71 of file usrmarshal.c.

◆ CLS_TYPEATTR

#define CLS_TYPEATTR   't'

Definition at line 72 of file usrmarshal.c.

◆ CLS_VARDESC

#define CLS_VARDESC   'v'

Definition at line 73 of file usrmarshal.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 25 of file usrmarshal.c.

◆ FADF_AUTOSETFLAGS

#define FADF_AUTOSETFLAGS
Value:
(FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
FADF_VARIANT | FADF_CREATEVECTOR)
const USHORT FADF_CREATEVECTOR
Definition: safearray.c:43

Definition at line 1120 of file usrmarshal.c.

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 26 of file usrmarshal.c.

Function Documentation

◆ BSTR_UserFree()

void WINAPI BSTR_UserFree ( ULONG pFlags,
BSTR pstr 
)

Definition at line 189 of file usrmarshal.c.

190{
191 TRACE("(%x,%p) => %p\n", *pFlags, pstr, *pstr);
192 SysFreeString(*pstr);
193 *pstr = NULL;
194}
#define NULL
Definition: types.h:112
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by test_marshal_BSTR(), and VARIANT_UserFree().

◆ BSTR_UserMarshal()

unsigned char *WINAPI BSTR_UserMarshal ( ULONG pFlags,
unsigned char Buffer,
BSTR pstr 
)

Definition at line 146 of file usrmarshal.c.

147{
149 DWORD len = SysStringByteLen(*pstr);
150
151 TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
152 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
153
156 header->len = header->len2 = (len + 1) / 2;
157 if (*pstr)
158 {
159 header->byte_len = len;
160 memcpy(header + 1, *pstr, header->len * 2);
161 }
162 else
163 header->byte_len = 0xffffffff; /* special case for a null bstr */
164
165 return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
166}
Definition: bufpool.h:45
WCHAR OLECHAR
Definition: compat.h:2292
#define ALIGN_POINTER(_Ptr, _Align)
Definition: usrmarshal.c:45
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum GLsizei len
Definition: glext.h:6722
#define debugstr_w
Definition: kernel32.h:32
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
UINT WINAPI SysStringByteLen(BSTR str)
Definition: oleaut.c:215

Referenced by LPSAFEARRAY_UserMarshal(), test_marshal_BSTR(), and VARIANT_UserMarshal().

◆ BSTR_UserSize()

ULONG WINAPI BSTR_UserSize ( ULONG pFlags,
ULONG  Start,
BSTR pstr 
)

Definition at line 136 of file usrmarshal.c.

137{
138 TRACE("(%x,%d,%p) => %p\n", *pFlags, Start, pstr, *pstr);
139 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
141 Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
142 TRACE("returning %d\n", Start);
143 return Start;
144}
#define ALIGN_LENGTH(_Len, _Align)
Definition: usrmarshal.c:44
return pTarget Start()

Referenced by LPSAFEARRAY_UserSize(), test_marshal_BSTR(), and wire_extra_user_size().

◆ BSTR_UserUnmarshal()

unsigned char *WINAPI BSTR_UserUnmarshal ( ULONG pFlags,
unsigned char Buffer,
BSTR pstr 
)

Definition at line 168 of file usrmarshal.c.

169{
171 TRACE("(%x,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
172
175 if(header->len != header->len2)
176 FIXME("len %08x != len2 %08x\n", header->len, header->len2);
177
178 if (header->byte_len == 0xffffffff)
179 {
180 SysFreeString(*pstr);
181 *pstr = NULL;
182 }
183 else SysReAllocStringLen( pstr, (OLECHAR *)(header + 1), header->len );
184
185 if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
186 return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
187}
#define FIXME(fmt,...)
Definition: precomp.h:53
int WINAPI SysReAllocStringLen(BSTR *old, const OLECHAR *str, unsigned int len)
Definition: oleaut.c:383

Referenced by LPSAFEARRAY_UserUnmarshal(), test_marshal_BSTR(), and VARIANT_UserUnmarshal().

◆ CLEANLOCALSTORAGE_UserFree()

void WINAPI CLEANLOCALSTORAGE_UserFree ( ULONG pFlags,
CLEANLOCALSTORAGE *  pstr 
)

Definition at line 122 of file usrmarshal.c.

123{
124 /* Nothing to do */
125}

◆ CLEANLOCALSTORAGE_UserMarshal()

unsigned char *WINAPI CLEANLOCALSTORAGE_UserMarshal ( ULONG pFlags,
unsigned char Buffer,
CLEANLOCALSTORAGE *  pstg 
)

Definition at line 81 of file usrmarshal.c.

82{
84 *(DWORD*)Buffer = pstg->flags;
85
86 if (!pstg->pInterface)
87 return Buffer + sizeof(DWORD);
88
89 switch(pstg->flags)
90 {
91 case CLS_LIBATTR:
92 ITypeLib_ReleaseTLibAttr((ITypeLib*)pstg->pInterface, *(TLIBATTR**)pstg->pStorage);
93 break;
94 case CLS_TYPEATTR:
95 ITypeInfo_ReleaseTypeAttr((ITypeInfo*)pstg->pInterface, *(TYPEATTR**)pstg->pStorage);
96 break;
97 case CLS_FUNCDESC:
98 ITypeInfo_ReleaseFuncDesc((ITypeInfo*)pstg->pInterface, *(FUNCDESC**)pstg->pStorage);
99 break;
100 case CLS_VARDESC:
101 ITypeInfo_ReleaseVarDesc((ITypeInfo*)pstg->pInterface, *(VARDESC**)pstg->pStorage);
102 break;
103
104 default:
105 ERR("Unknown type %x\n", pstg->flags);
106 }
107
108 *(VOID**)pstg->pStorage = NULL;
109 IUnknown_Release(pstg->pInterface);
110 pstg->pInterface = NULL;
111
112 return Buffer + sizeof(DWORD);
113}
#define ERR(fmt,...)
Definition: precomp.h:57
#define CLS_VARDESC
Definition: usrmarshal.c:73
#define CLS_FUNCDESC
Definition: usrmarshal.c:70
#define CLS_LIBATTR
Definition: usrmarshal.c:71
#define CLS_TYPEATTR
Definition: usrmarshal.c:72
if(dx< 0)
Definition: linetemp.h:194
#define DWORD
Definition: nt_native.h:44

◆ CLEANLOCALSTORAGE_UserSize()

ULONG WINAPI CLEANLOCALSTORAGE_UserSize ( ULONG pFlags,
ULONG  Start,
CLEANLOCALSTORAGE *  pstg 
)

Definition at line 75 of file usrmarshal.c.

76{
78 return Start + sizeof(DWORD);
79}

◆ CLEANLOCALSTORAGE_UserUnmarshal()

unsigned char *WINAPI CLEANLOCALSTORAGE_UserUnmarshal ( ULONG pFlags,
unsigned char Buffer,
CLEANLOCALSTORAGE *  pstr 
)

Definition at line 115 of file usrmarshal.c.

116{
118 pstr->flags = *(DWORD*)Buffer;
119 return Buffer + sizeof(DWORD);
120}

◆ dump_user_flags()

static void dump_user_flags ( const ULONG pFlags)
static

Definition at line 52 of file usrmarshal.c.

53{
55 TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
56 else
57 TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
58 switch (LOWORD(*pFlags))
59 {
60 case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
61 case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
62 case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
63 case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
64 default: TRACE("%d)", LOWORD(*pFlags));
65 }
66}
#define LOWORD(l)
Definition: pedump.c:82
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
#define HIWORD(l)
Definition: typedefs.h:247

Referenced by LPSAFEARRAY_UserFree(), LPSAFEARRAY_UserMarshal(), LPSAFEARRAY_UserSize(), and LPSAFEARRAY_UserUnmarshal().

◆ elem_mem_size()

static DWORD elem_mem_size ( wireSAFEARRAY  wiresa,
SF_TYPE  sftype 
)
static

Definition at line 830 of file usrmarshal.c.

831{
832#ifdef __REACTOS__
833 switch (sftype)
834 {
835 case SF_HAVEIID:
836 case SF_UNKNOWN:
837 case SF_DISPATCH:
838 return sizeof(void *);
839
840 case SF_BSTR:
841#else
842 if (sftype == SF_BSTR)
843#endif
844 return sizeof(BSTR);
845#ifdef __REACTOS__
846
847 case SF_VARIANT:
848#else
849 else if (sftype == SF_VARIANT)
850#endif
851 return sizeof(VARIANT);
852#ifdef __REACTOS__
853
854 default:
855#else
856 else
857#endif
858 return wiresa->cbElements;
859#ifdef __REACTOS__
860 }
861#endif
862}
struct tagVARIANT VARIANT
Definition: compat.h:2377
OLECHAR * BSTR
Definition: compat.h:2293

Referenced by LPSAFEARRAY_UserUnmarshal().

◆ elem_wire_size()

static DWORD elem_wire_size ( LPSAFEARRAY  lpsa,
SF_TYPE  sftype 
)
static

Definition at line 798 of file usrmarshal.c.

799{
800#ifdef __REACTOS__
801 switch (sftype)
802 {
803 case SF_BSTR:
804 case SF_HAVEIID:
805 case SF_UNKNOWN:
806 case SF_DISPATCH:
807#else
808 if (sftype == SF_BSTR)
809#endif
810 return sizeof(DWORD);
811#ifdef __REACTOS__
812
813 case SF_VARIANT:
814#else
815 else if (sftype == SF_VARIANT)
816#endif
817 return sizeof(variant_wire_t) - sizeof(DWORD);
818#ifdef __REACTOS__
819
820 default:
821#else
822 else
823#endif
824 return lpsa->cbElements;
825#ifdef __REACTOS__
826 }
827#endif
828}
ULONG cbElements
Definition: compat.h:2357

Referenced by check_safearray(), and LPSAFEARRAY_UserMarshal().

◆ free_embedded_arraydesc()

static void free_embedded_arraydesc ( ARRAYDESC *  adesc)
static

Definition at line 1549 of file usrmarshal.c.

1550{
1551 switch(adesc->tdescElem.vt)
1552 {
1553 case VT_PTR:
1554 case VT_SAFEARRAY:
1555 free_embedded_typedesc(adesc->tdescElem.u.lptdesc);
1556 CoTaskMemFree(adesc->tdescElem.u.lptdesc);
1557 break;
1558 case VT_CARRAY:
1559 free_embedded_arraydesc(adesc->tdescElem.u.lpadesc);
1560 CoTaskMemFree(adesc->tdescElem.u.lpadesc);
1561 break;
1562 }
1563}
@ VT_PTR
Definition: compat.h:2320
@ VT_SAFEARRAY
Definition: compat.h:2321
@ VT_CARRAY
Definition: compat.h:2322
static void free_embedded_arraydesc(ARRAYDESC *adesc)
Definition: usrmarshal.c:1549
static void free_embedded_typedesc(TYPEDESC *tdesc)
Definition: usrmarshal.c:1565
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442

Referenced by free_embedded_arraydesc(), and free_embedded_typedesc().

◆ free_embedded_elemdesc()

static void free_embedded_elemdesc ( ELEMDESC *  edesc)
static

Definition at line 1581 of file usrmarshal.c.

1582{
1583 free_embedded_typedesc(&edesc->tdesc);
1584 if(edesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1585 CoTaskMemFree(edesc->u.paramdesc.pparamdescex);
1586}

Referenced by ITypeInfo_ReleaseFuncDesc_Proxy(), and ITypeInfo_ReleaseVarDesc_Proxy().

◆ free_embedded_typedesc()

static void free_embedded_typedesc ( TYPEDESC *  tdesc)
static

Definition at line 1565 of file usrmarshal.c.

1566{
1567 switch(tdesc->vt)
1568 {
1569 case VT_PTR:
1570 case VT_SAFEARRAY:
1571 free_embedded_typedesc(tdesc->u.lptdesc);
1572 CoTaskMemFree(tdesc->u.lptdesc);
1573 break;
1574 case VT_CARRAY:
1575 free_embedded_arraydesc(tdesc->u.lpadesc);
1576 CoTaskMemFree(tdesc->u.lpadesc);
1577 break;
1578 }
1579}

Referenced by free_embedded_arraydesc(), free_embedded_elemdesc(), free_embedded_typedesc(), and ITypeInfo_ReleaseTypeAttr_Proxy().

◆ get_type_alignment()

static unsigned int get_type_alignment ( ULONG pFlags,
VARTYPE  vt 
)
static

Definition at line 261 of file usrmarshal.c.

262{
263 unsigned int size = get_type_size(pFlags, vt);
264 if(vt & VT_BYREF) return 3;
265 if(size == 0) return 0;
266 if(size <= 4) return size - 1;
267 return 7;
268}
@ VT_BYREF
Definition: compat.h:2342
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
Definition: suminfo.c:91
unsigned int get_type_size(ULONG *pFlags, VARTYPE vt)
Definition: usrmarshal.c:209
GLsizeiptr size
Definition: glext.h:5919

Referenced by VARIANT_UserMarshal(), VARIANT_UserSize(), and VARIANT_UserUnmarshal().

◆ get_type_size()

unsigned int get_type_size ( ULONG pFlags,
VARTYPE  vt 
)

Definition at line 209 of file usrmarshal.c.

210{
211 if (vt & VT_ARRAY) return 4;
212
213 switch (vt & ~VT_BYREF) {
214 case VT_EMPTY:
215 case VT_NULL:
216 return 0;
217 case VT_I1:
218 case VT_UI1:
219 return sizeof(CHAR);
220 case VT_I2:
221 case VT_UI2:
222 return sizeof(SHORT);
223 case VT_I4:
224 case VT_UI4:
225 case VT_HRESULT:
226 return sizeof(LONG);
227 case VT_INT:
228 case VT_UINT:
229 return sizeof(INT);
230 case VT_I8:
231 case VT_UI8:
232 return sizeof(LONGLONG);
233 case VT_R4:
234 return sizeof(FLOAT);
235 case VT_R8:
236 return sizeof(DOUBLE);
237 case VT_BOOL:
238 return sizeof(VARIANT_BOOL);
239 case VT_ERROR:
240 return sizeof(SCODE);
241 case VT_DATE:
242 return sizeof(DATE);
243 case VT_CY:
244 return sizeof(CY);
245 case VT_DECIMAL:
246 return sizeof(DECIMAL);
247 case VT_BSTR:
248 return sizeof(ULONG);
249 case VT_VARIANT:
250 return sizeof(VARIANT);
251 case VT_UNKNOWN:
252 case VT_DISPATCH:
253 case VT_RECORD:
254 return 0;
255 default:
256 FIXME("unhandled VT %d\n", vt);
257 return 0;
258 }
259}
#define CHAR(Char)
double DATE
Definition: compat.h:2253
union tagCY CY
struct tagDEC DECIMAL
short VARIANT_BOOL
Definition: compat.h:2290
LONG SCODE
Definition: compat.h:2252
@ VT_UI8
Definition: compat.h:2315
@ VT_BSTR
Definition: compat.h:2303
@ VT_INT
Definition: compat.h:2316
@ VT_R4
Definition: compat.h:2299
@ VT_NULL
Definition: compat.h:2296
@ VT_UNKNOWN
Definition: compat.h:2308
@ VT_UI2
Definition: compat.h:2312
@ VT_DECIMAL
Definition: compat.h:2309
@ VT_ERROR
Definition: compat.h:2305
@ VT_ARRAY
Definition: compat.h:2341
@ VT_R8
Definition: compat.h:2300
@ VT_CY
Definition: compat.h:2301
@ VT_VARIANT
Definition: compat.h:2307
@ VT_I8
Definition: compat.h:2314
@ VT_I1
Definition: compat.h:2310
@ VT_I4
Definition: compat.h:2298
@ VT_HRESULT
Definition: compat.h:2319
@ VT_DATE
Definition: compat.h:2302
@ VT_BOOL
Definition: compat.h:2306
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
@ VT_UINT
Definition: compat.h:2317
@ VT_EMPTY
Definition: compat.h:2295
@ VT_RECORD
Definition: compat.h:2326
@ VT_DISPATCH
Definition: compat.h:2304
@ VT_UI1
Definition: compat.h:2311
#define FLOAT
Definition: i386-dis.c:525
#define DOUBLE(x)
Definition: atom.c:30
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
#define INT
Definition: polytest.cpp:20
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59

Referenced by create_signature_columns_and_data(), get_type_alignment(), IRecordInfoImpl_RecordCopy(), to_array(), VARIANT_UserMarshal(), VARIANT_UserSize(), and VARIANT_UserUnmarshal().

◆ HFONT_UserFree()

void WINAPI HFONT_UserFree ( ULONG pFlags,
HFONT phfont 
)

Definition at line 1335 of file usrmarshal.c.

1336{
1337 FIXME(":stub\n");
1338 return;
1339}

◆ HFONT_UserMarshal()

unsigned char *WINAPI HFONT_UserMarshal ( ULONG pFlags,
unsigned char Buffer,
HFONT phfont 
)

Definition at line 1323 of file usrmarshal.c.

1324{
1325 FIXME(":stub\n");
1326 return NULL;
1327}

◆ HFONT_UserSize()

ULONG WINAPI HFONT_UserSize ( ULONG pFlags,
ULONG  Start,
HFONT phfont 
)

Definition at line 1317 of file usrmarshal.c.

1318{
1319 FIXME(":stub\n");
1320 return 0;
1321}

◆ HFONT_UserUnmarshal()

unsigned char *WINAPI HFONT_UserUnmarshal ( ULONG pFlags,
unsigned char Buffer,
HFONT phfont 
)

Definition at line 1329 of file usrmarshal.c.

1330{
1331 FIXME(":stub\n");
1332 return NULL;
1333}

◆ IAdviseSinkEx_OnViewStatusChange_Proxy()

void CALLBACK IAdviseSinkEx_OnViewStatusChange_Proxy ( IAdviseSinkEx This,
DWORD  dwViewStatus 
)

Definition at line 2626 of file usrmarshal.c.

2629{
2630 TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
2631 IAdviseSinkEx_RemoteOnViewStatusChange_Proxy(This, dwViewStatus);
2632}

◆ IAdviseSinkEx_OnViewStatusChange_Stub()

HRESULT __RPC_STUB IAdviseSinkEx_OnViewStatusChange_Stub ( IAdviseSinkEx This,
DWORD  dwViewStatus 
)

Definition at line 2634 of file usrmarshal.c.

2637{
2638 TRACE("(%p, 0x%08x)\n", This, dwViewStatus);
2639 IAdviseSinkEx_OnViewStatusChange(This, dwViewStatus);
2640 return S_OK;
2641}
#define S_OK
Definition: intsafe.h:52

◆ IClassFactory2_CreateInstanceLic_Proxy()

HRESULT CALLBACK IClassFactory2_CreateInstanceLic_Proxy ( IClassFactory2 This,
IUnknown pUnkOuter,
IUnknown pUnkReserved,
REFIID  riid,
BSTR  bstrKey,
PVOID ppvObj 
)

Definition at line 2481 of file usrmarshal.c.

2488{
2489 TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppvObj);
2490
2491 *ppvObj = NULL;
2492
2493 if (pUnkOuter)
2494 {
2495 ERR("aggregation is not allowed on remote objects\n");
2496 return CLASS_E_NOAGGREGATION;
2497 }
2498
2499 return IClassFactory2_RemoteCreateInstanceLic_Proxy(This, riid, bstrKey, (IUnknown**)ppvObj);
2500}
REFIID riid
Definition: atlbase.h:39
#define debugstr_guid
Definition: kernel32.h:35
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:3772

◆ IClassFactory2_CreateInstanceLic_Stub()

HRESULT __RPC_STUB IClassFactory2_CreateInstanceLic_Stub ( IClassFactory2 This,
REFIID  riid,
BSTR  bstrKey,
IUnknown **  ppvObj 
)

Definition at line 2502 of file usrmarshal.c.

2507{
2508 TRACE("(%s, %p)\n", debugstr_guid(riid), ppvObj);
2509 return IClassFactory2_CreateInstanceLic(This, NULL, NULL, riid, bstrKey, (void**)ppvObj);
2510}

◆ IDispatch_Invoke_Proxy()

HRESULT CALLBACK IDispatch_Invoke_Proxy ( IDispatch This,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)

Definition at line 1346 of file usrmarshal.c.

1356{
1357 HRESULT hr;
1358 VARIANT VarResult;
1359 UINT* rgVarRefIdx = NULL;
1360 VARIANTARG* rgVarRef = NULL;
1361 UINT u, cVarRef;
1362 UINT uArgErr;
1363 EXCEPINFO ExcepInfo;
1364
1365 TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This,
1366 dispIdMember, debugstr_guid(riid),
1367 lcid, wFlags, pDispParams, pVarResult,
1368 pExcepInfo, puArgErr);
1369
1370 /* [out] args can't be null, use dummy vars if needed */
1371 if (!pVarResult) pVarResult = &VarResult;
1372 if (!puArgErr) puArgErr = &uArgErr;
1373 if (!pExcepInfo) pExcepInfo = &ExcepInfo;
1374
1375 /* count by-ref args */
1376 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1377 VARIANTARG* arg = &pDispParams->rgvarg[u];
1378 if (V_ISBYREF(arg)) {
1379 cVarRef++;
1380 }
1381 }
1382 if (cVarRef) {
1383 rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
1384 rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
1385 /* make list of by-ref args */
1386 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
1387 VARIANTARG* arg = &pDispParams->rgvarg[u];
1388 if (V_ISBYREF(arg)) {
1389 rgVarRefIdx[cVarRef] = u;
1390 VariantInit(&rgVarRef[cVarRef]);
1391 VariantCopy(&rgVarRef[cVarRef], arg);
1393 cVarRef++;
1394 }
1395 }
1396 } else {
1397 /* [out] args still can't be null,
1398 * but we can point these anywhere in this case,
1399 * since they won't be written to when cVarRef is 0 */
1400 rgVarRefIdx = puArgErr;
1401 rgVarRef = pVarResult;
1402 }
1403 TRACE("passed by ref: %d args\n", cVarRef);
1404 hr = IDispatch_RemoteInvoke_Proxy(This,
1405 dispIdMember,
1406 riid,
1407 lcid,
1408 wFlags,
1409 pDispParams,
1410 pVarResult,
1411 pExcepInfo,
1412 puArgErr,
1413 cVarRef,
1414 rgVarRefIdx,
1415 rgVarRef);
1416 if (cVarRef) {
1417 for (u=0; u<cVarRef; u++) {
1418 unsigned i = rgVarRefIdx[u];
1419 VariantCopy(&pDispParams->rgvarg[i],
1420 &rgVarRef[u]);
1421 VariantClear(&rgVarRef[u]);
1422 }
1423 CoTaskMemFree(rgVarRef);
1424 CoTaskMemFree(rgVarRefIdx);
1425 }
1426
1427 if(pExcepInfo == &ExcepInfo)
1428 {
1429 SysFreeString(pExcepInfo->bstrSource);
1430 SysFreeString(pExcepInfo->bstrDescription);
1431 SysFreeString(pExcepInfo->bstrHelpFile);
1432 }
1433 return hr;
1434}
LCID lcid
Definition: locale.c:5656
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
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 * u
Definition: glfuncs.h:240
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
struct stdole::EXCEPINFO EXCEPINFO
unsigned int UINT
Definition: ndis.h:50
#define V_ISBYREF(A)
Definition: oleauto.h:217
HRESULT hr
Definition: shlfolder.c:183
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
HRESULT WINAPI VariantCopy(VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
Definition: variant.c:748
WINBASEAPI _In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon_undoc.h:337

◆ IDispatch_Invoke_Stub()

HRESULT __RPC_STUB IDispatch_Invoke_Stub ( IDispatch This,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
DWORD  dwFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT pArgErr,
UINT  cVarRef,
UINT rgVarRefIdx,
VARIANTARG rgVarRef 
)

Definition at line 1436 of file usrmarshal.c.

1449{
1450 HRESULT hr = S_OK;
1451 VARIANTARG *rgvarg, *arg;
1452 UINT u;
1453
1454 /* initialize out parameters, so that they can be marshalled
1455 * in case the real Invoke doesn't initialize them */
1456 VariantInit(pVarResult);
1457 memset(pExcepInfo, 0, sizeof(*pExcepInfo));
1458 *pArgErr = 0;
1459
1460 /* let the real Invoke operate on a copy of the in parameters,
1461 * so we don't risk losing pointers to allocated memory */
1462 rgvarg = pDispParams->rgvarg;
1463 arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
1464 if (!arg) return E_OUTOFMEMORY;
1465
1466 /* init all args so we can call VariantClear on all the args if the copy
1467 * below fails */
1468 for (u = 0; u < pDispParams->cArgs; u++)
1469 VariantInit(&arg[u]);
1470
1471 for (u = 0; u < pDispParams->cArgs; u++) {
1472 hr = VariantCopy(&arg[u], &rgvarg[u]);
1473 if (FAILED(hr))
1474 break;
1475 }
1476
1477 if (SUCCEEDED(hr)) {
1478 /* copy ref args to arg array */
1479 for (u=0; u<cVarRef; u++) {
1480 unsigned i = rgVarRefIdx[u];
1481 VariantCopy(&arg[i], &rgVarRef[u]);
1482 }
1483
1484 pDispParams->rgvarg = arg;
1485
1486 hr = IDispatch_Invoke(This,
1487 dispIdMember,
1488 riid,
1489 lcid,
1490 dwFlags,
1491 pDispParams,
1492 pVarResult,
1493 pExcepInfo,
1494 pArgErr);
1495
1496 /* copy ref args from arg array */
1497 for (u=0; u<cVarRef; u++) {
1498 unsigned i = rgVarRefIdx[u];
1499 VariantCopy(&rgVarRef[u], &arg[i]);
1500 }
1501 }
1502
1503 /* clear the duplicate argument list */
1504 for (u=0; u<pDispParams->cArgs; u++)
1505 VariantClear(&arg[u]);
1506
1507 pDispParams->rgvarg = rgvarg;
1509
1510 return hr;
1511}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
LPCWSTR LPCWSTR LPCWSTR DWORD dwFlags
Definition: env.c:37
#define memset(x, y, z)
Definition: compat.h:39
void * arg
Definition: msvc.h:10

◆ IEnumConnectionPoints_Next_Proxy()

HRESULT CALLBACK IEnumConnectionPoints_Next_Proxy ( IEnumConnectionPoints This,
ULONG  cConnections,
IConnectionPoint **  ppCP,
ULONG pcFetched 
)

Definition at line 2546 of file usrmarshal.c.

2551{
2552 ULONG fetched;
2553
2554 TRACE("(%u, %p %p)\n", cConnections, ppCP, pcFetched);
2555
2556 if (!pcFetched)
2557 pcFetched = &fetched;
2558
2559 return IEnumConnectionPoints_RemoteNext_Proxy(This, cConnections, ppCP, pcFetched);
2560}

◆ IEnumConnectionPoints_Next_Stub()

HRESULT __RPC_STUB IEnumConnectionPoints_Next_Stub ( IEnumConnectionPoints This,
ULONG  cConnections,
IConnectionPoint **  ppCP,
ULONG pcFetched 
)

Definition at line 2562 of file usrmarshal.c.

2567{
2568 HRESULT hr;
2569
2570 TRACE("(%u, %p, %p)\n", cConnections, ppCP, pcFetched);
2571
2572 *pcFetched = 0;
2573 hr = IEnumConnectionPoints_Next(This, cConnections, ppCP, pcFetched);
2574 if (hr == S_OK)
2575 *pcFetched = cConnections;
2576
2577 return hr;
2578}

◆ IEnumConnections_Next_Proxy()

HRESULT CALLBACK IEnumConnections_Next_Proxy ( IEnumConnections This,
ULONG  cConnections,
LPCONNECTDATA  rgcd,
ULONG pcFetched 
)

Definition at line 2512 of file usrmarshal.c.

2517{
2518 ULONG fetched;
2519
2520 TRACE("(%u, %p %p)\n", cConnections, rgcd, pcFetched);
2521
2522 if (!pcFetched)
2523 pcFetched = &fetched;
2524
2525 return IEnumConnections_RemoteNext_Proxy(This, cConnections, rgcd, pcFetched);
2526}

◆ IEnumConnections_Next_Stub()

HRESULT __RPC_STUB IEnumConnections_Next_Stub ( IEnumConnections This,
ULONG  cConnections,
LPCONNECTDATA  rgcd,
ULONG pcFetched 
)

Definition at line 2528 of file usrmarshal.c.

2533{
2534 HRESULT hr;
2535
2536 TRACE("(%u, %p, %p)\n", cConnections, rgcd, pcFetched);
2537
2538 *pcFetched = 0;
2539 hr = IEnumConnections_Next(This, cConnections, rgcd, pcFetched);
2540 if (hr == S_OK)
2541 *pcFetched = cConnections;
2542
2543 return hr;
2544}

◆ IEnumOleUndoUnits_Next_Proxy()

HRESULT CALLBACK IEnumOleUndoUnits_Next_Proxy ( IEnumOleUndoUnits This,
ULONG  cElt,
IOleUndoUnit **  rgElt,
ULONG pcEltFetched 
)

Definition at line 2643 of file usrmarshal.c.

2648{
2649 ULONG fetched;
2650
2651 TRACE("(%u, %p %p)\n", cElt, rgElt, pcEltFetched);
2652
2653 if (!pcEltFetched)
2654 pcEltFetched = &fetched;
2655
2656 return IEnumOleUndoUnits_RemoteNext_Proxy(This, cElt, rgElt, pcEltFetched);
2657}

◆ IEnumOleUndoUnits_Next_Stub()

HRESULT __RPC_STUB IEnumOleUndoUnits_Next_Stub ( IEnumOleUndoUnits This,
ULONG  cElt,
IOleUndoUnit **  rgElt,
ULONG pcEltFetched 
)

Definition at line 2659 of file usrmarshal.c.

2664{
2665 HRESULT hr;
2666
2667 TRACE("(%u, %p, %p)\n", cElt, rgElt, pcEltFetched);
2668
2669 *pcEltFetched = 0;
2670 hr = IEnumOleUndoUnits_Next(This, cElt, rgElt, pcEltFetched);
2671 if (hr == S_OK)
2672 *pcEltFetched = cElt;
2673
2674 return hr;
2675}

◆ IEnumVARIANT_Next_Proxy()

HRESULT CALLBACK IEnumVARIANT_Next_Proxy ( IEnumVARIANT This,
ULONG  celt,
VARIANT rgVar,
ULONG pCeltFetched 
)

Definition at line 1515 of file usrmarshal.c.

1520{
1521 ULONG fetched;
1522 if (!pCeltFetched)
1523 pCeltFetched = &fetched;
1524 return IEnumVARIANT_RemoteNext_Proxy(This,
1525 celt,
1526 rgVar,
1527 pCeltFetched);
1528}

◆ IEnumVARIANT_Next_Stub()

HRESULT __RPC_STUB IEnumVARIANT_Next_Stub ( IEnumVARIANT This,
ULONG  celt,
VARIANT rgVar,
ULONG pCeltFetched 
)

Definition at line 1530 of file usrmarshal.c.

1535{
1536 HRESULT hr;
1537 *pCeltFetched = 0;
1538 hr = IEnumVARIANT_Next(This,
1539 celt,
1540 rgVar,
1541 pCeltFetched);
1542 if (hr == S_OK) *pCeltFetched = celt;
1543 return hr;
1544}

◆ interface_variant_marshal()

static unsigned char * interface_variant_marshal ( ULONG pFlags,
unsigned char Buffer,
REFIID  riid,
IUnknown punk 
)
static

Definition at line 354 of file usrmarshal.c.

357{
358 TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags, Buffer, punk);
359
360 /* first DWORD is used to store pointer itself, truncated on win64 */
361 if(!punk)
362 {
363 memset(Buffer, 0, sizeof(ULONG));
364 return Buffer + sizeof(ULONG);
365 }
366 else
367 {
368 *(DWORD*)Buffer = (DWORD_PTR)punk;
369 Buffer += sizeof(DWORD);
370 }
371
372 return WdtpInterfacePointer_UserMarshal(pFlags, LOWORD(*pFlags), Buffer, punk, riid);
373}
unsigned char *WINAPI WdtpInterfacePointer_UserMarshal(ULONG *pFlags, ULONG RealFlags, unsigned char *pBuffer, IUnknown *punk, REFIID riid)
Definition: usrmarshal.c:1550
uint32_t DWORD_PTR
Definition: typedefs.h:65

Referenced by VARIANT_UserMarshal().

◆ interface_variant_size()

static unsigned interface_variant_size ( ULONG pFlags,
REFIID  riid,
IUnknown punk 
)
static

Definition at line 274 of file usrmarshal.c.

276{
277 ULONG size = 0;
278
279 if (punk)
280 {
281 size = WdtpInterfacePointer_UserSize(pFlags, LOWORD(*pFlags), 0, punk, riid);
282 if (!size)
283 {
284 ERR("interface variant buffer size calculation failed\n");
285 return 0;
286 }
287 }
288 size += sizeof(ULONG);
289 TRACE("wire-size extra of interface variant is %d\n", size);
290#ifdef __REACTOS__
291 return Start + size;
292#else
293 return size;
294#endif
295}
ULONG __RPC_USER WdtpInterfacePointer_UserSize(ULONG *pFlags, ULONG RealFlags, ULONG StartingSize, IUnknown *punk, REFIID riid)
Definition: usrmarshal.c:1515

Referenced by wire_extra_user_size().

◆ interface_variant_unmarshal()

static unsigned char * interface_variant_unmarshal ( ULONG pFlags,
unsigned char Buffer,
REFIID  riid,
IUnknown **  ppunk 
)
static

Definition at line 379 of file usrmarshal.c.

382{
383 DWORD ptr;
384
385 TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags, Buffer, ppunk);
386
387 /* skip pointer part itself */
388 ptr = *(DWORD*)Buffer;
389 Buffer += sizeof(DWORD);
390
391 if(!ptr)
392 return Buffer;
393
394 return WdtpInterfacePointer_UserUnmarshal(pFlags, Buffer, ppunk, riid);
395}
unsigned char *WINAPI WdtpInterfacePointer_UserUnmarshal(ULONG *pFlags, unsigned char *pBuffer, IUnknown **ppunk, REFIID riid)
Definition: usrmarshal.c:1607
static PVOID ptr
Definition: dispmode.c:27

Referenced by VARIANT_UserUnmarshal().

◆ IPersistMemory_Load_Proxy()

HRESULT CALLBACK IPersistMemory_Load_Proxy ( IPersistMemory This,
LPVOID  pMem,
ULONG  cbSize 
)

Definition at line 2580 of file usrmarshal.c.

2584{
2585 TRACE("(%p, %u)\n", pMem, cbSize);
2586
2587 if (!pMem)
2588 return E_POINTER;
2589
2590 return IPersistMemory_RemoteLoad_Proxy(This, pMem, cbSize);
2591}
#define E_POINTER
Definition: winerror.h:3481

◆ IPersistMemory_Load_Stub()

HRESULT __RPC_STUB IPersistMemory_Load_Stub ( IPersistMemory This,
BYTE pMem,
ULONG  cbSize 
)

Definition at line 2593 of file usrmarshal.c.

2597{
2598 TRACE("(%p, %u)\n", pMem, cbSize);
2599 return IPersistMemory_Load(This, pMem, cbSize);
2600}

◆ IPersistMemory_Save_Proxy()

HRESULT CALLBACK IPersistMemory_Save_Proxy ( IPersistMemory This,
LPVOID  pMem,
BOOL  fClearDirty,
ULONG  cbSize 
)

Definition at line 2602 of file usrmarshal.c.

2607{
2608 TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
2609
2610 if (!pMem)
2611 return E_POINTER;
2612
2613 return IPersistMemory_RemoteSave_Proxy(This, pMem, fClearDirty, cbSize);
2614}

◆ IPersistMemory_Save_Stub()

HRESULT __RPC_STUB IPersistMemory_Save_Stub ( IPersistMemory This,
BYTE pMem,
BOOL  fClearDirty,
ULONG  cbSize 
)

Definition at line 2616 of file usrmarshal.c.

2621{
2622 TRACE("(%p, %d, %u)\n", pMem, fClearDirty, cbSize);
2623 return IPersistMemory_Save(This, pMem, fClearDirty, cbSize);
2624}

◆ IPropertyBag_Read_Proxy()

HRESULT CALLBACK IPropertyBag_Read_Proxy ( IPropertyBag This,
LPCOLESTR  pszPropName,
VARIANT pVar,
IErrorLog pErrorLog 
)

Definition at line 2392 of file usrmarshal.c.

2397{
2398 IUnknown *pUnk = NULL;
2399 TRACE("(%p, %s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog);
2400
2401 if(!pVar)
2402 return E_POINTER;
2403
2404 if(V_VT(pVar) & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2405 {
2406 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2407 return E_NOTIMPL;
2408 }
2409
2410 switch(V_VT(pVar))
2411 {
2412 case VT_DISPATCH:
2413 pUnk = (IUnknown*)V_DISPATCH(pVar);
2414 break;
2415 case VT_UNKNOWN:
2416 pUnk = V_UNKNOWN(pVar);
2417 break;
2418 case VT_SAFEARRAY:
2419 FIXME("Safearray support not yet implemented.\n");
2420 return E_NOTIMPL;
2421 default:
2422 FIXME("Unknown V_VT %d - support not yet implemented.\n", V_VT(pVar));
2423 return E_NOTIMPL;
2424 }
2425
2426 return IPropertyBag_RemoteRead_Proxy(This, pszPropName, pVar, pErrorLog,
2427 V_VT(pVar), pUnk);
2428}
#define E_NOTIMPL
Definition: ddrawi.h:99
@ VT_VECTOR
Definition: compat.h:2340
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
#define V_UNKNOWN(A)
Definition: oleauto.h:281
#define V_VT(A)
Definition: oleauto.h:211
#define V_DISPATCH(A)
Definition: oleauto.h:239

◆ IPropertyBag_Read_Stub()

HRESULT __RPC_STUB IPropertyBag_Read_Stub ( IPropertyBag This,
LPCOLESTR  pszPropName,
VARIANT pVar,
IErrorLog pErrorLog,
DWORD  varType,
IUnknown pUnkObj 
)

Definition at line 2430 of file usrmarshal.c.

2437{
2438 static const WCHAR emptyWstr[] = {0};
2439 IDispatch *disp;
2440 HRESULT hr;
2441 TRACE("(%p, %s, %p, %p, %x, %p)\n", This, debugstr_w(pszPropName), pVar,
2442 pErrorLog, varType, pUnkObj);
2443
2444 if(varType & (VT_BYREF | VT_ARRAY | VT_VECTOR))
2445 {
2446 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar));
2447 return E_NOTIMPL;
2448 }
2449
2450 V_VT(pVar) = varType;
2451 switch(varType)
2452 {
2453 case VT_DISPATCH:
2454 hr = IUnknown_QueryInterface(pUnkObj, &IID_IDispatch, (LPVOID*)&disp);
2455 if(FAILED(hr))
2456 return hr;
2457 IUnknown_Release(pUnkObj);
2458 V_DISPATCH(pVar) = disp;
2459 break;
2460 case VT_UNKNOWN:
2461 V_UNKNOWN(pVar) = pUnkObj;
2462 break;
2463 case VT_BSTR:
2464 V_BSTR(pVar) = SysAllocString(emptyWstr);
2465 break;
2466 case VT_SAFEARRAY:
2467 FIXME("Safearray support not yet implemented.\n");
2468 return E_NOTIMPL;
2469 default:
2470 break;
2471 }
2472 hr = IPropertyBag_Read(This, pszPropName, pVar, pErrorLog);
2473 if(FAILED(hr))
2474 VariantClear(pVar);
2475
2476 return hr;
2477}
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
#define V_BSTR(A)
Definition: oleauto.h:226
const GUID IID_IDispatch
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ IQuickActivate_QuickActivate_Proxy()

HRESULT CALLBACK IQuickActivate_QuickActivate_Proxy ( IQuickActivate This,
QACONTAINER *  pQaContainer,
QACONTROL *  pQaControl 
)

Definition at line 2677 of file usrmarshal.c.

2681{
2682 FIXME("not implemented\n");
2683 return E_NOTIMPL;
2684}

◆ IQuickActivate_QuickActivate_Stub()

HRESULT __RPC_STUB IQuickActivate_QuickActivate_Stub ( IQuickActivate This,
QACONTAINER *  pQaContainer,
QACONTROL *  pQaControl 
)

Definition at line 2686 of file usrmarshal.c.

2690{
2691 FIXME("not implemented\n");
2692 return E_NOTIMPL;
2693}

◆ ITypeComp_Bind_Proxy()

HRESULT CALLBACK ITypeComp_Bind_Proxy ( ITypeComp This,
LPOLESTR  name,
ULONG  lHashVal,
WORD  flags,
ITypeInfo **  ti,
DESCKIND *  desckind,
BINDPTR *  bindptr 
)

Definition at line 1590 of file usrmarshal.c.

1598{
1599 CLEANLOCALSTORAGE stg = { 0 };
1600 ITypeComp *typecomp;
1601 FUNCDESC *funcdesc;
1602 VARDESC *vardesc;
1603 HRESULT hr;
1604
1605 TRACE("(%p, %s, %#x, %#x, %p, %p, %p)\n", This, debugstr_w(name), lHashVal, flags, ti,
1606 desckind, bindptr);
1607
1608 *desckind = DESCKIND_NONE;
1609 memset(bindptr, 0, sizeof(*bindptr));
1610
1611 hr = ITypeComp_RemoteBind_Proxy(This, name, lHashVal, flags, ti, desckind,
1612 &funcdesc, &vardesc, &typecomp, &stg);
1613
1614 if (hr == S_OK)
1615 {
1616 switch (*desckind)
1617 {
1618 case DESCKIND_FUNCDESC:
1619 bindptr->lpfuncdesc = funcdesc;
1620 break;
1621 case DESCKIND_VARDESC:
1622 case DESCKIND_IMPLICITAPPOBJ:
1623 bindptr->lpvardesc = vardesc;
1624 break;
1625 case DESCKIND_TYPECOMP:
1626 bindptr->lptcomp = typecomp;
1627 break;
1628 default:
1629 ;
1630 }
1631 }
1632
1633 return hr;
1634}
GLbitfield flags
Definition: glext.h:7161
Definition: name.c:39

◆ ITypeComp_Bind_Stub()

HRESULT __RPC_STUB ITypeComp_Bind_Stub ( ITypeComp This,
LPOLESTR  name,
ULONG  lHashVal,
WORD  flags,
ITypeInfo **  ti,
DESCKIND *  desckind,
FUNCDESC **  funcdesc,
VARDESC **  vardesc,
ITypeComp **  typecomp,
CLEANLOCALSTORAGE *  stg 
)

Definition at line 1636 of file usrmarshal.c.

1647{
1648 BINDPTR bindptr;
1649 HRESULT hr;
1650
1651 TRACE("(%p, %s, %#x, %#x, %p, %p, %p, %p, %p, %p)\n", This, debugstr_w(name),
1652 lHashVal, flags, ti, desckind, funcdesc, vardesc, typecomp, stg);
1653
1654 memset(stg, 0, sizeof(*stg));
1655 memset(&bindptr, 0, sizeof(bindptr));
1656
1657 *funcdesc = NULL;
1658 *vardesc = NULL;
1659 *typecomp = NULL;
1660 *ti = NULL;
1661
1662 hr = ITypeComp_Bind(This, name, lHashVal, flags, ti, desckind, &bindptr);
1663 if(hr != S_OK)
1664 return hr;
1665
1666 switch (*desckind)
1667 {
1668 case DESCKIND_FUNCDESC:
1669 *funcdesc = bindptr.lpfuncdesc;
1670 stg->pInterface = (IUnknown*)*ti;
1671 stg->pStorage = funcdesc;
1672 stg->flags = CLS_FUNCDESC;
1673 break;
1674 case DESCKIND_VARDESC:
1675 case DESCKIND_IMPLICITAPPOBJ:
1676 *vardesc = bindptr.lpvardesc;
1677 stg->pInterface = (IUnknown*)*ti;
1678 stg->pStorage = vardesc;
1679 stg->flags = CLS_VARDESC;
1680 break;
1681 case DESCKIND_TYPECOMP:
1682 *typecomp = bindptr.lptcomp;
1683 break;
1684 default:
1685 ;
1686 }
1687
1688 if (stg->pInterface)
1689 IUnknown_AddRef(stg->pInterface);
1690
1691 return hr;
1692}

◆ ITypeComp_BindType_Proxy()

HRESULT CALLBACK ITypeComp_BindType_Proxy ( ITypeComp This,
LPOLESTR  name,
ULONG  lHashVal,
ITypeInfo **  ti,
ITypeComp **  typecomp 
)

Definition at line 1694 of file usrmarshal.c.

1700{
1701 HRESULT hr;
1702
1703 TRACE("(%p, %s, %#x, %p, %p)\n", This, debugstr_w(name), lHashVal, ti, typecomp);
1704
1705 hr = ITypeComp_RemoteBindType_Proxy(This, name, lHashVal, ti);
1706 if (hr == S_OK)
1707 ITypeInfo_GetTypeComp(*ti, typecomp);
1708 else if (typecomp)
1709 *typecomp = NULL;
1710
1711 return hr;
1712}

◆ ITypeComp_BindType_Stub()

HRESULT __RPC_STUB ITypeComp_BindType_Stub ( ITypeComp This,
LPOLESTR  name,
ULONG  lHashVal,
ITypeInfo **  ti 
)

Definition at line 1714 of file usrmarshal.c.

1719{
1720 ITypeComp *typecomp = NULL;
1721 HRESULT hr;
1722
1723 TRACE("(%p, %s, %#x, %p)\n", This, debugstr_w(name), lHashVal, ti);
1724
1725 hr = ITypeComp_BindType(This, name, lHashVal, ti, &typecomp);
1726
1727 if (typecomp)
1728 ITypeComp_Release(typecomp);
1729
1730 return hr;
1731}

◆ ITypeInfo2_GetDocumentation2_Proxy()

HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy ( ITypeInfo2 This,
MEMBERID  memid,
LCID  lcid,
BSTR help_string,
DWORD help_context,
BSTR help_dll 
)

Definition at line 2127 of file usrmarshal.c.

2130{
2131 DWORD dummy_help_context, flags = 0;
2132 BSTR dummy_help_string, dummy_help_dll;
2133 HRESULT hr;
2134 TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, help_string, help_context, help_dll);
2135
2136 if(!help_string) help_string = &dummy_help_string;
2137 else flags = 1;
2138
2139 if(!help_context) help_context = &dummy_help_context;
2140 else flags |= 2;
2141
2142 if(!help_dll) help_dll = &dummy_help_dll;
2143 else flags |= 4;
2144
2145 hr = ITypeInfo2_RemoteGetDocumentation2_Proxy(This, memid, lcid, flags, help_string, help_context, help_dll);
2146
2147 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2148
2149 return hr;
2150}

◆ ITypeInfo2_GetDocumentation2_Stub()

HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub ( ITypeInfo2 This,
MEMBERID  memid,
LCID  lcid,
DWORD  flags,
BSTR help_string,
DWORD help_context,
BSTR help_dll 
)

Definition at line 2152 of file usrmarshal.c.

2156{
2157 TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This, memid, lcid, flags, help_string, help_context, help_dll);
2158
2159 *help_string = *help_dll = NULL;
2160 *help_context = 0;
2161
2162 if(!(flags & 1)) help_string = NULL;
2163 if(!(flags & 2)) help_context = NULL;
2164 if(!(flags & 4)) help_dll = NULL;
2165
2166 return ITypeInfo2_GetDocumentation2(This, memid, lcid, help_string, help_context, help_dll);
2167}

◆ ITypeInfo_AddressOfMember_Proxy()

HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy ( ITypeInfo This,
MEMBERID  memid,
INVOKEKIND  invKind,
PVOID ppv 
)

Definition at line 1989 of file usrmarshal.c.

1994{
1995 FIXME("not implemented\n");
1996 return E_FAIL;
1997}
#define E_FAIL
Definition: ddrawi.h:102

◆ ITypeInfo_AddressOfMember_Stub()

HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub ( ITypeInfo This)

Definition at line 1999 of file usrmarshal.c.

2001{
2002 FIXME("not implemented\n");
2003 return E_FAIL;
2004}

◆ ITypeInfo_CreateInstance_Proxy()

HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy ( ITypeInfo This,
IUnknown pUnkOuter,
REFIID  riid,
PVOID ppvObj 
)

Definition at line 2006 of file usrmarshal.c.

2011{
2012 FIXME("not implemented\n");
2013 return E_FAIL;
2014}

◆ ITypeInfo_CreateInstance_Stub()

HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub ( ITypeInfo This,
REFIID  riid,
IUnknown **  ppvObj 
)

Definition at line 2016 of file usrmarshal.c.

2020{
2021 FIXME("not implemented\n");
2022 return E_FAIL;
2023}

◆ ITypeInfo_GetContainingTypeLib_Proxy()

HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy ( ITypeInfo This,
ITypeLib **  ppTLib,
UINT pIndex 
)

Definition at line 2025 of file usrmarshal.c.

2029{
2030 ITypeLib *pTL;
2031 UINT index;
2032 HRESULT hr;
2033
2034 TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
2035
2036 hr = ITypeInfo_RemoteGetContainingTypeLib_Proxy(This, &pTL, &index);
2037 if(SUCCEEDED(hr))
2038 {
2039 if(pIndex)
2040 *pIndex = index;
2041
2042 if(ppTLib)
2043 *ppTLib = pTL;
2044 else
2045 ITypeLib_Release(pTL);
2046 }
2047 return hr;
2048}
#define index(s, c)
Definition: various.h:29
GLuint index
Definition: glext.h:6031
_Out_ PULONG _Out_ PULONG pIndex
Definition: ndis.h:4565

◆ ITypeInfo_GetContainingTypeLib_Stub()

HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub ( ITypeInfo This,
ITypeLib **  ppTLib,
UINT pIndex 
)

Definition at line 2050 of file usrmarshal.c.

2054{
2055 TRACE("(%p, %p, %p)\n", This, ppTLib, pIndex );
2056 return ITypeInfo_GetContainingTypeLib(This, ppTLib, pIndex);
2057}

◆ ITypeInfo_GetDllEntry_Proxy()

HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy ( ITypeInfo This,
MEMBERID  memid,
INVOKEKIND  invkind,
BSTR dll_name,
BSTR name,
WORD ordinal 
)

Definition at line 1946 of file usrmarshal.c.

1949{
1950 DWORD flags = 0;
1951 BSTR dummy_dll_name, dummy_name;
1952 WORD dummy_ordinal;
1953 HRESULT hr;
1954 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1955
1956 if(!dll_name) dll_name = &dummy_dll_name;
1957 else flags = 1;
1958
1959 if(!name) name = &dummy_name;
1960 else flags |= 2;
1961
1962 if(!ordinal) ordinal = &dummy_ordinal;
1963 else flags |= 4;
1964
1965 hr = ITypeInfo_RemoteGetDllEntry_Proxy(This, memid, invkind, flags, dll_name, name, ordinal);
1966
1967 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1968
1969 return hr;
1970}
unsigned short WORD
Definition: ntddk_ex.h:93

◆ ITypeInfo_GetDllEntry_Stub()

HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub ( ITypeInfo This,
MEMBERID  memid,
INVOKEKIND  invkind,
DWORD  flags,
BSTR dll_name,
BSTR name,
WORD ordinal 
)

Definition at line 1972 of file usrmarshal.c.

1976{
1977 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This, memid, invkind, dll_name, name, ordinal);
1978
1979 *dll_name = *name = NULL;
1980 *ordinal = 0;
1981
1982 if(!(flags & 1)) dll_name = NULL;
1983 if(!(flags & 2)) name = NULL;
1984 if(!(flags & 4)) ordinal = NULL;
1985
1986 return ITypeInfo_GetDllEntry(This, memid, invkind, dll_name, name, ordinal);
1987}

◆ ITypeInfo_GetDocumentation_Proxy()

HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy ( ITypeInfo This,
MEMBERID  memid,
BSTR name,
BSTR doc_string,
DWORD help_context,
BSTR help_file 
)

Definition at line 1901 of file usrmarshal.c.

1904{
1905 DWORD dummy_help_context, flags = 0;
1906 BSTR dummy_name, dummy_doc_string, dummy_help_file;
1907 HRESULT hr;
1908 TRACE("(%p, %08x, %p, %p, %p, %p)\n", This, memid, name, doc_string, help_context, help_file);
1909
1910 if(!name) name = &dummy_name;
1911 else flags = 1;
1912
1913 if(!doc_string) doc_string = &dummy_doc_string;
1914 else flags |= 2;
1915
1916 if(!help_context) help_context = &dummy_help_context;
1917 else flags |= 4;
1918
1919 if(!help_file) help_file = &dummy_help_file;
1920 else flags |= 8;
1921
1922 hr = ITypeInfo_RemoteGetDocumentation_Proxy(This, memid, flags, name, doc_string, help_context, help_file);
1923
1924 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1925
1926 return hr;
1927}

◆ ITypeInfo_GetDocumentation_Stub()

HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub ( ITypeInfo This,
MEMBERID  memid,
DWORD  flags,
BSTR name,
BSTR doc_string,
DWORD help_context,
BSTR help_file 
)

Definition at line 1929 of file usrmarshal.c.

1932{
1933 TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This, memid, flags, name, doc_string, help_context, help_file);
1934
1935 *name = *doc_string = *help_file = NULL;
1936 *help_context = 0;
1937
1938 if(!(flags & 1)) name = NULL;
1939 if(!(flags & 2)) doc_string = NULL;
1940 if(!(flags & 4)) help_context = NULL;
1941 if(!(flags & 8)) help_file = NULL;
1942
1943 return ITypeInfo_GetDocumentation(This, memid, name, doc_string, help_context, help_file);
1944}

◆ ITypeInfo_GetFuncDesc_Proxy()

HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy ( ITypeInfo This,
UINT  index,
FUNCDESC **  ppFuncDesc 
)

Definition at line 1769 of file usrmarshal.c.

1773{
1774 CLEANLOCALSTORAGE stg;
1775 TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1776
1777 stg.flags = 0;
1778 stg.pStorage = NULL;
1779 stg.pInterface = NULL;
1780
1781 return ITypeInfo_RemoteGetFuncDesc_Proxy(This, index, ppFuncDesc, &stg);
1782}

◆ ITypeInfo_GetFuncDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub ( ITypeInfo This,
UINT  index,
LPFUNCDESC *  ppFuncDesc,
CLEANLOCALSTORAGE *  pDummy 
)

Definition at line 1784 of file usrmarshal.c.

1789{
1790 HRESULT hr;
1791 TRACE("(%p, %d, %p)\n", This, index, ppFuncDesc);
1792
1793 hr = ITypeInfo_GetFuncDesc(This, index, ppFuncDesc);
1794 if(hr != S_OK)
1795 return hr;
1796
1797 pDummy->flags = CLS_FUNCDESC;
1798 ITypeInfo_AddRef(This);
1799 pDummy->pInterface = (IUnknown*)This;
1800 pDummy->pStorage = ppFuncDesc;
1801 return hr;
1802}

◆ ITypeInfo_GetIDsOfNames_Proxy()

HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy ( ITypeInfo This,
LPOLESTR rgszNames,
UINT  cNames,
MEMBERID *  pMemId 
)

Definition at line 1863 of file usrmarshal.c.

1868{
1869 FIXME("not implemented\n");
1870 return E_FAIL;
1871}

◆ ITypeInfo_GetIDsOfNames_Stub()

HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub ( ITypeInfo This)

Definition at line 1873 of file usrmarshal.c.

1875{
1876 FIXME("not implemented\n");
1877 return E_FAIL;
1878}

◆ ITypeInfo_GetNames_Proxy()

HRESULT CALLBACK ITypeInfo_GetNames_Proxy ( ITypeInfo This,
MEMBERID  memid,
BSTR rgBstrNames,
UINT  cMaxNames,
UINT pcNames 
)

Definition at line 1839 of file usrmarshal.c.

1845{
1846 TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1847
1848 return ITypeInfo_RemoteGetNames_Proxy(This, memid, rgBstrNames, cMaxNames, pcNames);
1849}

◆ ITypeInfo_GetNames_Stub()

HRESULT __RPC_STUB ITypeInfo_GetNames_Stub ( ITypeInfo This,
MEMBERID  memid,
BSTR rgBstrNames,
UINT  cMaxNames,
UINT pcNames 
)

Definition at line 1851 of file usrmarshal.c.

1857{
1858 TRACE("(%p, %08x, %p, %d, %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
1859
1860 return ITypeInfo_GetNames(This, memid, rgBstrNames, cMaxNames, pcNames);
1861}

◆ ITypeInfo_GetTypeAttr_Proxy()

HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy ( ITypeInfo This,
TYPEATTR **  ppTypeAttr 
)

Definition at line 1735 of file usrmarshal.c.

1739{
1740 CLEANLOCALSTORAGE stg;
1741 TRACE("(%p, %p)\n", This, ppTypeAttr);
1742
1743 stg.flags = 0;
1744 stg.pStorage = NULL;
1745 stg.pInterface = NULL;
1746
1747 return ITypeInfo_RemoteGetTypeAttr_Proxy(This, ppTypeAttr, &stg);
1748}

◆ ITypeInfo_GetTypeAttr_Stub()

HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub ( ITypeInfo This,
LPTYPEATTR *  ppTypeAttr,
CLEANLOCALSTORAGE *  pDummy 
)

Definition at line 1750 of file usrmarshal.c.

1754{
1755 HRESULT hr;
1756 TRACE("(%p, %p)\n", This, ppTypeAttr);
1757
1758 hr = ITypeInfo_GetTypeAttr(This, ppTypeAttr);
1759 if(hr != S_OK)
1760 return hr;
1761
1762 pDummy->flags = CLS_TYPEATTR;
1763 ITypeInfo_AddRef(This);
1764 pDummy->pInterface = (IUnknown*)This;
1765 pDummy->pStorage = ppTypeAttr;
1766 return hr;
1767}

◆ ITypeInfo_GetVarDesc_Proxy()

HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy ( ITypeInfo This,
UINT  index,
VARDESC **  ppVarDesc 
)

Definition at line 1804 of file usrmarshal.c.

1808{
1809 CLEANLOCALSTORAGE stg;
1810 TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1811
1812 stg.flags = 0;
1813 stg.pStorage = NULL;
1814 stg.pInterface = NULL;
1815
1816 return ITypeInfo_RemoteGetVarDesc_Proxy(This, index, ppVarDesc, &stg);
1817}

◆ ITypeInfo_GetVarDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub ( ITypeInfo This,
UINT  index,
LPVARDESC *  ppVarDesc,
CLEANLOCALSTORAGE *  pDummy 
)

Definition at line 1819 of file usrmarshal.c.

1824{
1825 HRESULT hr;
1826 TRACE("(%p, %d, %p)\n", This, index, ppVarDesc);
1827
1828 hr = ITypeInfo_GetVarDesc(This, index, ppVarDesc);
1829 if(hr != S_OK)
1830 return hr;
1831
1832 pDummy->flags = CLS_VARDESC;
1833 ITypeInfo_AddRef(This);
1834 pDummy->pInterface = (IUnknown*)This;
1835 pDummy->pStorage = ppVarDesc;
1836 return hr;
1837}

◆ ITypeInfo_Invoke_Proxy()

HRESULT CALLBACK ITypeInfo_Invoke_Proxy ( ITypeInfo This,
PVOID  pvInstance,
MEMBERID  memid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)

Definition at line 1880 of file usrmarshal.c.

1889{
1890 FIXME("not implemented\n");
1891 return E_FAIL;
1892}

◆ ITypeInfo_Invoke_Stub()

HRESULT __RPC_STUB ITypeInfo_Invoke_Stub ( ITypeInfo This)

Definition at line 1894 of file usrmarshal.c.

1896{
1897 FIXME("not implemented\n");
1898 return E_FAIL;
1899}

◆ ITypeInfo_ReleaseFuncDesc_Proxy()

void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy ( ITypeInfo This,
FUNCDESC *  pFuncDesc 
)

Definition at line 2075 of file usrmarshal.c.

2078{
2079 SHORT param;
2080 TRACE("(%p, %p)\n", This, pFuncDesc);
2081
2082 for(param = 0; param < pFuncDesc->cParams; param++)
2083 free_embedded_elemdesc(pFuncDesc->lprgelemdescParam + param);
2084 if(param)
2085 CoTaskMemFree(pFuncDesc->lprgelemdescParam);
2086
2087 free_embedded_elemdesc(&pFuncDesc->elemdescFunc);
2088
2089 if(pFuncDesc->cScodes != 0 && pFuncDesc->cScodes != -1)
2090 CoTaskMemFree(pFuncDesc->lprgscode);
2091
2092 CoTaskMemFree(pFuncDesc);
2093}
static void free_embedded_elemdesc(ELEMDESC *edesc)
Definition: usrmarshal.c:1581
GLfloat param
Definition: glext.h:5796

◆ ITypeInfo_ReleaseFuncDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub ( ITypeInfo This)

Definition at line 2095 of file usrmarshal.c.

2097{
2098 TRACE("nothing to do\n");
2099 return S_OK;
2100}

◆ ITypeInfo_ReleaseTypeAttr_Proxy()

void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy ( ITypeInfo This,
TYPEATTR *  pTypeAttr 
)

Definition at line 2059 of file usrmarshal.c.

2062{
2063 TRACE("(%p, %p)\n", This, pTypeAttr);
2064 free_embedded_typedesc(&pTypeAttr->tdescAlias);
2065 CoTaskMemFree(pTypeAttr);
2066}

◆ ITypeInfo_ReleaseTypeAttr_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub ( ITypeInfo This)

Definition at line 2068 of file usrmarshal.c.

2070{
2071 TRACE("nothing to do\n");
2072 return S_OK;
2073}

◆ ITypeInfo_ReleaseVarDesc_Proxy()

void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy ( ITypeInfo This,
VARDESC *  pVarDesc 
)

Definition at line 2102 of file usrmarshal.c.

2105{
2106 TRACE("(%p, %p)\n", This, pVarDesc);
2107
2108 CoTaskMemFree(pVarDesc->lpstrSchema);
2109
2110 if(pVarDesc->varkind == VAR_CONST)
2111 CoTaskMemFree(pVarDesc->u.lpvarValue);
2112
2113 free_embedded_elemdesc(&pVarDesc->elemdescVar);
2114 CoTaskMemFree(pVarDesc);
2115}

◆ ITypeInfo_ReleaseVarDesc_Stub()

HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub ( ITypeInfo This)

Definition at line 2117 of file usrmarshal.c.

2119{
2120 TRACE("nothing to do\n");
2121 return S_OK;
2122}

◆ ITypeLib2_GetDocumentation2_Proxy()

HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy ( ITypeLib2 This,
INT  index,
LCID  lcid,
BSTR help_string,
DWORD help_context,
BSTR help_dll 
)

Definition at line 2351 of file usrmarshal.c.

2354{
2355 DWORD dummy_help_context, flags = 0;
2356 BSTR dummy_help_string, dummy_help_dll;
2357 HRESULT hr;
2358 TRACE("(%p, %d, %08x, %p, %p, %p)\n", This, index, lcid, help_string, help_context, help_dll);
2359
2360 if(!help_string) help_string = &dummy_help_string;
2361 else flags = 1;
2362
2363 if(!help_context) help_context = &dummy_help_context;
2364 else flags |= 2;
2365
2366 if(!help_dll) help_dll = &dummy_help_dll;
2367 else flags |= 4;
2368
2369 hr = ITypeLib2_RemoteGetDocumentation2_Proxy(This, index, lcid, flags, help_string, help_context, help_dll);
2370
2371 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2372
2373 return hr;
2374}

◆ ITypeLib2_GetDocumentation2_Stub()

HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub ( ITypeLib2 This,
INT  index,
LCID  lcid,
DWORD  flags,
BSTR help_string,
DWORD help_context,
BSTR help_dll 
)

Definition at line 2376 of file usrmarshal.c.

2379{
2380 TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This, index, lcid, flags, help_string, help_context, help_dll);
2381
2382 *help_string = *help_dll = NULL;
2383 *help_context = 0;
2384
2385 if(!(flags & 1)) help_string = NULL;
2386 if(!(flags & 2)) help_context = NULL;
2387 if(!(flags & 4)) help_dll = NULL;
2388
2389 return ITypeLib2_GetDocumentation2(This, index, lcid, help_string, help_context, help_dll);
2390}

◆ ITypeLib2_GetLibStatistics_Proxy()

HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy ( ITypeLib2 This,
ULONG pcUniqueNames,
ULONG pcchUniqueNames 
)

Definition at line 2333 of file usrmarshal.c.

2337{
2338 FIXME("not implemented\n");
2339 return E_FAIL;
2340}

◆ ITypeLib2_GetLibStatistics_Stub()

HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub ( ITypeLib2 This,
ULONG pcUniqueNames,
ULONG pcchUniqueNames 
)

Definition at line 2342 of file usrmarshal.c.

2346{
2347 FIXME("not implemented\n");
2348 return E_FAIL;
2349}

◆ ITypeLib_FindName_Proxy()

HRESULT CALLBACK ITypeLib_FindName_Proxy ( ITypeLib This,
LPOLESTR  szNameBuf,
ULONG  lHashVal,
ITypeInfo **  ppTInfo,
MEMBERID *  rgMemId,
USHORT pcFound 
)

Definition at line 2290 of file usrmarshal.c.

2297{
2298 FIXME("not implemented\n");
2299 return E_FAIL;
2300}

◆ ITypeLib_FindName_Stub()

HRESULT __RPC_STUB ITypeLib_FindName_Stub ( ITypeLib This,
LPOLESTR  szNameBuf,
ULONG  lHashVal,
ITypeInfo **  ppTInfo,
MEMBERID *  rgMemId,
USHORT pcFound,
BSTR pBstrLibName 
)

Definition at line 2302 of file usrmarshal.c.

2310{
2311 FIXME("not implemented\n");
2312 return E_FAIL;
2313}

◆ ITypeLib_GetDocumentation_Proxy()

HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy ( ITypeLib This,
INT  index,
BSTR name,
BSTR doc_string,
DWORD help_context,
BSTR help_file 
)

Definition at line 2224 of file usrmarshal.c.

2227{
2228 DWORD dummy_help_context, flags = 0;
2229 BSTR dummy_name, dummy_doc_string, dummy_help_file;
2230 HRESULT hr;
2231 TRACE("(%p, %d, %p, %p, %p, %p)\n", This, index, name, doc_string, help_context, help_file);
2232
2233 if(!name) name = &dummy_name;
2234 else flags = 1;
2235
2236 if(!doc_string) doc_string = &dummy_doc_string;
2237 else flags |= 2;
2238
2239 if(!help_context) help_context = &dummy_help_context;
2240 else flags |= 4;
2241
2242 if(!help_file) help_file = &dummy_help_file;
2243 else flags |= 8;
2244
2245 hr = ITypeLib_RemoteGetDocumentation_Proxy(This, index, flags, name, doc_string, help_context, help_file);
2246
2247 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2248
2249 return hr;
2250}

◆ ITypeLib_GetDocumentation_Stub()

HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub ( ITypeLib This,
INT  index,
DWORD  flags,
BSTR name,
BSTR doc_string,
DWORD help_context,
BSTR help_file 
)

Definition at line 2252 of file usrmarshal.c.

2255{
2256 TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This, index, flags, name, doc_string, help_context, help_file);
2257
2258 *name = *doc_string = *help_file = NULL;
2259 *help_context = 0;
2260
2261 if(!(flags & 1)) name = NULL;
2262 if(!(flags & 2)) doc_string = NULL;
2263 if(!(flags & 4)) help_context = NULL;
2264 if(!(flags & 8)) help_file = NULL;
2265
2266 return ITypeLib_GetDocumentation(This, index, name, doc_string, help_context, help_file);
2267}

◆ ITypeLib_GetLibAttr_Proxy()

HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy ( ITypeLib This,
TLIBATTR **  ppTLibAttr 
)

Definition at line 2191 of file usrmarshal.c.

2194{
2195 CLEANLOCALSTORAGE stg;
2196 TRACE("(%p, %p)\n", This, ppTLibAttr);
2197
2198 stg.flags = 0;
2199 stg.pStorage = NULL;
2200 stg.pInterface = NULL;
2201
2202 return ITypeLib_RemoteGetLibAttr_Proxy(This, ppTLibAttr, &stg);
2203}

◆ ITypeLib_GetLibAttr_Stub()

HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub ( ITypeLib This,
LPTLIBATTR *  ppTLibAttr,
CLEANLOCALSTORAGE *  pDummy 
)

Definition at line 2205 of file usrmarshal.c.

2209{
2210 HRESULT hr;
2211 TRACE("(%p, %p)\n", This, ppTLibAttr);
2212
2213 hr = ITypeLib_GetLibAttr(This, ppTLibAttr);
2214 if(hr != S_OK)
2215 return hr;
2216
2217 pDummy->flags = CLS_LIBATTR;
2218 ITypeLib_AddRef(This);
2219 pDummy->pInterface = (IUnknown*)This;
2220 pDummy->pStorage = ppTLibAttr;
2221 return hr;
2222}

◆ ITypeLib_GetTypeInfoCount_Proxy()

UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy ( ITypeLib This)

Definition at line 2171 of file usrmarshal.c.

2173{
2174 UINT count = 0;
2175 TRACE("(%p)\n", This);
2176
2177 ITypeLib_RemoteGetTypeInfoCount_Proxy(This, &count);
2178
2179 return count;
2180}
GLuint GLuint GLsizei count
Definition: gl.h:1545

◆ ITypeLib_GetTypeInfoCount_Stub()

HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub ( ITypeLib This,
UINT pcTInfo 
)

Definition at line 2182 of file usrmarshal.c.

2185{
2186 TRACE("(%p, %p)\n", This, pcTInfo);
2187 *pcTInfo = ITypeLib_GetTypeInfoCount(This);
2188 return S_OK;
2189}

◆ ITypeLib_IsName_Proxy()

HRESULT CALLBACK ITypeLib_IsName_Proxy ( ITypeLib This,
LPOLESTR  szNameBuf,
ULONG  lHashVal,
BOOL pfName 
)

Definition at line 2269 of file usrmarshal.c.

2274{
2275 FIXME("not implemented\n");
2276 return E_FAIL;
2277}

◆ ITypeLib_IsName_Stub()

HRESULT __RPC_STUB ITypeLib_IsName_Stub ( ITypeLib This,
LPOLESTR  szNameBuf,
ULONG  lHashVal,
BOOL pfName,
BSTR pBstrLibName 
)

Definition at line 2279 of file usrmarshal.c.

2285{
2286 FIXME("not implemented\n");
2287 return E_FAIL;
2288}

◆ ITypeLib_ReleaseTLibAttr_Proxy()

void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy ( ITypeLib This,
TLIBATTR *  pTLibAttr 
)

Definition at line 2315 of file usrmarshal.c.

2318{
2319 TRACE("(%p, %p)\n", This, pTLibAttr);
2320 CoTaskMemFree(pTLibAttr);
2321}

◆ ITypeLib_ReleaseTLibAttr_Stub()

HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub ( ITypeLib This)

Definition at line 2323 of file usrmarshal.c.

2325{
2326 TRACE("nothing to do\n");
2327 return S_OK;
2328}

◆ LPSAFEARRAY_UserFree()

void WINAPI LPSAFEARRAY_UserFree ( ULONG pFlags,
LPSAFEARRAY ppsa 
)

Definition at line 1308 of file usrmarshal.c.

1309{
1310 TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *ppsa);
1311
1312 SafeArrayDestroy(*ppsa);
1313 *ppsa = NULL;
1314}
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
static void dump_user_flags(const ULONG *pFlags)
Definition: usrmarshal.c:52

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserFree().

◆ LPSAFEARRAY_UserMarshal()

unsigned char *WINAPI LPSAFEARRAY_UserMarshal ( ULONG pFlags,
unsigned char Buffer,
LPSAFEARRAY ppsa 
)

Definition at line 972 of file usrmarshal.c.

973{
974 HRESULT hr;
975
976 TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", Buffer, *ppsa);
977
979 *(ULONG *)Buffer = *ppsa ? 0x1 : 0x0;
980 Buffer += sizeof(ULONG);
981 if (*ppsa)
982 {
983 VARTYPE vt;
984 SAFEARRAY *psa = *ppsa;
985 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
986 SAFEARRAYBOUND *bound;
987 SF_TYPE sftype;
988 GUID guid;
989 INT i;
990
991 sftype = SAFEARRAY_GetUnionType(psa);
992
993 *(ULONG *)Buffer = psa->cDims;
994 Buffer += sizeof(ULONG);
995 *(USHORT *)Buffer = psa->cDims;
996 Buffer += sizeof(USHORT);
997 *(USHORT *)Buffer = psa->fFeatures;
998 Buffer += sizeof(USHORT);
999 *(ULONG *)Buffer = elem_wire_size(psa, sftype);
1000 Buffer += sizeof(ULONG);
1001
1003#ifdef __REACTOS__
1004 if ((psa->fFeatures & FADF_HAVEIID) || FAILED(hr)) vt = 0;
1005#else
1006 if (FAILED(hr)) vt = 0;
1007#endif
1008
1009 *(ULONG *)Buffer = (USHORT)psa->cLocks | (vt << 16);
1010 Buffer += sizeof(ULONG);
1011
1012 *(ULONG *)Buffer = sftype;
1013 Buffer += sizeof(ULONG);
1014
1015 *(ULONG *)Buffer = ulCellCount;
1016 Buffer += sizeof(ULONG);
1017 *(ULONG *)Buffer = psa->pvData ? 0x2 : 0x0;
1018 Buffer += sizeof(ULONG);
1019 if (sftype == SF_HAVEIID)
1020 {
1022 memcpy(Buffer, &guid, sizeof(guid));
1023 Buffer += sizeof(guid);
1024 }
1025
1026 /* bounds are marshaled in opposite order comparing to storage layout */
1027 bound = (SAFEARRAYBOUND*)Buffer;
1028 for (i = 0; i < psa->cDims; i++)
1029 {
1030 memcpy(bound++, &psa->rgsabound[psa->cDims-i-1], sizeof(psa->rgsabound[0]));
1031 }
1032 Buffer += sizeof(psa->rgsabound[0]) * psa->cDims;
1033
1034 *(ULONG *)Buffer = ulCellCount;
1035 Buffer += sizeof(ULONG);
1036
1037 if (psa->pvData)
1038 {
1039 switch (sftype)
1040 {
1041 case SF_BSTR:
1042 {
1043 BSTR* lpBstr;
1044
1045 for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
1046 Buffer = BSTR_UserMarshal(pFlags, Buffer, lpBstr);
1047
1048 break;
1049 }
1050 case SF_DISPATCH:
1051 case SF_UNKNOWN:
1052 case SF_HAVEIID:
1053#ifdef __REACTOS__
1054 {
1055 IUnknown **lpUnk;
1056 const GUID *iid;
1057
1058 if (sftype == SF_HAVEIID)
1059 iid = &guid;
1060 else if (sftype == SF_UNKNOWN)
1061 iid = &IID_IUnknown;
1062 else
1063 iid = &IID_IDispatch;
1064
1065 for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
1066 Buffer = interface_user_marshal(pFlags, Buffer, iid, *lpUnk);
1067
1068#else
1069 FIXME("marshal interfaces\n");
1070#endif
1071 break;
1072#ifdef __REACTOS__
1073 }
1074#endif
1075 case SF_VARIANT:
1076 {
1077 VARIANT* lpVariant;
1078
1079 for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
1080 Buffer = VARIANT_UserMarshal(pFlags, Buffer, lpVariant);
1081
1082 break;
1083 }
1084 case SF_RECORD:
1085 {
1086 IRecordInfo* pRecInfo = NULL;
1087
1088 hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
1089 if (FAILED(hr))
1091
1092 if (pRecInfo)
1093 {
1094 FIXME("write record info %p\n", pRecInfo);
1095
1096 IRecordInfo_Release(pRecInfo);
1097 }
1098 break;
1099 }
1100
1101 case SF_I8:
1103 /* fallthrough */
1104 case SF_I1:
1105 case SF_I2:
1106 case SF_I4:
1107 /* Just copy the data over */
1108 memcpy(Buffer, psa->pvData, ulCellCount * psa->cbElements);
1109 Buffer += ulCellCount * psa->cbElements;
1110 break;
1111 default:
1112 break;
1113 }
1114 }
1115
1116 }
1117 return Buffer;
1118}
const GUID IID_IUnknown
unsigned short VARTYPE
Definition: compat.h:2254
GUID guid
Definition: version.c:147
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
Definition: safearray.c:1670
HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY *psa, IRecordInfo **pRinfo)
Definition: safearray.c:1609
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY *psa, VARTYPE *pvt)
Definition: safearray.c:1534
static ULONG SAFEARRAY_GetCellCount(const SAFEARRAY *psa)
Definition: usrmarshal.c:726
static SF_TYPE SAFEARRAY_GetUnionType(SAFEARRAY *psa)
Definition: usrmarshal.c:743
unsigned char *WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
Definition: usrmarshal.c:420
static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
Definition: usrmarshal.c:798
unsigned char *WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
Definition: usrmarshal.c:146
static SCRIPT_CACHE SCRIPT_ANALYSIS * psa
Definition: usp10.c:64
unsigned short USHORT
Definition: pedump.c:61
void DECLSPEC_NORETURN WINAPI RpcRaiseException(RPC_STATUS exception)
Definition: rpcrt4_main.c:188
int32_t INT
Definition: typedefs.h:58

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserMarshal().

◆ LPSAFEARRAY_UserSize()

ULONG WINAPI LPSAFEARRAY_UserSize ( ULONG pFlags,
ULONG  StartingSize,
LPSAFEARRAY ppsa 
)

Definition at line 864 of file usrmarshal.c.

865{
866 ULONG size = StartingSize;
867
868 TRACE("("); dump_user_flags(pFlags); TRACE(", %d, %p\n", StartingSize, *ppsa);
869
870 ALIGN_LENGTH(size, 3);
871 size += sizeof(ULONG);
872 if (*ppsa)
873 {
874 SAFEARRAY *psa = *ppsa;
875 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
876 SF_TYPE sftype;
877 HRESULT hr;
878
879 size += sizeof(ULONG);
880 size += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
881
882 sftype = SAFEARRAY_GetUnionType(psa);
883 size += sizeof(ULONG);
884
885 size += sizeof(ULONG);
886 size += sizeof(ULONG);
887 if (sftype == SF_HAVEIID)
888 size += sizeof(IID);
889
890 size += sizeof(psa->rgsabound[0]) * psa->cDims;
891
892 size += sizeof(ULONG);
893
894 switch (sftype)
895 {
896 case SF_BSTR:
897 {
898 BSTR* lpBstr;
899
900 for (lpBstr = psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
901 size = BSTR_UserSize(pFlags, size, lpBstr);
902
903 break;
904 }
905 case SF_DISPATCH:
906 case SF_UNKNOWN:
907 case SF_HAVEIID:
908#ifdef __REACTOS__
909 {
910 IUnknown **lpUnk;
911 GUID guid;
912
913 if (sftype == SF_HAVEIID)
915 else if (sftype == SF_UNKNOWN)
917 else
919
920 for (lpUnk = psa->pvData; ulCellCount; ulCellCount--, lpUnk++)
921 size = interface_user_size(pFlags, size, &guid, *lpUnk);
922
923#else
924 FIXME("size interfaces\n");
925#endif
926 break;
927#ifdef __REACTOS__
928 }
929#endif
930 case SF_VARIANT:
931 {
932 VARIANT* lpVariant;
933
934 for (lpVariant = psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
935 size = VARIANT_UserSize(pFlags, size, lpVariant);
936
937 break;
938 }
939 case SF_RECORD:
940 {
941 IRecordInfo* pRecInfo = NULL;
942
943 hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
944 if (FAILED(hr))
946
947 if (pRecInfo)
948 {
949 FIXME("size record info %p\n", pRecInfo);
950
951 IRecordInfo_Release(pRecInfo);
952 }
953 break;
954 }
955 case SF_I8:
956 ALIGN_LENGTH(size, 7);
957 /* fallthrough */
958 case SF_I1:
959 case SF_I2:
960 case SF_I4:
961 size += ulCellCount * psa->cbElements;
962 break;
963 default:
964 break;
965 }
966
967 }
968
969 return size;
970}
ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
Definition: usrmarshal.c:136
ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
Definition: usrmarshal.c:397
struct _IID IID

Referenced by test_marshal_LPSAFEARRAY(), and wire_extra_user_size().

◆ LPSAFEARRAY_UserUnmarshal()

unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal ( ULONG pFlags,
unsigned char Buffer,
LPSAFEARRAY ppsa 
)

Definition at line 1124 of file usrmarshal.c.

1125{
1126 ULONG ptr;
1127 wireSAFEARRAY wiresa;
1128 ULONG cDims;
1129 HRESULT hr;
1130 SF_TYPE sftype;
1131 ULONG cell_count;
1132 GUID guid;
1133 VARTYPE vt;
1134 SAFEARRAYBOUND *wiresab;
1135
1136 TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", Buffer, ppsa);
1137
1139 ptr = *(ULONG *)Buffer;
1140 Buffer += sizeof(ULONG);
1141
1142 if (!ptr)
1143 {
1144 SafeArrayDestroy(*ppsa);
1145 *ppsa = NULL;
1146
1147 TRACE("NULL safe array unmarshaled\n");
1148
1149 return Buffer;
1150 }
1151
1152 cDims = *(ULONG *)Buffer;
1153 Buffer += sizeof(ULONG);
1154
1155 wiresa = (wireSAFEARRAY)Buffer;
1156 Buffer += 2 * sizeof(USHORT) + 2 * sizeof(ULONG);
1157
1158 if (cDims != wiresa->cDims)
1160
1161 /* FIXME: there should be a limit on how large cDims can be */
1162
1163 vt = HIWORD(wiresa->cLocks);
1164
1165 sftype = *(ULONG *)Buffer;
1166 Buffer += sizeof(ULONG);
1167
1168 cell_count = *(ULONG *)Buffer;
1169 Buffer += sizeof(ULONG);
1170 ptr = *(ULONG *)Buffer;
1171 Buffer += sizeof(ULONG);
1172 if (sftype == SF_HAVEIID)
1173 {
1174 memcpy(&guid, Buffer, sizeof(guid));
1175 Buffer += sizeof(guid);
1176 }
1177
1178 wiresab = (SAFEARRAYBOUND *)Buffer;
1179 Buffer += sizeof(wiresab[0]) * wiresa->cDims;
1180
1181 if(*ppsa && (*ppsa)->cDims==wiresa->cDims)
1182 {
1183 if(((*ppsa)->fFeatures & ~FADF_AUTOSETFLAGS) != (wiresa->fFeatures & ~FADF_AUTOSETFLAGS))
1185
1186 if(SAFEARRAY_GetCellCount(*ppsa)*(*ppsa)->cbElements != cell_count*elem_mem_size(wiresa, sftype))
1187 {
1188 if((*ppsa)->fFeatures & (FADF_AUTO|FADF_STATIC|FADF_EMBEDDED|FADF_FIXEDSIZE))
1190
1191 hr = SafeArrayDestroyData(*ppsa);
1192 if(FAILED(hr))
1194 }
1195 memcpy((*ppsa)->rgsabound, wiresab, sizeof(*wiresab)*wiresa->cDims);
1196
1197 if((*ppsa)->fFeatures & FADF_HAVEVARTYPE)
1198 ((DWORD*)(*ppsa))[-1] = vt;
1199 }
1200 else if(vt)
1201 {
1202 SafeArrayDestroy(*ppsa);
1203 *ppsa = SafeArrayCreateEx(vt, wiresa->cDims, wiresab, NULL);
1204 if (!*ppsa) RpcRaiseException(E_OUTOFMEMORY);
1205 }
1206 else
1207 {
1208 SafeArrayDestroy(*ppsa);
1209 if (FAILED(SafeArrayAllocDescriptor(wiresa->cDims, ppsa)))
1211 memcpy((*ppsa)->rgsabound, wiresab, sizeof(SAFEARRAYBOUND) * wiresa->cDims);
1212 }
1213
1214 /* be careful about which flags we set since they could be a security
1215 * risk */
1216 (*ppsa)->fFeatures &= FADF_AUTOSETFLAGS;
1217 (*ppsa)->fFeatures |= (wiresa->fFeatures & ~(FADF_AUTOSETFLAGS));
1218 /* FIXME: there should be a limit on how large wiresa->cbElements can be */
1219 (*ppsa)->cbElements = elem_mem_size(wiresa, sftype);
1220
1221 /* SafeArrayCreateEx allocates the data for us, but
1222 * SafeArrayAllocDescriptor doesn't */
1223 if(!(*ppsa)->pvData)
1224 {
1225 hr = SafeArrayAllocData(*ppsa);
1226 if (FAILED(hr))
1228 }
1229
1230 if ((*(ULONG *)Buffer != cell_count) || (SAFEARRAY_GetCellCount(*ppsa) != cell_count))
1232 Buffer += sizeof(ULONG);
1233
1234 if (ptr)
1235 {
1236 switch (sftype)
1237 {
1238 case SF_BSTR:
1239 {
1240 BSTR* lpBstr;
1241
1242 for (lpBstr = (*ppsa)->pvData; cell_count; cell_count--, lpBstr++)
1243 Buffer = BSTR_UserUnmarshal(pFlags, Buffer, lpBstr);
1244
1245 break;
1246 }
1247 case SF_DISPATCH:
1248 case SF_UNKNOWN:
1249 case SF_HAVEIID:
1250#ifdef __REACTOS__
1251 {
1252 IUnknown **lpUnk;
1253 const GUID *iid;
1254
1255 if (sftype == SF_HAVEIID)
1256 iid = &guid;
1257 else if (sftype == SF_UNKNOWN)
1258 iid = &IID_IUnknown;
1259 else
1260 iid = &IID_IDispatch;
1261
1262 for (lpUnk = (*ppsa)->pvData; cell_count; cell_count--, lpUnk++)
1263 Buffer = interface_user_unmarshal(pFlags, Buffer, iid, lpUnk);
1264
1265#else
1266 FIXME("marshal interfaces\n");
1267#endif
1268 break;
1269#ifdef __REACTOS__
1270 }
1271#endif
1272 case SF_VARIANT:
1273 {
1274 VARIANT* lpVariant;
1275
1276 for (lpVariant = (*ppsa)->pvData; cell_count; cell_count--, lpVariant++)
1277 Buffer = VARIANT_UserUnmarshal(pFlags, Buffer, lpVariant);
1278
1279 break;
1280 }
1281 case SF_RECORD:
1282 {
1283 FIXME("set record info\n");
1284
1285 break;
1286 }
1287
1288 case SF_I8:
1290 /* fallthrough */
1291 case SF_I1:
1292 case SF_I2:
1293 case SF_I4:
1294 /* Just copy the data over */
1295 memcpy((*ppsa)->pvData, Buffer, cell_count * (*ppsa)->cbElements);
1296 Buffer += cell_count * (*ppsa)->cbElements;
1297 break;
1298 default:
1299 break;
1300 }
1301 }
1302
1303 TRACE("safe array unmarshaled: %p\n", *ppsa);
1304
1305 return Buffer;
1306}
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
Definition: safearray.c:1256
HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
Definition: safearray.c:476
SAFEARRAY *WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound, LPVOID pvExtra)
Definition: safearray.c:628
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
Definition: safearray.c:557
unsigned char *WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
Definition: usrmarshal.c:534
#define FADF_AUTOSETFLAGS
Definition: usrmarshal.c:1120
static DWORD elem_mem_size(wireSAFEARRAY wiresa, SF_TYPE sftype)
Definition: usrmarshal.c:830
unsigned char *WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
Definition: usrmarshal.c:168
#define DISP_E_BADCALLEE
Definition: winerror.h:3629
#define RPC_S_INVALID_BOUND
Definition: winerror.h:1401

Referenced by test_marshal_LPSAFEARRAY(), and VARIANT_UserUnmarshal().

◆ SAFEARRAY_GetCellCount()

static ULONG SAFEARRAY_GetCellCount ( const SAFEARRAY psa)
static

Definition at line 726 of file usrmarshal.c.

727{
728 const SAFEARRAYBOUND* psab = psa->rgsabound;
729 USHORT cCount = psa->cDims;
730 ULONG ulNumCells = 1;
731
732 while (cCount--)
733 {
734 /* This is a valid bordercase. See testcases. -Marcus */
735 if (!psab->cElements)
736 return 0;
737 ulNumCells *= psab->cElements;
738 psab++;
739 }
740 return ulNumCells;
741}

Referenced by LPSAFEARRAY_UserMarshal(), LPSAFEARRAY_UserSize(), and LPSAFEARRAY_UserUnmarshal().

◆ SAFEARRAY_GetUnionType()

static SF_TYPE SAFEARRAY_GetUnionType ( SAFEARRAY psa)
inlinestatic

Definition at line 743 of file usrmarshal.c.

744{
745 VARTYPE vt;
746 HRESULT hr;
747
749 if (FAILED(hr))
750 {
751 if(psa->fFeatures & FADF_VARIANT) return SF_VARIANT;
752
753 switch(psa->cbElements)
754 {
755 case 1: vt = VT_I1; break;
756 case 2: vt = VT_I2; break;
757 case 4: vt = VT_I4; break;
758 case 8: vt = VT_I8; break;
759 default:
761 }
762 }
763
764 if (psa->fFeatures & FADF_HAVEIID)
765 return SF_HAVEIID;
766
767 switch (vt)
768 {
769 case VT_I1:
770 case VT_UI1: return SF_I1;
771 case VT_BOOL:
772 case VT_I2:
773 case VT_UI2: return SF_I2;
774 case VT_INT:
775 case VT_UINT:
776 case VT_I4:
777 case VT_UI4:
778 case VT_R4: return SF_I4;
779 case VT_DATE:
780 case VT_CY:
781 case VT_R8:
782 case VT_I8:
783 case VT_UI8: return SF_I8;
784 case VT_INT_PTR:
785 case VT_UINT_PTR: return (sizeof(UINT_PTR) == 4 ? SF_I4 : SF_I8);
786 case VT_BSTR: return SF_BSTR;
787 case VT_DISPATCH: return SF_DISPATCH;
788 case VT_VARIANT: return SF_VARIANT;
789 case VT_UNKNOWN: return SF_UNKNOWN;
790 /* Note: Return a non-zero size to indicate vt is valid. The actual size
791 * of a UDT is taken from the result of IRecordInfo_GetSize().
792 */
793 case VT_RECORD: return SF_RECORD;
794 default: return SF_ERROR;
795 }
796}
@ VT_UINT_PTR
Definition: compat.h:2328
@ VT_INT_PTR
Definition: compat.h:2327
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274

Referenced by LPSAFEARRAY_UserMarshal(), and LPSAFEARRAY_UserSize().

◆ VARIANT_UserFree()

void WINAPI VARIANT_UserFree ( ULONG pFlags,
VARIANT pvar 
)

Definition at line 679 of file usrmarshal.c.

680{
681 VARTYPE vt = V_VT(pvar);
682 PVOID ref = NULL;
683
684 TRACE("(%x,%p)\n", *pFlags, pvar);
685 TRACE("vt=%04x\n", V_VT(pvar));
686
687 if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
688
689 VariantClear(pvar);
690 if (!ref) return;
691
692 if(vt & VT_ARRAY)
693 {
694 if (vt & VT_BYREF)
695 LPSAFEARRAY_UserFree(pFlags, V_ARRAYREF(pvar));
696 else
697 LPSAFEARRAY_UserFree(pFlags, &V_ARRAY(pvar));
698 }
699 else
700 {
701 switch (vt)
702 {
703 case VT_BSTR | VT_BYREF:
704 BSTR_UserFree(pFlags, V_BSTRREF(pvar));
705 break;
706 case VT_VARIANT | VT_BYREF:
707 VARIANT_UserFree(pFlags, V_VARIANTREF(pvar));
708 break;
709 case VT_RECORD | VT_BYREF:
710 FIXME("handle BRECORD by ref\n");
711 break;
712 case VT_UNKNOWN | VT_BYREF:
713 case VT_DISPATCH | VT_BYREF:
714 if (*V_UNKNOWNREF(pvar))
715 IUnknown_Release(*V_UNKNOWNREF(pvar));
716 break;
717 }
718 }
719
721}
void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
Definition: usrmarshal.c:679
void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
Definition: usrmarshal.c:189
void WINAPI LPSAFEARRAY_UserFree(ULONG *pFlags, LPSAFEARRAY *ppsa)
Definition: usrmarshal.c:1308
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_ARRAYREF(A)
Definition: oleauto.h:223
#define V_BSTRREF(A)
Definition: oleauto.h:227
#define V_UNKNOWNREF(A)
Definition: oleauto.h:282
#define V_VARIANTREF(A)
Definition: oleauto.h:283
Definition: send.c:48
PVOID byref
Definition: compat.h:2421

Referenced by test_marshal_VARIANT(), and VARIANT_UserFree().

◆ VARIANT_UserMarshal()

unsigned char *WINAPI VARIANT_UserMarshal ( ULONG pFlags,
unsigned char Buffer,
VARIANT pvar 
)

Definition at line 420 of file usrmarshal.c.

421{
423 ULONG type_size;
424 int align;
425 unsigned char *Pos;
426
427 TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
428 TRACE("vt=%04x\n", V_VT(pvar));
429
431
433
434 header->clSize = 0; /* fixed up at the end */
435 header->rpcReserved = 0;
436 header->vt = pvar->n1.n2.vt;
437 header->wReserved1 = pvar->n1.n2.wReserved1;
438 header->wReserved2 = pvar->n1.n2.wReserved2;
439 header->wReserved3 = pvar->n1.n2.wReserved3;
440 header->switch_is = pvar->n1.n2.vt;
441 if(header->switch_is & VT_ARRAY)
442 header->switch_is &= ~VT_TYPEMASK;
443
444 Pos = (unsigned char*)(header + 1);
445 type_size = get_type_size(pFlags, V_VT(pvar));
446 align = get_type_alignment(pFlags, V_VT(pvar));
448
449 if(header->vt & VT_BYREF)
450 {
451 *(DWORD *)Pos = max(type_size, 4);
452 Pos += 4;
453 if((header->vt & VT_TYPEMASK) != VT_VARIANT)
454 {
455 memcpy(Pos, pvar->n1.n2.n3.byref, type_size);
456 Pos += type_size;
457 }
458 else
459 {
460 *(DWORD*)Pos = 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
461 Pos += 4;
462 }
463 }
464 else
465 {
466 if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
467 memcpy(Pos, pvar, type_size);
468 else
469 memcpy(Pos, &pvar->n1.n2.n3, type_size);
470 Pos += type_size;
471 }
472
473 if(header->vt & VT_ARRAY)
474 {
475 if(header->vt & VT_BYREF)
476 Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, V_ARRAYREF(pvar));
477 else
478 Pos = LPSAFEARRAY_UserMarshal(pFlags, Pos, &V_ARRAY(pvar));
479 }
480 else
481 {
482 switch (header->vt)
483 {
484 case VT_BSTR:
485 Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
486 break;
487 case VT_BSTR | VT_BYREF:
488 Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
489 break;
490 case VT_VARIANT | VT_BYREF:
491 Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
492 break;
493 case VT_UNKNOWN:
494#ifdef __REACTOS__
495 Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWN(pvar));
496#else
498#endif
499 break;
500 case VT_UNKNOWN | VT_BYREF:
501#ifdef __REACTOS__
502 Pos = interface_user_marshal(pFlags, Pos, &IID_IUnknown, *V_UNKNOWNREF(pvar));
503#else
505#endif
506 break;
507 case VT_DISPATCH:
508#ifdef __REACTOS__
509 Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
510#else
512#endif
513 break;
514 case VT_DISPATCH | VT_BYREF:
515#ifdef __REACTOS__
516 Pos = interface_user_marshal(pFlags, Pos, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
517#else
519#endif
520 break;
521 case VT_RECORD:
522 FIXME("handle BRECORD by val\n");
523 break;
524 case VT_RECORD | VT_BYREF:
525 FIXME("handle BRECORD by ref\n");
526 break;
527 }
528 }
529 header->clSize = ((Pos - Buffer) + 7) >> 3;
530 TRACE("marshalled size=%d\n", header->clSize);
531 return Pos;
532}
ush Pos
Definition: deflate.h:92
@ VT_TYPEMASK
Definition: compat.h:2346
unsigned char *WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
Definition: usrmarshal.c:972
static unsigned int get_type_alignment(ULONG *pFlags, VARTYPE vt)
Definition: usrmarshal.c:261
static unsigned char * interface_variant_marshal(ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown *punk)
Definition: usrmarshal.c:354
int align(int length, int align)
Definition: dsound8.c:36
#define V_DISPATCHREF(A)
Definition: oleauto.h:240
WORD wReserved1
Definition: compat.h:2382
WORD wReserved2
Definition: compat.h:2383
WORD wReserved3
Definition: compat.h:2384
VARTYPE vt
Definition: compat.h:2381
#define max(a, b)
Definition: svc.c:63

Referenced by LPSAFEARRAY_UserMarshal(), test_marshal_VARIANT(), and VARIANT_UserMarshal().

◆ VARIANT_UserSize()

ULONG WINAPI VARIANT_UserSize ( ULONG pFlags,
ULONG  Start,
VARIANT pvar 
)

Definition at line 397 of file usrmarshal.c.

398{
399 int align;
400 TRACE("(%x,%d,%p)\n", *pFlags, Start, pvar);
401 TRACE("vt=%04x\n", V_VT(pvar));
402
404 Start += sizeof(variant_wire_t);
405 if(V_VT(pvar) & VT_BYREF)
406 Start += 4;
407
408 align = get_type_alignment(pFlags, V_VT(pvar));
410 if(V_VT(pvar) == (VT_VARIANT | VT_BYREF))
411 Start += 4;
412 else
413 Start += get_type_size(pFlags, V_VT(pvar));
414 Start = wire_extra_user_size(pFlags, Start, pvar);
415
416 TRACE("returning %d\n", Start);
417 return Start;
418}
static ULONG wire_extra_user_size(ULONG *pFlags, ULONG Start, VARIANT *pvar)
Definition: usrmarshal.c:297

Referenced by LPSAFEARRAY_UserSize(), test_marshal_LPSAFEARRAY(), test_marshal_VARIANT(), and wire_extra_user_size().

◆ VARIANT_UserUnmarshal()

unsigned char *WINAPI VARIANT_UserUnmarshal ( ULONG pFlags,
unsigned char Buffer,
VARIANT pvar 
)

Definition at line 534 of file usrmarshal.c.

535{
537 ULONG type_size;
538 int align;
539 unsigned char *Pos;
540
541 TRACE("(%x,%p,%p)\n", *pFlags, Buffer, pvar);
542
544
546
547 Pos = (unsigned char*)(header + 1);
548 type_size = get_type_size(pFlags, header->vt);
549 align = get_type_alignment(pFlags, header->vt);
551
552 if(header->vt & VT_BYREF)
553 {
554 ULONG mem_size;
555 Pos += 4;
556
557 switch (header->vt & ~VT_BYREF)
558 {
559 /* these types have a different memory size compared to wire size */
560 case VT_UNKNOWN:
561 case VT_DISPATCH:
562 case VT_BSTR:
563 mem_size = sizeof(void *);
564 break;
565 default:
566 mem_size = type_size;
567 break;
568 }
569
570 if (V_VT(pvar) != header->vt)
571 {
572 VariantClear(pvar);
573 V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
574 memset(V_BYREF(pvar), 0, mem_size);
575 }
576 else if (!V_BYREF(pvar))
577 {
578 V_BYREF(pvar) = CoTaskMemAlloc(mem_size);
579 memset(V_BYREF(pvar), 0, mem_size);
580 }
581
582 if(!(header->vt & VT_ARRAY)
583 && (header->vt & VT_TYPEMASK) != VT_BSTR
584 && (header->vt & VT_TYPEMASK) != VT_VARIANT
585 && (header->vt & VT_TYPEMASK) != VT_UNKNOWN
586 && (header->vt & VT_TYPEMASK) != VT_DISPATCH
587 && (header->vt & VT_TYPEMASK) != VT_RECORD)
588 memcpy(V_BYREF(pvar), Pos, type_size);
589
590 if((header->vt & VT_TYPEMASK) != VT_VARIANT)
591 Pos += type_size;
592 else
593 Pos += 4;
594 }
595 else
596 {
597 VariantClear(pvar);
598 if(header->vt & VT_ARRAY)
599 V_ARRAY(pvar) = NULL;
600 else if((header->vt & VT_TYPEMASK) == VT_BSTR)
601 V_BSTR(pvar) = NULL;
602 else if((header->vt & VT_TYPEMASK) == VT_UNKNOWN)
603 V_UNKNOWN(pvar) = NULL;
604 else if((header->vt & VT_TYPEMASK) == VT_DISPATCH)
605 V_DISPATCH(pvar) = NULL;
606 else if((header->vt & VT_TYPEMASK) == VT_RECORD)
607 V_RECORD(pvar) = NULL;
608 else if((header->vt & VT_TYPEMASK) == VT_DECIMAL)
609 memcpy(pvar, Pos, type_size);
610 else
611 memcpy(&pvar->n1.n2.n3, Pos, type_size);
612 Pos += type_size;
613 }
614
615 pvar->n1.n2.vt = header->vt;
616 pvar->n1.n2.wReserved1 = header->wReserved1;
617 pvar->n1.n2.wReserved2 = header->wReserved2;
618 pvar->n1.n2.wReserved3 = header->wReserved3;
619
620 if(header->vt & VT_ARRAY)
621 {
622 if(header->vt & VT_BYREF)
624 else
625 Pos = LPSAFEARRAY_UserUnmarshal(pFlags, Pos, &V_ARRAY(pvar));
626 }
627 else
628 {
629 switch (header->vt)
630 {
631 case VT_BSTR:
632 Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
633 break;
634 case VT_BSTR | VT_BYREF:
635 Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
636 break;
637 case VT_VARIANT | VT_BYREF:
638 Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
639 break;
640 case VT_UNKNOWN:
641#ifdef __REACTOS__
642 Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, &V_UNKNOWN(pvar));
643#else
645#endif
646 break;
647 case VT_UNKNOWN | VT_BYREF:
648#ifdef __REACTOS__
649 Pos = interface_user_unmarshal(pFlags, Pos, &IID_IUnknown, V_UNKNOWNREF(pvar));
650#else
652#endif
653 break;
654 case VT_DISPATCH:
655#ifdef __REACTOS__
656 Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)&V_DISPATCH(pvar));
657#else
659#endif
660 break;
661 case VT_DISPATCH | VT_BYREF:
662#ifdef __REACTOS__
663 Pos = interface_user_unmarshal(pFlags, Pos, &IID_IDispatch, (IUnknown**)V_DISPATCHREF(pvar));
664#else
666#endif
667 break;
668 case VT_RECORD:
669 FIXME("handle BRECORD by val\n");
670 break;
671 case VT_RECORD | VT_BYREF:
672 FIXME("handle BRECORD by ref\n");
673 break;
674 }
675 }
676 return Pos;
677}
static unsigned char * interface_variant_unmarshal(ULONG *pFlags, unsigned char *Buffer, REFIID riid, IUnknown **ppunk)
Definition: usrmarshal.c:379
unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
Definition: usrmarshal.c:1124
#define V_BYREF(A)
Definition: oleauto.h:228
#define V_RECORD(A)
Definition: oleauto.h:213

Referenced by LPSAFEARRAY_UserUnmarshal(), test_marshal_VARIANT(), and VARIANT_UserUnmarshal().

◆ WdtpInterfacePointer_UserMarshal()

unsigned char *__RPC_USER WdtpInterfacePointer_UserMarshal ( ULONG pFlags,
ULONG  RealFlags,
unsigned char pBuffer,
IUnknown punk,
REFIID  riid 
)

Definition at line 1550 of file usrmarshal.c.

1551{
1553 IStream *stm;
1554 DWORD size;
1555 void *ptr;
1556
1557 TRACE("(%s, 0x%x, %p, &%p, %s)\n", debugstr_user_flags(pFlags), RealFlags, pBuffer, punk, debugstr_guid(riid));
1558
1559 if(!h) return NULL;
1560 if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
1561 {
1562 GlobalFree(h);
1563 return NULL;
1564 }
1565
1566 if(CoMarshalInterface(stm, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL) != S_OK)
1567 {
1568 IStream_Release(stm);
1569 return pBuffer;
1570 }
1571
1573 size = GlobalSize(h);
1574
1575 *(DWORD *)pBuffer = size;
1576 pBuffer += sizeof(DWORD);
1577 *(DWORD *)pBuffer = size;
1578 pBuffer += sizeof(DWORD);
1579
1580 ptr = GlobalLock(h);
1582 GlobalUnlock(h);
1583
1584 IStream_Release(stm);
1585 return pBuffer + size;
1586}
#define TRUE
Definition: types.h:120
HRESULT WINAPI CreateStreamOnHGlobal(HGLOBAL hGlobal, BOOL fDeleteOnRelease, LPSTREAM *ppstm)
HRESULT WINAPI CoMarshalInterface(IStream *pStream, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1876
static const char * debugstr_user_flags(ULONG *pFlags)
Definition: usrmarshal.c:51
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
HGLOBAL NTAPI GlobalFree(HGLOBAL hMem)
Definition: heapmem.c:611
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
SIZE_T NTAPI GlobalSize(HGLOBAL hMem)
Definition: heapmem.c:1090
PVOID pBuffer
#define GMEM_MOVEABLE
Definition: winbase.h:327

◆ WdtpInterfacePointer_UserSize()

ULONG __RPC_USER WdtpInterfacePointer_UserSize ( ULONG pFlags,
ULONG  RealFlags,
ULONG  StartingSize,
IUnknown punk,
REFIID  riid 
)

Definition at line 1515 of file usrmarshal.c.

1516{
1517 DWORD marshal_size = 0;
1518 HRESULT hr;
1519
1520 TRACE("(%s, 0%x, %d, %p, %s)\n", debugstr_user_flags(pFlags), RealFlags, StartingSize, punk, debugstr_guid(riid));
1521
1522 hr = CoGetMarshalSizeMax(&marshal_size, riid, punk, LOWORD(RealFlags), NULL, MSHLFLAGS_NORMAL);
1523 if(FAILED(hr)) return StartingSize;
1524
1525 ALIGN_LENGTH(StartingSize, 3);
1526 StartingSize += 2 * sizeof(DWORD);
1527 return StartingSize + marshal_size;
1528}
HRESULT WINAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, IUnknown *pUnk, DWORD dwDestContext, void *pvDestContext, DWORD mshlFlags)
Definition: marshal.c:1800

◆ WdtpInterfacePointer_UserUnmarshal()

unsigned char *__RPC_USER WdtpInterfacePointer_UserUnmarshal ( ULONG pFlags,
unsigned char pBuffer,
IUnknown **  ppunk,
REFIID  riid 
)

Definition at line 1607 of file usrmarshal.c.

1608{
1609 HRESULT hr;
1610 HGLOBAL h;
1611 IStream *stm;
1612 DWORD size;
1613 void *ptr;
1614 IUnknown *orig;
1615
1616 TRACE("(%s, %p, %p, %s)\n", debugstr_user_flags(pFlags), pBuffer, ppunk, debugstr_guid(riid));
1617
1619
1620 size = *(DWORD *)pBuffer;
1621 pBuffer += sizeof(DWORD);
1622 if(size != *(DWORD *)pBuffer)
1624
1625 pBuffer += sizeof(DWORD);
1626
1627 /* FIXME: sanity check on size */
1628
1630 if(!h) RaiseException(RPC_X_NO_MEMORY, 0, 0, NULL);
1631
1632 if(CreateStreamOnHGlobal(h, TRUE, &stm) != S_OK)
1633 {
1634 GlobalFree(h);
1636 }
1637
1638 ptr = GlobalLock(h);
1640 GlobalUnlock(h);
1641
1642 orig = *ppunk;
1643 hr = CoUnmarshalInterface(stm, riid, (void**)ppunk);
1644 IStream_Release(stm);
1645
1646 if(hr != S_OK) RaiseException(hr, 0, 0, NULL);
1647
1648 if(orig) IUnknown_Release(orig);
1649
1650 return pBuffer + size;
1651}
VOID WINAPI RaiseException(_In_ DWORD dwExceptionCode, _In_ DWORD dwExceptionFlags, _In_ DWORD nNumberOfArguments, _In_opt_ const ULONG_PTR *lpArguments)
Definition: except.c:700
HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv)
Definition: marshal.c:1981
#define RPC_X_NO_MEMORY
Definition: rpcnterr.h:35
#define RPC_X_BAD_STUB_DATA
Definition: winerror.h:1448

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( ole  )

◆ wire_extra_user_size()

static ULONG wire_extra_user_size ( ULONG pFlags,
ULONG  Start,
VARIANT pvar 
)
static

Definition at line 297 of file usrmarshal.c.

298{
299 if (V_ISARRAY(pvar))
300 {
301 if (V_ISBYREF(pvar))
302 return LPSAFEARRAY_UserSize(pFlags, Start, V_ARRAYREF(pvar));
303 else
304 return LPSAFEARRAY_UserSize(pFlags, Start, &V_ARRAY(pvar));
305 }
306
307 switch (V_VT(pvar)) {
308 case VT_BSTR:
309 return BSTR_UserSize(pFlags, Start, &V_BSTR(pvar));
310 case VT_BSTR | VT_BYREF:
311 return BSTR_UserSize(pFlags, Start, V_BSTRREF(pvar));
312 case VT_VARIANT | VT_BYREF:
313 return VARIANT_UserSize(pFlags, Start, V_VARIANTREF(pvar));
314 case VT_UNKNOWN:
315#ifdef __REACTOS__
316 return interface_user_size(pFlags, Start, &IID_IUnknown, V_UNKNOWN(pvar));
317#else
318 return Start + interface_variant_size(pFlags, &IID_IUnknown, V_UNKNOWN(pvar));
319#endif
320 case VT_UNKNOWN | VT_BYREF:
321#ifdef __REACTOS__
322 return interface_user_size(pFlags, Start, &IID_IUnknown, *V_UNKNOWNREF(pvar));
323#else
324 return Start + interface_variant_size(pFlags, &IID_IUnknown, *V_UNKNOWNREF(pvar));
325#endif
326 case VT_DISPATCH:
327#ifdef __REACTOS__
328 return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar));
329#else
331#endif
332 case VT_DISPATCH | VT_BYREF:
333#ifdef __REACTOS__
334 return interface_user_size(pFlags, Start, &IID_IDispatch, (IUnknown*)*V_DISPATCHREF(pvar));
335#else
337#endif
338 case VT_RECORD:
339 FIXME("wire-size record\n");
340 return Start;
341 case VT_SAFEARRAY:
342 case VT_SAFEARRAY | VT_BYREF:
343 FIXME("wire-size safearray: shouldn't be marshaling this\n");
344 return Start;
345 default:
346 return Start;
347 }
348}
ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
Definition: usrmarshal.c:864
static unsigned interface_variant_size(ULONG *pFlags, REFIID riid, IUnknown *punk)
Definition: usrmarshal.c:274
#define V_ISARRAY(A)
Definition: oleauto.h:218

Referenced by VARIANT_UserSize().