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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
42 /* FIXME: not supposed to be here */
44 const CLSID CLSID_PSDispatch
= {
45 0x20420, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}
48 static CStdPSFactoryBuffer PSFactoryBuffer
;
50 CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer
)
52 extern const ExtendedProxyFileInfo oaidl_ProxyFileInfo
;
54 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 /* CLEANLOCALSTORAGE */
66 /* I'm not sure how this is supposed to work yet */
68 unsigned long WINAPI
CLEANLOCALSTORAGE_UserSize(unsigned long *pFlags
, unsigned long Start
, CLEANLOCALSTORAGE
*pstg
)
70 return Start
+ sizeof(DWORD
);
73 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserMarshal(unsigned long *pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstg
)
76 return Buffer
+ sizeof(DWORD
);
79 unsigned char * WINAPI
CLEANLOCALSTORAGE_UserUnmarshal(unsigned long *pFlags
, unsigned char *Buffer
, CLEANLOCALSTORAGE
*pstr
)
81 return Buffer
+ sizeof(DWORD
);
84 void WINAPI
CLEANLOCALSTORAGE_UserFree(unsigned long *pFlags
, CLEANLOCALSTORAGE
*pstr
)
90 unsigned long WINAPI
BSTR_UserSize(unsigned long *pFlags
, unsigned long Start
, BSTR
*pstr
)
92 TRACE("(%lx,%ld,%p) => %p\n", *pFlags
, Start
, pstr
, *pstr
);
93 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
94 Start
+= sizeof(FLAGGED_WORD_BLOB
) + sizeof(OLECHAR
) * (SysStringLen(*pstr
) - 1);
95 TRACE("returning %ld\n", Start
);
99 unsigned char * WINAPI
BSTR_UserMarshal(unsigned long *pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
101 wireBSTR str
= (wireBSTR
)Buffer
;
103 TRACE("(%lx,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
104 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
106 str
->clSize
= SysStringLen(*pstr
);
108 memcpy(&str
->asData
, *pstr
, sizeof(OLECHAR
) * str
->clSize
);
109 return Buffer
+ sizeof(FLAGGED_WORD_BLOB
) + sizeof(OLECHAR
) * (str
->clSize
- 1);
112 unsigned char * WINAPI
BSTR_UserUnmarshal(unsigned long *pFlags
, unsigned char *Buffer
, BSTR
*pstr
)
114 wireBSTR str
= (wireBSTR
)Buffer
;
115 TRACE("(%lx,%p,%p) => %p\n", *pFlags
, Buffer
, pstr
, *pstr
);
117 SysReAllocStringLen(pstr
, (OLECHAR
*)&str
->asData
, str
->clSize
);
120 SysFreeString(*pstr
);
123 if (*pstr
) TRACE("string=%s\n", debugstr_w(*pstr
));
124 return Buffer
+ sizeof(FLAGGED_WORD_BLOB
) + sizeof(OLECHAR
) * (str
->clSize
- 1);
127 void WINAPI
BSTR_UserFree(unsigned long *pFlags
, BSTR
*pstr
)
129 TRACE("(%lx,%p) => %p\n", *pFlags
, pstr
, *pstr
);
131 SysFreeString(*pstr
);
137 /* I'm not too sure how to do this yet */
139 #define VARIANT_wiresize sizeof(struct _wireVARIANT)
141 static unsigned wire_size(VARTYPE vt
)
143 if (vt
& VT_ARRAY
) return 0;
145 switch (vt
& ~VT_BYREF
) {
154 return sizeof(SHORT
);
162 return sizeof(FLOAT
);
164 return sizeof(DOUBLE
);
166 return sizeof(VARIANT_BOOL
);
168 return sizeof(SCODE
);
174 return sizeof(DECIMAL
);
183 FIXME("unhandled VT %d\n", vt
);
188 static unsigned interface_variant_size(unsigned long *pFlags
, REFIID riid
, VARIANT
*pvar
)
192 /* find the buffer size of the marshalled dispatch interface */
193 hr
= CoGetMarshalSizeMax(&size
, riid
, V_UNKNOWN(pvar
), LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
195 if (!V_DISPATCH(pvar
))
196 WARN("NULL dispatch pointer\n");
198 ERR("Dispatch variant buffer size calculation failed, HRESULT=0x%lx\n", hr
);
201 size
+= sizeof(ULONG
); /* we have to store the buffersize in the stream */
202 TRACE("wire-size extra of dispatch variant is %ld\n", size
);
206 static unsigned wire_extra(unsigned long *pFlags
, VARIANT
*pvar
)
208 if (V_ISARRAY(pvar
)) {
209 FIXME("wire-size safearray\n");
212 switch (V_VT(pvar
)) {
214 return BSTR_UserSize(pFlags
, 0, &V_BSTR(pvar
));
215 case VT_BSTR
| VT_BYREF
:
216 return BSTR_UserSize(pFlags
, 0, V_BSTRREF(pvar
));
218 case VT_SAFEARRAY
| VT_BYREF
:
219 FIXME("wire-size safearray\n");
221 case VT_VARIANT
| VT_BYREF
:
222 return VARIANT_UserSize(pFlags
, 0, V_VARIANTREF(pvar
));
224 return interface_variant_size(pFlags
, &IID_IUnknown
, pvar
);
226 return interface_variant_size(pFlags
, &IID_IDispatch
, pvar
);
228 FIXME("wire-size record\n");
235 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
236 static unsigned char* interface_variant_marshal(unsigned long *pFlags
, unsigned char *Buffer
, REFIID riid
, VARIANT
*pvar
)
240 void *working_memlocked
;
241 unsigned char *oldpos
;
245 TRACE("pFlags=%ld, Buffer=%p, pvar=%p\n", *pFlags
, Buffer
, pvar
);
249 /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
250 * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
251 * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
252 * but that would be overkill here, hence this implementation. We save the size because the unmarshal
253 * code has no way to know how long the marshalled buffer is. */
255 size
= wire_extra(pFlags
, pvar
);
257 working_mem
= GlobalAlloc(0, size
);
258 if (!working_mem
) return oldpos
;
260 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
262 GlobalFree(working_mem
);
266 hr
= CoMarshalInterface(working
, riid
, V_UNKNOWN(pvar
), LOWORD(*pFlags
), NULL
, MSHLFLAGS_NORMAL
);
268 IStream_Release(working
); /* this also releases the hglobal */
272 working_memlocked
= GlobalLock(working_mem
);
273 memcpy(Buffer
, &size
, sizeof(ULONG
)); /* copy the buffersize */
274 Buffer
+= sizeof(ULONG
);
275 memcpy(Buffer
, working_memlocked
, size
);
276 GlobalUnlock(working_mem
);
278 IStream_Release(working
);
280 TRACE("done, size=%ld\n", sizeof(ULONG
) + size
);
281 return Buffer
+ sizeof(ULONG
) + size
;
284 /* helper: called for VT_DISPATCH / VT_UNKNOWN variants to unmarshal the buffer. returns Buffer on failure, new position otherwise */
285 static unsigned char *interface_variant_unmarshal(unsigned long *pFlags
, unsigned char *Buffer
, REFIID riid
, VARIANT
*pvar
)
289 void *working_memlocked
;
290 unsigned char *oldpos
;
294 TRACE("pFlags=%ld, Buffer=%p, pvar=%p\n", *pFlags
, Buffer
, pvar
);
298 /* get the buffersize */
299 memcpy(&size
, Buffer
, sizeof(ULONG
));
300 TRACE("buffersize=%ld\n", size
);
301 Buffer
+= sizeof(ULONG
);
303 working_mem
= GlobalAlloc(0, size
);
304 if (!working_mem
) return oldpos
;
306 hr
= CreateStreamOnHGlobal(working_mem
, TRUE
, &working
);
308 GlobalFree(working_mem
);
312 working_memlocked
= GlobalLock(working_mem
);
314 /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
315 memcpy(working_memlocked
, Buffer
, size
);
316 GlobalUnlock(working_mem
);
318 hr
= CoUnmarshalInterface(working
, riid
, (void**)&V_UNKNOWN(pvar
));
320 IStream_Release(working
);
324 IStream_Release(working
); /* this also frees the underlying hglobal */
326 TRACE("done, processed=%ld bytes\n", sizeof(ULONG
) + size
);
327 return Buffer
+ sizeof(ULONG
) + size
;
331 unsigned long WINAPI
VARIANT_UserSize(unsigned long *pFlags
, unsigned long Start
, VARIANT
*pvar
)
333 TRACE("(%lx,%ld,%p)\n", *pFlags
, Start
, pvar
);
334 TRACE("vt=%04x\n", V_VT(pvar
));
335 Start
+= VARIANT_wiresize
+ wire_extra(pFlags
, pvar
);
336 TRACE("returning %ld\n", Start
);
340 unsigned char * WINAPI
VARIANT_UserMarshal(unsigned long *pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
342 wireVARIANT var
= (wireVARIANT
)Buffer
;
343 unsigned size
, extra
;
344 unsigned char *Pos
= Buffer
+ VARIANT_wiresize
;
346 TRACE("(%lx,%p,%p)\n", *pFlags
, Buffer
, pvar
);
347 TRACE("vt=%04x\n", V_VT(pvar
));
349 memset(var
, 0, sizeof(*var
));
350 var
->clSize
= sizeof(*var
);
351 var
->vt
= pvar
->n1
.n2
.vt
;
353 var
->rpcReserved
= var
->vt
;
354 if ((var
->vt
& VT_ARRAY
) ||
355 ((var
->vt
& VT_TYPEMASK
) == VT_SAFEARRAY
))
356 var
->vt
= VT_ARRAY
| (var
->vt
& VT_BYREF
);
358 if (var
->vt
== VT_DECIMAL
) {
359 /* special case because decVal is on a different level */
360 var
->u
.decVal
= pvar
->n1
.decVal
;
364 size
= wire_size(V_VT(pvar
));
365 extra
= wire_extra(pFlags
, pvar
);
366 var
->wReserved1
= pvar
->n1
.n2
.wReserved1
;
367 var
->wReserved2
= pvar
->n1
.n2
.wReserved2
;
368 var
->wReserved3
= pvar
->n1
.n2
.wReserved3
;
370 if (var
->vt
& VT_BYREF
)
371 memcpy(&var
->u
.cVal
, pvar
->n1
.n2
.n3
.byref
, size
);
373 memcpy(&var
->u
.cVal
, &pvar
->n1
.n2
.n3
, size
);
375 if (!extra
) return Pos
;
379 Pos
= BSTR_UserMarshal(pFlags
, Pos
, &V_BSTR(pvar
));
381 case VT_BSTR
| VT_BYREF
:
382 Pos
= BSTR_UserMarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
384 case VT_VARIANT
| VT_BYREF
:
385 Pos
= VARIANT_UserMarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
387 case VT_DISPATCH
| VT_BYREF
:
388 FIXME("handle DISPATCH by ref\n");
391 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
392 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IUnknown
, pvar
);
395 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
396 Pos
= interface_variant_marshal(pFlags
, Pos
, &IID_IDispatch
, pvar
);
399 FIXME("handle BRECORD by val\n");
401 case VT_RECORD
| VT_BYREF
:
402 FIXME("handle BRECORD by ref\n");
405 FIXME("handle unknown complex type\n");
408 var
->clSize
= Pos
- Buffer
;
409 TRACE("marshalled size=%ld\n", var
->clSize
);
413 unsigned char * WINAPI
VARIANT_UserUnmarshal(unsigned long *pFlags
, unsigned char *Buffer
, VARIANT
*pvar
)
415 wireVARIANT var
= (wireVARIANT
)Buffer
;
417 unsigned char *Pos
= Buffer
+ VARIANT_wiresize
;
419 TRACE("(%lx,%p,%p)\n", *pFlags
, Buffer
, pvar
);
421 pvar
->n1
.n2
.vt
= var
->rpcReserved
;
422 TRACE("marshalled: clSize=%ld, vt=%04x\n", var
->clSize
, var
->vt
);
423 TRACE("vt=%04x\n", V_VT(pvar
));
424 TRACE("reserved: %d, %d, %d\n", var
->wReserved1
, var
->wReserved2
, var
->wReserved3
);
425 TRACE("val: %ld\n", var
->u
.lVal
);
427 if (var
->vt
== VT_DECIMAL
) {
428 /* special case because decVal is on a different level */
429 pvar
->n1
.decVal
= var
->u
.decVal
;
433 size
= wire_size(V_VT(pvar
));
434 pvar
->n1
.n2
.wReserved1
= var
->wReserved1
;
435 pvar
->n1
.n2
.wReserved2
= var
->wReserved2
;
436 pvar
->n1
.n2
.wReserved3
= var
->wReserved3
;
438 if (var
->vt
& VT_BYREF
) {
439 pvar
->n1
.n2
.n3
.byref
= CoTaskMemAlloc(size
);
440 memcpy(pvar
->n1
.n2
.n3
.byref
, &var
->u
.cVal
, size
);
443 memcpy(&pvar
->n1
.n2
.n3
, &var
->u
.cVal
, size
);
445 if (var
->clSize
<= VARIANT_wiresize
) return Pos
;
449 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, &V_BSTR(pvar
));
451 case VT_BSTR
| VT_BYREF
:
452 pvar
->n1
.n2
.n3
.byref
= CoTaskMemAlloc(sizeof(BSTR
));
453 *(BSTR
*)pvar
->n1
.n2
.n3
.byref
= NULL
;
454 Pos
= BSTR_UserUnmarshal(pFlags
, Pos
, V_BSTRREF(pvar
));
456 case VT_VARIANT
| VT_BYREF
:
457 pvar
->n1
.n2
.n3
.byref
= CoTaskMemAlloc(sizeof(VARIANT
));
458 Pos
= VARIANT_UserUnmarshal(pFlags
, Pos
, V_VARIANTREF(pvar
));
461 FIXME("handle BRECORD by val\n");
463 case VT_RECORD
| VT_BYREF
:
464 FIXME("handle BRECORD by ref\n");
467 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IUnknown
, pvar
);
470 Pos
= interface_variant_unmarshal(pFlags
, Pos
, &IID_IDispatch
, pvar
);
472 case VT_DISPATCH
| VT_BYREF
:
473 FIXME("handle DISPATCH by ref\n");
475 FIXME("handle unknown complex type\n");
478 if (Pos
!= Buffer
+ var
->clSize
) {
479 ERR("size difference during unmarshal\n");
481 return Buffer
+ var
->clSize
;
484 void WINAPI
VARIANT_UserFree(unsigned long *pFlags
, VARIANT
*pvar
)
486 VARTYPE vt
= V_VT(pvar
);
489 TRACE("(%lx,%p)\n", *pFlags
, pvar
);
490 TRACE("vt=%04x\n", V_VT(pvar
));
492 if (vt
& VT_BYREF
) ref
= pvar
->n1
.n2
.n3
.byref
;
498 case VT_BSTR
| VT_BYREF
:
499 BSTR_UserFree(pFlags
, ref
);
501 case VT_VARIANT
| VT_BYREF
:
502 VARIANT_UserFree(pFlags
, ref
);
504 case VT_RECORD
| VT_BYREF
:
505 FIXME("handle BRECORD by ref\n");
509 IUnknown_Release(V_UNKNOWN(pvar
));
512 FIXME("handle unknown complex type\n");
520 /* exactly how Invoke is marshalled is not very clear to me yet,
521 * but the way I've done it seems to work for me */
523 HRESULT CALLBACK
IDispatch_Invoke_Proxy(
529 DISPPARAMS
* pDispParams
,
531 EXCEPINFO
* pExcepInfo
,
536 UINT
* rgVarRefIdx
= NULL
;
537 VARIANTARG
* rgVarRef
= NULL
;
542 TRACE("(%p)->(%ld,%s,%lx,%x,%p,%p,%p,%p)\n", This
,
543 dispIdMember
, debugstr_guid(riid
),
544 lcid
, wFlags
, pDispParams
, pVarResult
,
545 pExcepInfo
, puArgErr
);
547 /* [out] args can't be null, use dummy vars if needed */
548 if (!pVarResult
) pVarResult
= &VarResult
;
549 if (!puArgErr
) puArgErr
= &uArgErr
;
550 if (!pExcepInfo
) pExcepInfo
= &ExcepInfo
;
552 /* count by-ref args */
553 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
554 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
555 if (V_ISBYREF(arg
)) {
560 rgVarRefIdx
= CoTaskMemAlloc(sizeof(UINT
)*cVarRef
);
561 rgVarRef
= CoTaskMemAlloc(sizeof(VARIANTARG
)*cVarRef
);
562 /* make list of by-ref args */
563 for (cVarRef
=0,u
=0; u
<pDispParams
->cArgs
; u
++) {
564 VARIANTARG
* arg
= &pDispParams
->rgvarg
[u
];
565 if (V_ISBYREF(arg
)) {
566 rgVarRefIdx
[cVarRef
] = u
;
567 VariantInit(&rgVarRef
[cVarRef
]);
572 /* [out] args still can't be null,
573 * but we can point these anywhere in this case,
574 * since they won't be written to when cVarRef is 0 */
575 rgVarRefIdx
= puArgErr
;
576 rgVarRef
= pVarResult
;
578 TRACE("passed by ref: %d args\n", cVarRef
);
579 hr
= IDispatch_RemoteInvoke_Proxy(This
,
592 for (u
=0; u
<cVarRef
; u
++) {
593 unsigned i
= rgVarRefIdx
[u
];
594 VariantCopy(&pDispParams
->rgvarg
[i
],
596 VariantClear(&rgVarRef
[u
]);
598 CoTaskMemFree(rgVarRef
);
599 CoTaskMemFree(rgVarRefIdx
);
602 if(pExcepInfo
== &ExcepInfo
)
604 SysFreeString(pExcepInfo
->bstrSource
);
605 SysFreeString(pExcepInfo
->bstrDescription
);
606 SysFreeString(pExcepInfo
->bstrHelpFile
);
611 HRESULT __RPC_STUB
IDispatch_Invoke_Stub(
617 DISPPARAMS
* pDispParams
,
619 EXCEPINFO
* pExcepInfo
,
623 VARIANTARG
* rgVarRef
)
626 VARIANTARG
*rgvarg
, *arg
;
629 /* initialize out parameters, so that they can be marshalled
630 * in case the real Invoke doesn't initialize them */
631 VariantInit(pVarResult
);
632 memset(pExcepInfo
, 0, sizeof(*pExcepInfo
));
635 /* let the real Invoke operate on a copy of the in parameters,
636 * so we don't risk losing pointers to allocated memory */
637 rgvarg
= pDispParams
->rgvarg
;
638 arg
= CoTaskMemAlloc(sizeof(VARIANTARG
)*pDispParams
->cArgs
);
639 if (!arg
) return E_OUTOFMEMORY
;
641 /* init all args so we can call VariantClear on all the args if the copy
643 for (u
= 0; u
< pDispParams
->cArgs
; u
++)
644 VariantInit(&arg
[u
]);
646 for (u
= 0; u
< pDispParams
->cArgs
; u
++) {
647 hr
= VariantCopy(&arg
[u
], &rgvarg
[u
]);
653 pDispParams
->rgvarg
= arg
;
655 hr
= IDispatch_Invoke(This
,
665 /* copy ref args to out list */
666 for (u
=0; u
<cVarRef
; u
++) {
667 unsigned i
= rgVarRefIdx
[u
];
668 VariantInit(&rgVarRef
[u
]);
669 VariantCopy(&rgVarRef
[u
], &arg
[i
]);
670 /* clear original if equal, to avoid double-free */
671 if (V_BYREF(&rgVarRef
[u
]) == V_BYREF(&rgvarg
[i
]))
672 VariantClear(&rgvarg
[i
]);
676 /* clear the duplicate argument list */
677 for (u
=0; u
<pDispParams
->cArgs
; u
++)
678 VariantClear(&arg
[u
]);
680 pDispParams
->rgvarg
= rgvarg
;
688 HRESULT CALLBACK
IEnumVARIANT_Next_Proxy(
696 pCeltFetched
= &fetched
;
697 return IEnumVARIANT_RemoteNext_Proxy(This
,
703 HRESULT __RPC_STUB
IEnumVARIANT_Next_Stub(
711 hr
= IEnumVARIANT_Next(This
,
715 if (hr
== S_OK
) *pCeltFetched
= celt
;
721 HRESULT CALLBACK
ITypeComp_Bind_Proxy(
730 FIXME("not implemented\n");
734 HRESULT __RPC_STUB
ITypeComp_Bind_Stub(
741 LPFUNCDESC
* ppFuncDesc
,
742 LPVARDESC
* ppVarDesc
,
743 ITypeComp
** ppTypeComp
,
744 CLEANLOCALSTORAGE
* pDummy
)
746 FIXME("not implemented\n");
750 HRESULT CALLBACK
ITypeComp_BindType_Proxy(
757 FIXME("not implemented\n");
761 HRESULT __RPC_STUB
ITypeComp_BindType_Stub(
767 FIXME("not implemented\n");
773 HRESULT CALLBACK
ITypeInfo_GetTypeAttr_Proxy(
775 TYPEATTR
** ppTypeAttr
)
777 FIXME("not implemented\n");
781 HRESULT __RPC_STUB
ITypeInfo_GetTypeAttr_Stub(
783 LPTYPEATTR
* ppTypeAttr
,
784 CLEANLOCALSTORAGE
* pDummy
)
786 FIXME("not implemented\n");
790 HRESULT CALLBACK
ITypeInfo_GetFuncDesc_Proxy(
793 FUNCDESC
** ppFuncDesc
)
795 FIXME("not implemented\n");
799 HRESULT __RPC_STUB
ITypeInfo_GetFuncDesc_Stub(
802 LPFUNCDESC
* ppFuncDesc
,
803 CLEANLOCALSTORAGE
* pDummy
)
805 FIXME("not implemented\n");
809 HRESULT CALLBACK
ITypeInfo_GetVarDesc_Proxy(
814 FIXME("not implemented\n");
818 HRESULT __RPC_STUB
ITypeInfo_GetVarDesc_Stub(
821 LPVARDESC
* ppVarDesc
,
822 CLEANLOCALSTORAGE
* pDummy
)
824 FIXME("not implemented\n");
828 HRESULT CALLBACK
ITypeInfo_GetNames_Proxy(
835 FIXME("not implemented\n");
839 HRESULT __RPC_STUB
ITypeInfo_GetNames_Stub(
846 FIXME("not implemented\n");
850 HRESULT CALLBACK
ITypeInfo_GetIDsOfNames_Proxy(
856 FIXME("not implemented\n");
860 HRESULT __RPC_STUB
ITypeInfo_GetIDsOfNames_Stub(
863 FIXME("not implemented\n");
867 HRESULT CALLBACK
ITypeInfo_Invoke_Proxy(
872 DISPPARAMS
* pDispParams
,
874 EXCEPINFO
* pExcepInfo
,
877 FIXME("not implemented\n");
881 HRESULT __RPC_STUB
ITypeInfo_Invoke_Stub(
884 FIXME("not implemented\n");
888 HRESULT CALLBACK
ITypeInfo_GetDocumentation_Proxy(
892 BSTR
* pBstrDocString
,
893 DWORD
* pdwHelpContext
,
896 FIXME("not implemented\n");
900 HRESULT __RPC_STUB
ITypeInfo_GetDocumentation_Stub(
905 BSTR
* pBstrDocString
,
906 DWORD
* pdwHelpContext
,
909 FIXME("not implemented\n");
913 HRESULT CALLBACK
ITypeInfo_GetDllEntry_Proxy(
921 FIXME("not implemented\n");
925 HRESULT __RPC_STUB
ITypeInfo_GetDllEntry_Stub(
934 FIXME("not implemented\n");
938 HRESULT CALLBACK
ITypeInfo_AddressOfMember_Proxy(
944 FIXME("not implemented\n");
948 HRESULT __RPC_STUB
ITypeInfo_AddressOfMember_Stub(
951 FIXME("not implemented\n");
955 HRESULT CALLBACK
ITypeInfo_CreateInstance_Proxy(
961 FIXME("not implemented\n");
965 HRESULT __RPC_STUB
ITypeInfo_CreateInstance_Stub(
970 FIXME("not implemented\n");
974 HRESULT CALLBACK
ITypeInfo_GetContainingTypeLib_Proxy(
983 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
985 hr
= ITypeInfo_RemoteGetContainingTypeLib_Proxy(This
, &pTL
, &index
);
994 ITypeLib_Release(pTL
);
999 HRESULT __RPC_STUB
ITypeInfo_GetContainingTypeLib_Stub(
1004 TRACE("(%p, %p, %p)\n", This
, ppTLib
, pIndex
);
1005 return ITypeInfo_GetContainingTypeLib(This
, ppTLib
, pIndex
);
1008 void CALLBACK
ITypeInfo_ReleaseTypeAttr_Proxy(
1010 TYPEATTR
* pTypeAttr
)
1012 FIXME("not implemented\n");
1015 HRESULT __RPC_STUB
ITypeInfo_ReleaseTypeAttr_Stub(
1018 FIXME("not implemented\n");
1022 void CALLBACK
ITypeInfo_ReleaseFuncDesc_Proxy(
1024 FUNCDESC
* pFuncDesc
)
1026 FIXME("not implemented\n");
1029 HRESULT __RPC_STUB
ITypeInfo_ReleaseFuncDesc_Stub(
1032 FIXME("not implemented\n");
1036 void CALLBACK
ITypeInfo_ReleaseVarDesc_Proxy(
1040 FIXME("not implemented\n");
1043 HRESULT __RPC_STUB
ITypeInfo_ReleaseVarDesc_Stub(
1046 FIXME("not implemented\n");
1053 HRESULT CALLBACK
ITypeInfo2_GetDocumentation2_Proxy(
1057 BSTR
* pbstrHelpString
,
1058 DWORD
* pdwHelpStringContext
,
1059 BSTR
* pbstrHelpStringDll
)
1061 FIXME("not implemented\n");
1065 HRESULT __RPC_STUB
ITypeInfo2_GetDocumentation2_Stub(
1070 BSTR
* pbstrHelpString
,
1071 DWORD
* pdwHelpStringContext
,
1072 BSTR
* pbstrHelpStringDll
)
1074 FIXME("not implemented\n");
1080 UINT CALLBACK
ITypeLib_GetTypeInfoCount_Proxy(
1084 TRACE("(%p)\n", This
);
1086 ITypeLib_RemoteGetTypeInfoCount_Proxy(This
, &count
);
1091 HRESULT __RPC_STUB
ITypeLib_GetTypeInfoCount_Stub(
1095 TRACE("(%p, %p)\n", This
, pcTInfo
);
1096 *pcTInfo
= ITypeLib_GetTypeInfoCount(This
);
1100 HRESULT CALLBACK
ITypeLib_GetLibAttr_Proxy(
1102 TLIBATTR
** ppTLibAttr
)
1104 CLEANLOCALSTORAGE stg
;
1105 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1106 return ITypeLib_RemoteGetLibAttr_Proxy(This
, ppTLibAttr
, &stg
);
1109 HRESULT __RPC_STUB
ITypeLib_GetLibAttr_Stub(
1111 LPTLIBATTR
* ppTLibAttr
,
1112 CLEANLOCALSTORAGE
* pDummy
)
1114 TRACE("(%p, %p)\n", This
, ppTLibAttr
);
1115 return ITypeLib_GetLibAttr(This
, ppTLibAttr
);
1118 HRESULT CALLBACK
ITypeLib_GetDocumentation_Proxy(
1122 BSTR
* pBstrDocString
,
1123 DWORD
* pdwHelpContext
,
1124 BSTR
* pBstrHelpFile
)
1126 FIXME("not implemented\n");
1130 HRESULT __RPC_STUB
ITypeLib_GetDocumentation_Stub(
1135 BSTR
* pBstrDocString
,
1136 DWORD
* pdwHelpContext
,
1137 BSTR
* pBstrHelpFile
)
1139 FIXME("not implemented\n");
1143 HRESULT CALLBACK
ITypeLib_IsName_Proxy(
1149 FIXME("not implemented\n");
1153 HRESULT __RPC_STUB
ITypeLib_IsName_Stub(
1160 FIXME("not implemented\n");
1164 HRESULT CALLBACK
ITypeLib_FindName_Proxy(
1168 ITypeInfo
** ppTInfo
,
1172 FIXME("not implemented\n");
1176 HRESULT __RPC_STUB
ITypeLib_FindName_Stub(
1180 ITypeInfo
** ppTInfo
,
1185 FIXME("not implemented\n");
1189 void CALLBACK
ITypeLib_ReleaseTLibAttr_Proxy(
1191 TLIBATTR
* pTLibAttr
)
1193 TRACE("(%p, %p)\n", This
, pTLibAttr
);
1194 CoTaskMemFree(pTLibAttr
);
1197 HRESULT __RPC_STUB
ITypeLib_ReleaseTLibAttr_Stub(
1200 TRACE("nothing to do\n");
1207 HRESULT CALLBACK
ITypeLib2_GetLibStatistics_Proxy(
1209 ULONG
* pcUniqueNames
,
1210 ULONG
* pcchUniqueNames
)
1212 FIXME("not implemented\n");
1216 HRESULT __RPC_STUB
ITypeLib2_GetLibStatistics_Stub(
1218 ULONG
* pcUniqueNames
,
1219 ULONG
* pcchUniqueNames
)
1221 FIXME("not implemented\n");
1225 HRESULT CALLBACK
ITypeLib2_GetDocumentation2_Proxy(
1229 BSTR
* pbstrHelpString
,
1230 DWORD
* pdwHelpStringContext
,
1231 BSTR
* pbstrHelpStringDll
)
1233 FIXME("not implemented\n");
1237 HRESULT __RPC_STUB
ITypeLib2_GetDocumentation2_Stub(
1242 BSTR
* pbstrHelpString
,
1243 DWORD
* pdwHelpStringContext
,
1244 BSTR
* pbstrHelpStringDll
)
1246 FIXME("not implemented\n");