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 wire_extra(unsigned long *pFlags, VARIANT *pvar)
193 if (V_ISARRAY(pvar)) {
194 FIXME("wire-size safearray\n");
197 switch (V_VT(pvar)) {
199 return BSTR_UserSize(pFlags, 0, &V_BSTR(pvar));
200 case VT_BSTR | VT_BYREF:
201 return BSTR_UserSize(pFlags, 0, V_BSTRREF(pvar));
203 case VT_SAFEARRAY | VT_BYREF:
204 FIXME("wire-size safearray\n");
206 case VT_VARIANT | VT_BYREF:
207 return VARIANT_UserSize(pFlags, 0, V_VARIANTREF(pvar));
210 /* find the buffer size of the marshalled dispatch interface */
211 hr = CoGetMarshalSizeMax(&size, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar), LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
213 if (!V_DISPATCH(pvar))
214 WARN("NULL dispatch pointer\n");
216 ERR("Dispatch variant buffer size calculation failed, HRESULT=0x%lx\n", hr);
219 size += sizeof(ULONG); /* we have to store the buffersize in the stream */
220 TRACE("wire-size extra of dispatch variant is %ld\n", size);
223 FIXME("wire-size record\n");
230 /* helper: called for VT_DISPATCH variants to marshal the IDispatch* into the buffer. returns Buffer on failure, new position otherwise */
231 static unsigned char* dispatch_variant_marshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar) {
234 void *working_memlocked;
235 unsigned char *oldpos;
239 TRACE("pFlags=%ld, Buffer=%p, pvar=%p\n", *pFlags, Buffer, pvar);
243 /* CoMarshalInterface needs a stream, whereas at this level we are operating in terms of buffers.
244 * We create a stream on an HGLOBAL, so we can simply do a memcpy to move it to the buffer.
245 * in rpcrt4/ndr_ole.c, a simple IStream implementation is wrapped around the buffer object,
246 * but that would be overkill here, hence this implementation. We save the size because the unmarshal
247 * code has no way to know how long the marshalled buffer is. */
249 size = wire_extra(pFlags, pvar);
251 working_mem = GlobalAlloc(0, size);
252 if (!working_mem) return oldpos;
254 hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
256 GlobalFree(working_mem);
260 hr = CoMarshalInterface(working, &IID_IDispatch, (IUnknown*)V_DISPATCH(pvar), LOWORD(*pFlags), NULL, MSHLFLAGS_NORMAL);
262 IStream_Release(working); /* this also releases the hglobal */
266 working_memlocked = GlobalLock(working_mem);
267 memcpy(Buffer, &size, sizeof(ULONG)); /* copy the buffersize */
268 Buffer += sizeof(ULONG);
269 memcpy(Buffer, working_memlocked, size);
270 GlobalUnlock(working_mem);
272 IStream_Release(working);
274 TRACE("done, size=%ld\n", sizeof(ULONG) + size);
275 return Buffer + sizeof(ULONG) + size;
278 /* helper: called for VT_DISPATCH variants to unmarshal the buffer back into a dispatch variant. returns Buffer on failure, new position otherwise */
279 static unsigned char *dispatch_variant_unmarshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar) {
282 void *working_memlocked;
283 unsigned char *oldpos;
287 TRACE("pFlags=%ld, Buffer=%p, pvar=%p\n", *pFlags, Buffer, pvar);
291 /* get the buffersize */
292 memcpy(&size, Buffer, sizeof(ULONG));
293 TRACE("buffersize=%ld\n", size);
294 Buffer += sizeof(ULONG);
296 working_mem = GlobalAlloc(0, size);
297 if (!working_mem) return oldpos;
299 hr = CreateStreamOnHGlobal(working_mem, TRUE, &working);
301 GlobalFree(working_mem);
305 working_memlocked = GlobalLock(working_mem);
307 /* now we copy the contents of the marshalling buffer to working_memlocked, unlock it, and demarshal the stream */
308 memcpy(working_memlocked, Buffer, size);
309 GlobalUnlock(working_mem);
311 hr = CoUnmarshalInterface(working, &IID_IDispatch, (void**)&V_DISPATCH(pvar));
313 IStream_Release(working);
317 IStream_Release(working); /* this also frees the underlying hglobal */
319 TRACE("done, processed=%ld bytes\n", sizeof(ULONG) + size);
320 return Buffer + sizeof(ULONG) + size;
324 unsigned long WINAPI VARIANT_UserSize(unsigned long *pFlags, unsigned long Start, VARIANT *pvar)
326 TRACE("(%lx,%ld,%p)\n", *pFlags, Start, pvar);
327 TRACE("vt=%04x\n", V_VT(pvar));
328 Start += VARIANT_wiresize + wire_extra(pFlags, pvar);
329 TRACE("returning %ld\n", Start);
333 unsigned char * WINAPI VARIANT_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar)
335 wireVARIANT var = (wireVARIANT)Buffer;
336 unsigned size, extra;
337 unsigned char *Pos = Buffer + VARIANT_wiresize;
339 TRACE("(%lx,%p,%p)\n", *pFlags, Buffer, pvar);
340 TRACE("vt=%04x\n", V_VT(pvar));
342 memset(var, 0, sizeof(*var));
343 var->clSize = sizeof(*var);
344 var->vt = pvar->n1.n2.vt;
346 var->rpcReserved = var->vt;
347 if ((var->vt & VT_ARRAY) ||
348 ((var->vt & VT_TYPEMASK) == VT_SAFEARRAY))
349 var->vt = VT_ARRAY | (var->vt & VT_BYREF);
351 if (var->vt == VT_DECIMAL) {
352 /* special case because decVal is on a different level */
353 var->u.decVal = pvar->n1.decVal;
357 size = wire_size(V_VT(pvar));
358 extra = wire_extra(pFlags, pvar);
359 var->wReserved1 = pvar->n1.n2.wReserved1;
360 var->wReserved2 = pvar->n1.n2.wReserved2;
361 var->wReserved3 = pvar->n1.n2.wReserved3;
363 if (var->vt & VT_BYREF)
364 memcpy(&var->u.cVal, pvar->n1.n2.n3.byref, size);
366 memcpy(&var->u.cVal, &pvar->n1.n2.n3, size);
368 if (!extra) return Pos;
372 Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
374 case VT_BSTR | VT_BYREF:
375 Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
377 case VT_VARIANT | VT_BYREF:
378 Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
380 case VT_DISPATCH | VT_BYREF:
381 FIXME("handle DISPATCH by ref\n");
384 /* this should probably call WdtpInterfacePointer_UserMarshal in ole32.dll */
385 Pos = dispatch_variant_marshal(pFlags, Pos, pvar);
388 FIXME("handle BRECORD by val\n");
390 case VT_RECORD | VT_BYREF:
391 FIXME("handle BRECORD by ref\n");
394 FIXME("handle unknown complex type\n");
397 var->clSize = Pos - Buffer;
398 TRACE("marshalled size=%ld\n", var->clSize);
402 unsigned char * WINAPI VARIANT_UserUnmarshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar)
404 wireVARIANT var = (wireVARIANT)Buffer;
406 unsigned char *Pos = Buffer + VARIANT_wiresize;
408 TRACE("(%lx,%p,%p)\n", *pFlags, Buffer, pvar);
410 pvar->n1.n2.vt = var->rpcReserved;
411 TRACE("marshalled: clSize=%ld, vt=%04x\n", var->clSize, var->vt);
412 TRACE("vt=%04x\n", V_VT(pvar));
413 TRACE("reserved: %d, %d, %d\n", var->wReserved1, var->wReserved2, var->wReserved3);
414 TRACE("val: %ld\n", var->u.lVal);
416 if (var->vt == VT_DECIMAL) {
417 /* special case because decVal is on a different level */
418 pvar->n1.decVal = var->u.decVal;
422 size = wire_size(V_VT(pvar));
423 pvar->n1.n2.wReserved1 = var->wReserved1;
424 pvar->n1.n2.wReserved2 = var->wReserved2;
425 pvar->n1.n2.wReserved3 = var->wReserved3;
427 if (var->vt & VT_BYREF) {
428 pvar->n1.n2.n3.byref = CoTaskMemAlloc(size);
429 memcpy(pvar->n1.n2.n3.byref, &var->u.cVal, size);
432 memcpy(&pvar->n1.n2.n3, &var->u.cVal, size);
434 if (var->clSize <= VARIANT_wiresize) return Pos;
438 Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
440 case VT_BSTR | VT_BYREF:
441 pvar->n1.n2.n3.byref = CoTaskMemAlloc(sizeof(BSTR));
442 *(BSTR*)pvar->n1.n2.n3.byref = NULL;
443 Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
445 case VT_VARIANT | VT_BYREF:
446 pvar->n1.n2.n3.byref = CoTaskMemAlloc(sizeof(VARIANT));
447 Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
450 FIXME("handle BRECORD by val\n");
452 case VT_RECORD | VT_BYREF:
453 FIXME("handle BRECORD by ref\n");
456 Pos = dispatch_variant_unmarshal(pFlags, Pos, pvar);
458 case VT_DISPATCH | VT_BYREF:
459 FIXME("handle DISPATCH by ref\n");
461 FIXME("handle unknown complex type\n");
464 if (Pos != Buffer + var->clSize) {
465 ERR("size difference during unmarshal\n");
467 return Buffer + var->clSize;
470 void WINAPI VARIANT_UserFree(unsigned long *pFlags, VARIANT *pvar)
472 VARTYPE vt = V_VT(pvar);
475 TRACE("(%lx,%p)\n", *pFlags, pvar);
476 TRACE("vt=%04x\n", V_VT(pvar));
478 if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
484 case VT_BSTR | VT_BYREF:
485 BSTR_UserFree(pFlags, ref);
487 case VT_VARIANT | VT_BYREF:
488 VARIANT_UserFree(pFlags, ref);
490 case VT_RECORD | VT_BYREF:
491 FIXME("handle BRECORD by ref\n");
494 FIXME("handle unknown complex type\n");
502 /* exactly how Invoke is marshalled is not very clear to me yet,
503 * but the way I've done it seems to work for me */
505 HRESULT CALLBACK IDispatch_Invoke_Proxy(
511 DISPPARAMS* pDispParams,
513 EXCEPINFO* pExcepInfo,
518 UINT* rgVarRefIdx = NULL;
519 VARIANTARG* rgVarRef = NULL;
523 TRACE("(%p)->(%ld,%s,%lx,%x,%p,%p,%p,%p)\n", This,
524 dispIdMember, debugstr_guid(riid),
525 lcid, wFlags, pDispParams, pVarResult,
526 pExcepInfo, puArgErr);
528 /* [out] args can't be null, use dummy vars if needed */
529 if (!pVarResult) pVarResult = &VarResult;
530 if (!puArgErr) puArgErr = &uArgErr;
532 /* count by-ref args */
533 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
534 VARIANTARG* arg = &pDispParams->rgvarg[u];
535 if (V_ISBYREF(arg)) {
540 rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
541 rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
542 /* make list of by-ref args */
543 for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
544 VARIANTARG* arg = &pDispParams->rgvarg[u];
545 if (V_ISBYREF(arg)) {
546 rgVarRefIdx[cVarRef] = u;
547 VariantInit(&rgVarRef[cVarRef]);
552 /* [out] args still can't be null,
553 * but we can point these anywhere in this case,
554 * since they won't be written to when cVarRef is 0 */
555 rgVarRefIdx = puArgErr;
556 rgVarRef = pVarResult;
558 TRACE("passed by ref: %d args\n", cVarRef);
559 hr = IDispatch_RemoteInvoke_Proxy(This,
572 for (u=0; u<cVarRef; u++) {
573 unsigned i = rgVarRefIdx[u];
574 VariantCopy(&pDispParams->rgvarg[i],
576 VariantClear(&rgVarRef[u]);
578 CoTaskMemFree(rgVarRef);
579 CoTaskMemFree(rgVarRefIdx);
584 HRESULT __RPC_STUB IDispatch_Invoke_Stub(
590 DISPPARAMS* pDispParams,
592 EXCEPINFO* pExcepInfo,
596 VARIANTARG* rgVarRef)
599 VARIANTARG *rgvarg, *arg;
602 /* initialize out parameters, so that they can be marshalled
603 * in case the real Invoke doesn't initialize them */
604 VariantInit(pVarResult);
605 memset(pExcepInfo, 0, sizeof(*pExcepInfo));
608 /* let the real Invoke operate on a copy of the in parameters,
609 * so we don't risk losing pointers to allocated memory */
610 rgvarg = pDispParams->rgvarg;
611 arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
612 if (!arg) return E_OUTOFMEMORY;
614 /* init all args so we can call VariantClear on all the args if the copy
616 for (u = 0; u < pDispParams->cArgs; u++)
617 VariantInit(&arg[u]);
619 for (u = 0; u < pDispParams->cArgs; u++) {
620 hr = VariantCopy(&arg[u], &rgvarg[u]);
626 pDispParams->rgvarg = arg;
628 hr = IDispatch_Invoke(This,
638 /* copy ref args to out list */
639 for (u=0; u<cVarRef; u++) {
640 unsigned i = rgVarRefIdx[u];
641 VariantInit(&rgVarRef[u]);
642 VariantCopy(&rgVarRef[u], &arg[i]);
643 /* clear original if equal, to avoid double-free */
644 if (V_BYREF(&rgVarRef[u]) == V_BYREF(&rgvarg[i]))
645 VariantClear(&rgvarg[i]);
649 /* clear the duplicate argument list */
650 for (u=0; u<pDispParams->cArgs; u++)
651 VariantClear(&arg[u]);
653 pDispParams->rgvarg = rgvarg;
661 HRESULT CALLBACK IEnumVARIANT_Next_Proxy(
669 pCeltFetched = &fetched;
670 return IEnumVARIANT_RemoteNext_Proxy(This,
676 HRESULT __RPC_STUB IEnumVARIANT_Next_Stub(
684 hr = IEnumVARIANT_Next(This,
688 if (hr == S_OK) *pCeltFetched = celt;
694 HRESULT CALLBACK ITypeComp_Bind_Proxy(
703 FIXME("not implemented\n");
707 HRESULT __RPC_STUB ITypeComp_Bind_Stub(
714 LPFUNCDESC* ppFuncDesc,
715 LPVARDESC* ppVarDesc,
716 ITypeComp** ppTypeComp,
717 CLEANLOCALSTORAGE* pDummy)
719 FIXME("not implemented\n");
723 HRESULT CALLBACK ITypeComp_BindType_Proxy(
730 FIXME("not implemented\n");
734 HRESULT __RPC_STUB ITypeComp_BindType_Stub(
740 FIXME("not implemented\n");
746 HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy(
748 TYPEATTR** ppTypeAttr)
750 FIXME("not implemented\n");
754 HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub(
756 LPTYPEATTR* ppTypeAttr,
757 CLEANLOCALSTORAGE* pDummy)
759 FIXME("not implemented\n");
763 HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy(
766 FUNCDESC** ppFuncDesc)
768 FIXME("not implemented\n");
772 HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub(
775 LPFUNCDESC* ppFuncDesc,
776 CLEANLOCALSTORAGE* pDummy)
778 FIXME("not implemented\n");
782 HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy(
787 FIXME("not implemented\n");
791 HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub(
794 LPVARDESC* ppVarDesc,
795 CLEANLOCALSTORAGE* pDummy)
797 FIXME("not implemented\n");
801 HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
808 FIXME("not implemented\n");
812 HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
819 FIXME("not implemented\n");
823 HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy(
829 FIXME("not implemented\n");
833 HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub(
836 FIXME("not implemented\n");
840 HRESULT CALLBACK ITypeInfo_Invoke_Proxy(
845 DISPPARAMS* pDispParams,
847 EXCEPINFO* pExcepInfo,
850 FIXME("not implemented\n");
854 HRESULT __RPC_STUB ITypeInfo_Invoke_Stub(
857 FIXME("not implemented\n");
861 HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(
865 BSTR* pBstrDocString,
866 DWORD* pdwHelpContext,
869 FIXME("not implemented\n");
873 HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(
878 BSTR* pBstrDocString,
879 DWORD* pdwHelpContext,
882 FIXME("not implemented\n");
886 HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(
894 FIXME("not implemented\n");
898 HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(
907 FIXME("not implemented\n");
911 HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy(
917 FIXME("not implemented\n");
921 HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub(
924 FIXME("not implemented\n");
928 HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy(
934 FIXME("not implemented\n");
938 HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub(
943 FIXME("not implemented\n");
947 HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy(
952 FIXME("not implemented\n");
956 HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub(
961 FIXME("not implemented\n");
965 void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy(
969 FIXME("not implemented\n");
972 HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub(
975 FIXME("not implemented\n");
979 void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy(
983 FIXME("not implemented\n");
986 HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub(
989 FIXME("not implemented\n");
993 void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
997 FIXME("not implemented\n");
1000 HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub(
1003 FIXME("not implemented\n");
1010 HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(
1014 BSTR* pbstrHelpString,
1015 DWORD* pdwHelpStringContext,
1016 BSTR* pbstrHelpStringDll)
1018 FIXME("not implemented\n");
1022 HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(
1027 BSTR* pbstrHelpString,
1028 DWORD* pdwHelpStringContext,
1029 BSTR* pbstrHelpStringDll)
1031 FIXME("not implemented\n");
1037 UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy(
1040 FIXME("not implemented\n");
1044 HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub(
1048 FIXME("not implemented\n");
1052 HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy(
1054 TLIBATTR** ppTLibAttr)
1056 FIXME("not implemented\n");
1060 HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub(
1062 LPTLIBATTR* ppTLibAttr,
1063 CLEANLOCALSTORAGE* pDummy)
1065 FIXME("not implemented\n");
1069 HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy(
1073 BSTR* pBstrDocString,
1074 DWORD* pdwHelpContext,
1075 BSTR* pBstrHelpFile)
1077 FIXME("not implemented\n");
1081 HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(
1086 BSTR* pBstrDocString,
1087 DWORD* pdwHelpContext,
1088 BSTR* pBstrHelpFile)
1090 FIXME("not implemented\n");
1094 HRESULT CALLBACK ITypeLib_IsName_Proxy(
1100 FIXME("not implemented\n");
1104 HRESULT __RPC_STUB ITypeLib_IsName_Stub(
1111 FIXME("not implemented\n");
1115 HRESULT CALLBACK ITypeLib_FindName_Proxy(
1119 ITypeInfo** ppTInfo,
1123 FIXME("not implemented\n");
1127 HRESULT __RPC_STUB ITypeLib_FindName_Stub(
1131 ITypeInfo** ppTInfo,
1136 FIXME("not implemented\n");
1140 void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy(
1142 TLIBATTR* pTLibAttr)
1144 FIXME("not implemented\n");
1147 HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub(
1150 FIXME("not implemented\n");
1157 HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy(
1159 ULONG* pcUniqueNames,
1160 ULONG* pcchUniqueNames)
1162 FIXME("not implemented\n");
1166 HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub(
1168 ULONG* pcUniqueNames,
1169 ULONG* pcchUniqueNames)
1171 FIXME("not implemented\n");
1175 HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(
1179 BSTR* pbstrHelpString,
1180 DWORD* pdwHelpStringContext,
1181 BSTR* pbstrHelpStringDll)
1183 FIXME("not implemented\n");
1187 HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(
1192 BSTR* pbstrHelpString,
1193 DWORD* pdwHelpStringContext,
1194 BSTR* pbstrHelpStringDll)
1196 FIXME("not implemented\n");