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");