2 * Misc marshalling routines
4 * Copyright 2002 Ove Kaaven
5 * Copyright 2003 Mike Hearn
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
44 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
45 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
46 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
47 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
49 static CStdPSFactoryBuffer PSFactoryBuffer
;
51 CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer
)
53 extern const ExtendedProxyFileInfo oleaut32_oaidl_ProxyFileInfo
;
54 extern const ExtendedProxyFileInfo oleaut32_ocidl_ProxyFileInfo
;
56 static const ProxyFileInfo
*OLEAUT32_ProxyFileList
[] = {
57 &oleaut32_oaidl_ProxyFileInfo
,
58 &oleaut32_ocidl_ProxyFileInfo
,
62 HRESULT
OLEAUTPS_DllGetClassObject(REFCLSID rclsid
, REFIID riid
, LPVOID
*ppv
)
64 return NdrDllGetClassObject(rclsid
, riid
, ppv
, OLEAUT32_ProxyFileList
,
65 &CLSID_PSDispatch
, &PSFactoryBuffer
);
68 static void dump_user_flags(const ULONG
*pFlags
)
70 if (HIWORD(*pFlags
) == NDR_LOCAL_DATA_REPRESENTATION
)
71 TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
73 TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags
));
74 switch (LOWORD(*pFlags
))
76 case MSHCTX_LOCAL
: TRACE("MSHCTX_LOCAL)"); break;
77 case MSHCTX_NOSHAREDMEM
: TRACE("MSHCTX_NOSHAREDMEM)"); break;
78 case MSHCTX_DIFFERENTMACHINE
: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
79 case MSHCTX_INPROC
: TRACE("MSHCTX_INPROC)"); break;
80 default: TRACE("%d)", LOWORD(*pFlags
));
84 /* CLEANLOCALSTORAGE */
86 #define CLS_FUNCDESC 'f'
87 #define CLS_LIBATTR 'l'
88 #define CLS_TYPEATTR 't'
89 #define CLS_VARDESC 'v'
91 ULONG WINAPI
CLEANLOCALSTORAGE_UserSize(ULONG
*pFlags
, ULONG Start
, CLEANLOCALSTORAGE
*pstg
)
93 ALIGN_LENGTH(Start
, 3);
94 return Start
+ sizeof(DWORD
);
97 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstg
)
99 ALIGN_POINTER(Buffer
, 3);
100 *(DWORD
*)Buffer
= pstg
->flags
;
104 ITypeLib_ReleaseTLibAttr((ITypeLib
*)pstg
->pInterface
, *(TLIBATTR
**)pstg
->pStorage
);
107 ITypeInfo_ReleaseTypeAttr((ITypeInfo
*)pstg
->pInterface
, *(TYPEATTR
**)pstg
->pStorage
);
110 ITypeInfo_ReleaseFuncDesc((ITypeInfo
*)pstg
->pInterface
, *(FUNCDESC
**)pstg
->pStorage
);
113 ITypeInfo_ReleaseVarDesc((ITypeInfo
*)pstg
->pInterface
, *(VARDESC
**)pstg
->pStorage
);
117 ERR("Unknown type %x\n", pstg
->flags
);
120 *(VOID
**)pstg
->pStorage
= NULL
;
121 IUnknown_Release(pstg
->pInterface
);
122 pstg
->pInterface
= NULL
;
124 return Buffer
+ sizeof(DWORD
);
127 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstr
)
129 ALIGN_POINTER(Buffer
, 3);
130 pstr
->flags
= *(DWORD
*)Buffer
;
131 return Buffer
+ sizeof(DWORD
);
134 void WINAPI
CLEANLOCALSTORAGE_UserFree(ULONG
*pFlags
, CLEANLOCALSTORAGE
*pstr
)
143 DWORD len
; /* No. of chars not including trailing '\0' */
144 DWORD byte_len
; /* len * 2 or 0xffffffff if len == 0 */
145 DWORD len2
; /* == len */
148 ULONG WINAPI
BSTR_UserSize(ULONG
*pFlags
, ULONG Start
, BSTR
*pstr
)
150 TRACE("(%x,%d,%p) => %p\n", *pFlags
, Start
, pstr
, *pstr
);
151 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
152 ALIGN_LENGTH(Start
, 3);
153 Start
+= sizeof(bstr_wire_t
) + ((SysStringByteLen(*pstr
) + 1) & ~1);
154 TRACE("returning %d\n", Start
);
158 unsigned char * WINAPI
BSTR_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
161 DWORD len
= SysStringByteLen(*pstr
);
163 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
164 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
166 ALIGN_POINTER(Buffer
, 3);
167 header
= (bstr_wire_t
*)Buffer
;
168 header
->len
= header
->len2
= (len
+ 1) / 2;
171 header
->byte_len
= len
;
172 memcpy(header
+ 1, *pstr
, header
->len
* 2);
175 header
->byte_len
= 0xffffffff; /* special case for a null bstr */
177 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
180 unsigned char * WINAPI
BSTR_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
183 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
185 ALIGN_POINTER(Buffer
, 3);
186 header
= (bstr_wire_t
*)Buffer
;
187 if(header
->len
!= header
->len2
)
188 FIXME("len %08x != len2 %08x\n", header
->len
, header
->len2
);
192 SysFreeString(*pstr
);
196 if(header
->byte_len
!= 0xffffffff)
197 *pstr
= SysAllocStringByteLen((char*)(header
+ 1), header
->byte_len
);
199 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
200 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
203 void WINAPI
BSTR_UserFree(ULONG
*pFlags
, BSTR
*pstr
)
205 TRACE("(%x,%p) => %p\n", *pFlags
, pstr
, *pstr
);
208 SysFreeString(*pstr
);
226 static unsigned int get_type_size(ULONG
*pFlags
, VARTYPE vt
)
228 if (vt
& VT_ARRAY
) return 4;
230 switch (vt
& ~VT_BYREF
) {
239 return sizeof(SHORT
);
247 return sizeof(FLOAT
);
249 return sizeof(DOUBLE
);
251 return sizeof(VARIANT_BOOL
);
253 return sizeof(SCODE
);
259 return sizeof(DECIMAL
);
263 return sizeof(VARIANT
);
269 FIXME("unhandled VT %d\n", vt
);
274 static unsigned int get_type_alignment(ULONG
*pFlags
, VARTYPE vt
)
276 unsigned int size
= get_type_size(pFlags
, vt
);
277 if(vt
& VT_BYREF
) return 3;
278 if(size
== 0) return 0;
279 if(size
<= 4) return size
- 1;
283 static unsigned interface_variant_size(const ULONG
*pFlags
, REFIID riid
, IUnknown
*punk
)
287 /* find the buffer size of the marshalled dispatch interface */
288 hr
= CoGetMarshalSizeMax(&size
, riid
, punk
, LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
291 WARN("NULL dispatch pointer\n");
293 ERR("Dispatch variant buffer size calculation failed, HRESULT=0x%x\n", hr
);
296 size
+= sizeof(ULONG
); /* we have to store the buffersize in the stream */
297 TRACE("wire-size extra of dispatch variant is %d\n", size
);
301 static ULONG
wire_extra_user_size(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
306 return LPSAFEARRAY_UserSize(pFlags
, Start
, V_ARRAYREF(pvar
));
308 return LPSAFEARRAY_UserSize(pFlags
, Start
, &V_ARRAY(pvar
));
311 switch (V_VT(pvar
)) {
313 return BSTR_UserSize(pFlags
, Start
, &V_BSTR(pvar
));
314 case VT_BSTR
| VT_BYREF
:
315 return BSTR_UserSize(pFlags
, Start
, V_BSTRREF(pvar
));
316 case VT_VARIANT
| VT_BYREF
:
317 return VARIANT_UserSize(pFlags
, Start
, V_VARIANTREF(pvar
));
319 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, V_UNKNOWN(pvar
));
320 case VT_UNKNOWN
| VT_BYREF
:
321 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
323 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
324 case VT_DISPATCH
| VT_BYREF
:
325 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
327 FIXME("wire-size record\n");
330 case VT_SAFEARRAY
| VT_BYREF
:
331 FIXME("wire-size safearray: shouldn't be marshaling this\n");
338 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
339 static unsigned char* interface_variant_marshal(const ULONG
*pFlags
, unsigned char *Buffer
,
340 REFIID riid
, IUnknown
*punk
)
344 void *working_memlocked
;
345 unsigned char *oldpos
;
349 TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags
, Buffer
, punk
);
353 /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
354 * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
355 * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
356 * but that would be overkill here, hence this implementation. We save the size because the unmarshal
357 * code has no way to know how long the marshalled buffer is. */
359 size
= interface_variant_size(pFlags
, riid
, punk
);
361 working_mem
= GlobalAlloc(0, size
);
362 if (!working_mem
) return oldpos
;
364 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
366 GlobalFree(working_mem
);
370 hr
= CoMarshalInterface(working
, riid
, punk
, LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
372 IStream_Release(working
); /* this also releases the hglobal */
376 working_memlocked
= GlobalLock(working_mem
);
377 memcpy(Buffer
, &size
, sizeof(ULONG
)); /* copy the buffersize */
378 memcpy(Buffer
+ sizeof(ULONG
), working_memlocked
, size
- sizeof(ULONG
));
379 GlobalUnlock(working_mem
);
381 IStream_Release(working
);
383 /* size includes the ULONG for the size written above */
384 TRACE("done, size=%d\n", size
);
385 return Buffer
+ size
;
388 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer. returns Buffer on failure, new position otherwise */
389 static unsigned char *interface_variant_unmarshal(const ULONG
*pFlags
, unsigned char *Buffer
,
390 REFIID riid
, IUnknown
**ppunk
)
394 void *working_memlocked
;
395 unsigned char *oldpos
;
399 TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags
, Buffer
, ppunk
);
403 /* get the buffersize */
404 memcpy(&size
, Buffer
, sizeof(ULONG
));
405 TRACE("buffersize=%d\n", size
);
407 working_mem
= GlobalAlloc(0, size
);
408 if (!working_mem
) return oldpos
;
410 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
412 GlobalFree(working_mem
);
416 working_memlocked
= GlobalLock(working_mem
);
418 /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
419 memcpy(working_memlocked
, Buffer
+ sizeof(ULONG
), size
);
420 GlobalUnlock(working_mem
);
422 hr
= CoUnmarshalInterface(working
, riid
, (void**)ppunk
);
424 IStream_Release(working
);
428 IStream_Release(working
); /* this also frees the underlying hglobal */
430 /* size includes the ULONG for the size written above */
431 TRACE("done, processed=%d bytes\n", size
);
432 return Buffer
+ size
;
436 ULONG WINAPI
VARIANT_UserSize(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
439 TRACE("(%x,%d,%p)\n", *pFlags
, Start
, pvar
);
440 TRACE("vt=%04x\n", V_VT(pvar
));
442 ALIGN_LENGTH(Start
, 7);
443 Start
+= sizeof(variant_wire_t
);
444 if(V_VT(pvar
) & VT_BYREF
)
447 align
= get_type_alignment(pFlags
, V_VT(pvar
));
448 ALIGN_LENGTH(Start
, align
);
449 if(V_VT(pvar
) == (VT_VARIANT
| VT_BYREF
))
452 Start
+= get_type_size(pFlags
, V_VT(pvar
));
453 Start
= wire_extra_user_size(pFlags
, Start
, pvar
);
455 TRACE("returning %d\n", Start
);
459 unsigned char * WINAPI
VARIANT_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
461 variant_wire_t
*header
;
466 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
467 TRACE("vt=%04x\n", V_VT(pvar
));
469 ALIGN_POINTER(Buffer
, 7);
471 header
= (variant_wire_t
*)Buffer
;
473 header
->clSize
= 0; /* fixed up at the end */
474 header
->rpcReserverd
= 0;
475 header
->vt
= pvar
->n1
.n2
.vt
;
476 header
->wReserved1
= pvar
->n1
.n2
.wReserved1
;
477 header
->wReserved2
= pvar
->n1
.n2
.wReserved2
;
478 header
->wReserved3
= pvar
->n1
.n2
.wReserved3
;
479 header
->switch_is
= pvar
->n1
.n2
.vt
;
480 if(header
->switch_is
& VT_ARRAY
)
481 header
->switch_is
&= ~VT_TYPEMASK
;
483 Pos
= (unsigned char*)(header
+ 1);
484 type_size
= get_type_size(pFlags
, V_VT(pvar
));
485 align
= get_type_alignment(pFlags
, V_VT(pvar
));
486 ALIGN_POINTER(Pos
, align
);
488 if(header
->vt
& VT_BYREF
)
490 *(DWORD
*)Pos
= max(type_size
, 4);
492 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
494 memcpy(Pos
, pvar
->n1
.n2
.n3
.byref
, type_size
);
499 *(DWORD
*)Pos
= 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
505 if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
506 memcpy(Pos
, pvar
, type_size
);
508 memcpy(Pos
, &pvar
->n1
.n2
.n3
, type_size
);
512 if(header
->vt
& VT_ARRAY
)
514 if(header
->vt
& VT_BYREF
)
515 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
517 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
524 Pos
= BSTR_UserMarshal(pFlags
, Pos
, &V_BSTR(pvar
));
526 case VT_BSTR
| VT_BYREF
:
527 Pos
= BSTR_UserMarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
529 case VT_VARIANT
| VT_BYREF
:
530 Pos
= VARIANT_UserMarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
533 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
534 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWN(pvar
));
536 case VT_UNKNOWN
| VT_BYREF
:
537 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
538 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
541 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
542 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
544 case VT_DISPATCH
| VT_BYREF
:
545 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
546 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
549 FIXME("handle BRECORD by val\n");
551 case VT_RECORD
| VT_BYREF
:
552 FIXME("handle BRECORD by ref\n");
556 header
->clSize
= ((Pos
- Buffer
) + 7) >> 3;
557 TRACE("marshalled size=%d\n", header
->clSize
);
561 unsigned char * WINAPI
VARIANT_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
563 variant_wire_t
*header
;
568 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
570 ALIGN_POINTER(Buffer
, 7);
572 header
= (variant_wire_t
*)Buffer
;
574 Pos
= (unsigned char*)(header
+ 1);
575 type_size
= get_type_size(pFlags
, header
->vt
);
576 align
= get_type_alignment(pFlags
, header
->vt
);
577 ALIGN_POINTER(Pos
, align
);
579 if(header
->vt
& VT_BYREF
)
582 if (V_VT(pvar
) != header
->vt
)
585 V_BYREF(pvar
) = CoTaskMemAlloc(type_size
);
587 else if (!V_BYREF(pvar
))
588 V_BYREF(pvar
) = CoTaskMemAlloc(type_size
);
589 memcpy(V_BYREF(pvar
), Pos
, type_size
);
590 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
598 if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
599 memcpy(pvar
, Pos
, type_size
);
601 memcpy(&pvar
->n1
.n2
.n3
, Pos
, type_size
);
605 pvar
->n1
.n2
.vt
= header
->vt
;
606 pvar
->n1
.n2
.wReserved1
= header
->wReserved1
;
607 pvar
->n1
.n2
.wReserved2
= header
->wReserved2
;
608 pvar
->n1
.n2
.wReserved3
= header
->wReserved3
;
610 if(header
->vt
& VT_ARRAY
)
612 if(header
->vt
& VT_BYREF
)
613 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
615 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
623 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, &V_BSTR(pvar
));
625 case VT_BSTR
| VT_BYREF
:
626 *V_BSTRREF(pvar
) = NULL
;
627 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
629 case VT_VARIANT
| VT_BYREF
:
630 Pos
= VARIANT_UserUnmarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
633 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
634 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, &V_UNKNOWN(pvar
));
636 case VT_UNKNOWN
| VT_BYREF
:
637 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
638 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWNREF(pvar
));
641 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
642 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)&V_DISPATCH(pvar
));
644 case VT_DISPATCH
| VT_BYREF
:
645 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
646 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)V_DISPATCHREF(pvar
));
649 FIXME("handle BRECORD by val\n");
651 case VT_RECORD
| VT_BYREF
:
652 FIXME("handle BRECORD by ref\n");
659 void WINAPI
VARIANT_UserFree(ULONG
*pFlags
, VARIANT
*pvar
)
661 VARTYPE vt
= V_VT(pvar
);
664 TRACE("(%x,%p)\n", *pFlags
, pvar
);
665 TRACE("vt=%04x\n", V_VT(pvar
));
667 if (vt
& VT_BYREF
) ref
= pvar
->n1
.n2
.n3
.byref
;
675 LPSAFEARRAY_UserFree(pFlags
, V_ARRAYREF(pvar
));
677 LPSAFEARRAY_UserFree(pFlags
, &V_ARRAY(pvar
));
683 case VT_BSTR
| VT_BYREF
:
684 BSTR_UserFree(pFlags
, V_BSTRREF(pvar
));
686 case VT_VARIANT
| VT_BYREF
:
687 VARIANT_UserFree(pFlags
, V_VARIANTREF(pvar
));
689 case VT_RECORD
| VT_BYREF
:
690 FIXME("handle BRECORD by ref\n");
692 case VT_UNKNOWN
| VT_BYREF
:
693 case VT_DISPATCH
| VT_BYREF
:
694 IUnknown_Release(*V_UNKNOWNREF(pvar
));
704 /* Get the number of cells in a SafeArray */
705 static ULONG
SAFEARRAY_GetCellCount(const SAFEARRAY
*psa
)
707 const SAFEARRAYBOUND
* psab
= psa
->rgsabound
;
708 USHORT cCount
= psa
->cDims
;
709 ULONG ulNumCells
= 1;
713 /* This is a valid bordercase. See testcases. -Marcus */
714 if (!psab
->cElements
)
716 ulNumCells
*= psab
->cElements
;
722 static inline SF_TYPE
SAFEARRAY_GetUnionType(SAFEARRAY
*psa
)
727 hr
= SafeArrayGetVartype(psa
, &vt
);
730 if(psa
->fFeatures
& FADF_VARIANT
) return SF_VARIANT
;
732 switch(psa
->cbElements
)
734 case 1: vt
= VT_I1
; break;
735 case 2: vt
= VT_I2
; break;
736 case 4: vt
= VT_I4
; break;
737 case 8: vt
= VT_I8
; break;
739 RpcRaiseException(hr
);
743 if (psa
->fFeatures
& FADF_HAVEIID
)
749 case VT_UI1
: return SF_I1
;
752 case VT_UI2
: return SF_I2
;
757 case VT_R4
: return SF_I4
;
762 case VT_UI8
: return SF_I8
;
764 case VT_UINT_PTR
: return (sizeof(UINT_PTR
) == 4 ? SF_I4
: SF_I8
);
765 case VT_BSTR
: return SF_BSTR
;
766 case VT_DISPATCH
: return SF_DISPATCH
;
767 case VT_VARIANT
: return SF_VARIANT
;
768 case VT_UNKNOWN
: return SF_UNKNOWN
;
769 /* Note: Return a non-zero size to indicate vt is valid. The actual size
770 * of a UDT is taken from the result of IRecordInfo_GetSize().
772 case VT_RECORD
: return SF_RECORD
;
773 default: return SF_ERROR
;
777 ULONG WINAPI
LPSAFEARRAY_UserSize(ULONG
*pFlags
, ULONG StartingSize
, LPSAFEARRAY
*ppsa
)
779 ULONG size
= StartingSize
;
781 TRACE("("); dump_user_flags(pFlags
); TRACE(", %d, %p\n", StartingSize
, *ppsa
);
783 ALIGN_LENGTH(size
, 3);
784 size
+= sizeof(ULONG_PTR
);
787 SAFEARRAY
*psa
= *ppsa
;
788 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
792 size
+= sizeof(ULONG
);
793 size
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
795 sftype
= SAFEARRAY_GetUnionType(psa
);
796 size
+= sizeof(ULONG
);
798 size
+= sizeof(ULONG
);
799 size
+= sizeof(ULONG_PTR
);
800 if (sftype
== SF_HAVEIID
)
803 size
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
805 size
+= sizeof(ULONG
);
813 for (lpBstr
= (BSTR
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
814 size
= BSTR_UserSize(pFlags
, size
, lpBstr
);
821 FIXME("size interfaces\n");
827 for (lpVariant
= (VARIANT
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
828 size
= VARIANT_UserSize(pFlags
, size
, lpVariant
);
834 IRecordInfo
* pRecInfo
= NULL
;
836 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
838 RpcRaiseException(hr
);
842 FIXME("size record info %p\n", pRecInfo
);
844 IRecordInfo_Release(pRecInfo
);
849 ALIGN_LENGTH(size
, 7);
854 size
+= ulCellCount
* psa
->cbElements
;
865 unsigned char * WINAPI
LPSAFEARRAY_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
869 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, &%p\n", Buffer
, *ppsa
);
871 ALIGN_POINTER(Buffer
, 3);
872 *(ULONG_PTR
*)Buffer
= *ppsa
? TRUE
: FALSE
;
873 Buffer
+= sizeof(ULONG_PTR
);
877 SAFEARRAY
*psa
= *ppsa
;
878 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
879 wireSAFEARRAY wiresa
;
883 *(ULONG
*)Buffer
= psa
->cDims
;
884 Buffer
+= sizeof(ULONG
);
885 wiresa
= (wireSAFEARRAY
)Buffer
;
886 wiresa
->cDims
= psa
->cDims
;
887 wiresa
->fFeatures
= psa
->fFeatures
;
888 wiresa
->cbElements
= psa
->cbElements
;
890 hr
= SafeArrayGetVartype(psa
, &vt
);
891 if (FAILED(hr
)) vt
= 0;
893 wiresa
->cLocks
= (USHORT
)psa
->cLocks
| (vt
<< 16);
895 Buffer
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
897 sftype
= SAFEARRAY_GetUnionType(psa
);
898 *(ULONG
*)Buffer
= sftype
;
899 Buffer
+= sizeof(ULONG
);
901 *(ULONG
*)Buffer
= ulCellCount
;
902 Buffer
+= sizeof(ULONG
);
903 *(ULONG_PTR
*)Buffer
= (ULONG_PTR
)psa
->pvData
;
904 Buffer
+= sizeof(ULONG_PTR
);
905 if (sftype
== SF_HAVEIID
)
907 SafeArrayGetIID(psa
, &guid
);
908 memcpy(Buffer
, &guid
, sizeof(guid
));
909 Buffer
+= sizeof(guid
);
912 memcpy(Buffer
, psa
->rgsabound
, sizeof(psa
->rgsabound
[0]) * psa
->cDims
);
913 Buffer
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
915 *(ULONG
*)Buffer
= ulCellCount
;
916 Buffer
+= sizeof(ULONG
);
926 for (lpBstr
= (BSTR
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
927 Buffer
= BSTR_UserMarshal(pFlags
, Buffer
, lpBstr
);
934 FIXME("marshal interfaces\n");
940 for (lpVariant
= (VARIANT
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
941 Buffer
= VARIANT_UserMarshal(pFlags
, Buffer
, lpVariant
);
947 IRecordInfo
* pRecInfo
= NULL
;
949 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
951 RpcRaiseException(hr
);
955 FIXME("write record info %p\n", pRecInfo
);
957 IRecordInfo_Release(pRecInfo
);
963 ALIGN_POINTER(Buffer
, 7);
968 /* Just copy the data over */
969 memcpy(Buffer
, psa
->pvData
, ulCellCount
* psa
->cbElements
);
970 Buffer
+= ulCellCount
* psa
->cbElements
;
981 #define FADF_AUTOSETFLAGS (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
982 FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
983 FADF_VARIANT | FADF_CREATEVECTOR)
985 unsigned char * WINAPI
LPSAFEARRAY_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
988 wireSAFEARRAY wiresa
;
995 SAFEARRAYBOUND
*wiresab
;
997 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, %p\n", Buffer
, ppsa
);
999 ALIGN_POINTER(Buffer
, 3);
1000 ptr
= *(ULONG_PTR
*)Buffer
;
1001 Buffer
+= sizeof(ULONG_PTR
);
1007 TRACE("NULL safe array unmarshaled\n");
1012 cDims
= *(ULONG
*)Buffer
;
1013 Buffer
+= sizeof(ULONG
);
1015 wiresa
= (wireSAFEARRAY
)Buffer
;
1016 Buffer
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
1018 if (cDims
!= wiresa
->cDims
)
1019 RpcRaiseException(RPC_S_INVALID_BOUND
);
1021 /* FIXME: there should be a limit on how large cDims can be */
1023 vt
= HIWORD(wiresa
->cLocks
);
1025 sftype
= *(ULONG
*)Buffer
;
1026 Buffer
+= sizeof(ULONG
);
1028 cell_count
= *(ULONG
*)Buffer
;
1029 Buffer
+= sizeof(ULONG
);
1030 ptr
= *(ULONG_PTR
*)Buffer
;
1031 Buffer
+= sizeof(ULONG_PTR
);
1032 if (sftype
== SF_HAVEIID
)
1034 memcpy(&guid
, Buffer
, sizeof(guid
));
1035 Buffer
+= sizeof(guid
);
1038 wiresab
= (SAFEARRAYBOUND
*)Buffer
;
1039 Buffer
+= sizeof(wiresab
[0]) * wiresa
->cDims
;
1042 *ppsa
= SafeArrayCreateEx(vt
, wiresa
->cDims
, wiresab
, NULL
);
1045 SafeArrayAllocDescriptor(wiresa
->cDims
, ppsa
);
1047 memcpy((*ppsa
)->rgsabound
, wiresab
, sizeof(SAFEARRAYBOUND
) * wiresa
->cDims
);
1050 RpcRaiseException(E_OUTOFMEMORY
);
1052 /* be careful about which flags we set since they could be a security
1054 (*ppsa
)->fFeatures
&= FADF_AUTOSETFLAGS
;
1055 (*ppsa
)->fFeatures
|= (wiresa
->fFeatures
& ~(FADF_AUTOSETFLAGS
));
1056 /* FIXME: there should be a limit on how large wiresa->cbElements can be */
1057 (*ppsa
)->cbElements
= wiresa
->cbElements
;
1058 (*ppsa
)->cLocks
= LOWORD(wiresa
->cLocks
);
1060 /* SafeArrayCreateEx allocates the data for us, but
1061 * SafeArrayAllocDescriptor doesn't */
1064 hr
= SafeArrayAllocData(*ppsa
);
1066 RpcRaiseException(hr
);
1069 if ((*(ULONG
*)Buffer
!= cell_count
) || (SAFEARRAY_GetCellCount(*ppsa
) != cell_count
))
1070 RpcRaiseException(RPC_S_INVALID_BOUND
);
1071 Buffer
+= sizeof(ULONG
);
1081 for (lpBstr
= (BSTR
*)(*ppsa
)->pvData
; cell_count
; cell_count
--, lpBstr
++)
1082 Buffer
= BSTR_UserUnmarshal(pFlags
, Buffer
, lpBstr
);
1089 FIXME("marshal interfaces\n");
1095 for (lpVariant
= (VARIANT
*)(*ppsa
)->pvData
; cell_count
; cell_count
--, lpVariant
++)
1096 Buffer
= VARIANT_UserUnmarshal(pFlags
, Buffer
, lpVariant
);
1102 FIXME("set record info\n");
1108 ALIGN_POINTER(Buffer
, 7);
1113 /* Just copy the data over */
1114 memcpy((*ppsa
)->pvData
, Buffer
, cell_count
* (*ppsa
)->cbElements
);
1115 Buffer
+= cell_count
* (*ppsa
)->cbElements
;
1122 TRACE("safe array unmarshaled: %p\n", *ppsa
);
1127 void WINAPI
LPSAFEARRAY_UserFree(ULONG
*pFlags
, LPSAFEARRAY
*ppsa
)
1129 TRACE("("); dump_user_flags(pFlags
); TRACE(", &%p\n", *ppsa
);
1131 SafeArrayDestroy(*ppsa
);
1135 ULONG WINAPI
HFONT_UserSize(ULONG
*pFlags
, ULONG Start
, HFONT
*phfont
)
1141 unsigned char * WINAPI
HFONT_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, HFONT
*phfont
)
1147 unsigned char * WINAPI
HFONT_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, HFONT
*phfont
)
1153 void WINAPI
HFONT_UserFree(ULONG
*pFlags
, HFONT
*phfont
)
1161 /* exactly how Invoke is marshalled is not very clear to me yet,
1162 * but the way I've done it seems to work for me */
1164 HRESULT CALLBACK
IDispatch_Invoke_Proxy(
1166 DISPID dispIdMember
,
1170 DISPPARAMS
* pDispParams
,
1171 VARIANT
* pVarResult
,
1172 EXCEPINFO
* pExcepInfo
,
1177 UINT
* rgVarRefIdx
= NULL
;
1178 VARIANTARG
* rgVarRef
= NULL
;
1181 EXCEPINFO ExcepInfo
;
1183 TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This
,
1184 dispIdMember
, debugstr_guid(riid
),
1185 lcid
, wFlags
, pDispParams
, pVarResult
,
1186 pExcepInfo
, puArgErr
);
1188 /* [out] args can't be null, use dummy vars if needed */
1189 if (!pVarResult
) pVarResult
= &VarResult
;
1190 if (!puArgErr
) puArgErr
= &uArgErr
;
1191 if (!pExcepInfo
) pExcepInfo
= &ExcepInfo
;
1193 /* count by-ref args */
1194 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
1195 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
1196 if (V_ISBYREF(arg
)) {
1201 rgVarRefIdx
= CoTaskMemAlloc(sizeof(UINT
)*cVarRef
);
1202 rgVarRef
= CoTaskMemAlloc(sizeof(VARIANTARG
)*cVarRef
);
1203 /* make list of by-ref args */
1204 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
1205 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
1206 if (V_ISBYREF(arg
)) {
1207 rgVarRefIdx
[cVarRef
] = u
;
1208 VariantInit(&rgVarRef
[cVarRef
]);
1213 /* [out] args still can't be null,
1214 * but we can point these anywhere in this case,
1215 * since they won't be written to when cVarRef is 0 */
1216 rgVarRefIdx
= puArgErr
;
1217 rgVarRef
= pVarResult
;
1219 TRACE("passed by ref: %d args\n", cVarRef
);
1220 hr
= IDispatch_RemoteInvoke_Proxy(This
,
1233 for (u
=0; u
<cVarRef
; u
++) {
1234 unsigned i
= rgVarRefIdx
[u
];
1235 VariantCopy(&pDispParams
->rgvarg
[i
],
1237 VariantClear(&rgVarRef
[u
]);
1239 CoTaskMemFree(rgVarRef
);
1240 CoTaskMemFree(rgVarRefIdx
);
1243 if(pExcepInfo
== &ExcepInfo
)
1245 SysFreeString(pExcepInfo
->bstrSource
);
1246 SysFreeString(pExcepInfo
->bstrDescription
);
1247 SysFreeString(pExcepInfo
->bstrHelpFile
);
1252 HRESULT __RPC_STUB
IDispatch_Invoke_Stub(
1254 DISPID dispIdMember
,
1258 DISPPARAMS
* pDispParams
,
1259 VARIANT
* pVarResult
,
1260 EXCEPINFO
* pExcepInfo
,
1264 VARIANTARG
* rgVarRef
)
1267 VARIANTARG
*rgvarg
, *arg
;
1270 /* initialize out parameters, so that they can be marshalled
1271 * in case the real Invoke doesn't initialize them */
1272 VariantInit(pVarResult
);
1273 memset(pExcepInfo
, 0, sizeof(*pExcepInfo
));
1276 /* let the real Invoke operate on a copy of the in parameters,
1277 * so we don't risk losing pointers to allocated memory */
1278 rgvarg
= pDispParams
->rgvarg
;
1279 arg
= CoTaskMemAlloc(sizeof(VARIANTARG
)*pDispParams
->cArgs
);
1280 if (!arg
) return E_OUTOFMEMORY
;
1282 /* init all args so we can call VariantClear on all the args if the copy
1284 for (u
= 0; u
< pDispParams
->cArgs
; u
++)
1285 VariantInit(&arg
[u
]);
1287 for (u
= 0; u
< pDispParams
->cArgs
; u
++) {
1288 hr
= VariantCopy(&arg
[u
], &rgvarg
[u
]);
1293 if (SUCCEEDED(hr
)) {
1294 pDispParams
->rgvarg
= arg
;
1296 hr
= IDispatch_Invoke(This
,
1306 /* copy ref args to out list */
1307 for (u
=0; u
<cVarRef
; u
++) {
1308 unsigned i
= rgVarRefIdx
[u
];
1309 VariantInit(&rgVarRef
[u
]);
1310 VariantCopy(&rgVarRef
[u
], &arg
[i
]);
1311 /* clear original if equal, to avoid double-free */
1312 if (V_BYREF(&rgVarRef
[u
]) == V_BYREF(&rgvarg
[i
]))
1313 VariantClear(&rgvarg
[i
]);
1317 /* clear the duplicate argument list */
1318 for (u
=0; u
<pDispParams
->cArgs
; u
++)
1319 VariantClear(&arg
[u
]);
1321 pDispParams
->rgvarg
= rgvarg
;
1329 HRESULT CALLBACK
IEnumVARIANT_Next_Proxy(
1333 ULONG
* pCeltFetched
)
1337 pCeltFetched
= &fetched
;
1338 return IEnumVARIANT_RemoteNext_Proxy(This
,
1344 HRESULT __RPC_STUB
IEnumVARIANT_Next_Stub(
1348 ULONG
* pCeltFetched
)
1352 hr
= IEnumVARIANT_Next(This
,
1356 if (hr
== S_OK
) *pCeltFetched
= celt
;
1360 /* TypeInfo related freers */
1362 static void free_embedded_typedesc(TYPEDESC
*tdesc
);
1363 static void free_embedded_arraydesc(ARRAYDESC
*adesc
)
1365 switch(adesc
->tdescElem
.vt
)
1369 free_embedded_typedesc(adesc
->tdescElem
.u
.lptdesc
);
1370 CoTaskMemFree(adesc
->tdescElem
.u
.lptdesc
);
1373 free_embedded_arraydesc(adesc
->tdescElem
.u
.lpadesc
);
1374 CoTaskMemFree(adesc
->tdescElem
.u
.lpadesc
);
1379 static void free_embedded_typedesc(TYPEDESC
*tdesc
)
1385 free_embedded_typedesc(tdesc
->u
.lptdesc
);
1386 CoTaskMemFree(tdesc
->u
.lptdesc
);
1389 free_embedded_arraydesc(tdesc
->u
.lpadesc
);
1390 CoTaskMemFree(tdesc
->u
.lpadesc
);
1395 static void free_embedded_elemdesc(ELEMDESC
*edesc
)
1397 free_embedded_typedesc(&edesc
->tdesc
);
1398 if(edesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
1399 CoTaskMemFree(edesc
->u
.paramdesc
.pparamdescex
);
1404 HRESULT CALLBACK
ITypeComp_Bind_Proxy(
1409 ITypeInfo
** ppTInfo
,
1410 DESCKIND
* pDescKind
,
1413 FIXME("not implemented\n");
1417 HRESULT __RPC_STUB
ITypeComp_Bind_Stub(
1422 ITypeInfo
** ppTInfo
,
1423 DESCKIND
* pDescKind
,
1424 LPFUNCDESC
* ppFuncDesc
,
1425 LPVARDESC
* ppVarDesc
,
1426 ITypeComp
** ppTypeComp
,
1427 CLEANLOCALSTORAGE
* pDummy
)
1429 FIXME("not implemented\n");
1433 HRESULT CALLBACK
ITypeComp_BindType_Proxy(
1437 ITypeInfo
** ppTInfo
,
1438 ITypeComp
** ppTComp
)
1440 FIXME("not implemented\n");
1444 HRESULT __RPC_STUB
ITypeComp_BindType_Stub(
1448 ITypeInfo
** ppTInfo
)
1450 FIXME("not implemented\n");
1456 HRESULT CALLBACK
ITypeInfo_GetTypeAttr_Proxy(
1458 TYPEATTR
** ppTypeAttr
)
1461 CLEANLOCALSTORAGE stg
;
1462 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1465 stg
.pStorage
= NULL
;
1466 stg
.pInterface
= NULL
;
1468 return ITypeInfo_RemoteGetTypeAttr_Proxy(This
, ppTypeAttr
, &stg
);
1471 HRESULT __RPC_STUB
ITypeInfo_GetTypeAttr_Stub(
1473 LPTYPEATTR
* ppTypeAttr
,
1474 CLEANLOCALSTORAGE
* pDummy
)
1477 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1479 hr
= ITypeInfo_GetTypeAttr(This
, ppTypeAttr
);
1483 pDummy
->flags
= CLS_TYPEATTR
;
1484 ITypeInfo_AddRef(This
);
1485 pDummy
->pInterface
= (IUnknown
*)This
;
1486 pDummy
->pStorage
= ppTypeAttr
;
1490 HRESULT CALLBACK
ITypeInfo_GetFuncDesc_Proxy(
1493 FUNCDESC
** ppFuncDesc
)
1495 CLEANLOCALSTORAGE stg
;
1496 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1499 stg
.pStorage
= NULL
;
1500 stg
.pInterface
= NULL
;
1502 return ITypeInfo_RemoteGetFuncDesc_Proxy(This
, index
, ppFuncDesc
, &stg
);
1505 HRESULT __RPC_STUB
ITypeInfo_GetFuncDesc_Stub(
1508 LPFUNCDESC
* ppFuncDesc
,
1509 CLEANLOCALSTORAGE
* pDummy
)
1512 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1514 hr
= ITypeInfo_GetFuncDesc(This
, index
, ppFuncDesc
);
1518 pDummy
->flags
= CLS_FUNCDESC
;
1519 ITypeInfo_AddRef(This
);
1520 pDummy
->pInterface
= (IUnknown
*)This
;
1521 pDummy
->pStorage
= ppFuncDesc
;
1525 HRESULT CALLBACK
ITypeInfo_GetVarDesc_Proxy(
1528 VARDESC
** ppVarDesc
)
1530 CLEANLOCALSTORAGE stg
;
1531 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1534 stg
.pStorage
= NULL
;
1535 stg
.pInterface
= NULL
;
1537 return ITypeInfo_RemoteGetVarDesc_Proxy(This
, index
, ppVarDesc
, &stg
);
1540 HRESULT __RPC_STUB
ITypeInfo_GetVarDesc_Stub(
1543 LPVARDESC
* ppVarDesc
,
1544 CLEANLOCALSTORAGE
* pDummy
)
1547 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1549 hr
= ITypeInfo_GetVarDesc(This
, index
, ppVarDesc
);
1553 pDummy
->flags
= CLS_VARDESC
;
1554 ITypeInfo_AddRef(This
);
1555 pDummy
->pInterface
= (IUnknown
*)This
;
1556 pDummy
->pStorage
= ppVarDesc
;
1560 HRESULT CALLBACK
ITypeInfo_GetNames_Proxy(
1567 FIXME("not implemented\n");
1571 HRESULT __RPC_STUB
ITypeInfo_GetNames_Stub(
1578 FIXME("not implemented\n");
1582 HRESULT CALLBACK
ITypeInfo_GetIDsOfNames_Proxy(
1584 LPOLESTR
* rgszNames
,
1588 FIXME("not implemented\n");
1592 HRESULT __RPC_STUB
ITypeInfo_GetIDsOfNames_Stub(
1595 FIXME("not implemented\n");
1599 HRESULT CALLBACK
ITypeInfo_Invoke_Proxy(
1604 DISPPARAMS
* pDispParams
,
1605 VARIANT
* pVarResult
,
1606 EXCEPINFO
* pExcepInfo
,
1609 FIXME("not implemented\n");
1613 HRESULT __RPC_STUB
ITypeInfo_Invoke_Stub(
1616 FIXME("not implemented\n");
1620 HRESULT CALLBACK
ITypeInfo_GetDocumentation_Proxy(
1624 BSTR
* pBstrDocString
,
1625 DWORD
* pdwHelpContext
,
1626 BSTR
* pBstrHelpFile
)
1629 BSTR name
, doc_string
, help_file
;
1631 TRACE("(%p, %08x, %p, %p, %p, %p)\n", This
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
1633 /* FIXME: presumably refPtrFlags is supposed to be a bitmask of which ptrs we actually want? */
1634 hr
= ITypeInfo_RemoteGetDocumentation_Proxy(This
, memid
, 0, &name
, &doc_string
, &help_context
, &help_file
);
1637 if(pBstrName
) *pBstrName
= name
;
1638 else SysFreeString(name
);
1640 if(pBstrDocString
) *pBstrDocString
= doc_string
;
1641 else SysFreeString(doc_string
);
1643 if(pBstrHelpFile
) *pBstrHelpFile
= help_file
;
1644 else SysFreeString(help_file
);
1646 if(pdwHelpContext
) *pdwHelpContext
= help_context
;
1651 HRESULT __RPC_STUB
ITypeInfo_GetDocumentation_Stub(
1656 BSTR
* pBstrDocString
,
1657 DWORD
* pdwHelpContext
,
1658 BSTR
* pBstrHelpFile
)
1660 TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This
, memid
, refPtrFlags
, pBstrName
, pBstrDocString
,
1661 pdwHelpContext
, pBstrHelpFile
);
1662 return ITypeInfo_GetDocumentation(This
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
1665 HRESULT CALLBACK
ITypeInfo_GetDllEntry_Proxy(
1673 FIXME("not implemented\n");
1677 HRESULT __RPC_STUB
ITypeInfo_GetDllEntry_Stub(
1686 FIXME("not implemented\n");
1690 HRESULT CALLBACK
ITypeInfo_AddressOfMember_Proxy(
1696 FIXME("not implemented\n");
1700 HRESULT __RPC_STUB
ITypeInfo_AddressOfMember_Stub(
1703 FIXME("not implemented\n");
1707 HRESULT CALLBACK
ITypeInfo_CreateInstance_Proxy(
1709 IUnknown
* pUnkOuter
,
1713 FIXME("not implemented\n");
1717 HRESULT __RPC_STUB
ITypeInfo_CreateInstance_Stub(
1722 FIXME("not implemented\n");
1726 HRESULT CALLBACK
ITypeInfo_GetContainingTypeLib_Proxy(
1735 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1737 hr
= ITypeInfo_RemoteGetContainingTypeLib_Proxy(This
, &pTL
, &index
);
1746 ITypeLib_Release(pTL
);
1751 HRESULT __RPC_STUB
ITypeInfo_GetContainingTypeLib_Stub(
1756 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1757 return ITypeInfo_GetContainingTypeLib(This
, ppTLib
, pIndex
);
1760 void CALLBACK
ITypeInfo_ReleaseTypeAttr_Proxy(
1762 TYPEATTR
* pTypeAttr
)
1764 TRACE("(%p, %p)\n", This
, pTypeAttr
);
1765 free_embedded_typedesc(&pTypeAttr
->tdescAlias
);
1766 CoTaskMemFree(pTypeAttr
);
1769 HRESULT __RPC_STUB
ITypeInfo_ReleaseTypeAttr_Stub(
1772 TRACE("nothing to do\n");
1776 void CALLBACK
ITypeInfo_ReleaseFuncDesc_Proxy(
1778 FUNCDESC
* pFuncDesc
)
1781 TRACE("(%p, %p)\n", This
, pFuncDesc
);
1783 for(param
= 0; param
< pFuncDesc
->cParams
; param
++)
1784 free_embedded_elemdesc(pFuncDesc
->lprgelemdescParam
+ param
);
1786 CoTaskMemFree(pFuncDesc
->lprgelemdescParam
);
1788 free_embedded_elemdesc(&pFuncDesc
->elemdescFunc
);
1790 if(pFuncDesc
->cScodes
!= 0 && pFuncDesc
->cScodes
!= -1)
1791 CoTaskMemFree(pFuncDesc
->lprgscode
);
1793 CoTaskMemFree(pFuncDesc
);
1796 HRESULT __RPC_STUB
ITypeInfo_ReleaseFuncDesc_Stub(
1799 TRACE("nothing to do\n");
1803 void CALLBACK
ITypeInfo_ReleaseVarDesc_Proxy(
1807 TRACE("(%p, %p)\n", This
, pVarDesc
);
1809 CoTaskMemFree(pVarDesc
->lpstrSchema
);
1811 if(pVarDesc
->varkind
== VAR_CONST
)
1812 CoTaskMemFree(pVarDesc
->u
.lpvarValue
);
1814 free_embedded_elemdesc(&pVarDesc
->elemdescVar
);
1815 CoTaskMemFree(pVarDesc
);
1818 HRESULT __RPC_STUB
ITypeInfo_ReleaseVarDesc_Stub(
1821 TRACE("nothing to do\n");
1828 HRESULT CALLBACK
ITypeInfo2_GetDocumentation2_Proxy(
1832 BSTR
* pbstrHelpString
,
1833 DWORD
* pdwHelpStringContext
,
1834 BSTR
* pbstrHelpStringDll
)
1836 FIXME("not implemented\n");
1840 HRESULT __RPC_STUB
ITypeInfo2_GetDocumentation2_Stub(
1845 BSTR
* pbstrHelpString
,
1846 DWORD
* pdwHelpStringContext
,
1847 BSTR
* pbstrHelpStringDll
)
1849 FIXME("not implemented\n");
1855 UINT CALLBACK
ITypeLib_GetTypeInfoCount_Proxy(
1859 TRACE("(%p)\n", This
);
1861 ITypeLib_RemoteGetTypeInfoCount_Proxy(This
, &count
);
1866 HRESULT __RPC_STUB
ITypeLib_GetTypeInfoCount_Stub(
1870 TRACE("(%p, %p)\n", This
, pcTInfo
);
1871 *pcTInfo
= ITypeLib_GetTypeInfoCount(This
);
1875 HRESULT CALLBACK
ITypeLib_GetLibAttr_Proxy(
1877 TLIBATTR
** ppTLibAttr
)
1879 CLEANLOCALSTORAGE stg
;
1880 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1883 stg
.pStorage
= NULL
;
1884 stg
.pInterface
= NULL
;
1886 return ITypeLib_RemoteGetLibAttr_Proxy(This
, ppTLibAttr
, &stg
);
1889 HRESULT __RPC_STUB
ITypeLib_GetLibAttr_Stub(
1891 LPTLIBATTR
* ppTLibAttr
,
1892 CLEANLOCALSTORAGE
* pDummy
)
1895 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1897 hr
= ITypeLib_GetLibAttr(This
, ppTLibAttr
);
1901 pDummy
->flags
= CLS_LIBATTR
;
1902 ITypeLib_AddRef(This
);
1903 pDummy
->pInterface
= (IUnknown
*)This
;
1904 pDummy
->pStorage
= ppTLibAttr
;
1908 HRESULT CALLBACK
ITypeLib_GetDocumentation_Proxy(
1912 BSTR
* pBstrDocString
,
1913 DWORD
* pdwHelpContext
,
1914 BSTR
* pBstrHelpFile
)
1916 FIXME("not implemented\n");
1920 HRESULT __RPC_STUB
ITypeLib_GetDocumentation_Stub(
1925 BSTR
* pBstrDocString
,
1926 DWORD
* pdwHelpContext
,
1927 BSTR
* pBstrHelpFile
)
1929 FIXME("not implemented\n");
1933 HRESULT CALLBACK
ITypeLib_IsName_Proxy(
1939 FIXME("not implemented\n");
1943 HRESULT __RPC_STUB
ITypeLib_IsName_Stub(
1950 FIXME("not implemented\n");
1954 HRESULT CALLBACK
ITypeLib_FindName_Proxy(
1958 ITypeInfo
** ppTInfo
,
1962 FIXME("not implemented\n");
1966 HRESULT __RPC_STUB
ITypeLib_FindName_Stub(
1970 ITypeInfo
** ppTInfo
,
1975 FIXME("not implemented\n");
1979 void CALLBACK
ITypeLib_ReleaseTLibAttr_Proxy(
1981 TLIBATTR
* pTLibAttr
)
1983 TRACE("(%p, %p)\n", This
, pTLibAttr
);
1984 CoTaskMemFree(pTLibAttr
);
1987 HRESULT __RPC_STUB
ITypeLib_ReleaseTLibAttr_Stub(
1990 TRACE("nothing to do\n");
1997 HRESULT CALLBACK
ITypeLib2_GetLibStatistics_Proxy(
1999 ULONG
* pcUniqueNames
,
2000 ULONG
* pcchUniqueNames
)
2002 FIXME("not implemented\n");
2006 HRESULT __RPC_STUB
ITypeLib2_GetLibStatistics_Stub(
2008 ULONG
* pcUniqueNames
,
2009 ULONG
* pcchUniqueNames
)
2011 FIXME("not implemented\n");
2015 HRESULT CALLBACK
ITypeLib2_GetDocumentation2_Proxy(
2019 BSTR
* pbstrHelpString
,
2020 DWORD
* pdwHelpStringContext
,
2021 BSTR
* pbstrHelpStringDll
)
2023 FIXME("not implemented\n");
2027 HRESULT __RPC_STUB
ITypeLib2_GetDocumentation2_Stub(
2032 BSTR
* pbstrHelpString
,
2033 DWORD
* pdwHelpStringContext
,
2034 BSTR
* pbstrHelpStringDll
)
2036 FIXME("not implemented\n");
2040 HRESULT CALLBACK
IPropertyBag_Read_Proxy(
2042 LPCOLESTR pszPropName
,
2044 IErrorLog
*pErrorLog
)
2046 FIXME("not implemented\n");
2050 HRESULT __RPC_STUB
IPropertyBag_Read_Stub(
2052 LPCOLESTR pszPropName
,
2054 IErrorLog
*pErrorLog
,
2058 FIXME("not implemented\n");
2062 /* call_as/local stubs for ocidl.idl */
2064 HRESULT CALLBACK
IClassFactory2_CreateInstanceLic_Proxy(
2065 IClassFactory2
* This
,
2066 IUnknown
*pUnkOuter
,
2067 IUnknown
*pUnkReserved
,
2072 FIXME("not implemented\n");
2076 HRESULT __RPC_STUB
IClassFactory2_CreateInstanceLic_Stub(
2077 IClassFactory2
* This
,
2082 FIXME("not implemented\n");
2086 HRESULT CALLBACK
IEnumConnections_Next_Proxy(
2087 IEnumConnections
* This
,
2092 FIXME("not implemented\n");
2096 HRESULT __RPC_STUB
IEnumConnections_Next_Stub(
2097 IEnumConnections
* This
,
2102 FIXME("not implemented\n");
2106 HRESULT CALLBACK
IEnumConnectionPoints_Next_Proxy(
2107 IEnumConnectionPoints
* This
,
2109 LPCONNECTIONPOINT
*ppCP
,
2112 FIXME("not implemented\n");
2116 HRESULT __RPC_STUB
IEnumConnectionPoints_Next_Stub(
2117 IEnumConnectionPoints
* This
,
2119 LPCONNECTIONPOINT
*ppCP
,
2122 FIXME("not implemented\n");
2126 HRESULT CALLBACK
IPersistMemory_Load_Proxy(
2127 IPersistMemory
* This
,
2131 FIXME("not implemented\n");
2135 HRESULT __RPC_STUB
IPersistMemory_Load_Stub(
2136 IPersistMemory
* This
,
2140 FIXME("not implemented\n");
2144 HRESULT CALLBACK
IPersistMemory_Save_Proxy(
2145 IPersistMemory
* This
,
2150 FIXME("not implemented\n");
2154 HRESULT __RPC_STUB
IPersistMemory_Save_Stub(
2155 IPersistMemory
* This
,
2160 FIXME("not implemented\n");
2164 void CALLBACK
IAdviseSinkEx_OnViewStatusChange_Proxy(
2165 IAdviseSinkEx
* This
,
2168 FIXME("not implemented\n");
2171 HRESULT __RPC_STUB
IAdviseSinkEx_OnViewStatusChange_Stub(
2172 IAdviseSinkEx
* This
,
2175 FIXME("not implemented\n");
2179 HRESULT CALLBACK
IEnumOleUndoUnits_Next_Proxy(
2180 IEnumOleUndoUnits
* This
,
2182 IOleUndoUnit
**rgElt
,
2183 ULONG
*pcEltFetched
)
2185 FIXME("not implemented\n");
2189 HRESULT __RPC_STUB
IEnumOleUndoUnits_Next_Stub(
2190 IEnumOleUndoUnits
* This
,
2192 IOleUndoUnit
**rgElt
,
2193 ULONG
*pcEltFetched
)
2195 FIXME("not implemented\n");
2199 HRESULT CALLBACK
IQuickActivate_QuickActivate_Proxy(
2200 IQuickActivate
* This
,
2201 QACONTAINER
*pQaContainer
,
2202 QACONTROL
*pQaControl
)
2204 FIXME("not implemented\n");
2208 HRESULT __RPC_STUB
IQuickActivate_QuickActivate_Stub(
2209 IQuickActivate
* This
,
2210 QACONTAINER
*pQaContainer
,
2211 QACONTROL
*pQaControl
)
2213 FIXME("not implemented\n");