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
39 #include "wine/debug.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
43 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
44 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
45 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
46 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
48 static CStdPSFactoryBuffer PSFactoryBuffer
;
50 CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer
)
52 extern const ExtendedProxyFileInfo oaidl_ProxyFileInfo
;
54 static const ProxyFileInfo
*OLEAUT32_ProxyFileList
[] = {
59 HRESULT
OLEAUTPS_DllGetClassObject(REFCLSID rclsid
, REFIID riid
, LPVOID
*ppv
)
61 return NdrDllGetClassObject(rclsid
, riid
, ppv
, OLEAUT32_ProxyFileList
,
62 &CLSID_PSDispatch
, &PSFactoryBuffer
);
65 static void dump_user_flags(ULONG
*pFlags
)
67 if (HIWORD(*pFlags
) == NDR_LOCAL_DATA_REPRESENTATION
)
68 TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
70 TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags
));
71 switch (LOWORD(*pFlags
))
73 case MSHCTX_LOCAL
: TRACE("MSHCTX_LOCAL)"); break;
74 case MSHCTX_NOSHAREDMEM
: TRACE("MSHCTX_NOSHAREDMEM)"); break;
75 case MSHCTX_DIFFERENTMACHINE
: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
76 case MSHCTX_INPROC
: TRACE("MSHCTX_INPROC)"); break;
77 default: TRACE("%d)", LOWORD(*pFlags
));
81 /* CLEANLOCALSTORAGE */
83 #define CLS_FUNCDESC 'f'
84 #define CLS_LIBATTR 'l'
85 #define CLS_TYPEATTR 't'
86 #define CLS_VARDESC 'v'
88 ULONG WINAPI
CLEANLOCALSTORAGE_UserSize(ULONG
*pFlags
, ULONG Start
, CLEANLOCALSTORAGE
*pstg
)
90 ALIGN_LENGTH(Start
, 3);
91 return Start
+ sizeof(DWORD
);
94 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstg
)
96 ALIGN_POINTER(Buffer
, 3);
97 *(DWORD
*)Buffer
= pstg
->flags
;
101 ITypeLib_ReleaseTLibAttr((ITypeLib
*)pstg
->pInterface
, *(TLIBATTR
**)pstg
->pStorage
);
104 ITypeInfo_ReleaseTypeAttr((ITypeInfo
*)pstg
->pInterface
, *(TYPEATTR
**)pstg
->pStorage
);
107 ITypeInfo_ReleaseFuncDesc((ITypeInfo
*)pstg
->pInterface
, *(FUNCDESC
**)pstg
->pStorage
);
110 ITypeInfo_ReleaseVarDesc((ITypeInfo
*)pstg
->pInterface
, *(VARDESC
**)pstg
->pStorage
);
114 ERR("Unknown type %x\n", pstg
->flags
);
117 *(VOID
**)pstg
->pStorage
= NULL
;
118 IUnknown_Release(pstg
->pInterface
);
119 pstg
->pInterface
= NULL
;
121 return Buffer
+ sizeof(DWORD
);
124 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstr
)
126 ALIGN_POINTER(Buffer
, 3);
127 pstr
->flags
= *(DWORD
*)Buffer
;
128 return Buffer
+ sizeof(DWORD
);
131 void WINAPI
CLEANLOCALSTORAGE_UserFree(ULONG
*pFlags
, CLEANLOCALSTORAGE
*pstr
)
140 DWORD len
; /* No. of chars not including trailing '\0' */
141 DWORD byte_len
; /* len * 2 or 0xffffffff if len == 0 */
142 DWORD len2
; /* == len */
145 ULONG WINAPI
BSTR_UserSize(ULONG
*pFlags
, ULONG Start
, BSTR
*pstr
)
147 TRACE("(%x,%d,%p) => %p\n", *pFlags
, Start
, pstr
, *pstr
);
148 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
149 ALIGN_LENGTH(Start
, 3);
150 Start
+= sizeof(bstr_wire_t
) + ((SysStringByteLen(*pstr
) + 1) & ~1);
151 TRACE("returning %d\n", Start
);
155 unsigned char * WINAPI
BSTR_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
158 DWORD len
= SysStringByteLen(*pstr
);
160 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
161 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
163 ALIGN_POINTER(Buffer
, 3);
164 header
= (bstr_wire_t
*)Buffer
;
165 header
->len
= header
->len2
= (len
+ 1) / 2;
168 header
->byte_len
= len
;
169 memcpy(header
+ 1, *pstr
, header
->len
* 2);
172 header
->byte_len
= 0xffffffff; /* special case for a null bstr */
174 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
177 unsigned char * WINAPI
BSTR_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
180 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
182 ALIGN_POINTER(Buffer
, 3);
183 header
= (bstr_wire_t
*)Buffer
;
184 if(header
->len
!= header
->len2
)
185 FIXME("len %08x != len2 %08x\n", header
->len
, header
->len2
);
189 SysFreeString(*pstr
);
193 if(header
->byte_len
!= 0xffffffff)
194 *pstr
= SysAllocStringByteLen((char*)(header
+ 1), header
->byte_len
);
196 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
197 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
200 void WINAPI
BSTR_UserFree(ULONG
*pFlags
, BSTR
*pstr
)
202 TRACE("(%x,%p) => %p\n", *pFlags
, pstr
, *pstr
);
205 SysFreeString(*pstr
);
223 static unsigned int get_type_size(ULONG
*pFlags
, VARIANT
*pvar
)
225 if (V_VT(pvar
) & VT_ARRAY
) return 4;
227 switch (V_VT(pvar
) & ~VT_BYREF
) {
236 return sizeof(SHORT
);
244 return sizeof(FLOAT
);
246 return sizeof(DOUBLE
);
248 return sizeof(VARIANT_BOOL
);
250 return sizeof(SCODE
);
256 return sizeof(DECIMAL
);
260 return sizeof(VARIANT
);
266 FIXME("unhandled VT %d\n", V_VT(pvar
));
271 static unsigned int get_type_alignment(ULONG
*pFlags
, VARIANT
*pvar
)
273 unsigned int size
= get_type_size(pFlags
, pvar
);
274 if(V_VT(pvar
) & VT_BYREF
) return 3;
275 if(size
== 0) return 0;
276 if(size
<= 4) return size
- 1;
280 static unsigned interface_variant_size(ULONG
*pFlags
, REFIID riid
, IUnknown
*punk
)
284 /* find the buffer size of the marshalled dispatch interface */
285 hr
= CoGetMarshalSizeMax(&size
, riid
, punk
, LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
288 WARN("NULL dispatch pointer\n");
290 ERR("Dispatch variant buffer size calculation failed, HRESULT=0x%x\n", hr
);
293 size
+= sizeof(ULONG
); /* we have to store the buffersize in the stream */
294 TRACE("wire-size extra of dispatch variant is %d\n", size
);
298 static ULONG
wire_extra_user_size(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
303 return LPSAFEARRAY_UserSize(pFlags
, Start
, V_ARRAYREF(pvar
));
305 return LPSAFEARRAY_UserSize(pFlags
, Start
, &V_ARRAY(pvar
));
308 switch (V_VT(pvar
)) {
310 return BSTR_UserSize(pFlags
, Start
, &V_BSTR(pvar
));
311 case VT_BSTR
| VT_BYREF
:
312 return BSTR_UserSize(pFlags
, Start
, V_BSTRREF(pvar
));
313 case VT_VARIANT
| VT_BYREF
:
314 return VARIANT_UserSize(pFlags
, Start
, V_VARIANTREF(pvar
));
316 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, V_UNKNOWN(pvar
));
317 case VT_UNKNOWN
| VT_BYREF
:
318 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
320 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
321 case VT_DISPATCH
| VT_BYREF
:
322 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
324 FIXME("wire-size record\n");
327 case VT_SAFEARRAY
| VT_BYREF
:
328 FIXME("wire-size safearray: shouldn't be marshaling this\n");
335 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
336 static unsigned char* interface_variant_marshal(ULONG
*pFlags
, unsigned char *Buffer
, REFIID riid
, IUnknown
*punk
)
340 void *working_memlocked
;
341 unsigned char *oldpos
;
345 TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags
, Buffer
, punk
);
349 /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
350 * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
351 * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
352 * but that would be overkill here, hence this implementation. We save the size because the unmarshal
353 * code has no way to know how long the marshalled buffer is. */
355 size
= interface_variant_size(pFlags
, riid
, punk
);
357 working_mem
= GlobalAlloc(0, size
);
358 if (!working_mem
) return oldpos
;
360 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
362 GlobalFree(working_mem
);
366 hr
= CoMarshalInterface(working
, riid
, punk
, LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
368 IStream_Release(working
); /* this also releases the hglobal */
372 working_memlocked
= GlobalLock(working_mem
);
373 memcpy(Buffer
, &size
, sizeof(ULONG
)); /* copy the buffersize */
374 memcpy(Buffer
+ sizeof(ULONG
), working_memlocked
, size
- sizeof(ULONG
));
375 GlobalUnlock(working_mem
);
377 IStream_Release(working
);
379 /* size includes the ULONG for the size written above */
380 TRACE("done, size=%d\n", size
);
381 return Buffer
+ size
;
384 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer. returns Buffer on failure, new position otherwise */
385 static unsigned char *interface_variant_unmarshal(ULONG
*pFlags
, unsigned char *Buffer
, REFIID riid
, IUnknown
**ppunk
)
389 void *working_memlocked
;
390 unsigned char *oldpos
;
394 TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags
, Buffer
, ppunk
);
398 /* get the buffersize */
399 memcpy(&size
, Buffer
, sizeof(ULONG
));
400 TRACE("buffersize=%d\n", size
);
402 working_mem
= GlobalAlloc(0, size
);
403 if (!working_mem
) return oldpos
;
405 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
407 GlobalFree(working_mem
);
411 working_memlocked
= GlobalLock(working_mem
);
413 /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
414 memcpy(working_memlocked
, Buffer
+ sizeof(ULONG
), size
);
415 GlobalUnlock(working_mem
);
417 hr
= CoUnmarshalInterface(working
, riid
, (void**)ppunk
);
419 IStream_Release(working
);
423 IStream_Release(working
); /* this also frees the underlying hglobal */
425 /* size includes the ULONG for the size written above */
426 TRACE("done, processed=%d bytes\n", size
);
427 return Buffer
+ size
;
431 ULONG WINAPI
VARIANT_UserSize(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
434 TRACE("(%x,%d,%p)\n", *pFlags
, Start
, pvar
);
435 TRACE("vt=%04x\n", V_VT(pvar
));
437 ALIGN_LENGTH(Start
, 7);
438 Start
+= sizeof(variant_wire_t
);
439 if(V_VT(pvar
) & VT_BYREF
)
442 align
= get_type_alignment(pFlags
, pvar
);
443 ALIGN_LENGTH(Start
, align
);
444 if(V_VT(pvar
) == (VT_VARIANT
| VT_BYREF
))
447 Start
+= get_type_size(pFlags
, pvar
);
448 Start
= wire_extra_user_size(pFlags
, Start
, pvar
);
450 TRACE("returning %d\n", Start
);
454 unsigned char * WINAPI
VARIANT_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
456 variant_wire_t
*header
;
461 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
462 TRACE("vt=%04x\n", V_VT(pvar
));
464 ALIGN_POINTER(Buffer
, 7);
466 header
= (variant_wire_t
*)Buffer
;
468 header
->clSize
= 0; /* fixed up at the end */
469 header
->rpcReserverd
= 0;
470 header
->vt
= pvar
->n1
.n2
.vt
;
471 header
->wReserved1
= pvar
->n1
.n2
.wReserved1
;
472 header
->wReserved2
= pvar
->n1
.n2
.wReserved2
;
473 header
->wReserved3
= pvar
->n1
.n2
.wReserved3
;
474 header
->switch_is
= pvar
->n1
.n2
.vt
;
475 if(header
->switch_is
& VT_ARRAY
)
476 header
->switch_is
&= ~VT_TYPEMASK
;
478 Pos
= (unsigned char*)(header
+ 1);
479 type_size
= get_type_size(pFlags
, pvar
);
480 align
= get_type_alignment(pFlags
, pvar
);
481 ALIGN_POINTER(Pos
, align
);
483 if(header
->vt
& VT_BYREF
)
485 *(DWORD
*)Pos
= max(type_size
, 4);
487 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
489 memcpy(Pos
, pvar
->n1
.n2
.n3
.byref
, type_size
);
494 *(DWORD
*)Pos
= 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
500 if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
501 memcpy(Pos
, pvar
, type_size
);
503 memcpy(Pos
, &pvar
->n1
.n2
.n3
, type_size
);
507 if(header
->vt
& VT_ARRAY
)
509 if(header
->vt
& VT_BYREF
)
510 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
512 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
519 Pos
= BSTR_UserMarshal(pFlags
, Pos
, &V_BSTR(pvar
));
521 case VT_BSTR
| VT_BYREF
:
522 Pos
= BSTR_UserMarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
524 case VT_VARIANT
| VT_BYREF
:
525 Pos
= VARIANT_UserMarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
528 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
529 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWN(pvar
));
531 case VT_UNKNOWN
| VT_BYREF
:
532 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
533 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
536 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
537 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
539 case VT_DISPATCH
| VT_BYREF
:
540 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
541 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
544 FIXME("handle BRECORD by val\n");
546 case VT_RECORD
| VT_BYREF
:
547 FIXME("handle BRECORD by ref\n");
551 header
->clSize
= ((Pos
- Buffer
) + 7) >> 3;
552 TRACE("marshalled size=%d\n", header
->clSize
);
556 unsigned char * WINAPI
VARIANT_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
558 variant_wire_t
*header
;
563 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
565 ALIGN_POINTER(Buffer
, 7);
568 header
= (variant_wire_t
*)Buffer
;
570 pvar
->n1
.n2
.vt
= header
->vt
;
571 pvar
->n1
.n2
.wReserved1
= header
->wReserved1
;
572 pvar
->n1
.n2
.wReserved2
= header
->wReserved2
;
573 pvar
->n1
.n2
.wReserved3
= header
->wReserved3
;
575 Pos
= (unsigned char*)(header
+ 1);
576 type_size
= get_type_size(pFlags
, pvar
);
577 align
= get_type_alignment(pFlags
, pvar
);
578 ALIGN_POINTER(Pos
, align
);
580 if(header
->vt
& VT_BYREF
)
583 pvar
->n1
.n2
.n3
.byref
= CoTaskMemAlloc(type_size
);
584 memcpy(pvar
->n1
.n2
.n3
.byref
, Pos
, type_size
);
585 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
592 if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
593 memcpy(pvar
, Pos
, type_size
);
595 memcpy(&pvar
->n1
.n2
.n3
, Pos
, type_size
);
599 if(header
->vt
& VT_ARRAY
)
601 if(header
->vt
& VT_BYREF
)
602 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
604 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
612 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, &V_BSTR(pvar
));
614 case VT_BSTR
| VT_BYREF
:
615 *V_BSTRREF(pvar
) = NULL
;
616 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
618 case VT_VARIANT
| VT_BYREF
:
619 Pos
= VARIANT_UserUnmarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
622 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
623 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, &V_UNKNOWN(pvar
));
625 case VT_UNKNOWN
| VT_BYREF
:
626 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
627 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWNREF(pvar
));
630 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
631 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)&V_DISPATCH(pvar
));
633 case VT_DISPATCH
| VT_BYREF
:
634 /* this should probably call WdtpInterfacePointer_UserUnmarshal in ole32.dll */
635 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)V_DISPATCHREF(pvar
));
638 FIXME("handle BRECORD by val\n");
640 case VT_RECORD
| VT_BYREF
:
641 FIXME("handle BRECORD by ref\n");
648 void WINAPI
VARIANT_UserFree(ULONG
*pFlags
, VARIANT
*pvar
)
650 VARTYPE vt
= V_VT(pvar
);
653 TRACE("(%x,%p)\n", *pFlags
, pvar
);
654 TRACE("vt=%04x\n", V_VT(pvar
));
656 if (vt
& VT_BYREF
) ref
= pvar
->n1
.n2
.n3
.byref
;
662 LPSAFEARRAY_UserFree(pFlags
, V_ARRAYREF(pvar
));
667 case VT_BSTR
| VT_BYREF
:
668 BSTR_UserFree(pFlags
, V_BSTRREF(pvar
));
670 case VT_VARIANT
| VT_BYREF
:
671 VARIANT_UserFree(pFlags
, V_VARIANTREF(pvar
));
673 case VT_RECORD
| VT_BYREF
:
674 FIXME("handle BRECORD by ref\n");
676 case VT_UNKNOWN
| VT_BYREF
:
677 case VT_DISPATCH
| VT_BYREF
:
678 IUnknown_Release(*V_UNKNOWNREF(pvar
));
688 /* Get the number of cells in a SafeArray */
689 static ULONG
SAFEARRAY_GetCellCount(const SAFEARRAY
*psa
)
691 const SAFEARRAYBOUND
* psab
= psa
->rgsabound
;
692 USHORT cCount
= psa
->cDims
;
693 ULONG ulNumCells
= 1;
697 /* This is a valid bordercase. See testcases. -Marcus */
698 if (!psab
->cElements
)
700 ulNumCells
*= psab
->cElements
;
706 static inline SF_TYPE
SAFEARRAY_GetUnionType(SAFEARRAY
*psa
)
711 hr
= SafeArrayGetVartype(psa
, &vt
);
714 if(psa
->fFeatures
& FADF_VARIANT
) return SF_VARIANT
;
716 switch(psa
->cbElements
)
718 case 1: vt
= VT_I1
; break;
719 case 2: vt
= VT_I2
; break;
720 case 4: vt
= VT_I4
; break;
721 case 8: vt
= VT_I8
; break;
723 RpcRaiseException(hr
);
727 if (psa
->fFeatures
& FADF_HAVEIID
)
733 case VT_UI1
: return SF_I1
;
736 case VT_UI2
: return SF_I2
;
741 case VT_R4
: return SF_I4
;
746 case VT_UI8
: return SF_I8
;
748 case VT_UINT_PTR
: return (sizeof(UINT_PTR
) == 4 ? SF_I4
: SF_I8
);
749 case VT_BSTR
: return SF_BSTR
;
750 case VT_DISPATCH
: return SF_DISPATCH
;
751 case VT_VARIANT
: return SF_VARIANT
;
752 case VT_UNKNOWN
: return SF_UNKNOWN
;
753 /* Note: Return a non-zero size to indicate vt is valid. The actual size
754 * of a UDT is taken from the result of IRecordInfo_GetSize().
756 case VT_RECORD
: return SF_RECORD
;
757 default: return SF_ERROR
;
761 ULONG WINAPI
LPSAFEARRAY_UserSize(ULONG
*pFlags
, ULONG StartingSize
, LPSAFEARRAY
*ppsa
)
763 ULONG size
= StartingSize
;
765 TRACE("("); dump_user_flags(pFlags
); TRACE(", %d, %p\n", StartingSize
, *ppsa
);
767 ALIGN_LENGTH(size
, 3);
768 size
+= sizeof(ULONG_PTR
);
771 SAFEARRAY
*psa
= *ppsa
;
772 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
776 size
+= sizeof(ULONG
);
777 size
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
779 sftype
= SAFEARRAY_GetUnionType(psa
);
780 size
+= sizeof(ULONG
);
782 size
+= sizeof(ULONG
);
783 size
+= sizeof(ULONG_PTR
);
784 if (sftype
== SF_HAVEIID
)
787 size
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
789 size
+= sizeof(ULONG
);
797 for (lpBstr
= (BSTR
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
798 size
= BSTR_UserSize(pFlags
, size
, lpBstr
);
805 FIXME("size interfaces\n");
811 for (lpVariant
= (VARIANT
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
812 size
= VARIANT_UserSize(pFlags
, size
, lpVariant
);
818 IRecordInfo
* pRecInfo
= NULL
;
820 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
822 RpcRaiseException(hr
);
826 FIXME("size record info %p\n", pRecInfo
);
828 IRecordInfo_Release(pRecInfo
);
833 ALIGN_LENGTH(size
, 7);
838 size
+= ulCellCount
* psa
->cbElements
;
849 unsigned char * WINAPI
LPSAFEARRAY_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
853 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, &%p\n", Buffer
, *ppsa
);
855 ALIGN_POINTER(Buffer
, 3);
856 *(ULONG_PTR
*)Buffer
= *ppsa
? TRUE
: FALSE
;
857 Buffer
+= sizeof(ULONG_PTR
);
861 SAFEARRAY
*psa
= *ppsa
;
862 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
863 wireSAFEARRAY wiresa
;
867 *(ULONG
*)Buffer
= psa
->cDims
;
868 Buffer
+= sizeof(ULONG
);
869 wiresa
= (wireSAFEARRAY
)Buffer
;
870 wiresa
->cDims
= psa
->cDims
;
871 wiresa
->fFeatures
= psa
->fFeatures
;
872 wiresa
->cbElements
= psa
->cbElements
;
874 hr
= SafeArrayGetVartype(psa
, &vt
);
875 if (FAILED(hr
)) vt
= 0;
877 wiresa
->cLocks
= (USHORT
)psa
->cLocks
| (vt
<< 16);
879 Buffer
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
881 sftype
= SAFEARRAY_GetUnionType(psa
);
882 *(ULONG
*)Buffer
= sftype
;
883 Buffer
+= sizeof(ULONG
);
885 *(ULONG
*)Buffer
= ulCellCount
;
886 Buffer
+= sizeof(ULONG
);
887 *(ULONG_PTR
*)Buffer
= (ULONG_PTR
)psa
->pvData
;
888 Buffer
+= sizeof(ULONG_PTR
);
889 if (sftype
== SF_HAVEIID
)
891 SafeArrayGetIID(psa
, &guid
);
892 memcpy(Buffer
, &guid
, sizeof(guid
));
893 Buffer
+= sizeof(guid
);
896 memcpy(Buffer
, psa
->rgsabound
, sizeof(psa
->rgsabound
[0]) * psa
->cDims
);
897 Buffer
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
899 *(ULONG
*)Buffer
= ulCellCount
;
900 Buffer
+= sizeof(ULONG
);
910 for (lpBstr
= (BSTR
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
911 Buffer
= BSTR_UserMarshal(pFlags
, Buffer
, lpBstr
);
918 FIXME("marshal interfaces\n");
924 for (lpVariant
= (VARIANT
*)psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
925 Buffer
= VARIANT_UserMarshal(pFlags
, Buffer
, lpVariant
);
931 IRecordInfo
* pRecInfo
= NULL
;
933 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
935 RpcRaiseException(hr
);
939 FIXME("write record info %p\n", pRecInfo
);
941 IRecordInfo_Release(pRecInfo
);
947 ALIGN_POINTER(Buffer
, 7);
952 /* Just copy the data over */
953 memcpy(Buffer
, psa
->pvData
, ulCellCount
* psa
->cbElements
);
954 Buffer
+= ulCellCount
* psa
->cbElements
;
965 #define FADF_AUTOSETFLAGS (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
966 FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
967 FADF_VARIANT | FADF_CREATEVECTOR)
969 unsigned char * WINAPI
LPSAFEARRAY_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
972 wireSAFEARRAY wiresa
;
979 SAFEARRAYBOUND
*wiresab
;
981 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, %p\n", Buffer
, ppsa
);
983 ALIGN_POINTER(Buffer
, 3);
984 ptr
= *(ULONG_PTR
*)Buffer
;
985 Buffer
+= sizeof(ULONG_PTR
);
991 TRACE("NULL safe array unmarshaled\n");
996 cDims
= *(ULONG
*)Buffer
;
997 Buffer
+= sizeof(ULONG
);
999 wiresa
= (wireSAFEARRAY
)Buffer
;
1000 Buffer
+= FIELD_OFFSET(struct _wireSAFEARRAY
, uArrayStructs
);
1002 if (cDims
!= wiresa
->cDims
)
1003 RpcRaiseException(RPC_S_INVALID_BOUND
);
1005 /* FIXME: there should be a limit on how large cDims can be */
1007 vt
= HIWORD(wiresa
->cLocks
);
1009 sftype
= *(ULONG
*)Buffer
;
1010 Buffer
+= sizeof(ULONG
);
1012 cell_count
= *(ULONG
*)Buffer
;
1013 Buffer
+= sizeof(ULONG
);
1014 ptr
= *(ULONG_PTR
*)Buffer
;
1015 Buffer
+= sizeof(ULONG_PTR
);
1016 if (sftype
== SF_HAVEIID
)
1018 memcpy(&guid
, Buffer
, sizeof(guid
));
1019 Buffer
+= sizeof(guid
);
1022 wiresab
= (SAFEARRAYBOUND
*)Buffer
;
1023 Buffer
+= sizeof(wiresab
[0]) * wiresa
->cDims
;
1026 *ppsa
= SafeArrayCreateEx(vt
, wiresa
->cDims
, wiresab
, NULL
);
1029 SafeArrayAllocDescriptor(wiresa
->cDims
, ppsa
);
1031 memcpy((*ppsa
)->rgsabound
, wiresab
, sizeof(SAFEARRAYBOUND
) * wiresa
->cDims
);
1034 RpcRaiseException(E_OUTOFMEMORY
);
1036 /* be careful about which flags we set since they could be a security
1038 (*ppsa
)->fFeatures
&= FADF_AUTOSETFLAGS
;
1039 (*ppsa
)->fFeatures
|= (wiresa
->fFeatures
& ~(FADF_AUTOSETFLAGS
));
1040 /* FIXME: there should be a limit on how large wiresa->cbElements can be */
1041 (*ppsa
)->cbElements
= wiresa
->cbElements
;
1042 (*ppsa
)->cLocks
= LOWORD(wiresa
->cLocks
);
1044 hr
= SafeArrayAllocData(*ppsa
);
1046 RpcRaiseException(hr
);
1048 if ((*(ULONG
*)Buffer
!= cell_count
) || (SAFEARRAY_GetCellCount(*ppsa
) != cell_count
))
1049 RpcRaiseException(RPC_S_INVALID_BOUND
);
1050 Buffer
+= sizeof(ULONG
);
1060 for (lpBstr
= (BSTR
*)(*ppsa
)->pvData
; cell_count
; cell_count
--, lpBstr
++)
1061 Buffer
= BSTR_UserUnmarshal(pFlags
, Buffer
, lpBstr
);
1068 FIXME("marshal interfaces\n");
1074 for (lpVariant
= (VARIANT
*)(*ppsa
)->pvData
; cell_count
; cell_count
--, lpVariant
++)
1075 Buffer
= VARIANT_UserUnmarshal(pFlags
, Buffer
, lpVariant
);
1081 FIXME("set record info\n");
1087 ALIGN_POINTER(Buffer
, 7);
1092 /* Just copy the data over */
1093 memcpy((*ppsa
)->pvData
, Buffer
, cell_count
* (*ppsa
)->cbElements
);
1094 Buffer
+= cell_count
* (*ppsa
)->cbElements
;
1101 TRACE("safe array unmarshaled: %p\n", *ppsa
);
1106 void WINAPI
LPSAFEARRAY_UserFree(ULONG
*pFlags
, LPSAFEARRAY
*ppsa
)
1108 TRACE("("); dump_user_flags(pFlags
); TRACE(", &%p\n", *ppsa
);
1110 SafeArrayDestroy(*ppsa
);
1114 /* exactly how Invoke is marshalled is not very clear to me yet,
1115 * but the way I've done it seems to work for me */
1117 HRESULT CALLBACK
IDispatch_Invoke_Proxy(
1119 DISPID dispIdMember
,
1123 DISPPARAMS
* pDispParams
,
1124 VARIANT
* pVarResult
,
1125 EXCEPINFO
* pExcepInfo
,
1130 UINT
* rgVarRefIdx
= NULL
;
1131 VARIANTARG
* rgVarRef
= NULL
;
1134 EXCEPINFO ExcepInfo
;
1136 TRACE("(%p)->(%d,%s,%x,%x,%p,%p,%p,%p)\n", This
,
1137 dispIdMember
, debugstr_guid(riid
),
1138 lcid
, wFlags
, pDispParams
, pVarResult
,
1139 pExcepInfo
, puArgErr
);
1141 /* [out] args can't be null, use dummy vars if needed */
1142 if (!pVarResult
) pVarResult
= &VarResult
;
1143 if (!puArgErr
) puArgErr
= &uArgErr
;
1144 if (!pExcepInfo
) pExcepInfo
= &ExcepInfo
;
1146 /* count by-ref args */
1147 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
1148 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
1149 if (V_ISBYREF(arg
)) {
1154 rgVarRefIdx
= CoTaskMemAlloc(sizeof(UINT
)*cVarRef
);
1155 rgVarRef
= CoTaskMemAlloc(sizeof(VARIANTARG
)*cVarRef
);
1156 /* make list of by-ref args */
1157 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
1158 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
1159 if (V_ISBYREF(arg
)) {
1160 rgVarRefIdx
[cVarRef
] = u
;
1161 VariantInit(&rgVarRef
[cVarRef
]);
1166 /* [out] args still can't be null,
1167 * but we can point these anywhere in this case,
1168 * since they won't be written to when cVarRef is 0 */
1169 rgVarRefIdx
= puArgErr
;
1170 rgVarRef
= pVarResult
;
1172 TRACE("passed by ref: %d args\n", cVarRef
);
1173 hr
= IDispatch_RemoteInvoke_Proxy(This
,
1186 for (u
=0; u
<cVarRef
; u
++) {
1187 unsigned i
= rgVarRefIdx
[u
];
1188 VariantCopy(&pDispParams
->rgvarg
[i
],
1190 VariantClear(&rgVarRef
[u
]);
1192 CoTaskMemFree(rgVarRef
);
1193 CoTaskMemFree(rgVarRefIdx
);
1196 if(pExcepInfo
== &ExcepInfo
)
1198 SysFreeString(pExcepInfo
->bstrSource
);
1199 SysFreeString(pExcepInfo
->bstrDescription
);
1200 SysFreeString(pExcepInfo
->bstrHelpFile
);
1205 HRESULT __RPC_STUB
IDispatch_Invoke_Stub(
1207 DISPID dispIdMember
,
1211 DISPPARAMS
* pDispParams
,
1212 VARIANT
* pVarResult
,
1213 EXCEPINFO
* pExcepInfo
,
1217 VARIANTARG
* rgVarRef
)
1220 VARIANTARG
*rgvarg
, *arg
;
1223 /* initialize out parameters, so that they can be marshalled
1224 * in case the real Invoke doesn't initialize them */
1225 VariantInit(pVarResult
);
1226 memset(pExcepInfo
, 0, sizeof(*pExcepInfo
));
1229 /* let the real Invoke operate on a copy of the in parameters,
1230 * so we don't risk losing pointers to allocated memory */
1231 rgvarg
= pDispParams
->rgvarg
;
1232 arg
= CoTaskMemAlloc(sizeof(VARIANTARG
)*pDispParams
->cArgs
);
1233 if (!arg
) return E_OUTOFMEMORY
;
1235 /* init all args so we can call VariantClear on all the args if the copy
1237 for (u
= 0; u
< pDispParams
->cArgs
; u
++)
1238 VariantInit(&arg
[u
]);
1240 for (u
= 0; u
< pDispParams
->cArgs
; u
++) {
1241 hr
= VariantCopy(&arg
[u
], &rgvarg
[u
]);
1246 if (SUCCEEDED(hr
)) {
1247 pDispParams
->rgvarg
= arg
;
1249 hr
= IDispatch_Invoke(This
,
1259 /* copy ref args to out list */
1260 for (u
=0; u
<cVarRef
; u
++) {
1261 unsigned i
= rgVarRefIdx
[u
];
1262 VariantInit(&rgVarRef
[u
]);
1263 VariantCopy(&rgVarRef
[u
], &arg
[i
]);
1264 /* clear original if equal, to avoid double-free */
1265 if (V_BYREF(&rgVarRef
[u
]) == V_BYREF(&rgvarg
[i
]))
1266 VariantClear(&rgvarg
[i
]);
1270 /* clear the duplicate argument list */
1271 for (u
=0; u
<pDispParams
->cArgs
; u
++)
1272 VariantClear(&arg
[u
]);
1274 pDispParams
->rgvarg
= rgvarg
;
1282 HRESULT CALLBACK
IEnumVARIANT_Next_Proxy(
1286 ULONG
* pCeltFetched
)
1290 pCeltFetched
= &fetched
;
1291 return IEnumVARIANT_RemoteNext_Proxy(This
,
1297 HRESULT __RPC_STUB
IEnumVARIANT_Next_Stub(
1301 ULONG
* pCeltFetched
)
1305 hr
= IEnumVARIANT_Next(This
,
1309 if (hr
== S_OK
) *pCeltFetched
= celt
;
1313 /* TypeInfo related freers */
1315 static void free_embedded_typedesc(TYPEDESC
*tdesc
);
1316 static void free_embedded_arraydesc(ARRAYDESC
*adesc
)
1318 switch(adesc
->tdescElem
.vt
)
1322 free_embedded_typedesc(adesc
->tdescElem
.u
.lptdesc
);
1323 CoTaskMemFree(adesc
->tdescElem
.u
.lptdesc
);
1326 free_embedded_arraydesc(adesc
->tdescElem
.u
.lpadesc
);
1327 CoTaskMemFree(adesc
->tdescElem
.u
.lpadesc
);
1332 static void free_embedded_typedesc(TYPEDESC
*tdesc
)
1338 free_embedded_typedesc(tdesc
->u
.lptdesc
);
1339 CoTaskMemFree(tdesc
->u
.lptdesc
);
1342 free_embedded_arraydesc(tdesc
->u
.lpadesc
);
1343 CoTaskMemFree(tdesc
->u
.lpadesc
);
1348 static void free_embedded_elemdesc(ELEMDESC
*edesc
)
1350 free_embedded_typedesc(&edesc
->tdesc
);
1351 if(edesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
1352 CoTaskMemFree(edesc
->u
.paramdesc
.pparamdescex
);
1357 HRESULT CALLBACK
ITypeComp_Bind_Proxy(
1362 ITypeInfo
** ppTInfo
,
1363 DESCKIND
* pDescKind
,
1366 FIXME("not implemented\n");
1370 HRESULT __RPC_STUB
ITypeComp_Bind_Stub(
1375 ITypeInfo
** ppTInfo
,
1376 DESCKIND
* pDescKind
,
1377 LPFUNCDESC
* ppFuncDesc
,
1378 LPVARDESC
* ppVarDesc
,
1379 ITypeComp
** ppTypeComp
,
1380 CLEANLOCALSTORAGE
* pDummy
)
1382 FIXME("not implemented\n");
1386 HRESULT CALLBACK
ITypeComp_BindType_Proxy(
1390 ITypeInfo
** ppTInfo
,
1391 ITypeComp
** ppTComp
)
1393 FIXME("not implemented\n");
1397 HRESULT __RPC_STUB
ITypeComp_BindType_Stub(
1401 ITypeInfo
** ppTInfo
)
1403 FIXME("not implemented\n");
1409 HRESULT CALLBACK
ITypeInfo_GetTypeAttr_Proxy(
1411 TYPEATTR
** ppTypeAttr
)
1414 CLEANLOCALSTORAGE stg
;
1415 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1418 stg
.pStorage
= NULL
;
1419 stg
.pInterface
= NULL
;
1421 return ITypeInfo_RemoteGetTypeAttr_Proxy(This
, ppTypeAttr
, &stg
);
1424 HRESULT __RPC_STUB
ITypeInfo_GetTypeAttr_Stub(
1426 LPTYPEATTR
* ppTypeAttr
,
1427 CLEANLOCALSTORAGE
* pDummy
)
1430 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1432 hr
= ITypeInfo_GetTypeAttr(This
, ppTypeAttr
);
1436 pDummy
->flags
= CLS_TYPEATTR
;
1437 ITypeInfo_AddRef(This
);
1438 pDummy
->pInterface
= (IUnknown
*)This
;
1439 pDummy
->pStorage
= ppTypeAttr
;
1443 HRESULT CALLBACK
ITypeInfo_GetFuncDesc_Proxy(
1446 FUNCDESC
** ppFuncDesc
)
1448 CLEANLOCALSTORAGE stg
;
1449 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1452 stg
.pStorage
= NULL
;
1453 stg
.pInterface
= NULL
;
1455 return ITypeInfo_RemoteGetFuncDesc_Proxy(This
, index
, ppFuncDesc
, &stg
);
1458 HRESULT __RPC_STUB
ITypeInfo_GetFuncDesc_Stub(
1461 LPFUNCDESC
* ppFuncDesc
,
1462 CLEANLOCALSTORAGE
* pDummy
)
1465 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1467 hr
= ITypeInfo_GetFuncDesc(This
, index
, ppFuncDesc
);
1471 pDummy
->flags
= CLS_FUNCDESC
;
1472 ITypeInfo_AddRef(This
);
1473 pDummy
->pInterface
= (IUnknown
*)This
;
1474 pDummy
->pStorage
= ppFuncDesc
;
1478 HRESULT CALLBACK
ITypeInfo_GetVarDesc_Proxy(
1481 VARDESC
** ppVarDesc
)
1483 CLEANLOCALSTORAGE stg
;
1484 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1487 stg
.pStorage
= NULL
;
1488 stg
.pInterface
= NULL
;
1490 return ITypeInfo_RemoteGetVarDesc_Proxy(This
, index
, ppVarDesc
, &stg
);
1493 HRESULT __RPC_STUB
ITypeInfo_GetVarDesc_Stub(
1496 LPVARDESC
* ppVarDesc
,
1497 CLEANLOCALSTORAGE
* pDummy
)
1500 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1502 hr
= ITypeInfo_GetVarDesc(This
, index
, ppVarDesc
);
1506 pDummy
->flags
= CLS_VARDESC
;
1507 ITypeInfo_AddRef(This
);
1508 pDummy
->pInterface
= (IUnknown
*)This
;
1509 pDummy
->pStorage
= ppVarDesc
;
1513 HRESULT CALLBACK
ITypeInfo_GetNames_Proxy(
1520 FIXME("not implemented\n");
1524 HRESULT __RPC_STUB
ITypeInfo_GetNames_Stub(
1531 FIXME("not implemented\n");
1535 HRESULT CALLBACK
ITypeInfo_GetIDsOfNames_Proxy(
1537 LPOLESTR
* rgszNames
,
1541 FIXME("not implemented\n");
1545 HRESULT __RPC_STUB
ITypeInfo_GetIDsOfNames_Stub(
1548 FIXME("not implemented\n");
1552 HRESULT CALLBACK
ITypeInfo_Invoke_Proxy(
1557 DISPPARAMS
* pDispParams
,
1558 VARIANT
* pVarResult
,
1559 EXCEPINFO
* pExcepInfo
,
1562 FIXME("not implemented\n");
1566 HRESULT __RPC_STUB
ITypeInfo_Invoke_Stub(
1569 FIXME("not implemented\n");
1573 HRESULT CALLBACK
ITypeInfo_GetDocumentation_Proxy(
1577 BSTR
* pBstrDocString
,
1578 DWORD
* pdwHelpContext
,
1579 BSTR
* pBstrHelpFile
)
1582 BSTR name
, doc_string
, help_file
;
1584 TRACE("(%p, %08x, %p, %p, %p, %p)\n", This
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
1586 /* FIXME: presumably refPtrFlags is supposed to be a bitmask of which ptrs we actually want? */
1587 hr
= ITypeInfo_RemoteGetDocumentation_Proxy(This
, memid
, 0, &name
, &doc_string
, &help_context
, &help_file
);
1590 if(pBstrName
) *pBstrName
= name
;
1591 else SysFreeString(name
);
1593 if(pBstrDocString
) *pBstrDocString
= doc_string
;
1594 else SysFreeString(doc_string
);
1596 if(pBstrHelpFile
) *pBstrHelpFile
= help_file
;
1597 else SysFreeString(help_file
);
1599 if(pdwHelpContext
) *pdwHelpContext
= help_context
;
1604 HRESULT __RPC_STUB
ITypeInfo_GetDocumentation_Stub(
1609 BSTR
* pBstrDocString
,
1610 DWORD
* pdwHelpContext
,
1611 BSTR
* pBstrHelpFile
)
1613 TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This
, memid
, refPtrFlags
, pBstrName
, pBstrDocString
,
1614 pdwHelpContext
, pBstrHelpFile
);
1615 return ITypeInfo_GetDocumentation(This
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
1618 HRESULT CALLBACK
ITypeInfo_GetDllEntry_Proxy(
1626 FIXME("not implemented\n");
1630 HRESULT __RPC_STUB
ITypeInfo_GetDllEntry_Stub(
1639 FIXME("not implemented\n");
1643 HRESULT CALLBACK
ITypeInfo_AddressOfMember_Proxy(
1649 FIXME("not implemented\n");
1653 HRESULT __RPC_STUB
ITypeInfo_AddressOfMember_Stub(
1656 FIXME("not implemented\n");
1660 HRESULT CALLBACK
ITypeInfo_CreateInstance_Proxy(
1662 IUnknown
* pUnkOuter
,
1666 FIXME("not implemented\n");
1670 HRESULT __RPC_STUB
ITypeInfo_CreateInstance_Stub(
1675 FIXME("not implemented\n");
1679 HRESULT CALLBACK
ITypeInfo_GetContainingTypeLib_Proxy(
1688 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1690 hr
= ITypeInfo_RemoteGetContainingTypeLib_Proxy(This
, &pTL
, &index
);
1699 ITypeLib_Release(pTL
);
1704 HRESULT __RPC_STUB
ITypeInfo_GetContainingTypeLib_Stub(
1709 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1710 return ITypeInfo_GetContainingTypeLib(This
, ppTLib
, pIndex
);
1713 void CALLBACK
ITypeInfo_ReleaseTypeAttr_Proxy(
1715 TYPEATTR
* pTypeAttr
)
1717 TRACE("(%p, %p)\n", This
, pTypeAttr
);
1718 free_embedded_typedesc(&pTypeAttr
->tdescAlias
);
1719 CoTaskMemFree(pTypeAttr
);
1722 HRESULT __RPC_STUB
ITypeInfo_ReleaseTypeAttr_Stub(
1725 TRACE("nothing to do\n");
1729 void CALLBACK
ITypeInfo_ReleaseFuncDesc_Proxy(
1731 FUNCDESC
* pFuncDesc
)
1734 TRACE("(%p, %p)\n", This
, pFuncDesc
);
1736 for(param
= 0; param
< pFuncDesc
->cParams
; param
++)
1737 free_embedded_elemdesc(pFuncDesc
->lprgelemdescParam
+ param
);
1739 CoTaskMemFree(pFuncDesc
->lprgelemdescParam
);
1741 free_embedded_elemdesc(&pFuncDesc
->elemdescFunc
);
1743 if(pFuncDesc
->cScodes
!= 0 && pFuncDesc
->cScodes
!= -1)
1744 CoTaskMemFree(pFuncDesc
->lprgscode
);
1746 CoTaskMemFree(pFuncDesc
);
1749 HRESULT __RPC_STUB
ITypeInfo_ReleaseFuncDesc_Stub(
1752 TRACE("nothing to do\n");
1756 void CALLBACK
ITypeInfo_ReleaseVarDesc_Proxy(
1760 TRACE("(%p, %p)\n", This
, pVarDesc
);
1762 CoTaskMemFree(pVarDesc
->lpstrSchema
);
1764 if(pVarDesc
->varkind
== VAR_CONST
)
1765 CoTaskMemFree(pVarDesc
->u
.lpvarValue
);
1767 free_embedded_elemdesc(&pVarDesc
->elemdescVar
);
1768 CoTaskMemFree(pVarDesc
);
1771 HRESULT __RPC_STUB
ITypeInfo_ReleaseVarDesc_Stub(
1774 TRACE("nothing to do\n");
1781 HRESULT CALLBACK
ITypeInfo2_GetDocumentation2_Proxy(
1785 BSTR
* pbstrHelpString
,
1786 DWORD
* pdwHelpStringContext
,
1787 BSTR
* pbstrHelpStringDll
)
1789 FIXME("not implemented\n");
1793 HRESULT __RPC_STUB
ITypeInfo2_GetDocumentation2_Stub(
1798 BSTR
* pbstrHelpString
,
1799 DWORD
* pdwHelpStringContext
,
1800 BSTR
* pbstrHelpStringDll
)
1802 FIXME("not implemented\n");
1808 UINT CALLBACK
ITypeLib_GetTypeInfoCount_Proxy(
1812 TRACE("(%p)\n", This
);
1814 ITypeLib_RemoteGetTypeInfoCount_Proxy(This
, &count
);
1819 HRESULT __RPC_STUB
ITypeLib_GetTypeInfoCount_Stub(
1823 TRACE("(%p, %p)\n", This
, pcTInfo
);
1824 *pcTInfo
= ITypeLib_GetTypeInfoCount(This
);
1828 HRESULT CALLBACK
ITypeLib_GetLibAttr_Proxy(
1830 TLIBATTR
** ppTLibAttr
)
1832 CLEANLOCALSTORAGE stg
;
1833 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1836 stg
.pStorage
= NULL
;
1837 stg
.pInterface
= NULL
;
1839 return ITypeLib_RemoteGetLibAttr_Proxy(This
, ppTLibAttr
, &stg
);
1842 HRESULT __RPC_STUB
ITypeLib_GetLibAttr_Stub(
1844 LPTLIBATTR
* ppTLibAttr
,
1845 CLEANLOCALSTORAGE
* pDummy
)
1848 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1850 hr
= ITypeLib_GetLibAttr(This
, ppTLibAttr
);
1854 pDummy
->flags
= CLS_LIBATTR
;
1855 ITypeLib_AddRef(This
);
1856 pDummy
->pInterface
= (IUnknown
*)This
;
1857 pDummy
->pStorage
= ppTLibAttr
;
1861 HRESULT CALLBACK
ITypeLib_GetDocumentation_Proxy(
1865 BSTR
* pBstrDocString
,
1866 DWORD
* pdwHelpContext
,
1867 BSTR
* pBstrHelpFile
)
1869 FIXME("not implemented\n");
1873 HRESULT __RPC_STUB
ITypeLib_GetDocumentation_Stub(
1878 BSTR
* pBstrDocString
,
1879 DWORD
* pdwHelpContext
,
1880 BSTR
* pBstrHelpFile
)
1882 FIXME("not implemented\n");
1886 HRESULT CALLBACK
ITypeLib_IsName_Proxy(
1892 FIXME("not implemented\n");
1896 HRESULT __RPC_STUB
ITypeLib_IsName_Stub(
1903 FIXME("not implemented\n");
1907 HRESULT CALLBACK
ITypeLib_FindName_Proxy(
1911 ITypeInfo
** ppTInfo
,
1915 FIXME("not implemented\n");
1919 HRESULT __RPC_STUB
ITypeLib_FindName_Stub(
1923 ITypeInfo
** ppTInfo
,
1928 FIXME("not implemented\n");
1932 void CALLBACK
ITypeLib_ReleaseTLibAttr_Proxy(
1934 TLIBATTR
* pTLibAttr
)
1936 TRACE("(%p, %p)\n", This
, pTLibAttr
);
1937 CoTaskMemFree(pTLibAttr
);
1940 HRESULT __RPC_STUB
ITypeLib_ReleaseTLibAttr_Stub(
1943 TRACE("nothing to do\n");
1950 HRESULT CALLBACK
ITypeLib2_GetLibStatistics_Proxy(
1952 ULONG
* pcUniqueNames
,
1953 ULONG
* pcchUniqueNames
)
1955 FIXME("not implemented\n");
1959 HRESULT __RPC_STUB
ITypeLib2_GetLibStatistics_Stub(
1961 ULONG
* pcUniqueNames
,
1962 ULONG
* pcchUniqueNames
)
1964 FIXME("not implemented\n");
1968 HRESULT CALLBACK
ITypeLib2_GetDocumentation2_Proxy(
1972 BSTR
* pbstrHelpString
,
1973 DWORD
* pdwHelpStringContext
,
1974 BSTR
* pbstrHelpStringDll
)
1976 FIXME("not implemented\n");
1980 HRESULT __RPC_STUB
ITypeLib2_GetDocumentation2_Stub(
1985 BSTR
* pbstrHelpString
,
1986 DWORD
* pdwHelpStringContext
,
1987 BSTR
* pbstrHelpStringDll
)
1989 FIXME("not implemented\n");