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