git.oblomov.eu Git - wine/blob - dlls/oleaut32/usrmarshal.c

   1 /*
   2  * Misc marshalling routines
   3  *
   4  * Copyright 2002 Ove Kaaven
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "winerror.h"
  31
  32 #include "ole2.h"
  33 #include "oleauto.h"
  34 #include "rpcproxy.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  38
  39 /* FIXME: not supposed to be here */
  40
  41 const CLSID CLSID_PSDispatch = {
  42   0x20420, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}
  43 };
  44
  45 static CStdPSFactoryBuffer PSFactoryBuffer;
  46
  47 CSTDSTUBBUFFERRELEASE(&PSFactoryBuffer)
  48
  49 extern const ExtendedProxyFileInfo oaidl_ProxyFileInfo;
  50
  51 const ProxyFileInfo* OLEAUT32_ProxyFileList[] = {
  52   &oaidl_ProxyFileInfo,
  53   NULL
  54 };
  55
  56 HRESULT OLEAUTPS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
  57 {
  58   return NdrDllGetClassObject(rclsid, riid, ppv, OLEAUT32_ProxyFileList,
  59                               &CLSID_PSDispatch, &PSFactoryBuffer);
  60 }
  61
  62 /* CLEANLOCALSTORAGE */
  63 /* I'm not sure how this is supposed to work yet */
  64
  65 unsigned long WINAPI CLEANLOCALSTORAGE_UserSize(unsigned long *pFlags, unsigned long Start, CLEANLOCALSTORAGE *pstg)
  66 {
  67   return Start + sizeof(DWORD);
  68 }
  69
  70 unsigned char * WINAPI CLEANLOCALSTORAGE_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstg)
  71 {
  72   *(DWORD*)Buffer = 0;
  73   return Buffer + sizeof(DWORD);
  74 }
  75
  76 unsigned char * WINAPI CLEANLOCALSTORAGE_UserUnmarshal(unsigned long *pFlags, unsigned char *Buffer, CLEANLOCALSTORAGE *pstr)
  77 {
  78   return Buffer + sizeof(DWORD);
  79 }
  80
  81 void WINAPI CLEANLOCALSTORAGE_UserFree(unsigned long *pFlags, CLEANLOCALSTORAGE *pstr)
  82 {
  83 }
  84
  85 /* BSTR */
  86
  87 unsigned long WINAPI BSTR_UserSize(unsigned long *pFlags, unsigned long Start, BSTR *pstr)
  88 {
  89   TRACE("(%lx,%ld,%p) => %p\n", *pFlags, Start, pstr, *pstr);
  90   if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
  91   Start += sizeof(FLAGGED_WORD_BLOB) + sizeof(OLECHAR) * (SysStringLen(*pstr) - 1);
  92   TRACE("returning %ld\n", Start);
  93   return Start;
  94 }
  95
  96 unsigned char * WINAPI BSTR_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, BSTR *pstr)
  97 {
  98   wireBSTR str = (wireBSTR)Buffer;
  99
 100   TRACE("(%lx,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
 101   if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 102   str->fFlags = 0;
 103   str->clSize = SysStringLen(*pstr);
 104   if (str->clSize)
 105     memcpy(&str->asData, *pstr, sizeof(OLECHAR) * str->clSize);
 106   return Buffer + sizeof(FLAGGED_WORD_BLOB) + sizeof(OLECHAR) * (str->clSize - 1);
 107 }
 108
 109 unsigned char * WINAPI BSTR_UserUnmarshal(unsigned long *pFlags, unsigned char *Buffer, BSTR *pstr)
 110 {
 111   wireBSTR str = (wireBSTR)Buffer;
 112   TRACE("(%lx,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
 113   if (str->clSize) {
 114     SysReAllocStringLen(pstr, (OLECHAR*)&str->asData, str->clSize);
 115   }
 116   else if (*pstr) {
 117     SysFreeString(*pstr);
 118     *pstr = NULL;
 119   }
 120   if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
 121   return Buffer + sizeof(FLAGGED_WORD_BLOB) + sizeof(OLECHAR) * (str->clSize - 1);
 122 }
 123
 124 void WINAPI BSTR_UserFree(unsigned long *pFlags, BSTR *pstr)
 125 {
 126   TRACE("(%lx,%p) => %p\n", *pFlags, pstr, *pstr);
 127   if (*pstr) {
 128     SysFreeString(*pstr);
 129     *pstr = NULL;
 130   }
 131 }
 132
 133 /* VARIANT */
 134 /* I'm not too sure how to do this yet */
 135
 136 #define VARIANT_wiresize sizeof(struct _wireVARIANT)
 137
 138 static unsigned wire_size(VARTYPE vt)
 139 {
 140   if (vt & VT_ARRAY) return 0;
 141
 142   switch (vt & ~VT_BYREF) {
 143   case VT_EMPTY:
 144   case VT_NULL:
 145     return 0;
 146   case VT_I1:
 147   case VT_UI1:
 148     return sizeof(CHAR);
 149   case VT_I2:
 150   case VT_UI2:
 151     return sizeof(SHORT);
 152   case VT_I4:
 153   case VT_UI4:
 154     return sizeof(LONG);
 155   case VT_INT:
 156   case VT_UINT:
 157     return sizeof(INT);
 158   case VT_R4:
 159     return sizeof(FLOAT);
 160   case VT_R8:
 161     return sizeof(DOUBLE);
 162   case VT_BOOL:
 163     return sizeof(VARIANT_BOOL);
 164   case VT_ERROR:
 165     return sizeof(SCODE);
 166   case VT_DATE:
 167     return sizeof(DATE);
 168   case VT_CY:
 169     return sizeof(CY);
 170   case VT_DECIMAL:
 171     return sizeof(DECIMAL);
 172   case VT_BSTR:
 173   case VT_VARIANT:
 174   case VT_UNKNOWN:
 175   case VT_DISPATCH:
 176   case VT_SAFEARRAY:
 177   case VT_RECORD:
 178     return 0;
 179   default:
 180     FIXME("unhandled VT %d\n", vt);
 181     return 0;
 182   }
 183 }
 184
 185 static unsigned wire_extra(unsigned long *pFlags, VARIANT *pvar)
 186 {
 187   if (V_VT(pvar) & VT_ARRAY) {
 188     FIXME("wire-size safearray\n");
 189     return 0;
 190   }
 191   switch (V_VT(pvar)) {
 192   case VT_BSTR:
 193     return BSTR_UserSize(pFlags, 0, &V_BSTR(pvar));
 194   case VT_BSTR | VT_BYREF:
 195     return BSTR_UserSize(pFlags, 0, V_BSTRREF(pvar));
 196   case VT_SAFEARRAY:
 197   case VT_SAFEARRAY | VT_BYREF:
 198     FIXME("wire-size safearray\n");
 199     return 0;
 200   case VT_VARIANT | VT_BYREF:
 201     return VARIANT_UserSize(pFlags, 0, V_VARIANTREF(pvar));
 202   case VT_UNKNOWN:
 203   case VT_DISPATCH:
 204     FIXME("wire-size interfaces\n");
 205     return 0;
 206   case VT_RECORD:
 207     FIXME("wire-size record\n");
 208     return 0;
 209   default:
 210     return 0;
 211   }
 212 }
 213
 214 unsigned long WINAPI VARIANT_UserSize(unsigned long *pFlags, unsigned long Start, VARIANT *pvar)
 215 {
 216   TRACE("(%lx,%ld,%p)\n", *pFlags, Start, pvar);
 217   TRACE("vt=%04x\n", V_VT(pvar));
 218   Start += VARIANT_wiresize + wire_extra(pFlags, pvar);
 219   TRACE("returning %ld\n", Start);
 220   return Start;
 221 }
 222
 223 unsigned char * WINAPI VARIANT_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar)
 224 {
 225   wireVARIANT var = (wireVARIANT)Buffer;
 226   unsigned size, extra;
 227   unsigned char *Pos = Buffer + VARIANT_wiresize;
 228
 229   TRACE("(%lx,%p,%p)\n", *pFlags, Buffer, pvar);
 230   TRACE("vt=%04x\n", V_VT(pvar));
 231
 232   memset(var, 0, sizeof(*var));
 233   var->clSize = sizeof(*var);
 234   var->vt = pvar->n1.n2.vt;
 235
 236   var->rpcReserved = var->vt;
 237   if ((var->vt & VT_ARRAY) ||
 238       ((var->vt & VT_TYPEMASK) == VT_SAFEARRAY))
 239     var->vt = VT_ARRAY | (var->vt & VT_BYREF);
 240
 241   if (var->vt == VT_DECIMAL) {
 242     /* special case because decVal is on a different level */
 243     var->u.decVal = pvar->n1.decVal;
 244     return Pos;
 245   }
 246
 247   size = wire_size(V_VT(pvar));
 248   extra = wire_extra(pFlags, pvar);
 249   var->wReserved1 = pvar->n1.n2.wReserved1;
 250   var->wReserved2 = pvar->n1.n2.wReserved2;
 251   var->wReserved3 = pvar->n1.n2.wReserved3;
 252   if (size) {
 253     if (var->vt & VT_BYREF)
 254       memcpy(&var->u.cVal, pvar->n1.n2.n3.byref, size);
 255     else
 256       memcpy(&var->u.cVal, &pvar->n1.n2.n3, size);
 257   }
 258   if (!extra) return Pos;
 259
 260   switch (var->vt) {
 261   case VT_BSTR:
 262     Pos = BSTR_UserMarshal(pFlags, Pos, &V_BSTR(pvar));
 263     break;
 264   case VT_BSTR | VT_BYREF:
 265     Pos = BSTR_UserMarshal(pFlags, Pos, V_BSTRREF(pvar));
 266     break;
 267   case VT_VARIANT | VT_BYREF:
 268     Pos = VARIANT_UserMarshal(pFlags, Pos, V_VARIANTREF(pvar));
 269     break;
 270   case VT_RECORD:
 271     FIXME("handle BRECORD by val\n");
 272     break;
 273   case VT_RECORD | VT_BYREF:
 274     FIXME("handle BRECORD by ref\n");
 275     break;
 276   default:
 277     FIXME("handle unknown complex type\n");
 278     break;
 279   }
 280   var->clSize = Pos - Buffer;
 281   TRACE("marshalled size=%ld\n", var->clSize);
 282   return Pos;
 283 }
 284
 285 unsigned char * WINAPI VARIANT_UserUnmarshal(unsigned long *pFlags, unsigned char *Buffer, VARIANT *pvar)
 286 {
 287   wireVARIANT var = (wireVARIANT)Buffer;
 288   unsigned size;
 289   unsigned char *Pos = Buffer + VARIANT_wiresize;
 290
 291   TRACE("(%lx,%p,%p)\n", *pFlags, Buffer, pvar);
 292   VariantInit(pvar);
 293   pvar->n1.n2.vt = var->rpcReserved;
 294   TRACE("marshalled: clSize=%ld, vt=%04x\n", var->clSize, var->vt);
 295   TRACE("vt=%04x\n", V_VT(pvar));
 296   TRACE("reserved: %d, %d, %d\n", var->wReserved1, var->wReserved2, var->wReserved3);
 297   TRACE("val: %ld\n", var->u.lVal);
 298
 299   if (var->vt == VT_DECIMAL) {
 300     /* special case because decVal is on a different level */
 301     pvar->n1.decVal = var->u.decVal;
 302     return Pos;
 303   }
 304
 305   size = wire_size(V_VT(pvar));
 306   pvar->n1.n2.wReserved1 = var->wReserved1;
 307   pvar->n1.n2.wReserved2 = var->wReserved2;
 308   pvar->n1.n2.wReserved3 = var->wReserved3;
 309   if (size) {
 310     if (var->vt & VT_BYREF) {
 311       pvar->n1.n2.n3.byref = CoTaskMemAlloc(size);
 312       memcpy(pvar->n1.n2.n3.byref, &var->u.cVal, size);
 313     }
 314     else
 315       memcpy(&pvar->n1.n2.n3, &var->u.cVal, size);
 316   }
 317   if (var->clSize <= VARIANT_wiresize) return Pos;
 318
 319   switch (var->vt) {
 320   case VT_BSTR:
 321     Pos = BSTR_UserUnmarshal(pFlags, Pos, &V_BSTR(pvar));
 322     break;
 323   case VT_BSTR | VT_BYREF:
 324     pvar->n1.n2.n3.byref = CoTaskMemAlloc(sizeof(BSTR));
 325     *(BSTR*)pvar->n1.n2.n3.byref = NULL;
 326     Pos = BSTR_UserUnmarshal(pFlags, Pos, V_BSTRREF(pvar));
 327     break;
 328   case VT_VARIANT | VT_BYREF:
 329     pvar->n1.n2.n3.byref = CoTaskMemAlloc(sizeof(VARIANT));
 330     Pos = VARIANT_UserUnmarshal(pFlags, Pos, V_VARIANTREF(pvar));
 331     break;
 332   case VT_RECORD:
 333     FIXME("handle BRECORD by val\n");
 334     break;
 335   case VT_RECORD | VT_BYREF:
 336     FIXME("handle BRECORD by ref\n");
 337     break;
 338   default:
 339     FIXME("handle unknown complex type\n");
 340     break;
 341   }
 342   if (Pos != Buffer + var->clSize) {
 343     ERR("size difference during unmarshal\n");
 344   }
 345   return Buffer + var->clSize;
 346 }
 347
 348 void WINAPI VARIANT_UserFree(unsigned long *pFlags, VARIANT *pvar)
 349 {
 350   VARTYPE vt = V_VT(pvar);
 351   PVOID ref = NULL;
 352
 353   TRACE("(%lx,%p)\n", *pFlags, pvar);
 354   TRACE("vt=%04x\n", V_VT(pvar));
 355
 356   if (vt & VT_BYREF) ref = pvar->n1.n2.n3.byref;
 357
 358   VariantClear(pvar);
 359   if (!ref) return;
 360
 361   switch (vt) {
 362   case VT_BSTR | VT_BYREF:
 363     BSTR_UserFree(pFlags, ref);
 364     break;
 365   case VT_VARIANT | VT_BYREF:
 366     VARIANT_UserFree(pFlags, ref);
 367     break;
 368   case VT_RECORD | VT_BYREF:
 369     FIXME("handle BRECORD by ref\n");
 370     break;
 371   default:
 372     FIXME("handle unknown complex type\n");
 373     break;
 374   }
 375
 376   CoTaskMemFree(ref);
 377 }
 378
 379 /* IDispatch */
 380 /* exactly how Invoke is marshalled is not very clear to me yet,
 381  * but the way I've done it seems to work for me */
 382
 383 HRESULT CALLBACK IDispatch_Invoke_Proxy(
 384     IDispatch* This,
 385     DISPID dispIdMember,
 386     REFIID riid,
 387     LCID lcid,
 388     WORD wFlags,
 389     DISPPARAMS* pDispParams,
 390     VARIANT* pVarResult,
 391     EXCEPINFO* pExcepInfo,
 392     UINT* puArgErr)
 393 {
 394   HRESULT hr;
 395   VARIANT VarResult;
 396   UINT* rgVarRefIdx = NULL;
 397   VARIANTARG* rgVarRef = NULL;
 398   UINT u, cVarRef;
 399
 400   TRACE("(%p)->(%ld,%s,%lx,%x,%p,%p,%p,%p)\n", This,
 401         dispIdMember, debugstr_guid(riid),
 402         lcid, wFlags, pDispParams, pVarResult,
 403         pExcepInfo, puArgErr);
 404
 405   /* [out] args can't be null, use dummy vars if needed */
 406   if (!pVarResult) pVarResult = &VarResult;
 407
 408   /* count by-ref args */
 409   for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
 410     VARIANTARG* arg = &pDispParams->rgvarg[u];
 411     if (V_VT(arg) & VT_BYREF) {
 412       cVarRef++;
 413     }
 414   }
 415   if (cVarRef) {
 416     rgVarRefIdx = CoTaskMemAlloc(sizeof(UINT)*cVarRef);
 417     rgVarRef = CoTaskMemAlloc(sizeof(VARIANTARG)*cVarRef);
 418     /* make list of by-ref args */
 419     for (cVarRef=0,u=0; u<pDispParams->cArgs; u++) {
 420       VARIANTARG* arg = &pDispParams->rgvarg[u];
 421       if (V_VT(arg) & VT_BYREF) {
 422         rgVarRefIdx[cVarRef] = u;
 423         VariantInit(&rgVarRef[cVarRef]);
 424         cVarRef++;
 425       }
 426     }
 427   } else {
 428     /* [out] args still can't be null,
 429      * but we can point these anywhere in this case,
 430      * since they won't be written to when cVarRef is 0 */
 431     rgVarRefIdx = puArgErr;
 432     rgVarRef = pVarResult;
 433   }
 434   TRACE("passed by ref: %d args\n", cVarRef);
 435   hr = IDispatch_RemoteInvoke_Proxy(This,
 436                                     dispIdMember,
 437                                     riid,
 438                                     lcid,
 439                                     wFlags,
 440                                     pDispParams,
 441                                     pVarResult,
 442                                     pExcepInfo,
 443                                     puArgErr,
 444                                     cVarRef,
 445                                     rgVarRefIdx,
 446                                     rgVarRef);
 447   if (cVarRef) {
 448     for (u=0; u<cVarRef; u++) {
 449       unsigned i = rgVarRefIdx[u];
 450       VariantCopy(&pDispParams->rgvarg[i],
 451                   &rgVarRef[u]);
 452       VariantClear(&rgVarRef[u]);
 453     }
 454     CoTaskMemFree(rgVarRef);
 455     CoTaskMemFree(rgVarRefIdx);
 456   }
 457   return hr;
 458 }
 459
 460 HRESULT __RPC_STUB IDispatch_Invoke_Stub(
 461     IDispatch* This,
 462     DISPID dispIdMember,
 463     REFIID riid,
 464     LCID lcid,
 465     DWORD dwFlags,
 466     DISPPARAMS* pDispParams,
 467     VARIANT* pVarResult,
 468     EXCEPINFO* pExcepInfo,
 469     UINT* pArgErr,
 470     UINT cVarRef,
 471     UINT* rgVarRefIdx,
 472     VARIANTARG* rgVarRef)
 473 {
 474   HRESULT hr;
 475   VARIANTARG *rgvarg, *arg;
 476   UINT u;
 477
 478   /* let the real Invoke operate on a copy of the in parameters,
 479    * so we don't risk losing pointers to allocated memory */
 480   rgvarg = pDispParams->rgvarg;
 481   arg = CoTaskMemAlloc(sizeof(VARIANTARG)*pDispParams->cArgs);
 482   for (u=0; u<pDispParams->cArgs; u++) {
 483     VariantInit(&arg[u]);
 484     VariantCopy(&arg[u], &rgvarg[u]);
 485   }
 486   pDispParams->rgvarg = arg;
 487
 488   /* initialize out parameters, so that they can be marshalled
 489    * in case the real Invoke doesn't initialize them */
 490   VariantInit(pVarResult);
 491   memset(pExcepInfo, 0, sizeof(*pExcepInfo));
 492   *pArgErr = 0;
 493
 494   hr = IDispatch_Invoke(This,
 495                         dispIdMember,
 496                         riid,
 497                         lcid,
 498                         dwFlags,
 499                         pDispParams,
 500                         pVarResult,
 501                         pExcepInfo,
 502                         pArgErr);
 503
 504   /* copy ref args to out list */
 505   for (u=0; u<cVarRef; u++) {
 506     unsigned i = rgVarRefIdx[u];
 507     VariantInit(&rgVarRef[u]);
 508     VariantCopy(&rgVarRef[u], &arg[i]);
 509     /* clear original if equal, to avoid double-free */
 510     if (V_BYREF(&rgVarRef[u]) == V_BYREF(&rgvarg[i]))
 511       VariantClear(&rgvarg[i]);
 512   }
 513   /* clear the duplicate argument list */
 514   for (u=0; u<pDispParams->cArgs; u++) {
 515     VariantClear(&arg[u]);
 516   }
 517   pDispParams->rgvarg = rgvarg;
 518   CoTaskMemFree(arg);
 519
 520   return hr;
 521 }
 522
 523 /* IEnumVARIANT */
 524
 525 HRESULT CALLBACK IEnumVARIANT_Next_Proxy(
 526     IEnumVARIANT* This,
 527     ULONG celt,
 528     VARIANT* rgVar,
 529     ULONG* pCeltFetched)
 530 {
 531   ULONG fetched;
 532   if (!pCeltFetched)
 533     pCeltFetched = &fetched;
 534   return IEnumVARIANT_RemoteNext_Proxy(This,
 535                                        celt,
 536                                        rgVar,
 537                                        pCeltFetched);
 538 }
 539
 540 HRESULT __RPC_STUB IEnumVARIANT_Next_Stub(
 541     IEnumVARIANT* This,
 542     ULONG celt,
 543     VARIANT* rgVar,
 544     ULONG* pCeltFetched)
 545 {
 546   HRESULT hr;
 547   *pCeltFetched = 0;
 548   hr = IEnumVARIANT_Next(This,
 549                          celt,
 550                          rgVar,
 551                          pCeltFetched);
 552   if (hr == S_OK) *pCeltFetched = celt;
 553   return hr;
 554 }
 555
 556 /* ITypeComp */
 557
 558 HRESULT CALLBACK ITypeComp_Bind_Proxy(
 559     ITypeComp* This,
 560     LPOLESTR szName,
 561     ULONG lHashVal,
 562     WORD wFlags,
 563     ITypeInfo** ppTInfo,
 564     DESCKIND* pDescKind,
 565     BINDPTR* pBindPtr)
 566 {
 567   FIXME("not implemented\n");
 568   return E_FAIL;
 569 }
 570
 571 HRESULT __RPC_STUB ITypeComp_Bind_Stub(
 572     ITypeComp* This,
 573     LPOLESTR szName,
 574     ULONG lHashVal,
 575     WORD wFlags,
 576     ITypeInfo** ppTInfo,
 577     DESCKIND* pDescKind,
 578     LPFUNCDESC* ppFuncDesc,
 579     LPVARDESC* ppVarDesc,
 580     ITypeComp** ppTypeComp,
 581     CLEANLOCALSTORAGE* pDummy)
 582 {
 583   FIXME("not implemented\n");
 584   return E_FAIL;
 585 }
 586
 587 HRESULT CALLBACK ITypeComp_BindType_Proxy(
 588     ITypeComp* This,
 589     LPOLESTR szName,
 590     ULONG lHashVal,
 591     ITypeInfo** ppTInfo,
 592     ITypeComp** ppTComp)
 593 {
 594   FIXME("not implemented\n");
 595   return E_FAIL;
 596 }
 597
 598 HRESULT __RPC_STUB ITypeComp_BindType_Stub(
 599     ITypeComp* This,
 600     LPOLESTR szName,
 601     ULONG lHashVal,
 602     ITypeInfo** ppTInfo)
 603 {
 604   FIXME("not implemented\n");
 605   return E_FAIL;
 606 }
 607
 608 /* ITypeInfo */
 609
 610 HRESULT CALLBACK ITypeInfo_GetTypeAttr_Proxy(
 611     ITypeInfo* This,
 612     TYPEATTR** ppTypeAttr)
 613 {
 614   FIXME("not implemented\n");
 615   return E_FAIL;
 616 }
 617
 618 HRESULT __RPC_STUB ITypeInfo_GetTypeAttr_Stub(
 619     ITypeInfo* This,
 620     LPTYPEATTR* ppTypeAttr,
 621     CLEANLOCALSTORAGE* pDummy)
 622 {
 623   FIXME("not implemented\n");
 624   return E_FAIL;
 625 }
 626
 627 HRESULT CALLBACK ITypeInfo_GetFuncDesc_Proxy(
 628     ITypeInfo* This,
 629     UINT index,
 630     FUNCDESC** ppFuncDesc)
 631 {
 632   FIXME("not implemented\n");
 633   return E_FAIL;
 634 }
 635
 636 HRESULT __RPC_STUB ITypeInfo_GetFuncDesc_Stub(
 637     ITypeInfo* This,
 638     UINT index,
 639     LPFUNCDESC* ppFuncDesc,
 640     CLEANLOCALSTORAGE* pDummy)
 641 {
 642   FIXME("not implemented\n");
 643   return E_FAIL;
 644 }
 645
 646 HRESULT CALLBACK ITypeInfo_GetVarDesc_Proxy(
 647     ITypeInfo* This,
 648     UINT index,
 649     VARDESC** ppVarDesc)
 650 {
 651   FIXME("not implemented\n");
 652   return E_FAIL;
 653 }
 654
 655 HRESULT __RPC_STUB ITypeInfo_GetVarDesc_Stub(
 656     ITypeInfo* This,
 657     UINT index,
 658     LPVARDESC* ppVarDesc,
 659     CLEANLOCALSTORAGE* pDummy)
 660 {
 661   FIXME("not implemented\n");
 662   return E_FAIL;
 663 }
 664
 665 HRESULT CALLBACK ITypeInfo_GetNames_Proxy(
 666     ITypeInfo* This,
 667     MEMBERID memid,
 668     BSTR* rgBstrNames,
 669     UINT cMaxNames,
 670     UINT* pcNames)
 671 {
 672   FIXME("not implemented\n");
 673   return E_FAIL;
 674 }
 675
 676 HRESULT __RPC_STUB ITypeInfo_GetNames_Stub(
 677     ITypeInfo* This,
 678     MEMBERID memid,
 679     BSTR* rgBstrNames,
 680     UINT cMaxNames,
 681     UINT* pcNames)
 682 {
 683   FIXME("not implemented\n");
 684   return E_FAIL;
 685 }
 686
 687 HRESULT CALLBACK ITypeInfo_GetIDsOfNames_Proxy(
 688     ITypeInfo* This,
 689     LPOLESTR* rgszNames,
 690     UINT cNames,
 691     MEMBERID* pMemId)
 692 {
 693   FIXME("not implemented\n");
 694   return E_FAIL;
 695 }
 696
 697 HRESULT __RPC_STUB ITypeInfo_GetIDsOfNames_Stub(
 698     ITypeInfo* This)
 699 {
 700   FIXME("not implemented\n");
 701   return E_FAIL;
 702 }
 703
 704 HRESULT CALLBACK ITypeInfo_Invoke_Proxy(
 705     ITypeInfo* This,
 706     PVOID pvInstance,
 707     MEMBERID memid,
 708     WORD wFlags,
 709     DISPPARAMS* pDispParams,
 710     VARIANT* pVarResult,
 711     EXCEPINFO* pExcepInfo,
 712     UINT* puArgErr)
 713 {
 714   FIXME("not implemented\n");
 715   return E_FAIL;
 716 }
 717
 718 HRESULT __RPC_STUB ITypeInfo_Invoke_Stub(
 719     ITypeInfo* This)
 720 {
 721   FIXME("not implemented\n");
 722   return E_FAIL;
 723 }
 724
 725 HRESULT CALLBACK ITypeInfo_GetDocumentation_Proxy(
 726     ITypeInfo* This,
 727     MEMBERID memid,
 728     BSTR* pBstrName,
 729     BSTR* pBstrDocString,
 730     DWORD* pdwHelpContext,
 731     BSTR* pBstrHelpFile)
 732 {
 733   FIXME("not implemented\n");
 734   return E_FAIL;
 735 }
 736
 737 HRESULT __RPC_STUB ITypeInfo_GetDocumentation_Stub(
 738     ITypeInfo* This,
 739     MEMBERID memid,
 740     DWORD refPtrFlags,
 741     BSTR* pBstrName,
 742     BSTR* pBstrDocString,
 743     DWORD* pdwHelpContext,
 744     BSTR* pBstrHelpFile)
 745 {
 746   FIXME("not implemented\n");
 747   return E_FAIL;
 748 }
 749
 750 HRESULT CALLBACK ITypeInfo_GetDllEntry_Proxy(
 751     ITypeInfo* This,
 752     MEMBERID memid,
 753     INVOKEKIND invKind,
 754     BSTR* pBstrDllName,
 755     BSTR* pBstrName,
 756     WORD* pwOrdinal)
 757 {
 758   FIXME("not implemented\n");
 759   return E_FAIL;
 760 }
 761
 762 HRESULT __RPC_STUB ITypeInfo_GetDllEntry_Stub(
 763     ITypeInfo* This,
 764     MEMBERID memid,
 765     INVOKEKIND invKind,
 766     DWORD refPtrFlags,
 767     BSTR* pBstrDllName,
 768     BSTR* pBstrName,
 769     WORD* pwOrdinal)
 770 {
 771   FIXME("not implemented\n");
 772   return E_FAIL;
 773 }
 774
 775 HRESULT CALLBACK ITypeInfo_AddressOfMember_Proxy(
 776     ITypeInfo* This,
 777     MEMBERID memid,
 778     INVOKEKIND invKind,
 779     PVOID* ppv)
 780 {
 781   FIXME("not implemented\n");
 782   return E_FAIL;
 783 }
 784
 785 HRESULT __RPC_STUB ITypeInfo_AddressOfMember_Stub(
 786     ITypeInfo* This)
 787 {
 788   FIXME("not implemented\n");
 789   return E_FAIL;
 790 }
 791
 792 HRESULT CALLBACK ITypeInfo_CreateInstance_Proxy(
 793     ITypeInfo* This,
 794     IUnknown* pUnkOuter,
 795     REFIID riid,
 796     PVOID* ppvObj)
 797 {
 798   FIXME("not implemented\n");
 799   return E_FAIL;
 800 }
 801
 802 HRESULT __RPC_STUB ITypeInfo_CreateInstance_Stub(
 803     ITypeInfo* This,
 804     REFIID riid,
 805     IUnknown** ppvObj)
 806 {
 807   FIXME("not implemented\n");
 808   return E_FAIL;
 809 }
 810
 811 HRESULT CALLBACK ITypeInfo_GetContainingTypeLib_Proxy(
 812     ITypeInfo* This,
 813     ITypeLib** ppTLib,
 814     UINT* pIndex)
 815 {
 816   FIXME("not implemented\n");
 817   return E_FAIL;
 818 }
 819
 820 HRESULT __RPC_STUB ITypeInfo_GetContainingTypeLib_Stub(
 821     ITypeInfo* This,
 822     ITypeLib** ppTLib,
 823     UINT* pIndex)
 824 {
 825   FIXME("not implemented\n");
 826   return E_FAIL;
 827 }
 828
 829 void CALLBACK ITypeInfo_ReleaseTypeAttr_Proxy(
 830     ITypeInfo* This,
 831     TYPEATTR* pTypeAttr)
 832 {
 833   FIXME("not implemented\n");
 834 }
 835
 836 HRESULT __RPC_STUB ITypeInfo_ReleaseTypeAttr_Stub(
 837     ITypeInfo* This)
 838 {
 839   FIXME("not implemented\n");
 840   return E_FAIL;
 841 }
 842
 843 void CALLBACK ITypeInfo_ReleaseFuncDesc_Proxy(
 844     ITypeInfo* This,
 845     FUNCDESC* pFuncDesc)
 846 {
 847   FIXME("not implemented\n");
 848 }
 849
 850 HRESULT __RPC_STUB ITypeInfo_ReleaseFuncDesc_Stub(
 851     ITypeInfo* This)
 852 {
 853   FIXME("not implemented\n");
 854   return E_FAIL;
 855 }
 856
 857 void CALLBACK ITypeInfo_ReleaseVarDesc_Proxy(
 858     ITypeInfo* This,
 859     VARDESC* pVarDesc)
 860 {
 861   FIXME("not implemented\n");
 862 }
 863
 864 HRESULT __RPC_STUB ITypeInfo_ReleaseVarDesc_Stub(
 865     ITypeInfo* This)
 866 {
 867   FIXME("not implemented\n");
 868   return E_FAIL;
 869 }
 870
 871
 872 /* ITypeInfo2 */
 873
 874 HRESULT CALLBACK ITypeInfo2_GetDocumentation2_Proxy(
 875     ITypeInfo2* This,
 876     MEMBERID memid,
 877     LCID lcid,
 878     BSTR* pbstrHelpString,
 879     DWORD* pdwHelpStringContext,
 880     BSTR* pbstrHelpStringDll)
 881 {
 882   FIXME("not implemented\n");
 883   return E_FAIL;
 884 }
 885
 886 HRESULT __RPC_STUB ITypeInfo2_GetDocumentation2_Stub(
 887     ITypeInfo2* This,
 888     MEMBERID memid,
 889     LCID lcid,
 890     DWORD refPtrFlags,
 891     BSTR* pbstrHelpString,
 892     DWORD* pdwHelpStringContext,
 893     BSTR* pbstrHelpStringDll)
 894 {
 895   FIXME("not implemented\n");
 896   return E_FAIL;
 897 }
 898
 899 /* ITypeLib */
 900
 901 UINT CALLBACK ITypeLib_GetTypeInfoCount_Proxy(
 902     ITypeLib* This)
 903 {
 904   FIXME("not implemented\n");
 905   return E_FAIL;
 906 }
 907
 908 HRESULT __RPC_STUB ITypeLib_GetTypeInfoCount_Stub(
 909     ITypeLib* This,
 910     UINT* pcTInfo)
 911 {
 912   FIXME("not implemented\n");
 913   return E_FAIL;
 914 }
 915
 916 HRESULT CALLBACK ITypeLib_GetLibAttr_Proxy(
 917     ITypeLib* This,
 918     TLIBATTR** ppTLibAttr)
 919 {
 920   FIXME("not implemented\n");
 921   return E_FAIL;
 922 }
 923
 924 HRESULT __RPC_STUB ITypeLib_GetLibAttr_Stub(
 925     ITypeLib* This,
 926     LPTLIBATTR* ppTLibAttr,
 927     CLEANLOCALSTORAGE* pDummy)
 928 {
 929   FIXME("not implemented\n");
 930   return E_FAIL;
 931 }
 932
 933 HRESULT CALLBACK ITypeLib_GetDocumentation_Proxy(
 934     ITypeLib* This,
 935     INT index,
 936     BSTR* pBstrName,
 937     BSTR* pBstrDocString,
 938     DWORD* pdwHelpContext,
 939     BSTR* pBstrHelpFile)
 940 {
 941   FIXME("not implemented\n");
 942   return E_FAIL;
 943 }
 944
 945 HRESULT __RPC_STUB ITypeLib_GetDocumentation_Stub(
 946     ITypeLib* This,
 947     INT index,
 948     DWORD refPtrFlags,
 949     BSTR* pBstrName,
 950     BSTR* pBstrDocString,
 951     DWORD* pdwHelpContext,
 952     BSTR* pBstrHelpFile)
 953 {
 954   FIXME("not implemented\n");
 955   return E_FAIL;
 956 }
 957
 958 HRESULT CALLBACK ITypeLib_IsName_Proxy(
 959     ITypeLib* This,
 960     LPOLESTR szNameBuf,
 961     ULONG lHashVal,
 962     BOOL* pfName)
 963 {
 964   FIXME("not implemented\n");
 965   return E_FAIL;
 966 }
 967
 968 HRESULT __RPC_STUB ITypeLib_IsName_Stub(
 969     ITypeLib* This,
 970     LPOLESTR szNameBuf,
 971     ULONG lHashVal,
 972     BOOL* pfName,
 973     BSTR* pBstrLibName)
 974 {
 975   FIXME("not implemented\n");
 976   return E_FAIL;
 977 }
 978
 979 HRESULT CALLBACK ITypeLib_FindName_Proxy(
 980     ITypeLib* This,
 981     LPOLESTR szNameBuf,
 982     ULONG lHashVal,
 983     ITypeInfo** ppTInfo,
 984     MEMBERID* rgMemId,
 985     USHORT* pcFound)
 986 {
 987   FIXME("not implemented\n");
 988   return E_FAIL;
 989 }
 990
 991 HRESULT __RPC_STUB ITypeLib_FindName_Stub(
 992     ITypeLib* This,
 993     LPOLESTR szNameBuf,
 994     ULONG lHashVal,
 995     ITypeInfo** ppTInfo,
 996     MEMBERID* rgMemId,
 997     USHORT* pcFound,
 998     BSTR* pBstrLibName)
 999 {
1000   FIXME("not implemented\n");
1001   return E_FAIL;
1002 }
1003
1004 void CALLBACK ITypeLib_ReleaseTLibAttr_Proxy(
1005     ITypeLib* This,
1006     TLIBATTR* pTLibAttr)
1007 {
1008   FIXME("not implemented\n");
1009 }
1010
1011 HRESULT __RPC_STUB ITypeLib_ReleaseTLibAttr_Stub(
1012     ITypeLib* This)
1013 {
1014   FIXME("not implemented\n");
1015   return E_FAIL;
1016 }
1017
1018
1019 /* ITypeLib2 */
1020
1021 HRESULT CALLBACK ITypeLib2_GetLibStatistics_Proxy(
1022     ITypeLib2* This,
1023     ULONG* pcUniqueNames,
1024     ULONG* pcchUniqueNames)
1025 {
1026   FIXME("not implemented\n");
1027   return E_FAIL;
1028 }
1029
1030 HRESULT __RPC_STUB ITypeLib2_GetLibStatistics_Stub(
1031     ITypeLib2* This,
1032     ULONG* pcUniqueNames,
1033     ULONG* pcchUniqueNames)
1034 {
1035   FIXME("not implemented\n");
1036   return E_FAIL;
1037 }
1038
1039 HRESULT CALLBACK ITypeLib2_GetDocumentation2_Proxy(
1040     ITypeLib2* This,
1041     INT index,
1042     LCID lcid,
1043     BSTR* pbstrHelpString,
1044     DWORD* pdwHelpStringContext,
1045     BSTR* pbstrHelpStringDll)
1046 {
1047   FIXME("not implemented\n");
1048   return E_FAIL;
1049 }
1050
1051 HRESULT __RPC_STUB ITypeLib2_GetDocumentation2_Stub(
1052     ITypeLib2* This,
1053     INT index,
1054     LCID lcid,
1055     DWORD refPtrFlags,
1056     BSTR* pbstrHelpString,
1057     DWORD* pdwHelpStringContext,
1058     BSTR* pbstrHelpStringDll)
1059 {
1060   FIXME("not implemented\n");
1061   return E_FAIL;
1062 }