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
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
42 #define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
43 #define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
44 #define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
45 #define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
47 /* ole32 exports those, not defined in public headers */
48 ULONG __RPC_USER
WdtpInterfacePointer_UserSize(ULONG
*, ULONG
, ULONG
, IUnknown
*, REFIID
);
49 unsigned char * __RPC_USER
WdtpInterfacePointer_UserMarshal(ULONG
*, ULONG
, unsigned char*, IUnknown
*, REFIID
);
50 unsigned char * __RPC_USER
WdtpInterfacePointer_UserUnmarshal(ULONG
*, unsigned char*, IUnknown
**, REFIID
);
52 static void dump_user_flags(const ULONG
*pFlags
)
54 if (HIWORD(*pFlags
) == NDR_LOCAL_DATA_REPRESENTATION
)
55 TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
57 TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags
));
58 switch (LOWORD(*pFlags
))
60 case MSHCTX_LOCAL
: TRACE("MSHCTX_LOCAL)"); break;
61 case MSHCTX_NOSHAREDMEM
: TRACE("MSHCTX_NOSHAREDMEM)"); break;
62 case MSHCTX_DIFFERENTMACHINE
: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
63 case MSHCTX_INPROC
: TRACE("MSHCTX_INPROC)"); break;
64 default: TRACE("%d)", LOWORD(*pFlags
));
68 /* CLEANLOCALSTORAGE */
70 #define CLS_FUNCDESC 'f'
71 #define CLS_LIBATTR 'l'
72 #define CLS_TYPEATTR 't'
73 #define CLS_VARDESC 'v'
75 ULONG WINAPI
CLEANLOCALSTORAGE_UserSize(ULONG
*pFlags
, ULONG Start
, CLEANLOCALSTORAGE
*pstg
)
77 ALIGN_LENGTH(Start
, 3);
78 return Start
+ sizeof(DWORD
);
81 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstg
)
83 ALIGN_POINTER(Buffer
, 3);
84 *(DWORD
*)Buffer
= pstg
->flags
;
88 ITypeLib_ReleaseTLibAttr((ITypeLib
*)pstg
->pInterface
, *(TLIBATTR
**)pstg
->pStorage
);
91 ITypeInfo_ReleaseTypeAttr((ITypeInfo
*)pstg
->pInterface
, *(TYPEATTR
**)pstg
->pStorage
);
94 ITypeInfo_ReleaseFuncDesc((ITypeInfo
*)pstg
->pInterface
, *(FUNCDESC
**)pstg
->pStorage
);
97 ITypeInfo_ReleaseVarDesc((ITypeInfo
*)pstg
->pInterface
, *(VARDESC
**)pstg
->pStorage
);
101 ERR("Unknown type %x\n", pstg
->flags
);
104 *(VOID
**)pstg
->pStorage
= NULL
;
105 IUnknown_Release(pstg
->pInterface
);
106 pstg
->pInterface
= NULL
;
108 return Buffer
+ sizeof(DWORD
);
111 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstr
)
113 ALIGN_POINTER(Buffer
, 3);
114 pstr
->flags
= *(DWORD
*)Buffer
;
115 return Buffer
+ sizeof(DWORD
);
118 void WINAPI
CLEANLOCALSTORAGE_UserFree(ULONG
*pFlags
, CLEANLOCALSTORAGE
*pstr
)
127 DWORD len
; /* No. of chars not including trailing '\0' */
128 DWORD byte_len
; /* len * 2 or 0xffffffff if len == 0 */
129 DWORD len2
; /* == len */
132 ULONG WINAPI
BSTR_UserSize(ULONG
*pFlags
, ULONG Start
, BSTR
*pstr
)
134 TRACE("(%x,%d,%p) => %p\n", *pFlags
, Start
, pstr
, *pstr
);
135 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
136 ALIGN_LENGTH(Start
, 3);
137 Start
+= sizeof(bstr_wire_t
) + ((SysStringByteLen(*pstr
) + 1) & ~1);
138 TRACE("returning %d\n", Start
);
142 unsigned char * WINAPI
BSTR_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
145 DWORD len
= SysStringByteLen(*pstr
);
147 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
148 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
150 ALIGN_POINTER(Buffer
, 3);
151 header
= (bstr_wire_t
*)Buffer
;
152 header
->len
= header
->len2
= (len
+ 1) / 2;
155 header
->byte_len
= len
;
156 memcpy(header
+ 1, *pstr
, header
->len
* 2);
159 header
->byte_len
= 0xffffffff; /* special case for a null bstr */
161 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
164 unsigned char * WINAPI
BSTR_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
167 TRACE("(%x,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
169 ALIGN_POINTER(Buffer
, 3);
170 header
= (bstr_wire_t
*)Buffer
;
171 if(header
->len
!= header
->len2
)
172 FIXME("len %08x != len2 %08x\n", header
->len
, header
->len2
);
174 if (header
->byte_len
== 0xffffffff)
176 SysFreeString(*pstr
);
179 else SysReAllocStringLen( pstr
, (OLECHAR
*)(header
+ 1), header
->len
);
181 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
182 return Buffer
+ sizeof(*header
) + sizeof(OLECHAR
) * header
->len
;
185 void WINAPI
BSTR_UserFree(ULONG
*pFlags
, BSTR
*pstr
)
187 TRACE("(%x,%p) => %p\n", *pFlags
, pstr
, *pstr
);
188 SysFreeString(*pstr
);
205 unsigned int get_type_size(ULONG
*pFlags
, VARTYPE vt
)
207 if (vt
& VT_ARRAY
) return 4;
209 switch (vt
& ~VT_BYREF
) {
218 return sizeof(SHORT
);
227 return sizeof(FLOAT
);
229 return sizeof(DOUBLE
);
231 return sizeof(VARIANT_BOOL
);
233 return sizeof(SCODE
);
239 return sizeof(DECIMAL
);
241 return sizeof(ULONG
);
243 return sizeof(VARIANT
);
249 FIXME("unhandled VT %d\n", vt
);
254 static unsigned int get_type_alignment(ULONG
*pFlags
, VARTYPE vt
)
256 unsigned int size
= get_type_size(pFlags
, vt
);
257 if(vt
& VT_BYREF
) return 3;
258 if(size
== 0) return 0;
259 if(size
<= 4) return size
- 1;
263 /* WdtpInterfacePointer_UserSize takes care of 2 additional DWORDs to store marshalling buffer size */
264 static unsigned interface_variant_size(ULONG
*pFlags
, REFIID riid
, IUnknown
*punk
)
270 size
= WdtpInterfacePointer_UserSize(pFlags
, LOWORD(*pFlags
), 0, punk
, riid
);
273 ERR("interface variant buffer size calculation failed\n");
277 size
+= sizeof(ULONG
);
278 TRACE("wire-size extra of interface variant is %d\n", size
);
282 static ULONG
wire_extra_user_size(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
287 return LPSAFEARRAY_UserSize(pFlags
, Start
, V_ARRAYREF(pvar
));
289 return LPSAFEARRAY_UserSize(pFlags
, Start
, &V_ARRAY(pvar
));
292 switch (V_VT(pvar
)) {
294 return BSTR_UserSize(pFlags
, Start
, &V_BSTR(pvar
));
295 case VT_BSTR
| VT_BYREF
:
296 return BSTR_UserSize(pFlags
, Start
, V_BSTRREF(pvar
));
297 case VT_VARIANT
| VT_BYREF
:
298 return VARIANT_UserSize(pFlags
, Start
, V_VARIANTREF(pvar
));
300 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, V_UNKNOWN(pvar
));
301 case VT_UNKNOWN
| VT_BYREF
:
302 return Start
+ interface_variant_size(pFlags
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
304 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
305 case VT_DISPATCH
| VT_BYREF
:
306 return Start
+ interface_variant_size(pFlags
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
308 FIXME("wire-size record\n");
311 case VT_SAFEARRAY
| VT_BYREF
:
312 FIXME("wire-size safearray: shouldn't be marshaling this\n");
319 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer */
320 static unsigned char* interface_variant_marshal(ULONG
*pFlags
, unsigned char *Buffer
,
321 REFIID riid
, IUnknown
*punk
)
323 TRACE("pFlags=%d, Buffer=%p, pUnk=%p\n", *pFlags
, Buffer
, punk
);
325 /* first DWORD is used to store pointer itself, truncated on win64 */
328 memset(Buffer
, 0, sizeof(ULONG
));
329 return Buffer
+ sizeof(ULONG
);
333 *(DWORD
*)Buffer
= (DWORD_PTR
)punk
;
334 Buffer
+= sizeof(DWORD
);
337 return WdtpInterfacePointer_UserMarshal(pFlags
, LOWORD(*pFlags
), Buffer
, punk
, riid
);
340 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer */
341 static unsigned char *interface_variant_unmarshal(ULONG
*pFlags
, unsigned char *Buffer
,
342 REFIID riid
, IUnknown
**ppunk
)
346 TRACE("pFlags=%d, Buffer=%p, ppUnk=%p\n", *pFlags
, Buffer
, ppunk
);
348 /* skip pointer part itself */
349 ptr
= *(DWORD
*)Buffer
;
350 Buffer
+= sizeof(DWORD
);
355 return WdtpInterfacePointer_UserUnmarshal(pFlags
, Buffer
, ppunk
, riid
);
358 ULONG WINAPI
VARIANT_UserSize(ULONG
*pFlags
, ULONG Start
, VARIANT
*pvar
)
361 TRACE("(%x,%d,%p)\n", *pFlags
, Start
, pvar
);
362 TRACE("vt=%04x\n", V_VT(pvar
));
364 ALIGN_LENGTH(Start
, 7);
365 Start
+= sizeof(variant_wire_t
);
366 if(V_VT(pvar
) & VT_BYREF
)
369 align
= get_type_alignment(pFlags
, V_VT(pvar
));
370 ALIGN_LENGTH(Start
, align
);
371 if(V_VT(pvar
) == (VT_VARIANT
| VT_BYREF
))
374 Start
+= get_type_size(pFlags
, V_VT(pvar
));
375 Start
= wire_extra_user_size(pFlags
, Start
, pvar
);
377 TRACE("returning %d\n", Start
);
381 unsigned char * WINAPI
VARIANT_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
383 variant_wire_t
*header
;
388 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
389 TRACE("vt=%04x\n", V_VT(pvar
));
391 ALIGN_POINTER(Buffer
, 7);
393 header
= (variant_wire_t
*)Buffer
;
395 header
->clSize
= 0; /* fixed up at the end */
396 header
->rpcReserved
= 0;
397 header
->vt
= pvar
->n1
.n2
.vt
;
398 header
->wReserved1
= pvar
->n1
.n2
.wReserved1
;
399 header
->wReserved2
= pvar
->n1
.n2
.wReserved2
;
400 header
->wReserved3
= pvar
->n1
.n2
.wReserved3
;
401 header
->switch_is
= pvar
->n1
.n2
.vt
;
402 if(header
->switch_is
& VT_ARRAY
)
403 header
->switch_is
&= ~VT_TYPEMASK
;
405 Pos
= (unsigned char*)(header
+ 1);
406 type_size
= get_type_size(pFlags
, V_VT(pvar
));
407 align
= get_type_alignment(pFlags
, V_VT(pvar
));
408 ALIGN_POINTER(Pos
, align
);
410 if(header
->vt
& VT_BYREF
)
412 *(DWORD
*)Pos
= max(type_size
, 4);
414 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
416 memcpy(Pos
, pvar
->n1
.n2
.n3
.byref
, type_size
);
421 *(DWORD
*)Pos
= 'U' | 's' << 8 | 'e' << 16 | 'r' << 24;
427 if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
428 memcpy(Pos
, pvar
, type_size
);
430 memcpy(Pos
, &pvar
->n1
.n2
.n3
, type_size
);
434 if(header
->vt
& VT_ARRAY
)
436 if(header
->vt
& VT_BYREF
)
437 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
439 Pos
= LPSAFEARRAY_UserMarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
446 Pos
= BSTR_UserMarshal(pFlags
, Pos
, &V_BSTR(pvar
));
448 case VT_BSTR
| VT_BYREF
:
449 Pos
= BSTR_UserMarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
451 case VT_VARIANT
| VT_BYREF
:
452 Pos
= VARIANT_UserMarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
455 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWN(pvar
));
457 case VT_UNKNOWN
| VT_BYREF
:
458 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, *V_UNKNOWNREF(pvar
));
461 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)V_DISPATCH(pvar
));
463 case VT_DISPATCH
| VT_BYREF
:
464 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
*)*V_DISPATCHREF(pvar
));
467 FIXME("handle BRECORD by val\n");
469 case VT_RECORD
| VT_BYREF
:
470 FIXME("handle BRECORD by ref\n");
474 header
->clSize
= ((Pos
- Buffer
) + 7) >> 3;
475 TRACE("marshalled size=%d\n", header
->clSize
);
479 unsigned char * WINAPI
VARIANT_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
481 variant_wire_t
*header
;
486 TRACE("(%x,%p,%p)\n", *pFlags
, Buffer
, pvar
);
488 ALIGN_POINTER(Buffer
, 7);
490 header
= (variant_wire_t
*)Buffer
;
492 Pos
= (unsigned char*)(header
+ 1);
493 type_size
= get_type_size(pFlags
, header
->vt
);
494 align
= get_type_alignment(pFlags
, header
->vt
);
495 ALIGN_POINTER(Pos
, align
);
497 if(header
->vt
& VT_BYREF
)
502 switch (header
->vt
& ~VT_BYREF
)
504 /* these types have a different memory size compared to wire size */
508 mem_size
= sizeof(void *);
511 mem_size
= type_size
;
515 if (V_VT(pvar
) != header
->vt
)
518 V_BYREF(pvar
) = CoTaskMemAlloc(mem_size
);
519 memset(V_BYREF(pvar
), 0, mem_size
);
521 else if (!V_BYREF(pvar
))
523 V_BYREF(pvar
) = CoTaskMemAlloc(mem_size
);
524 memset(V_BYREF(pvar
), 0, mem_size
);
527 if(!(header
->vt
& VT_ARRAY
)
528 && (header
->vt
& VT_TYPEMASK
) != VT_BSTR
529 && (header
->vt
& VT_TYPEMASK
) != VT_VARIANT
530 && (header
->vt
& VT_TYPEMASK
) != VT_UNKNOWN
531 && (header
->vt
& VT_TYPEMASK
) != VT_DISPATCH
532 && (header
->vt
& VT_TYPEMASK
) != VT_RECORD
)
533 memcpy(V_BYREF(pvar
), Pos
, type_size
);
535 if((header
->vt
& VT_TYPEMASK
) != VT_VARIANT
)
543 if(header
->vt
& VT_ARRAY
)
544 V_ARRAY(pvar
) = NULL
;
545 else if((header
->vt
& VT_TYPEMASK
) == VT_BSTR
)
547 else if((header
->vt
& VT_TYPEMASK
) == VT_UNKNOWN
)
548 V_UNKNOWN(pvar
) = NULL
;
549 else if((header
->vt
& VT_TYPEMASK
) == VT_DISPATCH
)
550 V_DISPATCH(pvar
) = NULL
;
551 else if((header
->vt
& VT_TYPEMASK
) == VT_RECORD
)
552 V_RECORD(pvar
) = NULL
;
553 else if((header
->vt
& VT_TYPEMASK
) == VT_DECIMAL
)
554 memcpy(pvar
, Pos
, type_size
);
556 memcpy(&pvar
->n1
.n2
.n3
, Pos
, type_size
);
560 pvar
->n1
.n2
.vt
= header
->vt
;
561 pvar
->n1
.n2
.wReserved1
= header
->wReserved1
;
562 pvar
->n1
.n2
.wReserved2
= header
->wReserved2
;
563 pvar
->n1
.n2
.wReserved3
= header
->wReserved3
;
565 if(header
->vt
& VT_ARRAY
)
567 if(header
->vt
& VT_BYREF
)
568 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, V_ARRAYREF(pvar
));
570 Pos
= LPSAFEARRAY_UserUnmarshal(pFlags
, Pos
, &V_ARRAY(pvar
));
577 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, &V_BSTR(pvar
));
579 case VT_BSTR
| VT_BYREF
:
580 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
582 case VT_VARIANT
| VT_BYREF
:
583 Pos
= VARIANT_UserUnmarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
586 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, &V_UNKNOWN(pvar
));
588 case VT_UNKNOWN
| VT_BYREF
:
589 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, V_UNKNOWNREF(pvar
));
592 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)&V_DISPATCH(pvar
));
594 case VT_DISPATCH
| VT_BYREF
:
595 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, (IUnknown
**)V_DISPATCHREF(pvar
));
598 FIXME("handle BRECORD by val\n");
600 case VT_RECORD
| VT_BYREF
:
601 FIXME("handle BRECORD by ref\n");
608 void WINAPI
VARIANT_UserFree(ULONG
*pFlags
, VARIANT
*pvar
)
610 VARTYPE vt
= V_VT(pvar
);
613 TRACE("(%x,%p)\n", *pFlags
, pvar
);
614 TRACE("vt=%04x\n", V_VT(pvar
));
616 if (vt
& VT_BYREF
) ref
= pvar
->n1
.n2
.n3
.byref
;
624 LPSAFEARRAY_UserFree(pFlags
, V_ARRAYREF(pvar
));
626 LPSAFEARRAY_UserFree(pFlags
, &V_ARRAY(pvar
));
632 case VT_BSTR
| VT_BYREF
:
633 BSTR_UserFree(pFlags
, V_BSTRREF(pvar
));
635 case VT_VARIANT
| VT_BYREF
:
636 VARIANT_UserFree(pFlags
, V_VARIANTREF(pvar
));
638 case VT_RECORD
| VT_BYREF
:
639 FIXME("handle BRECORD by ref\n");
641 case VT_UNKNOWN
| VT_BYREF
:
642 case VT_DISPATCH
| VT_BYREF
:
643 IUnknown_Release(*V_UNKNOWNREF(pvar
));
653 /* Get the number of cells in a SafeArray */
654 static ULONG
SAFEARRAY_GetCellCount(const SAFEARRAY
*psa
)
656 const SAFEARRAYBOUND
* psab
= psa
->rgsabound
;
657 USHORT cCount
= psa
->cDims
;
658 ULONG ulNumCells
= 1;
662 /* This is a valid bordercase. See testcases. -Marcus */
663 if (!psab
->cElements
)
665 ulNumCells
*= psab
->cElements
;
671 static inline SF_TYPE
SAFEARRAY_GetUnionType(SAFEARRAY
*psa
)
676 hr
= SafeArrayGetVartype(psa
, &vt
);
679 if(psa
->fFeatures
& FADF_VARIANT
) return SF_VARIANT
;
681 switch(psa
->cbElements
)
683 case 1: vt
= VT_I1
; break;
684 case 2: vt
= VT_I2
; break;
685 case 4: vt
= VT_I4
; break;
686 case 8: vt
= VT_I8
; break;
688 RpcRaiseException(hr
);
692 if (psa
->fFeatures
& FADF_HAVEIID
)
698 case VT_UI1
: return SF_I1
;
701 case VT_UI2
: return SF_I2
;
706 case VT_R4
: return SF_I4
;
711 case VT_UI8
: return SF_I8
;
713 case VT_UINT_PTR
: return (sizeof(UINT_PTR
) == 4 ? SF_I4
: SF_I8
);
714 case VT_BSTR
: return SF_BSTR
;
715 case VT_DISPATCH
: return SF_DISPATCH
;
716 case VT_VARIANT
: return SF_VARIANT
;
717 case VT_UNKNOWN
: return SF_UNKNOWN
;
718 /* Note: Return a non-zero size to indicate vt is valid. The actual size
719 * of a UDT is taken from the result of IRecordInfo_GetSize().
721 case VT_RECORD
: return SF_RECORD
;
722 default: return SF_ERROR
;
726 static DWORD
elem_wire_size(LPSAFEARRAY lpsa
, SF_TYPE sftype
)
728 if (sftype
== SF_BSTR
)
729 return sizeof(DWORD
);
730 else if (sftype
== SF_VARIANT
)
731 return sizeof(variant_wire_t
) - sizeof(DWORD
);
733 return lpsa
->cbElements
;
736 static DWORD
elem_mem_size(wireSAFEARRAY wiresa
, SF_TYPE sftype
)
738 if (sftype
== SF_BSTR
)
740 else if (sftype
== SF_VARIANT
)
741 return sizeof(VARIANT
);
743 return wiresa
->cbElements
;
746 ULONG WINAPI
LPSAFEARRAY_UserSize(ULONG
*pFlags
, ULONG StartingSize
, LPSAFEARRAY
*ppsa
)
748 ULONG size
= StartingSize
;
750 TRACE("("); dump_user_flags(pFlags
); TRACE(", %d, %p\n", StartingSize
, *ppsa
);
752 ALIGN_LENGTH(size
, 3);
753 size
+= sizeof(ULONG
);
756 SAFEARRAY
*psa
= *ppsa
;
757 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
761 size
+= sizeof(ULONG
);
762 size
+= 2 * sizeof(USHORT
) + 2 * sizeof(ULONG
);
764 sftype
= SAFEARRAY_GetUnionType(psa
);
765 size
+= sizeof(ULONG
);
767 size
+= sizeof(ULONG
);
768 size
+= sizeof(ULONG
);
769 if (sftype
== SF_HAVEIID
)
772 size
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
774 size
+= sizeof(ULONG
);
782 for (lpBstr
= psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
783 size
= BSTR_UserSize(pFlags
, size
, lpBstr
);
790 FIXME("size interfaces\n");
796 for (lpVariant
= psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
797 size
= VARIANT_UserSize(pFlags
, size
, lpVariant
);
803 IRecordInfo
* pRecInfo
= NULL
;
805 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
807 RpcRaiseException(hr
);
811 FIXME("size record info %p\n", pRecInfo
);
813 IRecordInfo_Release(pRecInfo
);
818 ALIGN_LENGTH(size
, 7);
823 size
+= ulCellCount
* psa
->cbElements
;
834 unsigned char * WINAPI
LPSAFEARRAY_UserMarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
838 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, &%p\n", Buffer
, *ppsa
);
840 ALIGN_POINTER(Buffer
, 3);
841 *(ULONG
*)Buffer
= *ppsa
? 0x1 : 0x0;
842 Buffer
+= sizeof(ULONG
);
846 SAFEARRAY
*psa
= *ppsa
;
847 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
848 SAFEARRAYBOUND
*bound
;
853 sftype
= SAFEARRAY_GetUnionType(psa
);
855 *(ULONG
*)Buffer
= psa
->cDims
;
856 Buffer
+= sizeof(ULONG
);
857 *(USHORT
*)Buffer
= psa
->cDims
;
858 Buffer
+= sizeof(USHORT
);
859 *(USHORT
*)Buffer
= psa
->fFeatures
;
860 Buffer
+= sizeof(USHORT
);
861 *(ULONG
*)Buffer
= elem_wire_size(psa
, sftype
);
862 Buffer
+= sizeof(ULONG
);
864 hr
= SafeArrayGetVartype(psa
, &vt
);
865 if (FAILED(hr
)) vt
= 0;
867 *(ULONG
*)Buffer
= (USHORT
)psa
->cLocks
| (vt
<< 16);
868 Buffer
+= sizeof(ULONG
);
870 *(ULONG
*)Buffer
= sftype
;
871 Buffer
+= sizeof(ULONG
);
873 *(ULONG
*)Buffer
= ulCellCount
;
874 Buffer
+= sizeof(ULONG
);
875 *(ULONG
*)Buffer
= psa
->pvData
? 0x2 : 0x0;
876 Buffer
+= sizeof(ULONG
);
877 if (sftype
== SF_HAVEIID
)
879 SafeArrayGetIID(psa
, &guid
);
880 memcpy(Buffer
, &guid
, sizeof(guid
));
881 Buffer
+= sizeof(guid
);
884 /* bounds are marshaled in opposite order comparing to storage layout */
885 bound
= (SAFEARRAYBOUND
*)Buffer
;
886 for (i
= 0; i
< psa
->cDims
; i
++)
888 memcpy(bound
++, &psa
->rgsabound
[psa
->cDims
-i
-1], sizeof(psa
->rgsabound
[0]));
890 Buffer
+= sizeof(psa
->rgsabound
[0]) * psa
->cDims
;
892 *(ULONG
*)Buffer
= ulCellCount
;
893 Buffer
+= sizeof(ULONG
);
903 for (lpBstr
= psa
->pvData
; ulCellCount
; ulCellCount
--, lpBstr
++)
904 Buffer
= BSTR_UserMarshal(pFlags
, Buffer
, lpBstr
);
911 FIXME("marshal interfaces\n");
917 for (lpVariant
= psa
->pvData
; ulCellCount
; ulCellCount
--, lpVariant
++)
918 Buffer
= VARIANT_UserMarshal(pFlags
, Buffer
, lpVariant
);
924 IRecordInfo
* pRecInfo
= NULL
;
926 hr
= SafeArrayGetRecordInfo(psa
, &pRecInfo
);
928 RpcRaiseException(hr
);
932 FIXME("write record info %p\n", pRecInfo
);
934 IRecordInfo_Release(pRecInfo
);
940 ALIGN_POINTER(Buffer
, 7);
945 /* Just copy the data over */
946 memcpy(Buffer
, psa
->pvData
, ulCellCount
* psa
->cbElements
);
947 Buffer
+= ulCellCount
* psa
->cbElements
;
958 #define FADF_AUTOSETFLAGS (FADF_HAVEIID | FADF_RECORD | FADF_HAVEVARTYPE | \
959 FADF_BSTR | FADF_UNKNOWN | FADF_DISPATCH | \
960 FADF_VARIANT | FADF_CREATEVECTOR)
962 unsigned char * WINAPI
LPSAFEARRAY_UserUnmarshal(ULONG
*pFlags
, unsigned char *Buffer
, LPSAFEARRAY
*ppsa
)
965 wireSAFEARRAY wiresa
;
972 SAFEARRAYBOUND
*wiresab
;
974 TRACE("("); dump_user_flags(pFlags
); TRACE(", %p, %p\n", Buffer
, ppsa
);
976 ALIGN_POINTER(Buffer
, 3);
977 ptr
= *(ULONG
*)Buffer
;
978 Buffer
+= sizeof(ULONG
);
982 SafeArrayDestroy(*ppsa
);
985 TRACE("NULL safe array unmarshaled\n");
990 cDims
= *(ULONG
*)Buffer
;
991 Buffer
+= sizeof(ULONG
);
993 wiresa
= (wireSAFEARRAY
)Buffer
;
994 Buffer
+= 2 * sizeof(USHORT
) + 2 * sizeof(ULONG
);
996 if (cDims
!= wiresa
->cDims
)
997 RpcRaiseException(RPC_S_INVALID_BOUND
);
999 /* FIXME: there should be a limit on how large cDims can be */
1001 vt
= HIWORD(wiresa
->cLocks
);
1003 sftype
= *(ULONG
*)Buffer
;
1004 Buffer
+= sizeof(ULONG
);
1006 cell_count
= *(ULONG
*)Buffer
;
1007 Buffer
+= sizeof(ULONG
);
1008 ptr
= *(ULONG
*)Buffer
;
1009 Buffer
+= sizeof(ULONG
);
1010 if (sftype
== SF_HAVEIID
)
1012 memcpy(&guid
, Buffer
, sizeof(guid
));
1013 Buffer
+= sizeof(guid
);
1016 wiresab
= (SAFEARRAYBOUND
*)Buffer
;
1017 Buffer
+= sizeof(wiresab
[0]) * wiresa
->cDims
;
1019 if(*ppsa
&& (*ppsa
)->cDims
==wiresa
->cDims
)
1021 if(((*ppsa
)->fFeatures
& ~FADF_AUTOSETFLAGS
) != (wiresa
->fFeatures
& ~FADF_AUTOSETFLAGS
))
1022 RpcRaiseException(DISP_E_BADCALLEE
);
1024 if(SAFEARRAY_GetCellCount(*ppsa
)*(*ppsa
)->cbElements
!= cell_count
*elem_mem_size(wiresa
, sftype
))
1026 if((*ppsa
)->fFeatures
& (FADF_AUTO
|FADF_STATIC
|FADF_EMBEDDED
|FADF_FIXEDSIZE
))
1027 RpcRaiseException(DISP_E_BADCALLEE
);
1029 hr
= SafeArrayDestroyData(*ppsa
);
1031 RpcRaiseException(hr
);
1033 memcpy((*ppsa
)->rgsabound
, wiresab
, sizeof(*wiresab
)*wiresa
->cDims
);
1035 if((*ppsa
)->fFeatures
& FADF_HAVEVARTYPE
)
1036 ((DWORD
*)(*ppsa
))[-1] = vt
;
1040 SafeArrayDestroy(*ppsa
);
1041 *ppsa
= SafeArrayCreateEx(vt
, wiresa
->cDims
, wiresab
, NULL
);
1042 if (!*ppsa
) RpcRaiseException(E_OUTOFMEMORY
);
1046 SafeArrayDestroy(*ppsa
);
1047 if (FAILED(SafeArrayAllocDescriptor(wiresa
->cDims
, ppsa
)))
1048 RpcRaiseException(E_OUTOFMEMORY
);
1049 memcpy((*ppsa
)->rgsabound
, wiresab
, sizeof(SAFEARRAYBOUND
) * wiresa
->cDims
);
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
= elem_mem_size(wiresa
, sftype
);
1059 /* SafeArrayCreateEx allocates the data for us, but
1060 * SafeArrayAllocDescriptor doesn't */
1061 if(!(*ppsa
)->pvData
)
1063 hr
= SafeArrayAllocData(*ppsa
);
1065 RpcRaiseException(hr
);
1068 if ((*(ULONG
*)Buffer
!= cell_count
) || (SAFEARRAY_GetCellCount(*ppsa
) != cell_count
))
1069 RpcRaiseException(RPC_S_INVALID_BOUND
);
1070 Buffer
+= sizeof(ULONG
);
1080 for (lpBstr
= (*ppsa
)->pvData
; cell_count
; cell_count
--, lpBstr
++)
1081 Buffer
= BSTR_UserUnmarshal(pFlags
, Buffer
, lpBstr
);
1088 FIXME("marshal interfaces\n");
1094 for (lpVariant
= (*ppsa
)->pvData
; cell_count
; cell_count
--, lpVariant
++)
1095 Buffer
= VARIANT_UserUnmarshal(pFlags
, Buffer
, lpVariant
);
1101 FIXME("set record info\n");
1107 ALIGN_POINTER(Buffer
, 7);
1112 /* Just copy the data over */
1113 memcpy((*ppsa
)->pvData
, Buffer
, cell_count
* (*ppsa
)->cbElements
);
1114 Buffer
+= cell_count
* (*ppsa
)->cbElements
;
1121 TRACE("safe array unmarshaled: %p\n", *ppsa
);
1126 void WINAPI
LPSAFEARRAY_UserFree(ULONG
*pFlags
, LPSAFEARRAY
*ppsa
)
1128 TRACE("("); dump_user_flags(pFlags
); TRACE(", &%p\n", *ppsa
);
1130 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
]);
1209 VariantCopy(&rgVarRef
[cVarRef
], arg
);
1215 /* [out] args still can't be null,
1216 * but we can point these anywhere in this case,
1217 * since they won't be written to when cVarRef is 0 */
1218 rgVarRefIdx
= puArgErr
;
1219 rgVarRef
= pVarResult
;
1221 TRACE("passed by ref: %d args\n", cVarRef
);
1222 hr
= IDispatch_RemoteInvoke_Proxy(This
,
1235 for (u
=0; u
<cVarRef
; u
++) {
1236 unsigned i
= rgVarRefIdx
[u
];
1237 VariantCopy(&pDispParams
->rgvarg
[i
],
1239 VariantClear(&rgVarRef
[u
]);
1241 CoTaskMemFree(rgVarRef
);
1242 CoTaskMemFree(rgVarRefIdx
);
1245 if(pExcepInfo
== &ExcepInfo
)
1247 SysFreeString(pExcepInfo
->bstrSource
);
1248 SysFreeString(pExcepInfo
->bstrDescription
);
1249 SysFreeString(pExcepInfo
->bstrHelpFile
);
1254 HRESULT __RPC_STUB
IDispatch_Invoke_Stub(
1256 DISPID dispIdMember
,
1260 DISPPARAMS
* pDispParams
,
1261 VARIANT
* pVarResult
,
1262 EXCEPINFO
* pExcepInfo
,
1266 VARIANTARG
* rgVarRef
)
1269 VARIANTARG
*rgvarg
, *arg
;
1272 /* initialize out parameters, so that they can be marshalled
1273 * in case the real Invoke doesn't initialize them */
1274 VariantInit(pVarResult
);
1275 memset(pExcepInfo
, 0, sizeof(*pExcepInfo
));
1278 /* let the real Invoke operate on a copy of the in parameters,
1279 * so we don't risk losing pointers to allocated memory */
1280 rgvarg
= pDispParams
->rgvarg
;
1281 arg
= CoTaskMemAlloc(sizeof(VARIANTARG
)*pDispParams
->cArgs
);
1282 if (!arg
) return E_OUTOFMEMORY
;
1284 /* init all args so we can call VariantClear on all the args if the copy
1286 for (u
= 0; u
< pDispParams
->cArgs
; u
++)
1287 VariantInit(&arg
[u
]);
1289 for (u
= 0; u
< pDispParams
->cArgs
; u
++) {
1290 hr
= VariantCopy(&arg
[u
], &rgvarg
[u
]);
1295 if (SUCCEEDED(hr
)) {
1296 /* copy ref args to arg array */
1297 for (u
=0; u
<cVarRef
; u
++) {
1298 unsigned i
= rgVarRefIdx
[u
];
1299 VariantCopy(&arg
[i
], &rgVarRef
[u
]);
1302 pDispParams
->rgvarg
= arg
;
1304 hr
= IDispatch_Invoke(This
,
1314 /* copy ref args from arg array */
1315 for (u
=0; u
<cVarRef
; u
++) {
1316 unsigned i
= rgVarRefIdx
[u
];
1317 VariantCopy(&rgVarRef
[u
], &arg
[i
]);
1321 /* clear the duplicate argument list */
1322 for (u
=0; u
<pDispParams
->cArgs
; u
++)
1323 VariantClear(&arg
[u
]);
1325 pDispParams
->rgvarg
= rgvarg
;
1333 HRESULT CALLBACK
IEnumVARIANT_Next_Proxy(
1337 ULONG
* pCeltFetched
)
1341 pCeltFetched
= &fetched
;
1342 return IEnumVARIANT_RemoteNext_Proxy(This
,
1348 HRESULT __RPC_STUB
IEnumVARIANT_Next_Stub(
1352 ULONG
* pCeltFetched
)
1356 hr
= IEnumVARIANT_Next(This
,
1360 if (hr
== S_OK
) *pCeltFetched
= celt
;
1364 /* TypeInfo related freers */
1366 static void free_embedded_typedesc(TYPEDESC
*tdesc
);
1367 static void free_embedded_arraydesc(ARRAYDESC
*adesc
)
1369 switch(adesc
->tdescElem
.vt
)
1373 free_embedded_typedesc(adesc
->tdescElem
.u
.lptdesc
);
1374 CoTaskMemFree(adesc
->tdescElem
.u
.lptdesc
);
1377 free_embedded_arraydesc(adesc
->tdescElem
.u
.lpadesc
);
1378 CoTaskMemFree(adesc
->tdescElem
.u
.lpadesc
);
1383 static void free_embedded_typedesc(TYPEDESC
*tdesc
)
1389 free_embedded_typedesc(tdesc
->u
.lptdesc
);
1390 CoTaskMemFree(tdesc
->u
.lptdesc
);
1393 free_embedded_arraydesc(tdesc
->u
.lpadesc
);
1394 CoTaskMemFree(tdesc
->u
.lpadesc
);
1399 static void free_embedded_elemdesc(ELEMDESC
*edesc
)
1401 free_embedded_typedesc(&edesc
->tdesc
);
1402 if(edesc
->u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
1403 CoTaskMemFree(edesc
->u
.paramdesc
.pparamdescex
);
1408 HRESULT CALLBACK
ITypeComp_Bind_Proxy(
1413 ITypeInfo
** ppTInfo
,
1414 DESCKIND
* pDescKind
,
1417 FIXME("not implemented\n");
1421 HRESULT __RPC_STUB
ITypeComp_Bind_Stub(
1426 ITypeInfo
** ppTInfo
,
1427 DESCKIND
* pDescKind
,
1428 LPFUNCDESC
* ppFuncDesc
,
1429 LPVARDESC
* ppVarDesc
,
1430 ITypeComp
** ppTypeComp
,
1431 CLEANLOCALSTORAGE
* pDummy
)
1433 FIXME("not implemented\n");
1437 HRESULT CALLBACK
ITypeComp_BindType_Proxy(
1441 ITypeInfo
** ppTInfo
,
1442 ITypeComp
** ppTComp
)
1444 FIXME("not implemented\n");
1448 HRESULT __RPC_STUB
ITypeComp_BindType_Stub(
1452 ITypeInfo
** ppTInfo
)
1454 FIXME("not implemented\n");
1460 HRESULT CALLBACK
ITypeInfo_GetTypeAttr_Proxy(
1462 TYPEATTR
** ppTypeAttr
)
1465 CLEANLOCALSTORAGE stg
;
1466 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1469 stg
.pStorage
= NULL
;
1470 stg
.pInterface
= NULL
;
1472 return ITypeInfo_RemoteGetTypeAttr_Proxy(This
, ppTypeAttr
, &stg
);
1475 HRESULT __RPC_STUB
ITypeInfo_GetTypeAttr_Stub(
1477 LPTYPEATTR
* ppTypeAttr
,
1478 CLEANLOCALSTORAGE
* pDummy
)
1481 TRACE("(%p, %p)\n", This
, ppTypeAttr
);
1483 hr
= ITypeInfo_GetTypeAttr(This
, ppTypeAttr
);
1487 pDummy
->flags
= CLS_TYPEATTR
;
1488 ITypeInfo_AddRef(This
);
1489 pDummy
->pInterface
= (IUnknown
*)This
;
1490 pDummy
->pStorage
= ppTypeAttr
;
1494 HRESULT CALLBACK
ITypeInfo_GetFuncDesc_Proxy(
1497 FUNCDESC
** ppFuncDesc
)
1499 CLEANLOCALSTORAGE stg
;
1500 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1503 stg
.pStorage
= NULL
;
1504 stg
.pInterface
= NULL
;
1506 return ITypeInfo_RemoteGetFuncDesc_Proxy(This
, index
, ppFuncDesc
, &stg
);
1509 HRESULT __RPC_STUB
ITypeInfo_GetFuncDesc_Stub(
1512 LPFUNCDESC
* ppFuncDesc
,
1513 CLEANLOCALSTORAGE
* pDummy
)
1516 TRACE("(%p, %d, %p)\n", This
, index
, ppFuncDesc
);
1518 hr
= ITypeInfo_GetFuncDesc(This
, index
, ppFuncDesc
);
1522 pDummy
->flags
= CLS_FUNCDESC
;
1523 ITypeInfo_AddRef(This
);
1524 pDummy
->pInterface
= (IUnknown
*)This
;
1525 pDummy
->pStorage
= ppFuncDesc
;
1529 HRESULT CALLBACK
ITypeInfo_GetVarDesc_Proxy(
1532 VARDESC
** ppVarDesc
)
1534 CLEANLOCALSTORAGE stg
;
1535 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1538 stg
.pStorage
= NULL
;
1539 stg
.pInterface
= NULL
;
1541 return ITypeInfo_RemoteGetVarDesc_Proxy(This
, index
, ppVarDesc
, &stg
);
1544 HRESULT __RPC_STUB
ITypeInfo_GetVarDesc_Stub(
1547 LPVARDESC
* ppVarDesc
,
1548 CLEANLOCALSTORAGE
* pDummy
)
1551 TRACE("(%p, %d, %p)\n", This
, index
, ppVarDesc
);
1553 hr
= ITypeInfo_GetVarDesc(This
, index
, ppVarDesc
);
1557 pDummy
->flags
= CLS_VARDESC
;
1558 ITypeInfo_AddRef(This
);
1559 pDummy
->pInterface
= (IUnknown
*)This
;
1560 pDummy
->pStorage
= ppVarDesc
;
1564 HRESULT CALLBACK
ITypeInfo_GetNames_Proxy(
1571 TRACE("(%p, %08x, %p, %d, %p)\n", This
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
1573 return ITypeInfo_RemoteGetNames_Proxy(This
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
1576 HRESULT __RPC_STUB
ITypeInfo_GetNames_Stub(
1583 TRACE("(%p, %08x, %p, %d, %p)\n", This
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
1585 return ITypeInfo_GetNames(This
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
1588 HRESULT CALLBACK
ITypeInfo_GetIDsOfNames_Proxy(
1590 LPOLESTR
* rgszNames
,
1594 FIXME("not implemented\n");
1598 HRESULT __RPC_STUB
ITypeInfo_GetIDsOfNames_Stub(
1601 FIXME("not implemented\n");
1605 HRESULT CALLBACK
ITypeInfo_Invoke_Proxy(
1610 DISPPARAMS
* pDispParams
,
1611 VARIANT
* pVarResult
,
1612 EXCEPINFO
* pExcepInfo
,
1615 FIXME("not implemented\n");
1619 HRESULT __RPC_STUB
ITypeInfo_Invoke_Stub(
1622 FIXME("not implemented\n");
1626 HRESULT CALLBACK
ITypeInfo_GetDocumentation_Proxy(ITypeInfo
*This
, MEMBERID memid
,
1627 BSTR
*name
, BSTR
*doc_string
,
1628 DWORD
*help_context
, BSTR
*help_file
)
1630 DWORD dummy_help_context
, flags
= 0;
1631 BSTR dummy_name
, dummy_doc_string
, dummy_help_file
;
1633 TRACE("(%p, %08x, %p, %p, %p, %p)\n", This
, memid
, name
, doc_string
, help_context
, help_file
);
1635 if(!name
) name
= &dummy_name
;
1638 if(!doc_string
) doc_string
= &dummy_doc_string
;
1641 if(!help_context
) help_context
= &dummy_help_context
;
1644 if(!help_file
) help_file
= &dummy_help_file
;
1647 hr
= ITypeInfo_RemoteGetDocumentation_Proxy(This
, memid
, flags
, name
, doc_string
, help_context
, help_file
);
1649 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1654 HRESULT __RPC_STUB
ITypeInfo_GetDocumentation_Stub(ITypeInfo
*This
, MEMBERID memid
,
1655 DWORD flags
, BSTR
*name
, BSTR
*doc_string
,
1656 DWORD
*help_context
, BSTR
*help_file
)
1658 TRACE("(%p, %08x, %08x, %p, %p, %p, %p)\n", This
, memid
, flags
, name
, doc_string
, help_context
, help_file
);
1660 *name
= *doc_string
= *help_file
= NULL
;
1663 if(!(flags
& 1)) name
= NULL
;
1664 if(!(flags
& 2)) doc_string
= NULL
;
1665 if(!(flags
& 4)) help_context
= NULL
;
1666 if(!(flags
& 8)) help_file
= NULL
;
1668 return ITypeInfo_GetDocumentation(This
, memid
, name
, doc_string
, help_context
, help_file
);
1671 HRESULT CALLBACK
ITypeInfo_GetDllEntry_Proxy(ITypeInfo
*This
, MEMBERID memid
,
1672 INVOKEKIND invkind
, BSTR
*dll_name
,
1673 BSTR
* name
, WORD
*ordinal
)
1676 BSTR dummy_dll_name
, dummy_name
;
1679 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This
, memid
, invkind
, dll_name
, name
, ordinal
);
1681 if(!dll_name
) dll_name
= &dummy_dll_name
;
1684 if(!name
) name
= &dummy_name
;
1687 if(!ordinal
) ordinal
= &dummy_ordinal
;
1690 hr
= ITypeInfo_RemoteGetDllEntry_Proxy(This
, memid
, invkind
, flags
, dll_name
, name
, ordinal
);
1692 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1697 HRESULT __RPC_STUB
ITypeInfo_GetDllEntry_Stub(ITypeInfo
*This
, MEMBERID memid
,
1698 INVOKEKIND invkind
, DWORD flags
,
1699 BSTR
*dll_name
, BSTR
*name
,
1702 TRACE("(%p, %08x, %x, %p, %p, %p)\n", This
, memid
, invkind
, dll_name
, name
, ordinal
);
1704 *dll_name
= *name
= NULL
;
1707 if(!(flags
& 1)) dll_name
= NULL
;
1708 if(!(flags
& 2)) name
= NULL
;
1709 if(!(flags
& 4)) ordinal
= NULL
;
1711 return ITypeInfo_GetDllEntry(This
, memid
, invkind
, dll_name
, name
, ordinal
);
1714 HRESULT CALLBACK
ITypeInfo_AddressOfMember_Proxy(
1720 FIXME("not implemented\n");
1724 HRESULT __RPC_STUB
ITypeInfo_AddressOfMember_Stub(
1727 FIXME("not implemented\n");
1731 HRESULT CALLBACK
ITypeInfo_CreateInstance_Proxy(
1733 IUnknown
* pUnkOuter
,
1737 FIXME("not implemented\n");
1741 HRESULT __RPC_STUB
ITypeInfo_CreateInstance_Stub(
1746 FIXME("not implemented\n");
1750 HRESULT CALLBACK
ITypeInfo_GetContainingTypeLib_Proxy(
1759 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1761 hr
= ITypeInfo_RemoteGetContainingTypeLib_Proxy(This
, &pTL
, &index
);
1770 ITypeLib_Release(pTL
);
1775 HRESULT __RPC_STUB
ITypeInfo_GetContainingTypeLib_Stub(
1780 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1781 return ITypeInfo_GetContainingTypeLib(This
, ppTLib
, pIndex
);
1784 void CALLBACK
ITypeInfo_ReleaseTypeAttr_Proxy(
1786 TYPEATTR
* pTypeAttr
)
1788 TRACE("(%p, %p)\n", This
, pTypeAttr
);
1789 free_embedded_typedesc(&pTypeAttr
->tdescAlias
);
1790 CoTaskMemFree(pTypeAttr
);
1793 HRESULT __RPC_STUB
ITypeInfo_ReleaseTypeAttr_Stub(
1796 TRACE("nothing to do\n");
1800 void CALLBACK
ITypeInfo_ReleaseFuncDesc_Proxy(
1802 FUNCDESC
* pFuncDesc
)
1805 TRACE("(%p, %p)\n", This
, pFuncDesc
);
1807 for(param
= 0; param
< pFuncDesc
->cParams
; param
++)
1808 free_embedded_elemdesc(pFuncDesc
->lprgelemdescParam
+ param
);
1810 CoTaskMemFree(pFuncDesc
->lprgelemdescParam
);
1812 free_embedded_elemdesc(&pFuncDesc
->elemdescFunc
);
1814 if(pFuncDesc
->cScodes
!= 0 && pFuncDesc
->cScodes
!= -1)
1815 CoTaskMemFree(pFuncDesc
->lprgscode
);
1817 CoTaskMemFree(pFuncDesc
);
1820 HRESULT __RPC_STUB
ITypeInfo_ReleaseFuncDesc_Stub(
1823 TRACE("nothing to do\n");
1827 void CALLBACK
ITypeInfo_ReleaseVarDesc_Proxy(
1831 TRACE("(%p, %p)\n", This
, pVarDesc
);
1833 CoTaskMemFree(pVarDesc
->lpstrSchema
);
1835 if(pVarDesc
->varkind
== VAR_CONST
)
1836 CoTaskMemFree(pVarDesc
->u
.lpvarValue
);
1838 free_embedded_elemdesc(&pVarDesc
->elemdescVar
);
1839 CoTaskMemFree(pVarDesc
);
1842 HRESULT __RPC_STUB
ITypeInfo_ReleaseVarDesc_Stub(
1845 TRACE("nothing to do\n");
1852 HRESULT CALLBACK
ITypeInfo2_GetDocumentation2_Proxy(ITypeInfo2
*This
, MEMBERID memid
,
1853 LCID lcid
, BSTR
*help_string
,
1854 DWORD
*help_context
, BSTR
*help_dll
)
1856 DWORD dummy_help_context
, flags
= 0;
1857 BSTR dummy_help_string
, dummy_help_dll
;
1859 TRACE("(%p, %08x, %08x, %p, %p, %p)\n", This
, memid
, lcid
, help_string
, help_context
, help_dll
);
1861 if(!help_string
) help_string
= &dummy_help_string
;
1864 if(!help_context
) help_context
= &dummy_help_context
;
1867 if(!help_dll
) help_dll
= &dummy_help_dll
;
1870 hr
= ITypeInfo2_RemoteGetDocumentation2_Proxy(This
, memid
, lcid
, flags
, help_string
, help_context
, help_dll
);
1872 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1877 HRESULT __RPC_STUB
ITypeInfo2_GetDocumentation2_Stub(ITypeInfo2
*This
, MEMBERID memid
,
1878 LCID lcid
, DWORD flags
,
1879 BSTR
*help_string
, DWORD
*help_context
,
1882 TRACE("(%p, %08x, %08x, %08x, %p, %p, %p)\n", This
, memid
, lcid
, flags
, help_string
, help_context
, help_dll
);
1884 *help_string
= *help_dll
= NULL
;
1887 if(!(flags
& 1)) help_string
= NULL
;
1888 if(!(flags
& 2)) help_context
= NULL
;
1889 if(!(flags
& 4)) help_dll
= NULL
;
1891 return ITypeInfo2_GetDocumentation2(This
, memid
, lcid
, help_string
, help_context
, help_dll
);
1896 UINT CALLBACK
ITypeLib_GetTypeInfoCount_Proxy(
1900 TRACE("(%p)\n", This
);
1902 ITypeLib_RemoteGetTypeInfoCount_Proxy(This
, &count
);
1907 HRESULT __RPC_STUB
ITypeLib_GetTypeInfoCount_Stub(
1911 TRACE("(%p, %p)\n", This
, pcTInfo
);
1912 *pcTInfo
= ITypeLib_GetTypeInfoCount(This
);
1916 HRESULT CALLBACK
ITypeLib_GetLibAttr_Proxy(
1918 TLIBATTR
** ppTLibAttr
)
1920 CLEANLOCALSTORAGE stg
;
1921 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1924 stg
.pStorage
= NULL
;
1925 stg
.pInterface
= NULL
;
1927 return ITypeLib_RemoteGetLibAttr_Proxy(This
, ppTLibAttr
, &stg
);
1930 HRESULT __RPC_STUB
ITypeLib_GetLibAttr_Stub(
1932 LPTLIBATTR
* ppTLibAttr
,
1933 CLEANLOCALSTORAGE
* pDummy
)
1936 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1938 hr
= ITypeLib_GetLibAttr(This
, ppTLibAttr
);
1942 pDummy
->flags
= CLS_LIBATTR
;
1943 ITypeLib_AddRef(This
);
1944 pDummy
->pInterface
= (IUnknown
*)This
;
1945 pDummy
->pStorage
= ppTLibAttr
;
1949 HRESULT CALLBACK
ITypeLib_GetDocumentation_Proxy(ITypeLib
*This
, INT index
, BSTR
*name
,
1950 BSTR
*doc_string
, DWORD
*help_context
,
1953 DWORD dummy_help_context
, flags
= 0;
1954 BSTR dummy_name
, dummy_doc_string
, dummy_help_file
;
1956 TRACE("(%p, %d, %p, %p, %p, %p)\n", This
, index
, name
, doc_string
, help_context
, help_file
);
1958 if(!name
) name
= &dummy_name
;
1961 if(!doc_string
) doc_string
= &dummy_doc_string
;
1964 if(!help_context
) help_context
= &dummy_help_context
;
1967 if(!help_file
) help_file
= &dummy_help_file
;
1970 hr
= ITypeLib_RemoteGetDocumentation_Proxy(This
, index
, flags
, name
, doc_string
, help_context
, help_file
);
1972 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
1977 HRESULT __RPC_STUB
ITypeLib_GetDocumentation_Stub(ITypeLib
*This
, INT index
, DWORD flags
,
1978 BSTR
*name
, BSTR
*doc_string
,
1979 DWORD
*help_context
, BSTR
*help_file
)
1981 TRACE("(%p, %d, %08x, %p, %p, %p, %p)\n", This
, index
, flags
, name
, doc_string
, help_context
, help_file
);
1983 *name
= *doc_string
= *help_file
= NULL
;
1986 if(!(flags
& 1)) name
= NULL
;
1987 if(!(flags
& 2)) doc_string
= NULL
;
1988 if(!(flags
& 4)) help_context
= NULL
;
1989 if(!(flags
& 8)) help_file
= NULL
;
1991 return ITypeLib_GetDocumentation(This
, index
, name
, doc_string
, help_context
, help_file
);
1994 HRESULT CALLBACK
ITypeLib_IsName_Proxy(
2000 FIXME("not implemented\n");
2004 HRESULT __RPC_STUB
ITypeLib_IsName_Stub(
2011 FIXME("not implemented\n");
2015 HRESULT CALLBACK
ITypeLib_FindName_Proxy(
2019 ITypeInfo
** ppTInfo
,
2023 FIXME("not implemented\n");
2027 HRESULT __RPC_STUB
ITypeLib_FindName_Stub(
2031 ITypeInfo
** ppTInfo
,
2036 FIXME("not implemented\n");
2040 void CALLBACK
ITypeLib_ReleaseTLibAttr_Proxy(
2042 TLIBATTR
* pTLibAttr
)
2044 TRACE("(%p, %p)\n", This
, pTLibAttr
);
2045 CoTaskMemFree(pTLibAttr
);
2048 HRESULT __RPC_STUB
ITypeLib_ReleaseTLibAttr_Stub(
2051 TRACE("nothing to do\n");
2058 HRESULT CALLBACK
ITypeLib2_GetLibStatistics_Proxy(
2060 ULONG
* pcUniqueNames
,
2061 ULONG
* pcchUniqueNames
)
2063 FIXME("not implemented\n");
2067 HRESULT __RPC_STUB
ITypeLib2_GetLibStatistics_Stub(
2069 ULONG
* pcUniqueNames
,
2070 ULONG
* pcchUniqueNames
)
2072 FIXME("not implemented\n");
2076 HRESULT CALLBACK
ITypeLib2_GetDocumentation2_Proxy(ITypeLib2
*This
, INT index
,
2077 LCID lcid
, BSTR
*help_string
,
2078 DWORD
*help_context
, BSTR
*help_dll
)
2080 DWORD dummy_help_context
, flags
= 0;
2081 BSTR dummy_help_string
, dummy_help_dll
;
2083 TRACE("(%p, %d, %08x, %p, %p, %p)\n", This
, index
, lcid
, help_string
, help_context
, help_dll
);
2085 if(!help_string
) help_string
= &dummy_help_string
;
2088 if(!help_context
) help_context
= &dummy_help_context
;
2091 if(!help_dll
) help_dll
= &dummy_help_dll
;
2094 hr
= ITypeLib2_RemoteGetDocumentation2_Proxy(This
, index
, lcid
, flags
, help_string
, help_context
, help_dll
);
2096 /* We don't need to free the dummy BSTRs since the stub ensures that these will be NULLs. */
2101 HRESULT __RPC_STUB
ITypeLib2_GetDocumentation2_Stub(ITypeLib2
*This
, INT index
, LCID lcid
,
2102 DWORD flags
, BSTR
*help_string
,
2103 DWORD
*help_context
, BSTR
*help_dll
)
2105 TRACE("(%p, %d, %08x, %08x, %p, %p, %p)\n", This
, index
, lcid
, flags
, help_string
, help_context
, help_dll
);
2107 *help_string
= *help_dll
= NULL
;
2110 if(!(flags
& 1)) help_string
= NULL
;
2111 if(!(flags
& 2)) help_context
= NULL
;
2112 if(!(flags
& 4)) help_dll
= NULL
;
2114 return ITypeLib2_GetDocumentation2(This
, index
, lcid
, help_string
, help_context
, help_dll
);
2117 HRESULT CALLBACK
IPropertyBag_Read_Proxy(
2119 LPCOLESTR pszPropName
,
2121 IErrorLog
*pErrorLog
)
2123 IUnknown
*pUnk
= NULL
;
2124 TRACE("(%p, %s, %p, %p)\n", This
, debugstr_w(pszPropName
), pVar
, pErrorLog
);
2129 if(V_VT(pVar
) & (VT_BYREF
| VT_ARRAY
| VT_VECTOR
))
2131 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar
));
2138 pUnk
= (IUnknown
*)V_DISPATCH(pVar
);
2141 pUnk
= V_UNKNOWN(pVar
);
2144 FIXME("Safearray support not yet implemented.\n");
2147 FIXME("Unknown V_VT %d - support not yet implemented.\n", V_VT(pVar
));
2151 return IPropertyBag_RemoteRead_Proxy(This
, pszPropName
, pVar
, pErrorLog
,
2155 HRESULT __RPC_STUB
IPropertyBag_Read_Stub(
2157 LPCOLESTR pszPropName
,
2159 IErrorLog
*pErrorLog
,
2163 static const WCHAR emptyWstr
[] = {0};
2166 TRACE("(%p, %s, %p, %p, %x, %p)\n", This
, debugstr_w(pszPropName
), pVar
,
2167 pErrorLog
, varType
, pUnkObj
);
2169 if(varType
& (VT_BYREF
| VT_ARRAY
| VT_VECTOR
))
2171 FIXME("Variant type %x is byref, array or vector. Not implemented.\n", V_VT(pVar
));
2175 V_VT(pVar
) = varType
;
2179 hr
= IUnknown_QueryInterface(pUnkObj
, &IID_IDispatch
, (LPVOID
*)&disp
);
2182 IUnknown_Release(pUnkObj
);
2183 V_DISPATCH(pVar
) = disp
;
2186 V_UNKNOWN(pVar
) = pUnkObj
;
2189 V_BSTR(pVar
) = SysAllocString(emptyWstr
);
2192 FIXME("Safearray support not yet implemented.\n");
2197 hr
= IPropertyBag_Read(This
, pszPropName
, pVar
, pErrorLog
);
2204 /* call_as/local stubs for ocidl.idl */
2206 HRESULT CALLBACK
IClassFactory2_CreateInstanceLic_Proxy(
2207 IClassFactory2
* This
,
2208 IUnknown
*pUnkOuter
,
2209 IUnknown
*pUnkReserved
,
2214 TRACE("(%p, %s, %p)\n", pUnkOuter
, debugstr_guid(riid
), ppvObj
);
2220 ERR("aggregation is not allowed on remote objects\n");
2221 return CLASS_E_NOAGGREGATION
;
2224 return IClassFactory2_RemoteCreateInstanceLic_Proxy(This
, riid
, bstrKey
, (IUnknown
**)ppvObj
);
2227 HRESULT __RPC_STUB
IClassFactory2_CreateInstanceLic_Stub(
2228 IClassFactory2
* This
,
2233 TRACE("(%s, %p)\n", debugstr_guid(riid
), ppvObj
);
2234 return IClassFactory2_CreateInstanceLic(This
, NULL
, NULL
, riid
, bstrKey
, (void**)ppvObj
);
2237 HRESULT CALLBACK
IEnumConnections_Next_Proxy(
2238 IEnumConnections
* This
,
2245 TRACE("(%u, %p %p)\n", cConnections
, rgcd
, pcFetched
);
2248 pcFetched
= &fetched
;
2250 return IEnumConnections_RemoteNext_Proxy(This
, cConnections
, rgcd
, pcFetched
);
2253 HRESULT __RPC_STUB
IEnumConnections_Next_Stub(
2254 IEnumConnections
* This
,
2261 TRACE("(%u, %p, %p)\n", cConnections
, rgcd
, pcFetched
);
2264 hr
= IEnumConnections_Next(This
, cConnections
, rgcd
, pcFetched
);
2266 *pcFetched
= cConnections
;
2271 HRESULT CALLBACK
IEnumConnectionPoints_Next_Proxy(
2272 IEnumConnectionPoints
* This
,
2274 IConnectionPoint
**ppCP
,
2279 TRACE("(%u, %p %p)\n", cConnections
, ppCP
, pcFetched
);
2282 pcFetched
= &fetched
;
2284 return IEnumConnectionPoints_RemoteNext_Proxy(This
, cConnections
, ppCP
, pcFetched
);
2287 HRESULT __RPC_STUB
IEnumConnectionPoints_Next_Stub(
2288 IEnumConnectionPoints
* This
,
2290 IConnectionPoint
**ppCP
,
2295 TRACE("(%u, %p, %p)\n", cConnections
, ppCP
, pcFetched
);
2298 hr
= IEnumConnectionPoints_Next(This
, cConnections
, ppCP
, pcFetched
);
2300 *pcFetched
= cConnections
;
2305 HRESULT CALLBACK
IPersistMemory_Load_Proxy(
2306 IPersistMemory
* This
,
2310 TRACE("(%p, %u)\n", pMem
, cbSize
);
2315 return IPersistMemory_RemoteLoad_Proxy(This
, pMem
, cbSize
);
2318 HRESULT __RPC_STUB
IPersistMemory_Load_Stub(
2319 IPersistMemory
* This
,
2323 TRACE("(%p, %u)\n", pMem
, cbSize
);
2324 return IPersistMemory_Load(This
, pMem
, cbSize
);
2327 HRESULT CALLBACK
IPersistMemory_Save_Proxy(
2328 IPersistMemory
* This
,
2333 TRACE("(%p, %d, %u)\n", pMem
, fClearDirty
, cbSize
);
2338 return IPersistMemory_RemoteSave_Proxy(This
, pMem
, fClearDirty
, cbSize
);
2341 HRESULT __RPC_STUB
IPersistMemory_Save_Stub(
2342 IPersistMemory
* This
,
2347 TRACE("(%p, %d, %u)\n", pMem
, fClearDirty
, cbSize
);
2348 return IPersistMemory_Save(This
, pMem
, fClearDirty
, cbSize
);
2351 void CALLBACK
IAdviseSinkEx_OnViewStatusChange_Proxy(
2352 IAdviseSinkEx
* This
,
2355 TRACE("(%p, 0x%08x)\n", This
, dwViewStatus
);
2356 IAdviseSinkEx_RemoteOnViewStatusChange_Proxy(This
, dwViewStatus
);
2359 HRESULT __RPC_STUB
IAdviseSinkEx_OnViewStatusChange_Stub(
2360 IAdviseSinkEx
* This
,
2363 TRACE("(%p, 0x%08x)\n", This
, dwViewStatus
);
2364 IAdviseSinkEx_OnViewStatusChange(This
, dwViewStatus
);
2368 HRESULT CALLBACK
IEnumOleUndoUnits_Next_Proxy(
2369 IEnumOleUndoUnits
* This
,
2371 IOleUndoUnit
**rgElt
,
2372 ULONG
*pcEltFetched
)
2376 TRACE("(%u, %p %p)\n", cElt
, rgElt
, pcEltFetched
);
2379 pcEltFetched
= &fetched
;
2381 return IEnumOleUndoUnits_RemoteNext_Proxy(This
, cElt
, rgElt
, pcEltFetched
);
2384 HRESULT __RPC_STUB
IEnumOleUndoUnits_Next_Stub(
2385 IEnumOleUndoUnits
* This
,
2387 IOleUndoUnit
**rgElt
,
2388 ULONG
*pcEltFetched
)
2392 TRACE("(%u, %p, %p)\n", cElt
, rgElt
, pcEltFetched
);
2395 hr
= IEnumOleUndoUnits_Next(This
, cElt
, rgElt
, pcEltFetched
);
2397 *pcEltFetched
= cElt
;
2402 HRESULT CALLBACK
IQuickActivate_QuickActivate_Proxy(
2403 IQuickActivate
* This
,
2404 QACONTAINER
*pQaContainer
,
2405 QACONTROL
*pQaControl
)
2407 FIXME("not implemented\n");
2411 HRESULT __RPC_STUB
IQuickActivate_QuickActivate_Stub(
2412 IQuickActivate
* This
,
2413 QACONTAINER
*pQaContainer
,
2414 QACONTROL
*pQaControl
)
2416 FIXME("not implemented\n");