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

   1 /*
   2  *      TYPELIB
   3  *
   4  *      Copyright 1997  Marcus Meissner
   5  *                    1999  Rein Klazes
   6  *                    2000  Francois Jacques
   7  *                    2001  Huw D M Davies for CodeWeavers
   8  *                    2005  Robert Shearman, for CodeWeavers
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  * --------------------------------------------------------------------------------------
  25  * Known problems (2000, Francois Jacques)
  26  *
  27  * - Tested using OLEVIEW (Platform SDK tool) only.
  28  *
  29  * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
  30  *   creating by doing a straight copy of the dispinterface instance and just changing
  31  *   its typekind. Pointed structures aren't copied - only the address of the pointers.
  32  *
  33  * - locale stuff is partially implemented but hasn't been tested.
  34  *
  35  * - typelib file is still read in its entirety, but it is released now.
  36  *
  37  * --------------------------------------------------------------------------------------
  38  *  Known problems left from previous implementation (1999, Rein Klazes) :
  39  *
  40  * -. Data structures are straightforward, but slow for look-ups.
  41  * -. (related) nothing is hashed
  42  * -. Most error return values are just guessed not checked with windows
  43  *      behaviour.
  44  * -. lousy fatal error handling
  45  *
  46  */
  47
  48 #include "config.h"
  49 #include "wine/port.h"
  50
  51 #include <stdlib.h>
  52 #include <string.h>
  53 #include <stdarg.h>
  54 #include <stdio.h>
  55 #include <ctype.h>
  56
  57 #define COBJMACROS
  58 #define NONAMELESSUNION
  59 #define NONAMELESSSTRUCT
  60
  61 #include "winerror.h"
  62 #include "windef.h"
  63 #include "winbase.h"
  64 #include "winnls.h"
  65 #include "winreg.h"
  66 #include "winuser.h"
  67
  68 #include "wine/unicode.h"
  69 #include "objbase.h"
  70 #include "typelib.h"
  71 #include "wine/debug.h"
  72 #include "variant.h"
  73 #include "wine/list.h"
  74
  75 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  76 WINE_DECLARE_DEBUG_CHANNEL(typelib);
  77
  78 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt);
  79 static HRESULT TLB_AllocAndInitVarDesc(const VARDESC *src, VARDESC **dest_ptr);
  80
  81 /****************************************************************************
  82  *              FromLExxx
  83  *
  84  * Takes p_iVal (which is in little endian) and returns it
  85  *   in the host machine's byte order.
  86  */
  87 #ifdef WORDS_BIGENDIAN
  88 static WORD FromLEWord(WORD p_iVal)
  89 {
  90   return (((p_iVal & 0x00FF) << 8) |
  91           ((p_iVal & 0xFF00) >> 8));
  92 }
  93
  94
  95 static DWORD FromLEDWord(DWORD p_iVal)
  96 {
  97   return (((p_iVal & 0x000000FF) << 24) |
  98           ((p_iVal & 0x0000FF00) <<  8) |
  99           ((p_iVal & 0x00FF0000) >>  8) |
 100           ((p_iVal & 0xFF000000) >> 24));
 101 }
 102 #else
 103 #define FromLEWord(X)  (X)
 104 #define FromLEDWord(X) (X)
 105 #endif
 106
 107 #define DISPATCH_HREF_OFFSET 0x01000000
 108 #define DISPATCH_HREF_MASK   0xff000000
 109
 110 /****************************************************************************
 111  *              FromLExxx
 112  *
 113  * Fix byte order in any structure if necessary
 114  */
 115 #ifdef WORDS_BIGENDIAN
 116 static void FromLEWords(void *p_Val, int p_iSize)
 117 {
 118   WORD *Val = p_Val;
 119
 120   p_iSize /= sizeof(WORD);
 121
 122   while (p_iSize) {
 123     *Val = FromLEWord(*Val);
 124     Val++;
 125     p_iSize--;
 126   }
 127 }
 128
 129
 130 static void FromLEDWords(void *p_Val, int p_iSize)
 131 {
 132   DWORD *Val = p_Val;
 133
 134   p_iSize /= sizeof(DWORD);
 135
 136   while (p_iSize) {
 137     *Val = FromLEDWord(*Val);
 138     Val++;
 139     p_iSize--;
 140   }
 141 }
 142 #else
 143 #define FromLEWords(X,Y) /*nothing*/
 144 #define FromLEDWords(X,Y) /*nothing*/
 145 #endif
 146
 147 /*
 148  * Find a typelib key which matches a requested maj.min version.
 149  */
 150 static BOOL find_typelib_key( REFGUID guid, WORD wMaj, WORD *wMin )
 151 {
 152     static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
 153     WCHAR buffer[60];
 154     char key_name[16];
 155     DWORD len, i;
 156     INT best_min = -1;
 157     HKEY hkey;
 158
 159     memcpy( buffer, typelibW, sizeof(typelibW) );
 160     StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
 161
 162     if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS)
 163         return FALSE;
 164
 165     len = sizeof(key_name);
 166     i = 0;
 167     while (RegEnumKeyExA(hkey, i++, key_name, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
 168     {
 169         INT v_maj, v_min;
 170
 171         if (sscanf(key_name, "%x.%x", &v_maj, &v_min) == 2)
 172         {
 173             TRACE("found %s: %x.%x\n", debugstr_w(buffer), v_maj, v_min);
 174
 175             if (wMaj == v_maj)
 176             {
 177                 if (*wMin == v_min)
 178                 {
 179                     best_min = v_min;
 180                     break; /* exact match */
 181                 }
 182                 if (v_min > best_min) best_min = v_min;
 183             }
 184         }
 185         len = sizeof(key_name);
 186     }
 187     RegCloseKey( hkey );
 188     if (best_min >= 0)
 189     {
 190         *wMin = best_min;
 191         return TRUE;
 192     }
 193     return FALSE;
 194 }
 195
 196 /* get the path of a typelib key, in the form "Typelib\\<guid>\\<maj>.<min>" */
 197 /* buffer must be at least 60 characters long */
 198 static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer )
 199 {
 200     static const WCHAR TypelibW[] = {'T','y','p','e','l','i','b','\\',0};
 201     static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0};
 202
 203     memcpy( buffer, TypelibW, sizeof(TypelibW) );
 204     StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
 205     sprintfW( buffer + strlenW(buffer), VersionFormatW, wMaj, wMin );
 206     return buffer;
 207 }
 208
 209 /* get the path of an interface key, in the form "Interface\\<guid>" */
 210 /* buffer must be at least 50 characters long */
 211 static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer )
 212 {
 213     static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0};
 214
 215     memcpy( buffer, InterfaceW, sizeof(InterfaceW) );
 216     StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
 217     return buffer;
 218 }
 219
 220 /* get the lcid subkey for a typelib, in the form "<lcid>\\<syskind>" */
 221 /* buffer must be at least 16 characters long */
 222 static WCHAR *get_lcid_subkey( LCID lcid, SYSKIND syskind, WCHAR *buffer )
 223 {
 224     static const WCHAR LcidFormatW[] = {'%','l','x','\\',0};
 225     static const WCHAR win16W[] = {'w','i','n','1','6',0};
 226     static const WCHAR win32W[] = {'w','i','n','3','2',0};
 227
 228     sprintfW( buffer, LcidFormatW, lcid );
 229     switch(syskind)
 230     {
 231     case SYS_WIN16: strcatW( buffer, win16W ); break;
 232     case SYS_WIN32: strcatW( buffer, win32W ); break;
 233     default:
 234         TRACE("Typelib is for unsupported syskind %i\n", syskind);
 235         return NULL;
 236     }
 237     return buffer;
 238 }
 239
 240 static int TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib);
 241
 242
 243 /****************************************************************************
 244  *              QueryPathOfRegTypeLib   [OLEAUT32.164]
 245  *
 246  * Gets the path to a registered type library.
 247  *
 248  * PARAMS
 249  *  guid [I] referenced guid
 250  *  wMaj [I] major version
 251  *  wMin [I] minor version
 252  *  lcid [I] locale id
 253  *  path [O] path of typelib
 254  *
 255  * RETURNS
 256  *  Success: S_OK.
 257  *  Failure: If the type library is not registered then TYPE_E_LIBNOTREGISTERED
 258  *  or TYPE_E_REGISTRYACCESS if the type library registration key couldn't be
 259  *  opened.
 260  */
 261 HRESULT WINAPI QueryPathOfRegTypeLib(
 262         REFGUID guid,
 263         WORD wMaj,
 264         WORD wMin,
 265         LCID lcid,
 266         LPBSTR path )
 267 {
 268     HRESULT hr = TYPE_E_LIBNOTREGISTERED;
 269     LCID myLCID = lcid;
 270     HKEY hkey;
 271     WCHAR buffer[60];
 272     WCHAR Path[MAX_PATH];
 273     LONG res;
 274
 275     TRACE_(typelib)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
 276
 277     if (!find_typelib_key( guid, wMaj, &wMin )) return TYPE_E_LIBNOTREGISTERED;
 278     get_typelib_key( guid, wMaj, wMin, buffer );
 279
 280     res = RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey );
 281     if (res == ERROR_FILE_NOT_FOUND)
 282     {
 283         TRACE_(typelib)("%s not found\n", debugstr_w(buffer));
 284         return TYPE_E_LIBNOTREGISTERED;
 285     }
 286     else if (res != ERROR_SUCCESS)
 287     {
 288         TRACE_(typelib)("failed to open %s for read access\n", debugstr_w(buffer));
 289         return TYPE_E_REGISTRYACCESS;
 290     }
 291
 292     while (hr != S_OK)
 293     {
 294         LONG dwPathLen = sizeof(Path);
 295
 296         get_lcid_subkey( myLCID, SYS_WIN32, buffer );
 297
 298         if (RegQueryValueW(hkey, buffer, Path, &dwPathLen))
 299         {
 300             if (!lcid)
 301                 break;
 302             else if (myLCID == lcid)
 303             {
 304                 /* try with sub-langid */
 305                 myLCID = SUBLANGID(lcid);
 306             }
 307             else if ((myLCID == SUBLANGID(lcid)) && myLCID)
 308             {
 309                 /* try with system langid */
 310                 myLCID = 0;
 311             }
 312             else
 313             {
 314                 break;
 315             }
 316         }
 317         else
 318         {
 319             *path = SysAllocString( Path );
 320             hr = S_OK;
 321         }
 322     }
 323     RegCloseKey( hkey );
 324     TRACE_(typelib)("-- 0x%08x\n", hr);
 325     return hr;
 326 }
 327
 328 /******************************************************************************
 329  * CreateTypeLib [OLEAUT32.160]  creates a typelib
 330  *
 331  * RETURNS
 332  *    Success: S_OK
 333  *    Failure: Status
 334  */
 335 HRESULT WINAPI CreateTypeLib(
 336         SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
 337 ) {
 338     FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
 339     return E_FAIL;
 340 }
 341
 342 /******************************************************************************
 343  *              LoadTypeLib     [OLEAUT32.161]
 344  *
 345  * Loads a type library
 346  *
 347  * PARAMS
 348  *  szFile [I] Name of file to load from.
 349  *  pptLib [O] Pointer that receives ITypeLib object on success.
 350  *
 351  * RETURNS
 352  *    Success: S_OK
 353  *    Failure: Status
 354  *
 355  * SEE
 356  *  LoadTypeLibEx, LoadRegTypeLib, CreateTypeLib.
 357  */
 358 HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib * *pptLib)
 359 {
 360     TRACE("(%s,%p)\n",debugstr_w(szFile), pptLib);
 361     return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
 362 }
 363
 364 /******************************************************************************
 365  *              LoadTypeLibEx   [OLEAUT32.183]
 366  *
 367  * Loads and optionally registers a type library
 368  *
 369  * RETURNS
 370  *    Success: S_OK
 371  *    Failure: Status
 372  */
 373 HRESULT WINAPI LoadTypeLibEx(
 374     LPCOLESTR szFile,  /* [in] Name of file to load from */
 375     REGKIND  regkind,  /* [in] Specify kind of registration */
 376     ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
 377 {
 378     WCHAR szPath[MAX_PATH+1];
 379     HRESULT res;
 380
 381     TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
 382
 383     *pptLib = NULL;
 384
 385     res = TLB_ReadTypeLib(szFile, szPath, MAX_PATH + 1, (ITypeLib2**)pptLib);
 386
 387     if (SUCCEEDED(res))
 388         switch(regkind)
 389         {
 390             case REGKIND_DEFAULT:
 391                 /* don't register typelibs supplied with full path. Experimentation confirms the following */
 392                 if (((szFile[0] == '\\') && (szFile[1] == '\\')) ||
 393                     (szFile[0] && (szFile[1] == ':'))) break;
 394                 /* else fall-through */
 395
 396             case REGKIND_REGISTER:
 397                 if (!SUCCEEDED(res = RegisterTypeLib(*pptLib, (LPOLESTR)szPath, NULL)))
 398                 {
 399                     IUnknown_Release(*pptLib);
 400                     *pptLib = 0;
 401                 }
 402                 break;
 403             case REGKIND_NONE:
 404                 break;
 405         }
 406
 407     TRACE(" returns %08x\n",res);
 408     return res;
 409 }
 410
 411 /******************************************************************************
 412  *              LoadRegTypeLib  [OLEAUT32.162]
 413  *
 414  * Loads a registered type library.
 415  *
 416  * PARAMS
 417  *  rguid     [I] GUID of the registered type library.
 418  *  wVerMajor [I] major version.
 419  *  wVerMinor [I] minor version.
 420  *  lcid      [I] locale ID.
 421  *  ppTLib    [O] pointer that receives an ITypeLib object on success.
 422  *
 423  * RETURNS
 424  *  Success: S_OK.
 425  *  Failure: Any HRESULT code returned from QueryPathOfRegTypeLib or
 426  *  LoadTypeLib.
 427  */
 428 HRESULT WINAPI LoadRegTypeLib(
 429         REFGUID rguid,
 430         WORD wVerMajor,
 431         WORD wVerMinor,
 432         LCID lcid,
 433         ITypeLib **ppTLib)
 434 {
 435     BSTR bstr=NULL;
 436     HRESULT res;
 437
 438     *ppTLib = NULL;
 439
 440     res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
 441
 442     if(SUCCEEDED(res))
 443     {
 444         res= LoadTypeLib(bstr, ppTLib);
 445         SysFreeString(bstr);
 446     }
 447
 448     TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
 449
 450     return res;
 451 }
 452
 453
 454 /* some string constants shared between RegisterTypeLib and UnRegisterTypeLib */
 455 static const WCHAR TypeLibW[] = {'T','y','p','e','L','i','b',0};
 456 static const WCHAR FLAGSW[] = {'F','L','A','G','S',0};
 457 static const WCHAR HELPDIRW[] = {'H','E','L','P','D','I','R',0};
 458 static const WCHAR ProxyStubClsidW[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0};
 459 static const WCHAR ProxyStubClsid32W[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
 460
 461 /******************************************************************************
 462  *              RegisterTypeLib [OLEAUT32.163]
 463  * Adds information about a type library to the System Registry
 464  * NOTES
 465  *    Docs: ITypeLib FAR * ptlib
 466  *    Docs: OLECHAR FAR* szFullPath
 467  *    Docs: OLECHAR FAR* szHelpDir
 468  *
 469  * RETURNS
 470  *    Success: S_OK
 471  *    Failure: Status
 472  */
 473 HRESULT WINAPI RegisterTypeLib(
 474      ITypeLib * ptlib,     /* [in] Pointer to the library*/
 475      OLECHAR * szFullPath, /* [in] full Path of the library*/
 476      OLECHAR * szHelpDir)  /* [in] dir to the helpfile for the library,
 477                                                          may be NULL*/
 478 {
 479     static const WCHAR PSOA[] = {'{','0','0','0','2','0','4','2','4','-',
 480                                  '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
 481                                  '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
 482     HRESULT res;
 483     TLIBATTR *attr;
 484     WCHAR keyName[60];
 485     WCHAR tmp[16];
 486     HKEY key, subKey;
 487     UINT types, tidx;
 488     TYPEKIND kind;
 489     DWORD disposition;
 490
 491     if (ptlib == NULL || szFullPath == NULL)
 492         return E_INVALIDARG;
 493
 494     if (!SUCCEEDED(ITypeLib_GetLibAttr(ptlib, &attr)))
 495         return E_FAIL;
 496
 497     get_typelib_key( &attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, keyName );
 498
 499     res = S_OK;
 500     if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
 501         KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
 502     {
 503         LPOLESTR doc;
 504
 505         /* Set the human-readable name of the typelib */
 506         if (SUCCEEDED(ITypeLib_GetDocumentation(ptlib, -1, NULL, &doc, NULL, NULL)))
 507         {
 508             if (RegSetValueExW(key, NULL, 0, REG_SZ,
 509                 (BYTE *)doc, (lstrlenW(doc)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
 510                 res = E_FAIL;
 511
 512             SysFreeString(doc);
 513         }
 514         else
 515             res = E_FAIL;
 516
 517         /* Make up the name of the typelib path subkey */
 518         if (!get_lcid_subkey( attr->lcid, attr->syskind, tmp )) res = E_FAIL;
 519
 520         /* Create the typelib path subkey */
 521         if (res == S_OK && RegCreateKeyExW(key, tmp, 0, NULL, 0,
 522             KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
 523         {
 524             if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
 525                 (BYTE *)szFullPath, (lstrlenW(szFullPath)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
 526                 res = E_FAIL;
 527
 528             RegCloseKey(subKey);
 529         }
 530         else
 531             res = E_FAIL;
 532
 533         /* Create the flags subkey */
 534         if (res == S_OK && RegCreateKeyExW(key, FLAGSW, 0, NULL, 0,
 535             KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
 536         {
 537             /* FIXME: is %u correct? */
 538             static const WCHAR formatW[] = {'%','u',0};
 539             WCHAR buf[20];
 540             sprintfW(buf, formatW, attr->wLibFlags);
 541             if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
 542                                (BYTE *)buf, (strlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS)
 543                 res = E_FAIL;
 544
 545             RegCloseKey(subKey);
 546         }
 547         else
 548             res = E_FAIL;
 549
 550         /* create the helpdir subkey */
 551         if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0,
 552             KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS)
 553         {
 554             BOOL freeHelpDir = FALSE;
 555             OLECHAR* pIndexStr;
 556
 557             /* if we created a new key, and helpDir was null, set the helpdir
 558                to the directory which contains the typelib. However,
 559                if we just opened an existing key, we leave the helpdir alone */
 560             if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) {
 561                 szHelpDir = SysAllocString(szFullPath);
 562                 pIndexStr = strrchrW(szHelpDir, '\\');
 563                 if (pIndexStr) {
 564                     *pIndexStr = 0;
 565                 }
 566                 freeHelpDir = TRUE;
 567             }
 568
 569             /* if we have an szHelpDir, set it! */
 570             if (szHelpDir != NULL) {
 571                 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
 572                     (BYTE *)szHelpDir, (lstrlenW(szHelpDir)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS) {
 573                     res = E_FAIL;
 574                 }
 575             }
 576
 577             /* tidy up */
 578             if (freeHelpDir) SysFreeString(szHelpDir);
 579             RegCloseKey(subKey);
 580
 581         } else {
 582             res = E_FAIL;
 583         }
 584
 585         RegCloseKey(key);
 586     }
 587     else
 588         res = E_FAIL;
 589
 590     /* register OLE Automation-compatible interfaces for this typelib */
 591     types = ITypeLib_GetTypeInfoCount(ptlib);
 592     for (tidx=0; tidx<types; tidx++) {
 593         if (SUCCEEDED(ITypeLib_GetTypeInfoType(ptlib, tidx, &kind))) {
 594             LPOLESTR name = NULL;
 595             ITypeInfo *tinfo = NULL;
 596
 597             ITypeLib_GetDocumentation(ptlib, tidx, &name, NULL, NULL, NULL);
 598
 599             switch (kind) {
 600             case TKIND_INTERFACE:
 601                 TRACE_(typelib)("%d: interface %s\n", tidx, debugstr_w(name));
 602                 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
 603                 break;
 604
 605             case TKIND_DISPATCH:
 606                 TRACE_(typelib)("%d: dispinterface %s\n", tidx, debugstr_w(name));
 607                 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
 608                 break;
 609
 610             default:
 611                 TRACE_(typelib)("%d: %s\n", tidx, debugstr_w(name));
 612                 break;
 613             }
 614
 615             if (tinfo) {
 616                 TYPEATTR *tattr = NULL;
 617                 ITypeInfo_GetTypeAttr(tinfo, &tattr);
 618
 619                 if (tattr) {
 620                     TRACE_(typelib)("guid=%s, flags=%04x (",
 621                                     debugstr_guid(&tattr->guid),
 622                                     tattr->wTypeFlags);
 623
 624                     if (TRACE_ON(typelib)) {
 625 #define XX(x) if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
 626                         XX(FAPPOBJECT);
 627                         XX(FCANCREATE);
 628                         XX(FLICENSED);
 629                         XX(FPREDECLID);
 630                         XX(FHIDDEN);
 631                         XX(FCONTROL);
 632                         XX(FDUAL);
 633                         XX(FNONEXTENSIBLE);
 634                         XX(FOLEAUTOMATION);
 635                         XX(FRESTRICTED);
 636                         XX(FAGGREGATABLE);
 637                         XX(FREPLACEABLE);
 638                         XX(FDISPATCHABLE);
 639                         XX(FREVERSEBIND);
 640                         XX(FPROXY);
 641 #undef XX
 642                         MESSAGE("\n");
 643                     }
 644
 645                     if (tattr->wTypeFlags & (TYPEFLAG_FOLEAUTOMATION|TYPEFLAG_FDUAL|TYPEFLAG_FDISPATCHABLE))
 646                     {
 647                         /* register interface<->typelib coupling */
 648                         get_interface_key( &tattr->guid, keyName );
 649                         if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
 650                                             KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
 651                         {
 652                             if (name)
 653                                 RegSetValueExW(key, NULL, 0, REG_SZ,
 654                                                (BYTE *)name, (strlenW(name)+1) * sizeof(OLECHAR));
 655
 656                             if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0,
 657                                 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
 658                                 RegSetValueExW(subKey, NULL, 0, REG_SZ,
 659                                                (const BYTE *)PSOA, sizeof PSOA);
 660                                 RegCloseKey(subKey);
 661                             }
 662
 663                             if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0,
 664                                 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
 665                                 RegSetValueExW(subKey, NULL, 0, REG_SZ,
 666                                                (const BYTE *)PSOA, sizeof PSOA);
 667                                 RegCloseKey(subKey);
 668                             }
 669
 670                             if (RegCreateKeyExW(key, TypeLibW, 0, NULL, 0,
 671                                 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
 672                             {
 673                                 WCHAR buffer[40];
 674                                 static const WCHAR fmtver[] = {'%','x','.','%','x',0 };
 675                                 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
 676
 677                                 StringFromGUID2(&attr->guid, buffer, 40);
 678                                 RegSetValueExW(subKey, NULL, 0, REG_SZ,
 679                                                (BYTE *)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
 680                                 sprintfW(buffer, fmtver, attr->wMajorVerNum, attr->wMinorVerNum);
 681                                 RegSetValueExW(subKey, VersionW, 0, REG_SZ,
 682                                                (BYTE*)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
 683                                 RegCloseKey(subKey);
 684                             }
 685
 686                             RegCloseKey(key);
 687                         }
 688                     }
 689
 690                     ITypeInfo_ReleaseTypeAttr(tinfo, tattr);
 691                 }
 692
 693                 ITypeInfo_Release(tinfo);
 694             }
 695
 696             SysFreeString(name);
 697         }
 698     }
 699
 700     ITypeLib_ReleaseTLibAttr(ptlib, attr);
 701
 702     return res;
 703 }
 704
 705
 706 /******************************************************************************
 707  *      UnRegisterTypeLib       [OLEAUT32.186]
 708  * Removes information about a type library from the System Registry
 709  * NOTES
 710  *
 711  * RETURNS
 712  *    Success: S_OK
 713  *    Failure: Status
 714  */
 715 HRESULT WINAPI UnRegisterTypeLib(
 716     REFGUID libid,      /* [in] Guid of the library */
 717         WORD wVerMajor, /* [in] major version */
 718         WORD wVerMinor, /* [in] minor version */
 719         LCID lcid,      /* [in] locale id */
 720         SYSKIND syskind)
 721 {
 722     BSTR tlibPath = NULL;
 723     DWORD tmpLength;
 724     WCHAR keyName[60];
 725     WCHAR subKeyName[50];
 726     int result = S_OK;
 727     DWORD i = 0;
 728     BOOL deleteOtherStuff;
 729     HKEY key = NULL;
 730     HKEY subKey = NULL;
 731     TYPEATTR* typeAttr = NULL;
 732     TYPEKIND kind;
 733     ITypeInfo* typeInfo = NULL;
 734     ITypeLib* typeLib = NULL;
 735     int numTypes;
 736
 737     TRACE("(IID: %s)\n",debugstr_guid(libid));
 738
 739     /* Create the path to the key */
 740     get_typelib_key( libid, wVerMajor, wVerMinor, keyName );
 741
 742     if (syskind != SYS_WIN16 && syskind != SYS_WIN32)
 743     {
 744         TRACE("Unsupported syskind %i\n", syskind);
 745         result = E_INVALIDARG;
 746         goto end;
 747     }
 748
 749     /* get the path to the typelib on disk */
 750     if (QueryPathOfRegTypeLib(libid, wVerMajor, wVerMinor, lcid, &tlibPath) != S_OK) {
 751         result = E_INVALIDARG;
 752         goto end;
 753     }
 754
 755     /* Try and open the key to the type library. */
 756     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ | KEY_WRITE, &key) != ERROR_SUCCESS) {
 757         result = E_INVALIDARG;
 758         goto end;
 759     }
 760
 761     /* Try and load the type library */
 762     if (LoadTypeLibEx(tlibPath, REGKIND_NONE, &typeLib)) {
 763         result = TYPE_E_INVALIDSTATE;
 764         goto end;
 765     }
 766
 767     /* remove any types registered with this typelib */
 768     numTypes = ITypeLib_GetTypeInfoCount(typeLib);
 769     for (i=0; i<numTypes; i++) {
 770         /* get the kind of type */
 771         if (ITypeLib_GetTypeInfoType(typeLib, i, &kind) != S_OK) {
 772             goto enddeleteloop;
 773         }
 774
 775         /* skip non-interfaces, and get type info for the type */
 776         if ((kind != TKIND_INTERFACE) && (kind != TKIND_DISPATCH)) {
 777             goto enddeleteloop;
 778         }
 779         if (ITypeLib_GetTypeInfo(typeLib, i, &typeInfo) != S_OK) {
 780             goto enddeleteloop;
 781         }
 782         if (ITypeInfo_GetTypeAttr(typeInfo, &typeAttr) != S_OK) {
 783             goto enddeleteloop;
 784         }
 785
 786         /* the path to the type */
 787         get_interface_key( &typeAttr->guid, subKeyName );
 788
 789         /* Delete its bits */
 790         if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE, &subKey) != ERROR_SUCCESS) {
 791             goto enddeleteloop;
 792         }
 793         RegDeleteKeyW(subKey, ProxyStubClsidW);
 794         RegDeleteKeyW(subKey, ProxyStubClsid32W);
 795         RegDeleteKeyW(subKey, TypeLibW);
 796         RegCloseKey(subKey);
 797         subKey = NULL;
 798         RegDeleteKeyW(HKEY_CLASSES_ROOT, subKeyName);
 799
 800 enddeleteloop:
 801         if (typeAttr) ITypeInfo_ReleaseTypeAttr(typeInfo, typeAttr);
 802         typeAttr = NULL;
 803         if (typeInfo) ITypeInfo_Release(typeInfo);
 804         typeInfo = NULL;
 805     }
 806
 807     /* Now, delete the type library path subkey */
 808     get_lcid_subkey( lcid, syskind, subKeyName );
 809     RegDeleteKeyW(key, subKeyName);
 810     *strrchrW( subKeyName, '\\' ) = 0;  /* remove last path component */
 811     RegDeleteKeyW(key, subKeyName);
 812
 813     /* check if there is anything besides the FLAGS/HELPDIR keys.
 814        If there is, we don't delete them */
 815     tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
 816     deleteOtherStuff = TRUE;
 817     i = 0;
 818     while(RegEnumKeyExW(key, i++, subKeyName, &tmpLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
 819         tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
 820
 821         /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
 822         if (!strcmpW(subKeyName, FLAGSW)) continue;
 823         if (!strcmpW(subKeyName, HELPDIRW)) continue;
 824         deleteOtherStuff = FALSE;
 825         break;
 826     }
 827
 828     /* only delete the other parts of the key if we're absolutely sure */
 829     if (deleteOtherStuff) {
 830         RegDeleteKeyW(key, FLAGSW);
 831         RegDeleteKeyW(key, HELPDIRW);
 832         RegCloseKey(key);
 833         key = NULL;
 834
 835         RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
 836         *strrchrW( keyName, '\\' ) = 0;  /* remove last path component */
 837         RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
 838     }
 839
 840 end:
 841     if (tlibPath) SysFreeString(tlibPath);
 842     if (typeLib) ITypeLib_Release(typeLib);
 843     if (subKey) RegCloseKey(subKey);
 844     if (key) RegCloseKey(key);
 845     return result;
 846 }
 847
 848 /*======================= ITypeLib implementation =======================*/
 849
 850 typedef struct tagTLBCustData
 851 {
 852     GUID guid;
 853     VARIANT data;
 854     struct tagTLBCustData* next;
 855 } TLBCustData;
 856
 857 /* data structure for import typelibs */
 858 typedef struct tagTLBImpLib
 859 {
 860     int offset;                 /* offset in the file (MSFT)
 861                                    offset in nametable (SLTG)
 862                                    just used to identify library while reading
 863                                    data from file */
 864     GUID guid;                  /* libid */
 865     BSTR name;                  /* name */
 866
 867     LCID lcid;                  /* lcid of imported typelib */
 868
 869     WORD wVersionMajor;         /* major version number */
 870     WORD wVersionMinor;         /* minor version number */
 871
 872     struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib, or
 873                                             NULL if not yet loaded */
 874     struct tagTLBImpLib * next;
 875 } TLBImpLib;
 876
 877 /* internal ITypeLib data */
 878 typedef struct tagITypeLibImpl
 879 {
 880     const ITypeLib2Vtbl *lpVtbl;
 881     const ITypeCompVtbl *lpVtblTypeComp;
 882     LONG ref;
 883     TLIBATTR LibAttr;            /* guid,lcid,syskind,version,flags */
 884
 885     /* strings can be stored in tlb as multibyte strings BUT they are *always*
 886      * exported to the application as a UNICODE string.
 887      */
 888     BSTR Name;
 889     BSTR DocString;
 890     BSTR HelpFile;
 891     BSTR HelpStringDll;
 892     unsigned long  dwHelpContext;
 893     int TypeInfoCount;          /* nr of typeinfo's in librarry */
 894     struct tagITypeInfoImpl *pTypeInfo;   /* linked list of type info data */
 895     int ctCustData;             /* number of items in cust data list */
 896     TLBCustData * pCustData;    /* linked list to cust data */
 897     TLBImpLib   * pImpLibs;     /* linked list to all imported typelibs */
 898     int ctTypeDesc;             /* number of items in type desc array */
 899     TYPEDESC * pTypeDesc;       /* array of TypeDescriptions found in the
 900                                    library. Only used while reading MSFT
 901                                    typelibs */
 902     struct list ref_list;       /* list of ref types in this typelib */
 903     HREFTYPE dispatch_href;     /* reference to IDispatch, -1 if unused */
 904
 905
 906     /* typelibs are cached, keyed by path and index, so store the linked list info within them */
 907     struct tagITypeLibImpl *next, *prev;
 908     WCHAR *path;
 909     INT index;
 910 } ITypeLibImpl;
 911
 912 static const ITypeLib2Vtbl tlbvt;
 913 static const ITypeCompVtbl tlbtcvt;
 914
 915 static inline ITypeLibImpl *impl_from_ITypeComp( ITypeComp *iface )
 916 {
 917     return (ITypeLibImpl *)((char*)iface - FIELD_OFFSET(ITypeLibImpl, lpVtblTypeComp));
 918 }
 919
 920 /* ITypeLib methods */
 921 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength);
 922 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength);
 923
 924 /*======================= ITypeInfo implementation =======================*/
 925
 926 /* data for referenced types */
 927 typedef struct tagTLBRefType
 928 {
 929     INT index;              /* Type index for internal ref or for external ref
 930                                it the format is SLTG.  -2 indicates to
 931                                use guid */
 932
 933     GUID guid;              /* guid of the referenced type */
 934                             /* if index == TLB_REF_USE_GUID */
 935
 936     HREFTYPE reference;     /* The href of this ref */
 937     TLBImpLib *pImpTLInfo;  /* If ref is external ptr to library data
 938                                TLB_REF_INTERNAL for internal refs
 939                                TLB_REF_NOT_FOUND for broken refs */
 940
 941     struct list entry;
 942 } TLBRefType;
 943
 944 #define TLB_REF_USE_GUID -2
 945
 946 #define TLB_REF_INTERNAL (void*)-2
 947 #define TLB_REF_NOT_FOUND (void*)-1
 948
 949 /* internal Parameter data */
 950 typedef struct tagTLBParDesc
 951 {
 952     BSTR Name;
 953     int ctCustData;
 954     TLBCustData * pCustData;        /* linked list to cust data */
 955 } TLBParDesc;
 956
 957 /* internal Function data */
 958 typedef struct tagTLBFuncDesc
 959 {
 960     FUNCDESC funcdesc;      /* lots of info on the function and its attributes. */
 961     BSTR Name;             /* the name of this function */
 962     TLBParDesc *pParamDesc; /* array with param names and custom data */
 963     int helpcontext;
 964     int HelpStringContext;
 965     BSTR HelpString;
 966     BSTR Entry;            /* if its Hiword==0, it numeric; -1 is not present*/
 967     int ctCustData;
 968     TLBCustData * pCustData;        /* linked list to cust data; */
 969     struct tagTLBFuncDesc * next;
 970 } TLBFuncDesc;
 971
 972 /* internal Variable data */
 973 typedef struct tagTLBVarDesc
 974 {
 975     VARDESC vardesc;        /* lots of info on the variable and its attributes. */
 976     BSTR Name;             /* the name of this variable */
 977     int HelpContext;
 978     int HelpStringContext;  /* FIXME: where? */
 979     BSTR HelpString;
 980     int ctCustData;
 981     TLBCustData * pCustData;/* linked list to cust data; */
 982     struct tagTLBVarDesc * next;
 983 } TLBVarDesc;
 984
 985 /* internal implemented interface data */
 986 typedef struct tagTLBImplType
 987 {
 988     HREFTYPE hRef;          /* hRef of interface */
 989     int implflags;          /* IMPLFLAG_*s */
 990     int ctCustData;
 991     TLBCustData * pCustData;/* linked list to custom data; */
 992     struct tagTLBImplType *next;
 993 } TLBImplType;
 994
 995 /* internal TypeInfo data */
 996 typedef struct tagITypeInfoImpl
 997 {
 998     const ITypeInfo2Vtbl *lpVtbl;
 999     const ITypeCompVtbl  *lpVtblTypeComp;
1000     LONG ref;
1001     BOOL no_free_data; /* don't free data structurees */
1002     TYPEATTR TypeAttr ;         /* _lots_ of type information. */
1003     ITypeLibImpl * pTypeLib;        /* back pointer to typelib */
1004     int index;                  /* index in this typelib; */
1005     HREFTYPE hreftype;          /* hreftype for app object binding */
1006     /* type libs seem to store the doc strings in ascii
1007      * so why should we do it in unicode?
1008      */
1009     BSTR Name;
1010     BSTR DocString;
1011     BSTR DllName;
1012     unsigned long  dwHelpContext;
1013     unsigned long  dwHelpStringContext;
1014
1015     /* functions  */
1016     TLBFuncDesc * funclist;     /* linked list with function descriptions */
1017
1018     /* variables  */
1019     TLBVarDesc * varlist;       /* linked list with variable descriptions */
1020
1021     /* Implemented Interfaces  */
1022     TLBImplType * impltypelist;
1023
1024     int ctCustData;
1025     TLBCustData * pCustData;        /* linked list to cust data; */
1026     struct tagITypeInfoImpl * next;
1027 } ITypeInfoImpl;
1028
1029 static inline ITypeInfoImpl *info_impl_from_ITypeComp( ITypeComp *iface )
1030 {
1031     return (ITypeInfoImpl *)((char*)iface - FIELD_OFFSET(ITypeInfoImpl, lpVtblTypeComp));
1032 }
1033
1034 static const ITypeInfo2Vtbl tinfvt;
1035 static const ITypeCompVtbl  tcompvt;
1036
1037 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void);
1038
1039 typedef struct tagTLBContext
1040 {
1041         unsigned int oStart;  /* start of TLB in file */
1042         unsigned int pos;     /* current pos */
1043         unsigned int length;  /* total length */
1044         void *mapping;        /* memory mapping */
1045         MSFT_SegDir * pTblDir;
1046         ITypeLibImpl* pLibInfo;
1047 } TLBContext;
1048
1049
1050 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL, int offset);
1051
1052 /*
1053  debug
1054 */
1055 static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
1056     if (pTD->vt & VT_RESERVED)
1057         szVarType += strlen(strcpy(szVarType, "reserved | "));
1058     if (pTD->vt & VT_BYREF)
1059         szVarType += strlen(strcpy(szVarType, "ref to "));
1060     if (pTD->vt & VT_ARRAY)
1061         szVarType += strlen(strcpy(szVarType, "array of "));
1062     if (pTD->vt & VT_VECTOR)
1063         szVarType += strlen(strcpy(szVarType, "vector of "));
1064     switch(pTD->vt & VT_TYPEMASK) {
1065     case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
1066     case VT_I2: sprintf(szVarType, "VT_I2"); break;
1067     case VT_I4: sprintf(szVarType, "VT_I4"); break;
1068     case VT_R4: sprintf(szVarType, "VT_R4"); break;
1069     case VT_R8: sprintf(szVarType, "VT_R8"); break;
1070     case VT_BOOL: sprintf(szVarType, "VT_BOOL"); break;
1071     case VT_ERROR: sprintf(szVarType, "VT_ERROR"); break;
1072     case VT_CY: sprintf(szVarType, "VT_CY"); break;
1073     case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
1074     case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
1075     case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
1076     case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
1077     case VT_I1: sprintf(szVarType, "VT_I1"); break;
1078     case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
1079     case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
1080     case VT_INT: sprintf(szVarType, "VT_INT"); break;
1081     case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
1082     case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
1083     case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
1084     case VT_HRESULT: sprintf(szVarType, "VT_HRESULT"); break;
1085     case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %x",
1086                                  pTD->u.hreftype); break;
1087     case VT_PTR: sprintf(szVarType, "ptr to ");
1088       dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
1089       break;
1090     case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
1091       dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
1092       break;
1093     case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
1094                             pTD->u.lpadesc->cDims); /* FIXME print out sizes */
1095       dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
1096       break;
1097
1098     default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
1099     }
1100 }
1101
1102 static void dump_ELEMDESC(const ELEMDESC *edesc) {
1103   char buf[200];
1104   USHORT flags = edesc->u.paramdesc.wParamFlags;
1105   dump_TypeDesc(&edesc->tdesc,buf);
1106   MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
1107   MESSAGE("\t\tu.paramdesc.wParamFlags");
1108   if (!flags) MESSAGE(" PARAMFLAGS_NONE");
1109   if (flags & PARAMFLAG_FIN) MESSAGE(" PARAMFLAG_FIN");
1110   if (flags & PARAMFLAG_FOUT) MESSAGE(" PARAMFLAG_FOUT");
1111   if (flags & PARAMFLAG_FLCID) MESSAGE(" PARAMFLAG_FLCID");
1112   if (flags & PARAMFLAG_FRETVAL) MESSAGE(" PARAMFLAG_FRETVAL");
1113   if (flags & PARAMFLAG_FOPT) MESSAGE(" PARAMFLAG_FOPT");
1114   if (flags & PARAMFLAG_FHASDEFAULT) MESSAGE(" PARAMFLAG_FHASDEFAULT");
1115   if (flags & PARAMFLAG_FHASCUSTDATA) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
1116   MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
1117 }
1118 static void dump_FUNCDESC(const FUNCDESC *funcdesc) {
1119   int i;
1120   MESSAGE("memid is %08x\n",funcdesc->memid);
1121   for (i=0;i<funcdesc->cParams;i++) {
1122       MESSAGE("Param %d:\n",i);
1123       dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
1124   }
1125   MESSAGE("\tfunckind: %d (",funcdesc->funckind);
1126   switch (funcdesc->funckind) {
1127   case FUNC_VIRTUAL: MESSAGE("virtual");break;
1128   case FUNC_PUREVIRTUAL: MESSAGE("pure virtual");break;
1129   case FUNC_NONVIRTUAL: MESSAGE("nonvirtual");break;
1130   case FUNC_STATIC: MESSAGE("static");break;
1131   case FUNC_DISPATCH: MESSAGE("dispatch");break;
1132   default: MESSAGE("unknown");break;
1133   }
1134   MESSAGE(")\n\tinvkind: %d (",funcdesc->invkind);
1135   switch (funcdesc->invkind) {
1136   case INVOKE_FUNC: MESSAGE("func");break;
1137   case INVOKE_PROPERTYGET: MESSAGE("property get");break;
1138   case INVOKE_PROPERTYPUT: MESSAGE("property put");break;
1139   case INVOKE_PROPERTYPUTREF: MESSAGE("property put ref");break;
1140   }
1141   MESSAGE(")\n\tcallconv: %d (",funcdesc->callconv);
1142   switch (funcdesc->callconv) {
1143   case CC_CDECL: MESSAGE("cdecl");break;
1144   case CC_PASCAL: MESSAGE("pascal");break;
1145   case CC_STDCALL: MESSAGE("stdcall");break;
1146   case CC_SYSCALL: MESSAGE("syscall");break;
1147   default:break;
1148   }
1149   MESSAGE(")\n\toVft: %d\n", funcdesc->oVft);
1150   MESSAGE("\tcParamsOpt: %d\n", funcdesc->cParamsOpt);
1151   MESSAGE("\twFlags: %x\n", funcdesc->wFuncFlags);
1152
1153   MESSAGE("\telemdescFunc (return value type):\n");
1154   dump_ELEMDESC(&funcdesc->elemdescFunc);
1155 }
1156
1157 static const char * const typekind_desc[] =
1158 {
1159         "TKIND_ENUM",
1160         "TKIND_RECORD",
1161         "TKIND_MODULE",
1162         "TKIND_INTERFACE",
1163         "TKIND_DISPATCH",
1164         "TKIND_COCLASS",
1165         "TKIND_ALIAS",
1166         "TKIND_UNION",
1167         "TKIND_MAX"
1168 };
1169
1170 static void dump_TLBFuncDescOne(const TLBFuncDesc * pfd)
1171 {
1172   int i;
1173   MESSAGE("%s(%u)\n", debugstr_w(pfd->Name), pfd->funcdesc.cParams);
1174   for (i=0;i<pfd->funcdesc.cParams;i++)
1175       MESSAGE("\tparm%d: %s\n",i,debugstr_w(pfd->pParamDesc[i].Name));
1176
1177
1178   dump_FUNCDESC(&(pfd->funcdesc));
1179
1180   MESSAGE("\thelpstring: %s\n", debugstr_w(pfd->HelpString));
1181   MESSAGE("\tentry: %s\n", (pfd->Entry == (void *)-1) ? "invalid" : debugstr_w(pfd->Entry));
1182 }
1183 static void dump_TLBFuncDesc(const TLBFuncDesc * pfd)
1184 {
1185         while (pfd)
1186         {
1187           dump_TLBFuncDescOne(pfd);
1188           pfd = pfd->next;
1189         };
1190 }
1191 static void dump_TLBVarDesc(const TLBVarDesc * pvd)
1192 {
1193         while (pvd)
1194         {
1195           TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
1196           pvd = pvd->next;
1197         };
1198 }
1199
1200 static void dump_TLBImpLib(const TLBImpLib *import)
1201 {
1202     TRACE_(typelib)("%s %s\n", debugstr_guid(&(import->guid)),
1203                     debugstr_w(import->name));
1204     TRACE_(typelib)("v%d.%d lcid=%x offset=%x\n", import->wVersionMajor,
1205                     import->wVersionMinor, import->lcid, import->offset);
1206 }
1207
1208 static void dump_TLBRefType(const ITypeLibImpl *pTL)
1209 {
1210     TLBRefType *ref;
1211
1212     LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
1213     {
1214         TRACE_(typelib)("href:0x%08x\n", ref->reference);
1215         if(ref->index == -1)
1216             TRACE_(typelib)("%s\n", debugstr_guid(&(ref->guid)));
1217         else
1218             TRACE_(typelib)("type no: %d\n", ref->index);
1219
1220         if(ref->pImpTLInfo != TLB_REF_INTERNAL && ref->pImpTLInfo != TLB_REF_NOT_FOUND)
1221         {
1222             TRACE_(typelib)("in lib\n");
1223             dump_TLBImpLib(ref->pImpTLInfo);
1224         }
1225     }
1226 }
1227
1228 static void dump_TLBImplType(const TLBImplType * impl)
1229 {
1230     while (impl) {
1231         TRACE_(typelib)(
1232                 "implementing/inheriting interface hRef = %x implflags %x\n",
1233                 impl->hRef, impl->implflags);
1234         impl = impl->next;
1235     }
1236 }
1237
1238 static void dump_Variant(const VARIANT * pvar)
1239 {
1240     SYSTEMTIME st;
1241
1242     TRACE("%p->{%s%s", pvar, debugstr_VT(pvar), debugstr_VF(pvar));
1243
1244     if (pvar)
1245     {
1246       if (V_ISBYREF(pvar) || V_TYPE(pvar) == VT_UNKNOWN ||
1247           V_TYPE(pvar) == VT_DISPATCH || V_TYPE(pvar) == VT_RECORD)
1248       {
1249         TRACE(",%p", V_BYREF(pvar));
1250       }
1251       else if (V_ISARRAY(pvar) || V_ISVECTOR(pvar))
1252       {
1253         TRACE(",%p", V_ARRAY(pvar));
1254       }
1255       else switch (V_TYPE(pvar))
1256       {
1257       case VT_I1:   TRACE(",%d", V_I1(pvar)); break;
1258       case VT_UI1:  TRACE(",%d", V_UI1(pvar)); break;
1259       case VT_I2:   TRACE(",%d", V_I2(pvar)); break;
1260       case VT_UI2:  TRACE(",%d", V_UI2(pvar)); break;
1261       case VT_INT:
1262       case VT_I4:   TRACE(",%d", V_I4(pvar)); break;
1263       case VT_UINT:
1264       case VT_UI4:  TRACE(",%d", V_UI4(pvar)); break;
1265       case VT_I8:   TRACE(",0x%08x,0x%08x", (ULONG)(V_I8(pvar) >> 32),
1266                           (ULONG)(V_I8(pvar) & 0xffffffff)); break;
1267       case VT_UI8:  TRACE(",0x%08x,0x%08x", (ULONG)(V_UI8(pvar) >> 32),
1268                           (ULONG)(V_UI8(pvar) & 0xffffffff)); break;
1269       case VT_R4:   TRACE(",%3.3e", V_R4(pvar)); break;
1270       case VT_R8:   TRACE(",%3.3e", V_R8(pvar)); break;
1271       case VT_BOOL: TRACE(",%s", V_BOOL(pvar) ? "TRUE" : "FALSE"); break;
1272       case VT_BSTR: TRACE(",%s", debugstr_w(V_BSTR(pvar))); break;
1273       case VT_CY:   TRACE(",0x%08x,0x%08x", V_CY(pvar).s.Hi,
1274                            V_CY(pvar).s.Lo); break;
1275       case VT_DATE:
1276         if(!VariantTimeToSystemTime(V_DATE(pvar), &st))
1277           TRACE(",<invalid>");
1278         else
1279           TRACE(",%04d/%02d/%02d %02d:%02d:%02d", st.wYear, st.wMonth, st.wDay,
1280                 st.wHour, st.wMinute, st.wSecond);
1281         break;
1282       case VT_ERROR:
1283       case VT_VOID:
1284       case VT_USERDEFINED:
1285       case VT_EMPTY:
1286       case VT_NULL:  break;
1287       default:       TRACE(",?"); break;
1288       }
1289     }
1290     TRACE("}\n");
1291 }
1292
1293 static void dump_DispParms(const DISPPARAMS * pdp)
1294 {
1295     int index;
1296
1297     TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
1298
1299     if (pdp->cNamedArgs && pdp->rgdispidNamedArgs)
1300     {
1301         TRACE("named args:\n");
1302         for (index = 0; index < pdp->cNamedArgs; index++)
1303             TRACE( "\t0x%x\n", pdp->rgdispidNamedArgs[index] );
1304     }
1305
1306     if (pdp->cArgs && pdp->rgvarg)
1307     {
1308         TRACE("args:\n");
1309         for (index = 0; index < pdp->cArgs; index++)
1310             dump_Variant( &pdp->rgvarg[index] );
1311     }
1312 }
1313
1314 static void dump_TypeInfo(const ITypeInfoImpl * pty)
1315 {
1316     TRACE("%p ref=%u\n", pty, pty->ref);
1317     TRACE("%s %s\n", debugstr_w(pty->Name), debugstr_w(pty->DocString));
1318     TRACE("attr:%s\n", debugstr_guid(&(pty->TypeAttr.guid)));
1319     TRACE("kind:%s\n", typekind_desc[pty->TypeAttr.typekind]);
1320     TRACE("fct:%u var:%u impl:%u\n",
1321       pty->TypeAttr.cFuncs, pty->TypeAttr.cVars, pty->TypeAttr.cImplTypes);
1322     TRACE("wTypeFlags: 0x%04x\n", pty->TypeAttr.wTypeFlags);
1323     TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
1324     if (pty->TypeAttr.typekind == TKIND_MODULE) TRACE("dllname:%s\n", debugstr_w(pty->DllName));
1325     if (TRACE_ON(ole))
1326         dump_TLBFuncDesc(pty->funclist);
1327     dump_TLBVarDesc(pty->varlist);
1328     dump_TLBImplType(pty->impltypelist);
1329 }
1330
1331 static void dump_VARDESC(const VARDESC *v)
1332 {
1333     MESSAGE("memid %d\n",v->memid);
1334     MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
1335     MESSAGE("oInst %d\n",v->u.oInst);
1336     dump_ELEMDESC(&(v->elemdescVar));
1337     MESSAGE("wVarFlags %x\n",v->wVarFlags);
1338     MESSAGE("varkind %d\n",v->varkind);
1339 }
1340
1341 static TYPEDESC stndTypeDesc[VT_LPWSTR+1]=
1342 {
1343     /* VT_LPWSTR is largest type that */
1344     /* may appear in type description*/
1345     {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
1346     {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
1347     {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
1348     {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
1349     {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
1350     {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
1351     {{0},30},{{0},31}
1352 };
1353
1354 static void TLB_abort(void)
1355 {
1356     DebugBreak();
1357 }
1358 static void * TLB_Alloc(unsigned size)
1359 {
1360     void * ret;
1361     if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
1362         /* FIXME */
1363         ERR("cannot allocate memory\n");
1364     }
1365     return ret;
1366 }
1367
1368 static void TLB_Free(void * ptr)
1369 {
1370     HeapFree(GetProcessHeap(), 0, ptr);
1371 }
1372
1373 /* returns the size required for a deep copy of a typedesc into a
1374  * flat buffer */
1375 static SIZE_T TLB_SizeTypeDesc( const TYPEDESC *tdesc, BOOL alloc_initial_space )
1376 {
1377     SIZE_T size = 0;
1378
1379     if (alloc_initial_space)
1380         size += sizeof(TYPEDESC);
1381
1382     switch (tdesc->vt)
1383     {
1384     case VT_PTR:
1385     case VT_SAFEARRAY:
1386         size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
1387         break;
1388     case VT_CARRAY:
1389         size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
1390         size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
1391         break;
1392     }
1393     return size;
1394 }
1395
1396 /* deep copy a typedesc into a flat buffer */
1397 static void *TLB_CopyTypeDesc( TYPEDESC *dest, const TYPEDESC *src, void *buffer )
1398 {
1399     if (!dest)
1400     {
1401         dest = buffer;
1402         buffer = (char *)buffer + sizeof(TYPEDESC);
1403     }
1404
1405     *dest = *src;
1406
1407     switch (src->vt)
1408     {
1409     case VT_PTR:
1410     case VT_SAFEARRAY:
1411         dest->u.lptdesc = buffer;
1412         buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
1413         break;
1414     case VT_CARRAY:
1415         dest->u.lpadesc = buffer;
1416         memcpy(dest->u.lpadesc, src->u.lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]));
1417         buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]);
1418         buffer = TLB_CopyTypeDesc(&dest->u.lpadesc->tdescElem, &src->u.lpadesc->tdescElem, buffer);
1419         break;
1420     }
1421     return buffer;
1422 }
1423
1424 /**********************************************************************
1425  *
1426  *  Functions for reading MSFT typelibs (those created by CreateTypeLib2)
1427  */
1428 static inline unsigned int MSFT_Tell(const TLBContext *pcx)
1429 {
1430     return pcx->pos;
1431 }
1432
1433 static inline void MSFT_Seek(TLBContext *pcx, long where)
1434 {
1435     if (where != DO_NOT_SEEK)
1436     {
1437         where += pcx->oStart;
1438         if (where > pcx->length)
1439         {
1440             /* FIXME */
1441             ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
1442             TLB_abort();
1443         }
1444         pcx->pos = where;
1445     }
1446 }
1447
1448 /* read function */
1449 static DWORD MSFT_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
1450 {
1451     TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08lx\n",
1452        pcx->pos, count, pcx->oStart, pcx->length, where);
1453
1454     MSFT_Seek(pcx, where);
1455     if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
1456     memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
1457     pcx->pos += count;
1458     return count;
1459 }
1460
1461 static DWORD MSFT_ReadLEDWords(void *buffer,  DWORD count, TLBContext *pcx,
1462                                long where )
1463 {
1464   DWORD ret;
1465
1466   ret = MSFT_Read(buffer, count, pcx, where);
1467   FromLEDWords(buffer, ret);
1468
1469   return ret;
1470 }
1471
1472 static DWORD MSFT_ReadLEWords(void *buffer,  DWORD count, TLBContext *pcx,
1473                               long where )
1474 {
1475   DWORD ret;
1476
1477   ret = MSFT_Read(buffer, count, pcx, where);
1478   FromLEWords(buffer, ret);
1479
1480   return ret;
1481 }
1482
1483 static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
1484 {
1485     if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
1486         memset(pGuid,0, sizeof(GUID));
1487         return;
1488     }
1489     MSFT_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
1490     pGuid->Data1 = FromLEDWord(pGuid->Data1);
1491     pGuid->Data2 = FromLEWord(pGuid->Data2);
1492     pGuid->Data3 = FromLEWord(pGuid->Data3);
1493     TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
1494 }
1495
1496 static HREFTYPE MSFT_ReadHreftype( TLBContext *pcx, int offset )
1497 {
1498     MSFT_NameIntro niName;
1499
1500     if (offset < 0)
1501     {
1502         ERR_(typelib)("bad offset %d\n", offset);
1503         return -1;
1504     }
1505
1506     MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1507                       pcx->pTblDir->pNametab.offset+offset);
1508
1509     return niName.hreftype;
1510 }
1511
1512 static BSTR MSFT_ReadName( TLBContext *pcx, int offset)
1513 {
1514     char * name;
1515     MSFT_NameIntro niName;
1516     int lengthInChars;
1517     BSTR bstrName = NULL;
1518
1519     if (offset < 0)
1520     {
1521         ERR_(typelib)("bad offset %d\n", offset);
1522         return NULL;
1523     }
1524     MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1525                       pcx->pTblDir->pNametab.offset+offset);
1526     niName.namelen &= 0xFF; /* FIXME: correct ? */
1527     name=TLB_Alloc((niName.namelen & 0xff) +1);
1528     MSFT_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
1529     name[niName.namelen & 0xff]='\0';
1530
1531     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1532                                         name, -1, NULL, 0);
1533
1534     /* no invalid characters in string */
1535     if (lengthInChars)
1536     {
1537         bstrName = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1538
1539         /* don't check for invalid character since this has been done previously */
1540         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, bstrName, lengthInChars);
1541     }
1542     TLB_Free(name);
1543
1544     TRACE_(typelib)("%s %d\n", debugstr_w(bstrName), lengthInChars);
1545     return bstrName;
1546 }
1547
1548 static BSTR MSFT_ReadString( TLBContext *pcx, int offset)
1549 {
1550     char * string;
1551     INT16 length;
1552     int lengthInChars;
1553     BSTR bstr = NULL;
1554
1555     if(offset<0) return NULL;
1556     MSFT_ReadLEWords(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
1557     if(length <= 0) return 0;
1558     string=TLB_Alloc(length +1);
1559     MSFT_Read(string, length, pcx, DO_NOT_SEEK);
1560     string[length]='\0';
1561
1562     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1563                                         string, -1, NULL, 0);
1564
1565     /* no invalid characters in string */
1566     if (lengthInChars)
1567     {
1568         bstr = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1569
1570         /* don't check for invalid character since this has been done previously */
1571         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, bstr, lengthInChars);
1572     }
1573     TLB_Free(string);
1574
1575     TRACE_(typelib)("%s %d\n", debugstr_w(bstr), lengthInChars);
1576     return bstr;
1577 }
1578 /*
1579  * read a value and fill a VARIANT structure
1580  */
1581 static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
1582 {
1583     int size;
1584
1585     TRACE_(typelib)("\n");
1586
1587     if(offset <0) { /* data are packed in here */
1588         V_VT(pVar) = (offset & 0x7c000000 )>> 26;
1589         V_I4(pVar) = offset & 0x3ffffff;
1590         return;
1591     }
1592     MSFT_ReadLEWords(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
1593                      pcx->pTblDir->pCustData.offset + offset );
1594     TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
1595     switch (V_VT(pVar)){
1596         case VT_EMPTY:  /* FIXME: is this right? */
1597         case VT_NULL:   /* FIXME: is this right? */
1598         case VT_I2  :   /* this should not happen */
1599         case VT_I4  :
1600         case VT_R4  :
1601         case VT_ERROR   :
1602         case VT_BOOL    :
1603         case VT_I1  :
1604         case VT_UI1 :
1605         case VT_UI2 :
1606         case VT_UI4 :
1607         case VT_INT :
1608         case VT_UINT    :
1609         case VT_VOID    : /* FIXME: is this right? */
1610         case VT_HRESULT :
1611             size=4; break;
1612         case VT_R8  :
1613         case VT_CY  :
1614         case VT_DATE    :
1615         case VT_I8  :
1616         case VT_UI8 :
1617         case VT_DECIMAL :  /* FIXME: is this right? */
1618         case VT_FILETIME :
1619             size=8;break;
1620             /* pointer types with known behaviour */
1621         case VT_BSTR    :{
1622             char * ptr;
1623             MSFT_ReadLEDWords(&size, sizeof(INT), pcx, DO_NOT_SEEK );
1624             if(size < 0) {
1625                 char next;
1626                 DWORD origPos = MSFT_Tell(pcx), nullPos;
1627
1628                 do {
1629                     MSFT_Read(&next, 1, pcx, DO_NOT_SEEK);
1630                 } while (next);
1631                 nullPos = MSFT_Tell(pcx);
1632                 size = nullPos - origPos;
1633                 MSFT_Seek(pcx, origPos);
1634             }
1635             ptr=TLB_Alloc(size);/* allocate temp buffer */
1636             MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);/* read string (ANSI) */
1637             V_BSTR(pVar)=SysAllocStringLen(NULL,size);
1638             /* FIXME: do we need a AtoW conversion here? */
1639             V_UNION(pVar, bstrVal[size])='\0';
1640             while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
1641             TLB_Free(ptr);
1642         }
1643         size=-4; break;
1644     /* FIXME: this will not work AT ALL when the variant contains a pointer */
1645         case VT_DISPATCH :
1646         case VT_VARIANT :
1647         case VT_UNKNOWN :
1648         case VT_PTR :
1649         case VT_SAFEARRAY :
1650         case VT_CARRAY  :
1651         case VT_USERDEFINED :
1652         case VT_LPSTR   :
1653         case VT_LPWSTR  :
1654         case VT_BLOB    :
1655         case VT_STREAM  :
1656         case VT_STORAGE :
1657         case VT_STREAMED_OBJECT :
1658         case VT_STORED_OBJECT   :
1659         case VT_BLOB_OBJECT :
1660         case VT_CF  :
1661         case VT_CLSID   :
1662         default:
1663             size=0;
1664             FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
1665                 V_VT(pVar));
1666     }
1667
1668     if(size>0) /* (big|small) endian correct? */
1669         MSFT_Read(&(V_I2(pVar)), size, pcx, DO_NOT_SEEK );
1670     return;
1671 }
1672 /*
1673  * create a linked list with custom data
1674  */
1675 static int MSFT_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
1676 {
1677     MSFT_CDGuid entry;
1678     TLBCustData* pNew;
1679     int count=0;
1680
1681     TRACE_(typelib)("\n");
1682
1683     while(offset >=0){
1684         count++;
1685         pNew=TLB_Alloc(sizeof(TLBCustData));
1686         MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
1687         MSFT_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
1688         MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
1689         /* add new custom data at head of the list */
1690         pNew->next=*ppCustData;
1691         *ppCustData=pNew;
1692         offset = entry.next;
1693     }
1694     return count;
1695 }
1696
1697 static void MSFT_GetTdesc(TLBContext *pcx, INT type, TYPEDESC *pTd,
1698                           ITypeInfoImpl *pTI)
1699 {
1700     if(type <0)
1701         pTd->vt=type & VT_TYPEMASK;
1702     else
1703         *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
1704
1705     if(pTd->vt == VT_USERDEFINED)
1706       MSFT_DoRefType(pcx, pTI->pTypeLib, pTd->u.hreftype);
1707
1708     TRACE_(typelib)("vt type = %X\n", pTd->vt);
1709 }
1710
1711 static void MSFT_ResolveReferencedTypes(TLBContext *pcx, ITypeInfoImpl *pTI, TYPEDESC *lpTypeDesc)
1712 {
1713     /* resolve referenced type if any */
1714     while (lpTypeDesc)
1715     {
1716         switch (lpTypeDesc->vt)
1717         {
1718         case VT_PTR:
1719             lpTypeDesc = lpTypeDesc->u.lptdesc;
1720             break;
1721
1722         case VT_CARRAY:
1723             lpTypeDesc = & (lpTypeDesc->u.lpadesc->tdescElem);
1724             break;
1725
1726         case VT_USERDEFINED:
1727             MSFT_DoRefType(pcx, pTI->pTypeLib,
1728                            lpTypeDesc->u.hreftype);
1729
1730             lpTypeDesc = NULL;
1731             break;
1732
1733         default:
1734             lpTypeDesc = NULL;
1735         }
1736     }
1737 }
1738
1739 static void
1740 MSFT_DoFuncs(TLBContext*     pcx,
1741             ITypeInfoImpl*  pTI,
1742             int             cFuncs,
1743             int             cVars,
1744             int             offset,
1745             TLBFuncDesc**   pptfd)
1746 {
1747     /*
1748      * member information is stored in a data structure at offset
1749      * indicated by the memoffset field of the typeinfo structure
1750      * There are several distinctive parts.
1751      * The first part starts with a field that holds the total length
1752      * of this (first) part excluding this field. Then follow the records,
1753      * for each member there is one record.
1754      *
1755      * The first entry is always the length of the record (including this
1756      * length word).
1757      * The rest of the record depends on the type of the member. If there is
1758      * a field indicating the member type (function, variable, interface, etc)
1759      * I have not found it yet. At this time we depend on the information
1760      * in the type info and the usual order how things are stored.
1761      *
1762      * Second follows an array sized nrMEM*sizeof(INT) with a member id
1763      * for each member;
1764      *
1765      * Third is an equal sized array with file offsets to the name entry
1766      * of each member.
1767      *
1768      * The fourth and last (?) part is an array with offsets to the records
1769      * in the first part of this file segment.
1770      */
1771
1772     int infolen, nameoffset, reclength, nrattributes, i;
1773     int recoffset = offset + sizeof(INT);
1774
1775     char *recbuf = HeapAlloc(GetProcessHeap(), 0, 0xffff);
1776     MSFT_FuncRecord * pFuncRec=(MSFT_FuncRecord *) recbuf;
1777     TLBFuncDesc *ptfd_prev = NULL;
1778
1779     TRACE_(typelib)("\n");
1780
1781     MSFT_ReadLEDWords(&infolen, sizeof(INT), pcx, offset);
1782
1783     for ( i = 0; i < cFuncs ; i++ )
1784     {
1785         *pptfd = TLB_Alloc(sizeof(TLBFuncDesc));
1786
1787         /* name, eventually add to a hash table */
1788         MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1789                           offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1790
1791         /* nameoffset is sometimes -1 on the second half of a propget/propput
1792          * pair of functions */
1793         if ((nameoffset == -1) && (i > 0))
1794             (*pptfd)->Name = SysAllocString(ptfd_prev->Name);
1795         else
1796             (*pptfd)->Name = MSFT_ReadName(pcx, nameoffset);
1797
1798         /* read the function information record */
1799         MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1800
1801         reclength &= 0xffff;
1802
1803         MSFT_ReadLEDWords(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1804
1805         /* do the attributes */
1806         nrattributes = (reclength - pFuncRec->nrargs * 3 * sizeof(int) - 0x18)
1807                        / sizeof(int);
1808
1809         if ( nrattributes > 0 )
1810         {
1811             (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
1812
1813             if ( nrattributes > 1 )
1814             {
1815                 (*pptfd)->HelpString = MSFT_ReadString(pcx,
1816                                                       pFuncRec->OptAttr[1]) ;
1817
1818                 if ( nrattributes > 2 )
1819                 {
1820                     if ( pFuncRec->FKCCIC & 0x2000 )
1821                     {
1822                        if (HIWORD(pFuncRec->OptAttr[2]) != 0)
1823                            ERR("ordinal 0x%08x invalid, HIWORD != 0\n", pFuncRec->OptAttr[2]);
1824                        (*pptfd)->Entry = (BSTR)pFuncRec->OptAttr[2];
1825                     }
1826                     else
1827                     {
1828                         (*pptfd)->Entry = MSFT_ReadString(pcx,
1829                                                          pFuncRec->OptAttr[2]);
1830                     }
1831                     if( nrattributes > 5 )
1832                     {
1833                         (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
1834
1835                         if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
1836                         {
1837                             MSFT_CustData(pcx,
1838                                           pFuncRec->OptAttr[6],
1839                                           &(*pptfd)->pCustData);
1840                         }
1841                     }
1842                 }
1843                 else
1844                 {
1845                     (*pptfd)->Entry = (BSTR)-1;
1846                 }
1847             }
1848         }
1849
1850         /* fill the FuncDesc Structure */
1851         MSFT_ReadLEDWords( & (*pptfd)->funcdesc.memid, sizeof(INT), pcx,
1852                            offset + infolen + ( i + 1) * sizeof(INT));
1853
1854         (*pptfd)->funcdesc.funckind   =  (pFuncRec->FKCCIC)      & 0x7;
1855         (*pptfd)->funcdesc.invkind    =  (pFuncRec->FKCCIC) >> 3 & 0xF;
1856         (*pptfd)->funcdesc.callconv   =  (pFuncRec->FKCCIC) >> 8 & 0xF;
1857         (*pptfd)->funcdesc.cParams    =   pFuncRec->nrargs  ;
1858         (*pptfd)->funcdesc.cParamsOpt =   pFuncRec->nroargs ;
1859         (*pptfd)->funcdesc.oVft       =   pFuncRec->VtableOffset ;
1860         (*pptfd)->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
1861
1862         MSFT_GetTdesc(pcx,
1863                       pFuncRec->DataType,
1864                       &(*pptfd)->funcdesc.elemdescFunc.tdesc,
1865                       pTI);
1866         MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptfd)->funcdesc.elemdescFunc.tdesc);
1867
1868         /* do the parameters/arguments */
1869         if(pFuncRec->nrargs)
1870         {
1871             int j = 0;
1872             MSFT_ParameterInfo paraminfo;
1873
1874             (*pptfd)->funcdesc.lprgelemdescParam =
1875                 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
1876
1877             (*pptfd)->pParamDesc =
1878                 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
1879
1880             MSFT_ReadLEDWords(&paraminfo, sizeof(paraminfo), pcx,
1881                               recoffset + reclength - pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
1882
1883             for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
1884             {
1885                 ELEMDESC *elemdesc = &(*pptfd)->funcdesc.lprgelemdescParam[j];
1886
1887                 MSFT_GetTdesc(pcx,
1888                               paraminfo.DataType,
1889                               &elemdesc->tdesc,
1890                               pTI);
1891
1892                 elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
1893
1894                 /* name */
1895                 if (paraminfo.oName == -1)
1896                     /* this occurs for [propput] or [propget] methods, so
1897                      * we should just set the name of the parameter to the
1898                      * name of the method. */
1899                     (*pptfd)->pParamDesc[j].Name = SysAllocString((*pptfd)->Name);
1900                 else
1901                     (*pptfd)->pParamDesc[j].Name =
1902                         MSFT_ReadName( pcx, paraminfo.oName );
1903                 TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w((*pptfd)->pParamDesc[j].Name));
1904
1905                 MSFT_ResolveReferencedTypes(pcx, pTI, &elemdesc->tdesc);
1906
1907                 /* default value */
1908                 if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
1909                      (pFuncRec->FKCCIC & 0x1000) )
1910                 {
1911                     INT* pInt = (INT *)((char *)pFuncRec +
1912                                    reclength -
1913                                    (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
1914
1915                     PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
1916
1917                     pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
1918                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
1919
1920                     MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
1921                         pInt[j], pcx);
1922                 }
1923                 else
1924                     elemdesc->u.paramdesc.pparamdescex = NULL;
1925                 /* custom info */
1926                 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
1927                 {
1928                     MSFT_CustData(pcx,
1929                                   pFuncRec->OptAttr[7+j],
1930                                   &(*pptfd)->pParamDesc[j].pCustData);
1931                 }
1932
1933                 /* SEEK value = jump to offset,
1934                  * from there jump to the end of record,
1935                  * go back by (j-1) arguments
1936                  */
1937                 MSFT_ReadLEDWords( &paraminfo ,
1938                            sizeof(MSFT_ParameterInfo), pcx,
1939                            recoffset + reclength - ((pFuncRec->nrargs - j - 1)
1940                                                * sizeof(MSFT_ParameterInfo)));
1941             }
1942         }
1943
1944         /* scode is not used: archaic win16 stuff FIXME: right? */
1945         (*pptfd)->funcdesc.cScodes   = 0 ;
1946         (*pptfd)->funcdesc.lprgscode = NULL ;
1947
1948         ptfd_prev = *pptfd;
1949         pptfd      = & ((*pptfd)->next);
1950         recoffset += reclength;
1951     }
1952     HeapFree(GetProcessHeap(), 0, recbuf);
1953 }
1954
1955 static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
1956                        int cVars, int offset, TLBVarDesc ** pptvd)
1957 {
1958     int infolen, nameoffset, reclength;
1959     char recbuf[256];
1960     MSFT_VarRecord * pVarRec=(MSFT_VarRecord *) recbuf;
1961     int i;
1962     int recoffset;
1963
1964     TRACE_(typelib)("\n");
1965
1966     MSFT_ReadLEDWords(&infolen,sizeof(INT), pcx, offset);
1967     MSFT_ReadLEDWords(&recoffset,sizeof(INT), pcx, offset + infolen +
1968                       ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
1969     recoffset += offset+sizeof(INT);
1970     for(i=0;i<cVars;i++){
1971         *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
1972     /* name, eventually add to a hash table */
1973         MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1974                           offset + infolen + (2*cFuncs + cVars + i + 1) * sizeof(INT));
1975         (*pptvd)->Name=MSFT_ReadName(pcx, nameoffset);
1976     /* read the variable information record */
1977         MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1978         reclength &=0xff;
1979         MSFT_ReadLEDWords(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1980     /* Optional data */
1981         if(reclength >(6*sizeof(INT)) )
1982             (*pptvd)->HelpContext=pVarRec->HelpContext;
1983         if(reclength >(7*sizeof(INT)) )
1984             (*pptvd)->HelpString = MSFT_ReadString(pcx, pVarRec->oHelpString) ;
1985         if(reclength >(8*sizeof(INT)) )
1986         if(reclength >(9*sizeof(INT)) )
1987             (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
1988     /* fill the VarDesc Structure */
1989         MSFT_ReadLEDWords(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
1990                           offset + infolen + (cFuncs + i + 1) * sizeof(INT));
1991         (*pptvd)->vardesc.varkind = pVarRec->VarKind;
1992         (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
1993         MSFT_GetTdesc(pcx, pVarRec->DataType,
1994             &(*pptvd)->vardesc.elemdescVar.tdesc, pTI);
1995 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
1996         if(pVarRec->VarKind == VAR_CONST ){
1997             (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
1998             MSFT_ReadValue((*pptvd)->vardesc.u.lpvarValue,
1999                 pVarRec->OffsValue, pcx);
2000         } else
2001             (*pptvd)->vardesc.u.oInst=pVarRec->OffsValue;
2002         MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptvd)->vardesc.elemdescVar.tdesc);
2003         pptvd=&((*pptvd)->next);
2004         recoffset += reclength;
2005     }
2006 }
2007 /* fill in data for a hreftype (offset). When the referenced type is contained
2008  * in the typelib, it's just an (file) offset in the type info base dir.
2009  * If comes from import, it's an offset+1 in the ImpInfo table
2010  * */
2011 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL,
2012                           int offset)
2013 {
2014     int j;
2015     TLBRefType *ref;
2016
2017     TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
2018
2019     LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
2020     {
2021         if(ref->reference == offset) return;
2022     }
2023
2024     ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
2025     list_add_tail(&pTL->ref_list, &ref->entry);
2026
2027     if(!MSFT_HREFTYPE_INTHISFILE( offset)) {
2028         /* external typelib */
2029         MSFT_ImpInfo impinfo;
2030         TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
2031
2032         TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
2033
2034         MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx,
2035                           pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
2036         for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
2037             if(pImpLib->offset==impinfo.oImpFile) break;
2038             pImpLib=pImpLib->next;
2039         }
2040         if(pImpLib){
2041             ref->reference = offset;
2042             ref->pImpTLInfo = pImpLib;
2043             if(impinfo.flags & MSFT_IMPINFO_OFFSET_IS_GUID) {
2044                 MSFT_ReadGuid(&ref->guid, impinfo.oGuid, pcx);
2045                 TRACE("importing by guid %s\n", debugstr_guid(&ref->guid));
2046                 ref->index = TLB_REF_USE_GUID;
2047             } else
2048                 ref->index = impinfo.oGuid;
2049         }else{
2050             ERR("Cannot find a reference\n");
2051             ref->reference = -1;
2052             ref->pImpTLInfo = TLB_REF_NOT_FOUND;
2053         }
2054     }else{
2055         /* in this typelib */
2056         ref->index = MSFT_HREFTYPE_INDEX(offset);
2057         ref->reference = offset;
2058         ref->pImpTLInfo = TLB_REF_INTERNAL;
2059     }
2060 }
2061
2062 /* process Implemented Interfaces of a com class */
2063 static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
2064                             int offset)
2065 {
2066     int i;
2067     MSFT_RefRecord refrec;
2068     TLBImplType **ppImpl = &pTI->impltypelist;
2069
2070     TRACE_(typelib)("\n");
2071
2072     for(i=0;i<count;i++){
2073         if(offset<0) break; /* paranoia */
2074         *ppImpl=TLB_Alloc(sizeof(**ppImpl));
2075         MSFT_ReadLEDWords(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
2076         MSFT_DoRefType(pcx, pTI->pTypeLib, refrec.reftype);
2077         (*ppImpl)->hRef = refrec.reftype;
2078         (*ppImpl)->implflags=refrec.flags;
2079         (*ppImpl)->ctCustData=
2080             MSFT_CustData(pcx, refrec.oCustData, &(*ppImpl)->pCustData);
2081         offset=refrec.onext;
2082         ppImpl=&((*ppImpl)->next);
2083     }
2084 }
2085 /*
2086  * process a typeinfo record
2087  */
2088 static ITypeInfoImpl * MSFT_DoTypeInfo(
2089     TLBContext *pcx,
2090     int count,
2091     ITypeLibImpl * pLibInfo)
2092 {
2093     MSFT_TypeInfoBase tiBase;
2094     ITypeInfoImpl *ptiRet;
2095
2096     TRACE_(typelib)("count=%u\n", count);
2097
2098     ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
2099     MSFT_ReadLEDWords(&tiBase, sizeof(tiBase) ,pcx ,
2100                       pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
2101
2102 /* this is where we are coming from */
2103     ptiRet->pTypeLib = pLibInfo;
2104     ptiRet->index=count;
2105 /* fill in the typeattr fields */
2106
2107     MSFT_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
2108     ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid;   /* FIXME: correct? */
2109     ptiRet->TypeAttr.lpstrSchema=NULL;              /* reserved */
2110     ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
2111     ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
2112     ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
2113     ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
2114     ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
2115     ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
2116     ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
2117     ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
2118     ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
2119     ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
2120     if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
2121         MSFT_GetTdesc(pcx, tiBase.datatype1,
2122             &ptiRet->TypeAttr.tdescAlias, ptiRet);
2123
2124 /*  FIXME: */
2125 /*    IDLDESC  idldescType; *//* never saw this one != zero  */
2126
2127 /* name, eventually add to a hash table */
2128     ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
2129     ptiRet->hreftype = MSFT_ReadHreftype(pcx, tiBase.NameOffset);
2130     TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
2131     /* help info */
2132     ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
2133     ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
2134     ptiRet->dwHelpContext=tiBase.helpcontext;
2135
2136     if (ptiRet->TypeAttr.typekind == TKIND_MODULE)
2137         ptiRet->DllName = MSFT_ReadString(pcx, tiBase.datatype1);
2138
2139 /* note: InfoType's Help file and HelpStringDll come from the containing
2140  * library. Further HelpString and Docstring appear to be the same thing :(
2141  */
2142     /* functions */
2143     if(ptiRet->TypeAttr.cFuncs >0 )
2144         MSFT_DoFuncs(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2145                     ptiRet->TypeAttr.cVars,
2146                     tiBase.memoffset, & ptiRet->funclist);
2147     /* variables */
2148     if(ptiRet->TypeAttr.cVars >0 )
2149         MSFT_DoVars(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2150                    ptiRet->TypeAttr.cVars,
2151                    tiBase.memoffset, & ptiRet->varlist);
2152     if(ptiRet->TypeAttr.cImplTypes >0 ) {
2153         switch(ptiRet->TypeAttr.typekind)
2154         {
2155         case TKIND_COCLASS:
2156             MSFT_DoImplTypes(pcx, ptiRet, ptiRet->TypeAttr.cImplTypes ,
2157                 tiBase.datatype1);
2158             break;
2159         case TKIND_DISPATCH:
2160             /* This is not -1 when the interface is a non-base dual interface or
2161                when a dispinterface wraps an interface ie the idl 'dispinterface x {interface y;};'.
2162                Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
2163                not this interface.
2164             */
2165
2166             if (tiBase.datatype1 != -1)
2167             {
2168                 ptiRet->impltypelist = TLB_Alloc(sizeof(TLBImplType));
2169                 ptiRet->impltypelist->hRef = tiBase.datatype1;
2170                 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2171             }
2172           break;
2173         default:
2174             ptiRet->impltypelist=TLB_Alloc(sizeof(TLBImplType));
2175             MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2176             ptiRet->impltypelist->hRef = tiBase.datatype1;
2177             break;
2178        }
2179     }
2180     ptiRet->ctCustData=
2181         MSFT_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
2182
2183     TRACE_(typelib)("%s guid: %s kind:%s\n",
2184        debugstr_w(ptiRet->Name),
2185        debugstr_guid(&ptiRet->TypeAttr.guid),
2186        typekind_desc[ptiRet->TypeAttr.typekind]);
2187
2188     return ptiRet;
2189 }
2190
2191 /* Because type library parsing has some degree of overhead, and some apps repeatedly load the same
2192  * typelibs over and over, we cache them here. According to MSDN Microsoft have a similar scheme in
2193  * place. This will cause a deliberate memory leak, but generally losing RAM for cycles is an acceptable
2194  * tradeoff here.
2195  */
2196 static ITypeLibImpl *tlb_cache_first;
2197 static CRITICAL_SECTION cache_section;
2198 static CRITICAL_SECTION_DEBUG cache_section_debug =
2199 {
2200     0, 0, &cache_section,
2201     { &cache_section_debug.ProcessLocksList, &cache_section_debug.ProcessLocksList },
2202       0, 0, { (DWORD_PTR)(__FILE__ ": typelib loader cache") }
2203 };
2204 static CRITICAL_SECTION cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 };
2205
2206
2207 /****************************************************************************
2208  *      TLB_ReadTypeLib
2209  *
2210  * find the type of the typelib file and map the typelib resource into
2211  * the memory
2212  */
2213 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
2214 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2215 static int TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
2216 {
2217     ITypeLibImpl *entry;
2218     int ret = TYPE_E_CANTLOADLIBRARY;
2219     INT index = 1;
2220     HINSTANCE hinstDLL;
2221     LPWSTR index_str, file = (LPWSTR)pszFileName;
2222
2223     *ppTypeLib = NULL;
2224
2225     index_str = strrchrW(pszFileName, '\\');
2226     if(index_str && *++index_str != '\0')
2227     {
2228         LPWSTR end_ptr;
2229         long idx = strtolW(index_str, &end_ptr, 10);
2230         if(*end_ptr == '\0')
2231         {
2232             int str_len = index_str - pszFileName - 1;
2233             index = idx;
2234             file = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
2235             memcpy(file, pszFileName, str_len * sizeof(WCHAR));
2236             file[str_len] = 0;
2237         }
2238     }
2239
2240     if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
2241     {
2242         if(strchrW(file, '\\'))
2243         {
2244             lstrcpyW(pszPath, file);
2245         }
2246         else
2247         {
2248             int len = GetSystemDirectoryW(pszPath, cchPath);
2249             pszPath[len] = '\\';
2250             memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR));
2251         }
2252     }
2253
2254     if(file != pszFileName) HeapFree(GetProcessHeap(), 0, file);
2255
2256     TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
2257
2258     /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2259     EnterCriticalSection(&cache_section);
2260     for (entry = tlb_cache_first; entry != NULL; entry = entry->next)
2261     {
2262         if (!strcmpiW(entry->path, pszPath) && entry->index == index)
2263         {
2264             TRACE("cache hit\n");
2265             *ppTypeLib = (ITypeLib2*)entry;
2266             ITypeLib_AddRef(*ppTypeLib);
2267             LeaveCriticalSection(&cache_section);
2268             return S_OK;
2269         }
2270     }
2271     LeaveCriticalSection(&cache_section);
2272
2273     /* now actually load and parse the typelib */
2274
2275     hinstDLL = LoadLibraryExW(pszPath, 0, DONT_RESOLVE_DLL_REFERENCES |
2276             LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
2277
2278     if (hinstDLL)
2279     {
2280         static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
2281         HRSRC hrsrc = FindResourceW(hinstDLL, MAKEINTRESOURCEW(index), TYPELIBW);
2282         if (hrsrc)
2283         {
2284             HGLOBAL hGlobal = LoadResource(hinstDLL, hrsrc);
2285             if (hGlobal)
2286             {
2287                 LPVOID pBase = LockResource(hGlobal);
2288                 DWORD  dwTLBLength = SizeofResource(hinstDLL, hrsrc);
2289
2290                 if (pBase)
2291                 {
2292                     /* try to load as incore resource */
2293                     DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2294                     if (dwSignature == MSFT_SIGNATURE)
2295                         *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2296                     else if (dwSignature == SLTG_SIGNATURE)
2297                         *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2298                     else
2299                         FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
2300                 }
2301                 FreeResource( hGlobal );
2302             }
2303         }
2304         FreeLibrary(hinstDLL);
2305     }
2306     else
2307     {
2308         HANDLE hFile = CreateFileW(pszPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
2309         if (INVALID_HANDLE_VALUE != hFile)
2310         {
2311             HANDLE hMapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL );
2312             if (hMapping)
2313             {
2314                 LPVOID pBase = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
2315                 if(pBase)
2316                 {
2317                     /* retrieve file size */
2318                     DWORD dwTLBLength = GetFileSize(hFile, NULL);
2319                     DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2320
2321                     if (dwSignature == MSFT_SIGNATURE)
2322                         *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2323                     else if (dwSignature == SLTG_SIGNATURE)
2324                         *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2325
2326                     UnmapViewOfFile(pBase);
2327                 }
2328                 CloseHandle(hMapping);
2329             }
2330             CloseHandle(hFile);
2331         }
2332     }
2333
2334     if(*ppTypeLib) {
2335         ITypeLibImpl *impl = (ITypeLibImpl*)*ppTypeLib;
2336
2337         TRACE("adding to cache\n");
2338         impl->path = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath)+1) * sizeof(WCHAR));
2339         lstrcpyW(impl->path, pszPath);
2340         /* We should really canonicalise the path here. */
2341         impl->index = index;
2342
2343         /* FIXME: check if it has added already in the meantime */
2344         EnterCriticalSection(&cache_section);
2345         if ((impl->next = tlb_cache_first) != NULL) impl->next->prev = impl;
2346         impl->prev = NULL;
2347         tlb_cache_first = impl;
2348         LeaveCriticalSection(&cache_section);
2349         ret = S_OK;
2350     } else
2351         ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
2352
2353     return ret;
2354 }
2355
2356 /*================== ITypeLib(2) Methods ===================================*/
2357
2358 static ITypeLibImpl* TypeLibImpl_Constructor(void)
2359 {
2360     ITypeLibImpl* pTypeLibImpl;
2361
2362     pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
2363     if (!pTypeLibImpl) return NULL;
2364
2365     pTypeLibImpl->lpVtbl = &tlbvt;
2366     pTypeLibImpl->lpVtblTypeComp = &tlbtcvt;
2367     pTypeLibImpl->ref = 1;
2368
2369     list_init(&pTypeLibImpl->ref_list);
2370     pTypeLibImpl->dispatch_href = -1;
2371
2372     return pTypeLibImpl;
2373 }
2374
2375 /****************************************************************************
2376  *      ITypeLib2_Constructor_MSFT
2377  *
2378  * loading an MSFT typelib from an in-memory image
2379  */
2380 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
2381 {
2382     TLBContext cx;
2383     long lPSegDir;
2384     MSFT_Header tlbHeader;
2385     MSFT_SegDir tlbSegDir;
2386     ITypeLibImpl * pTypeLibImpl;
2387
2388     TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
2389
2390     pTypeLibImpl = TypeLibImpl_Constructor();
2391     if (!pTypeLibImpl) return NULL;
2392
2393     /* get pointer to beginning of typelib data */
2394     cx.pos = 0;
2395     cx.oStart=0;
2396     cx.mapping = pLib;
2397     cx.pLibInfo = pTypeLibImpl;
2398     cx.length = dwTLBLength;
2399
2400     /* read header */
2401     MSFT_ReadLEDWords((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
2402     TRACE_(typelib)("header:\n");
2403     TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
2404     if (tlbHeader.magic1 != MSFT_SIGNATURE) {
2405         FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
2406         return NULL;
2407     }
2408     TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
2409
2410     /* there is a small amount of information here until the next important
2411      * part:
2412      * the segment directory . Try to calculate the amount of data */
2413     lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
2414
2415     /* now read the segment directory */
2416     TRACE("read segment directory (at %ld)\n",lPSegDir);
2417     MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
2418     cx.pTblDir = &tlbSegDir;
2419
2420     /* just check two entries */
2421     if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
2422     {
2423         ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
2424         HeapFree(GetProcessHeap(),0,pTypeLibImpl);
2425         return NULL;
2426     }
2427
2428     /* now fill our internal data */
2429     /* TLIBATTR fields */
2430     MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
2431
2432     /*    pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;*/
2433     /* Windows seems to have zero here, is this correct? */
2434     if(SUBLANGID(tlbHeader.lcid) == SUBLANG_NEUTRAL)
2435       pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(tlbHeader.lcid),0),0);
2436     else
2437       pTypeLibImpl->LibAttr.lcid = 0;
2438
2439     pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
2440     pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
2441     pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
2442     pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
2443
2444     /* name, eventually add to a hash table */
2445     pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
2446
2447     /* help info */
2448     pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
2449     pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
2450
2451     if( tlbHeader.varflags & HELPDLLFLAG)
2452     {
2453             int offset;
2454             MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
2455             pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
2456     }
2457
2458     pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
2459
2460     /* custom data */
2461     if(tlbHeader.CustomDataOffset >= 0)
2462     {
2463         pTypeLibImpl->ctCustData = MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
2464     }
2465
2466     /* fill in typedescriptions */
2467     if(tlbSegDir.pTypdescTab.length > 0)
2468     {
2469         int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
2470         INT16 td[4];
2471         pTypeLibImpl->ctTypeDesc = cTD;
2472         pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
2473         MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
2474         for(i=0; i<cTD; )
2475         {
2476             /* FIXME: add several sanity checks here */
2477             pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
2478             if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
2479             {
2480                 /* FIXME: check safearray */
2481                 if(td[3] < 0)
2482                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
2483                 else
2484                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
2485             }
2486             else if(td[0] == VT_CARRAY)
2487             {
2488                 /* array descr table here */
2489                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
2490             }
2491             else if(td[0] == VT_USERDEFINED)
2492             {
2493                 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
2494             }
2495             if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
2496         }
2497
2498         /* second time around to fill the array subscript info */
2499         for(i=0;i<cTD;i++)
2500         {
2501             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
2502             if(tlbSegDir.pArrayDescriptions.offset>0)
2503             {
2504                 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
2505                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
2506
2507                 if(td[1]<0)
2508                     pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
2509                 else
2510                     pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = stndTypeDesc[td[0]/8];
2511
2512                 pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
2513
2514                 for(j = 0; j<td[2]; j++)
2515                 {
2516                     MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
2517                                       sizeof(INT), &cx, DO_NOT_SEEK);
2518                     MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
2519                                       sizeof(INT), &cx, DO_NOT_SEEK);
2520                 }
2521             }
2522             else
2523             {
2524                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
2525                 ERR("didn't find array description data\n");
2526             }
2527         }
2528     }
2529
2530     /* imported type libs */
2531     if(tlbSegDir.pImpFiles.offset>0)
2532     {
2533         TLBImpLib **ppImpLib = &(pTypeLibImpl->pImpLibs);
2534         int oGuid, offset = tlbSegDir.pImpFiles.offset;
2535         UINT16 size;
2536
2537         while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
2538         {
2539             char *name;
2540             DWORD len;
2541
2542             *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
2543             (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
2544             MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
2545
2546             MSFT_ReadLEDWords(&(*ppImpLib)->lcid,         sizeof(LCID),   &cx, DO_NOT_SEEK);
2547             MSFT_ReadLEWords(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
2548             MSFT_ReadLEWords(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
2549             MSFT_ReadLEWords(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
2550
2551             size >>= 2;
2552             name = TLB_Alloc(size+1);
2553             MSFT_Read(name, size, &cx, DO_NOT_SEEK);
2554             len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0 );
2555             (*ppImpLib)->name = TLB_Alloc(len * sizeof(WCHAR));
2556             MultiByteToWideChar(CP_ACP, 0, name, -1, (*ppImpLib)->name, len );
2557             TLB_Free(name);
2558
2559             MSFT_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
2560             offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
2561
2562             ppImpLib = &(*ppImpLib)->next;
2563         }
2564     }
2565
2566     pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
2567     if(pTypeLibImpl->dispatch_href != -1)
2568         MSFT_DoRefType(&cx, pTypeLibImpl, pTypeLibImpl->dispatch_href);
2569
2570     /* type info's */
2571     if(tlbHeader.nrtypeinfos >= 0 )
2572     {
2573         /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
2574         ITypeInfoImpl **ppTI = &(pTypeLibImpl->pTypeInfo);
2575         int i;
2576
2577         for(i = 0; i<(int)tlbHeader.nrtypeinfos; i++)
2578         {
2579             *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
2580
2581             ppTI = &((*ppTI)->next);
2582             (pTypeLibImpl->TypeInfoCount)++;
2583         }
2584     }
2585
2586     TRACE("(%p)\n", pTypeLibImpl);
2587     return (ITypeLib2*) pTypeLibImpl;
2588 }
2589
2590
2591 static BSTR TLB_MultiByteToBSTR(const char *ptr)
2592 {
2593     DWORD len;
2594     WCHAR *nameW;
2595     BSTR ret;
2596
2597     len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
2598     nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2599     MultiByteToWideChar(CP_ACP, 0, ptr, -1, nameW, len);
2600     ret = SysAllocString(nameW);
2601     HeapFree(GetProcessHeap(), 0, nameW);
2602     return ret;
2603 }
2604
2605 static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
2606 {
2607   char b[3];
2608   int i;
2609   short s;
2610
2611   if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
2612     FIXME("Can't parse guid %s\n", debugstr_guid(guid));
2613     return FALSE;
2614   }
2615
2616   guid->Data4[0] = s >> 8;
2617   guid->Data4[1] = s & 0xff;
2618
2619   b[2] = '\0';
2620   for(i = 0; i < 6; i++) {
2621     memcpy(b, str + 24 + 2 * i, 2);
2622     guid->Data4[i + 2] = strtol(b, NULL, 16);
2623   }
2624   return TRUE;
2625 }
2626
2627 static WORD SLTG_ReadString(const char *ptr, BSTR *pBstr)
2628 {
2629     WORD bytelen;
2630     DWORD len;
2631     WCHAR *nameW;
2632
2633     *pBstr = NULL;
2634     bytelen = *(const WORD*)ptr;
2635     if(bytelen == 0xffff) return 2;
2636     len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
2637     nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2638     len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, nameW, len);
2639     *pBstr = SysAllocStringLen(nameW, len);
2640     HeapFree(GetProcessHeap(), 0, nameW);
2641     return bytelen + 2;
2642 }
2643
2644 static WORD SLTG_ReadStringA(const char *ptr, char **str)
2645 {
2646     WORD bytelen;
2647
2648     *str = NULL;
2649     bytelen = *(const WORD*)ptr;
2650     if(bytelen == 0xffff) return 2;
2651     *str = HeapAlloc(GetProcessHeap(), 0, bytelen + 1);
2652     memcpy(*str, ptr + 2, bytelen);
2653     (*str)[bytelen] = '\0';
2654     return bytelen + 2;
2655 }
2656
2657 static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
2658 {
2659     char *ptr = pLibBlk;
2660     WORD w;
2661
2662     if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
2663         FIXME("libblk magic = %04x\n", w);
2664         return 0;
2665     }
2666
2667     ptr += 6;
2668     if((w = *(WORD*)ptr) != 0xffff) {
2669         FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
2670         ptr += w;
2671     }
2672     ptr += 2;
2673
2674     ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
2675
2676     ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
2677
2678     pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
2679     ptr += 4;
2680
2681     pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
2682     ptr += 2;
2683
2684     if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
2685         pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
2686     else
2687         pTypeLibImpl->LibAttr.lcid = 0;
2688     ptr += 2;
2689
2690     ptr += 4; /* skip res12 */
2691
2692     pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
2693     ptr += 2;
2694
2695     pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
2696     ptr += 2;
2697
2698     pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
2699     ptr += 2;
2700
2701     memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
2702     ptr += sizeof(GUID);
2703
2704     return ptr - (char*)pLibBlk;
2705 }
2706
2707 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
2708 typedef struct
2709 {
2710     unsigned int num;
2711     HREFTYPE refs[1];
2712 } sltg_ref_lookup_t;
2713
2714 static HRESULT sltg_get_typelib_ref(const sltg_ref_lookup_t *table, DWORD typeinfo_ref,
2715                                     HREFTYPE *typelib_ref)
2716 {
2717     if(typeinfo_ref < table->num)
2718     {
2719         *typelib_ref = table->refs[typeinfo_ref];
2720         return S_OK;
2721     }
2722
2723     ERR("Unable to find reference\n");
2724     *typelib_ref = -1;
2725     return E_FAIL;
2726 }
2727
2728 static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
2729 {
2730     BOOL done = FALSE;
2731
2732     while(!done) {
2733         if((*pType & 0xe00) == 0xe00) {
2734             pTD->vt = VT_PTR;
2735             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2736                                        sizeof(TYPEDESC));
2737             pTD = pTD->u.lptdesc;
2738         }
2739         switch(*pType & 0x3f) {
2740         case VT_PTR:
2741             pTD->vt = VT_PTR;
2742             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2743                                        sizeof(TYPEDESC));
2744             pTD = pTD->u.lptdesc;
2745             break;
2746
2747         case VT_USERDEFINED:
2748             pTD->vt = VT_USERDEFINED;
2749             sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
2750             done = TRUE;
2751             break;
2752
2753         case VT_CARRAY:
2754           {
2755             /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
2756                array */
2757
2758             SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
2759
2760             pTD->vt = VT_CARRAY;
2761             pTD->u.lpadesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2762                                 sizeof(ARRAYDESC) +
2763                                 (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
2764             pTD->u.lpadesc->cDims = pSA->cDims;
2765             memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
2766                    pSA->cDims * sizeof(SAFEARRAYBOUND));
2767
2768             pTD = &pTD->u.lpadesc->tdescElem;
2769             break;
2770           }
2771
2772         case VT_SAFEARRAY:
2773           {
2774             /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
2775                useful? */
2776
2777             pType++;
2778             pTD->vt = VT_SAFEARRAY;
2779             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2780                                        sizeof(TYPEDESC));
2781             pTD = pTD->u.lptdesc;
2782             break;
2783           }
2784         default:
2785             pTD->vt = *pType & 0x3f;
2786             done = TRUE;
2787             break;
2788         }
2789         pType++;
2790     }
2791     return pType;
2792 }
2793
2794 static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
2795                          ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
2796 {
2797     /* Handle [in/out] first */
2798     if((*pType & 0xc000) == 0xc000)
2799         pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
2800     else if(*pType & 0x8000)
2801         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
2802     else if(*pType & 0x4000)
2803         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
2804     else
2805         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
2806
2807     if(*pType & 0x2000)
2808         pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
2809
2810     if(*pType & 0x80)
2811         pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
2812
2813     return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
2814 }
2815
2816
2817 static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
2818                         char *pNameTable)
2819 {
2820     int ref;
2821     char *name;
2822     TLBRefType *ref_type;
2823     sltg_ref_lookup_t *table;
2824     HREFTYPE typelib_ref;
2825
2826     if(pRef->magic != SLTG_REF_MAGIC) {
2827         FIXME("Ref magic = %x\n", pRef->magic);
2828         return NULL;
2829     }
2830     name = ( (char*)(&pRef->names) + pRef->number);
2831
2832     table = HeapAlloc(GetProcessHeap(), 0, sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
2833     table->num = pRef->number >> 3;
2834
2835     /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
2836
2837     /* We don't want the first href to be 0 */
2838     typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
2839
2840     for(ref = 0; ref < pRef->number >> 3; ref++) {
2841         char *refname;
2842         unsigned int lib_offs, type_num;
2843
2844         ref_type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref_type));
2845
2846         name += SLTG_ReadStringA(name, &refname);
2847         if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
2848             FIXME("Can't sscanf ref\n");
2849         if(lib_offs != 0xffff) {
2850             TLBImpLib **import = &pTL->pImpLibs;
2851
2852             while(*import) {
2853                 if((*import)->offset == lib_offs)
2854                     break;
2855                 import = &(*import)->next;
2856             }
2857             if(!*import) {
2858                 char fname[MAX_PATH+1];
2859                 int len;
2860
2861                 *import = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2862                                     sizeof(**import));
2863                 (*import)->offset = lib_offs;
2864                 TLB_GUIDFromString( pNameTable + lib_offs + 4,
2865                                     &(*import)->guid);
2866                 if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
2867                           &(*import)->wVersionMajor,
2868                           &(*import)->wVersionMinor,
2869                           &(*import)->lcid, fname) != 4) {
2870                   FIXME("can't sscanf ref %s\n",
2871                         pNameTable + lib_offs + 40);
2872                 }
2873                 len = strlen(fname);
2874                 if(fname[len-1] != '#')
2875                     FIXME("fname = %s\n", fname);
2876                 fname[len-1] = '\0';
2877                 (*import)->name = TLB_MultiByteToBSTR(fname);
2878             }
2879             ref_type->pImpTLInfo = *import;
2880
2881             /* Store a reference to IDispatch */
2882             if(pTL->dispatch_href == -1 && IsEqualGUID(&(*import)->guid, &IID_StdOle) && type_num == 4)
2883                 pTL->dispatch_href = typelib_ref;
2884
2885         } else { /* internal ref */
2886           ref_type->pImpTLInfo = TLB_REF_INTERNAL;
2887         }
2888         ref_type->reference = typelib_ref;
2889         ref_type->index = type_num;
2890
2891         HeapFree(GetProcessHeap(), 0, refname);
2892         list_add_tail(&pTL->ref_list, &ref_type->entry);
2893
2894         table->refs[ref] = typelib_ref;
2895         typelib_ref += 4;
2896     }
2897     if((BYTE)*name != SLTG_REF_MAGIC)
2898       FIXME("End of ref block magic = %x\n", *name);
2899     dump_TLBRefType(pTL);
2900     return table;
2901 }
2902
2903 static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
2904                           BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
2905 {
2906     SLTG_ImplInfo *info;
2907     TLBImplType **ppImplType = &pTI->impltypelist;
2908     /* I don't really get this structure, usually it's 0x16 bytes
2909        long, but iuser.tlb contains some that are 0x18 bytes long.
2910        That's ok because we can use the next ptr to jump to the next
2911        one. But how do we know the length of the last one?  The WORD
2912        at offs 0x8 might be the clue.  For now I'm just assuming that
2913        the last one is the regular 0x16 bytes. */
2914
2915     info = (SLTG_ImplInfo*)pBlk;
2916     while(1) {
2917         *ppImplType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2918                                 sizeof(**ppImplType));
2919         sltg_get_typelib_ref(ref_lookup, info->ref, &(*ppImplType)->hRef);
2920         (*ppImplType)->implflags = info->impltypeflags;
2921         pTI->TypeAttr.cImplTypes++;
2922         ppImplType = &(*ppImplType)->next;
2923
2924         if(info->next == 0xffff)
2925             break;
2926         if(OneOnly)
2927             FIXME("Interface inheriting more than one interface\n");
2928         info = (SLTG_ImplInfo*)(pBlk + info->next);
2929     }
2930     info++; /* see comment at top of function */
2931     return (char*)info;
2932 }
2933
2934 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
2935                         const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
2936 {
2937   TLBVarDesc **ppVarDesc = &pTI->varlist;
2938   BSTR bstrPrevName = NULL;
2939   SLTG_Variable *pItem;
2940   unsigned short i;
2941   WORD *pType;
2942   char buf[300];
2943
2944   for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
2945       pItem = (SLTG_Variable *)(pBlk + pItem->next), i++) {
2946
2947       *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2948                              sizeof(**ppVarDesc));
2949       (*ppVarDesc)->vardesc.memid = pItem->memid;
2950
2951       if (pItem->magic != SLTG_VAR_MAGIC &&
2952           pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
2953           FIXME_(typelib)("var magic = %02x\n", pItem->magic);
2954           return;
2955       }
2956
2957       if (pItem->name == 0xfffe)
2958         (*ppVarDesc)->Name = SysAllocString(bstrPrevName);
2959       else
2960         (*ppVarDesc)->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
2961
2962       TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
2963       TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
2964
2965       if (pItem->flags & 0x40) {
2966         TRACE_(typelib)("VAR_DISPATCH\n");
2967         (*ppVarDesc)->vardesc.varkind = VAR_DISPATCH;
2968       }
2969       else if (pItem->flags & 0x10) {
2970         TRACE_(typelib)("VAR_CONST\n");
2971         (*ppVarDesc)->vardesc.varkind = VAR_CONST;
2972         (*ppVarDesc)->vardesc.u.lpvarValue = HeapAlloc(GetProcessHeap(), 0,
2973                                                        sizeof(VARIANT));
2974         V_VT((*ppVarDesc)->vardesc.u.lpvarValue) = VT_INT;
2975         V_UNION((*ppVarDesc)->vardesc.u.lpvarValue, intVal) =
2976           *(INT*)(pBlk + pItem->byte_offs);
2977       }
2978       else {
2979         TRACE_(typelib)("VAR_PERINSTANCE\n");
2980         (*ppVarDesc)->vardesc.u.oInst = pItem->byte_offs;
2981         (*ppVarDesc)->vardesc.varkind = VAR_PERINSTANCE;
2982       }
2983
2984       if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
2985         (*ppVarDesc)->vardesc.wVarFlags = pItem->varflags;
2986
2987       if (pItem->flags & 0x80)
2988         (*ppVarDesc)->vardesc.wVarFlags |= VARFLAG_FREADONLY;
2989
2990       if(pItem->flags & 0x02)
2991           pType = &pItem->type;
2992       else
2993           pType = (WORD*)(pBlk + pItem->type);
2994
2995       if (pItem->flags & ~0xd2)
2996         FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xd2);
2997
2998       SLTG_DoElem(pType, pBlk,
2999                   &(*ppVarDesc)->vardesc.elemdescVar, ref_lookup);
3000
3001       dump_TypeDesc(&(*ppVarDesc)->vardesc.elemdescVar.tdesc, buf);
3002
3003       bstrPrevName = (*ppVarDesc)->Name;
3004       ppVarDesc = &((*ppVarDesc)->next);
3005   }
3006   pTI->TypeAttr.cVars = cVars;
3007 }
3008
3009 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
3010                          unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3011 {
3012     SLTG_Function *pFunc;
3013     unsigned short i;
3014     TLBFuncDesc **ppFuncDesc = &pTI->funclist;
3015
3016     for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs;
3017         pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++) {
3018
3019         int param;
3020         WORD *pType, *pArg;
3021
3022         *ppFuncDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3023                                 sizeof(**ppFuncDesc));
3024
3025         switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
3026         case SLTG_FUNCTION_MAGIC:
3027             (*ppFuncDesc)->funcdesc.funckind = FUNC_PUREVIRTUAL;
3028             break;
3029         case SLTG_DISPATCH_FUNCTION_MAGIC:
3030             (*ppFuncDesc)->funcdesc.funckind = FUNC_DISPATCH;
3031             break;
3032         case SLTG_STATIC_FUNCTION_MAGIC:
3033             (*ppFuncDesc)->funcdesc.funckind = FUNC_STATIC;
3034             break;
3035         default:
3036             FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
3037             HeapFree(GetProcessHeap(), 0, *ppFuncDesc);
3038             *ppFuncDesc = NULL;
3039             return;
3040         }
3041         (*ppFuncDesc)->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
3042
3043         (*ppFuncDesc)->funcdesc.memid = pFunc->dispid;
3044         (*ppFuncDesc)->funcdesc.invkind = pFunc->inv >> 4;
3045         (*ppFuncDesc)->funcdesc.callconv = pFunc->nacc & 0x7;
3046         (*ppFuncDesc)->funcdesc.cParams = pFunc->nacc >> 3;
3047         (*ppFuncDesc)->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
3048         (*ppFuncDesc)->funcdesc.oVft = pFunc->vtblpos;
3049
3050         if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
3051             (*ppFuncDesc)->funcdesc.wFuncFlags = pFunc->funcflags;
3052
3053         if(pFunc->retnextopt & 0x80)
3054             pType = &pFunc->rettype;
3055         else
3056             pType = (WORD*)(pBlk + pFunc->rettype);
3057
3058         SLTG_DoElem(pType, pBlk, &(*ppFuncDesc)->funcdesc.elemdescFunc, ref_lookup);
3059
3060         (*ppFuncDesc)->funcdesc.lprgelemdescParam =
3061           HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3062                     (*ppFuncDesc)->funcdesc.cParams * sizeof(ELEMDESC));
3063         (*ppFuncDesc)->pParamDesc =
3064           HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3065                     (*ppFuncDesc)->funcdesc.cParams * sizeof(TLBParDesc));
3066
3067         pArg = (WORD*)(pBlk + pFunc->arg_off);
3068
3069         for(param = 0; param < (*ppFuncDesc)->funcdesc.cParams; param++) {
3070             char *paramName = pNameTable + *pArg;
3071             BOOL HaveOffs;
3072             /* If arg type follows then paramName points to the 2nd
3073                letter of the name, else the next WORD is an offset to
3074                the arg type and paramName points to the first letter.
3075                So let's take one char off paramName and see if we're
3076                pointing at an alpha-numeric char.  However if *pArg is
3077                0xffff or 0xfffe then the param has no name, the former
3078                meaning that the next WORD is the type, the latter
3079                meaning the the next WORD is an offset to the type. */
3080
3081             HaveOffs = FALSE;
3082             if(*pArg == 0xffff)
3083                 paramName = NULL;
3084             else if(*pArg == 0xfffe) {
3085                 paramName = NULL;
3086                 HaveOffs = TRUE;
3087             }
3088             else if(paramName[-1] && !isalnum(paramName[-1]))
3089                 HaveOffs = TRUE;
3090
3091             pArg++;
3092
3093             if(HaveOffs) { /* the next word is an offset to type */
3094                 pType = (WORD*)(pBlk + *pArg);
3095                 SLTG_DoElem(pType, pBlk,
3096                             &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3097                 pArg++;
3098             } else {
3099                 if(paramName)
3100                   paramName--;
3101                 pArg = SLTG_DoElem(pArg, pBlk,
3102                                    &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3103             }
3104
3105             /* Are we an optional param ? */
3106             if((*ppFuncDesc)->funcdesc.cParams - param <=
3107                (*ppFuncDesc)->funcdesc.cParamsOpt)
3108               (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
3109
3110             if(paramName) {
3111                 (*ppFuncDesc)->pParamDesc[param].Name =
3112                   TLB_MultiByteToBSTR(paramName);
3113             }
3114         }
3115
3116         ppFuncDesc = &((*ppFuncDesc)->next);
3117         if(pFunc->next == 0xffff) break;
3118     }
3119     pTI->TypeAttr.cFuncs = cFuncs;
3120 }
3121
3122 static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
3123                                 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3124                                 SLTG_TypeInfoTail *pTITail)
3125 {
3126     char *pFirstItem, *pNextItem;
3127     sltg_ref_lookup_t *ref_lookup = NULL;
3128
3129     if(pTIHeader->href_table != 0xffffffff) {
3130         ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3131                     pNameTable);
3132     }
3133
3134     pFirstItem = pNextItem = pBlk;
3135
3136     if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3137         pNextItem = SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
3138     }
3139     HeapFree(GetProcessHeap(), 0, ref_lookup);
3140 }
3141
3142
3143 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
3144                                   char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3145                                   const SLTG_TypeInfoTail *pTITail)
3146 {
3147     char *pFirstItem, *pNextItem;
3148     sltg_ref_lookup_t *ref_lookup = NULL;
3149
3150     if(pTIHeader->href_table != 0xffffffff) {
3151         ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3152                     pNameTable);
3153     }
3154
3155     pFirstItem = pNextItem = pBlk;
3156
3157     if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3158         pNextItem = SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
3159     }
3160
3161     if (pTITail->funcs_off != 0xffff)
3162         SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3163
3164     HeapFree(GetProcessHeap(), 0, ref_lookup);
3165
3166     if (TRACE_ON(typelib))
3167         dump_TLBFuncDesc(pTI->funclist);
3168 }
3169
3170 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
3171                                const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3172                                const SLTG_TypeInfoTail *pTITail)
3173 {
3174   SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3175 }
3176
3177 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
3178                               char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3179                               const SLTG_TypeInfoTail *pTITail)
3180 {
3181   WORD *pType;
3182   sltg_ref_lookup_t *ref_lookup = NULL;
3183
3184   if (pTITail->simple_alias) {
3185     /* if simple alias, no more processing required */
3186     pTI->TypeAttr.tdescAlias.vt = pTITail->tdescalias_vt;
3187     return;
3188   }
3189
3190   if(pTIHeader->href_table != 0xffffffff) {
3191       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3192                   pNameTable);
3193   }
3194
3195   /* otherwise it is an offset to a type */
3196   pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
3197
3198   SLTG_DoType(pType, pBlk, &pTI->TypeAttr.tdescAlias, ref_lookup);
3199
3200   HeapFree(GetProcessHeap(), 0, ref_lookup);
3201 }
3202
3203 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
3204                                  char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3205                                  const SLTG_TypeInfoTail *pTITail)
3206 {
3207   sltg_ref_lookup_t *ref_lookup = NULL;
3208   if (pTIHeader->href_table != 0xffffffff)
3209       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3210                                   pNameTable);
3211
3212   if (pTITail->vars_off != 0xffff)
3213     SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3214
3215   if (pTITail->funcs_off != 0xffff)
3216     SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3217
3218   /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3219    * of dispinterface functons including the IDispatch ones, so
3220    * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3221   pTI->TypeAttr.cbSizeVft = pTI->TypeAttr.cFuncs * sizeof(void *);
3222
3223   HeapFree(GetProcessHeap(), 0, ref_lookup);
3224   if (TRACE_ON(typelib))
3225       dump_TLBFuncDesc(pTI->funclist);
3226 }
3227
3228 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
3229                              const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3230                              const SLTG_TypeInfoTail *pTITail)
3231 {
3232   SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3233 }
3234
3235 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
3236                                char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3237                                const SLTG_TypeInfoTail *pTITail)
3238 {
3239   sltg_ref_lookup_t *ref_lookup = NULL;
3240   if (pTIHeader->href_table != 0xffffffff)
3241       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3242                                   pNameTable);
3243
3244   if (pTITail->vars_off != 0xffff)
3245     SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3246
3247   if (pTITail->funcs_off != 0xffff)
3248     SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3249   HeapFree(GetProcessHeap(), 0, ref_lookup);
3250 }
3251
3252 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3253    managable copy of it into this */
3254 typedef struct {
3255   WORD small_no;
3256   char *index_name;
3257   char *other_name;
3258   WORD res1a;
3259   WORD name_offs;
3260   WORD more_bytes;
3261   char *extra;
3262   WORD res20;
3263   DWORD helpcontext;
3264   WORD res26;
3265   GUID uuid;
3266 } SLTG_InternalOtherTypeInfo;
3267
3268 /****************************************************************************
3269  *      ITypeLib2_Constructor_SLTG
3270  *
3271  * loading a SLTG typelib from an in-memory image
3272  */
3273 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
3274 {
3275     ITypeLibImpl *pTypeLibImpl;
3276     SLTG_Header *pHeader;
3277     SLTG_BlkEntry *pBlkEntry;
3278     SLTG_Magic *pMagic;
3279     SLTG_Index *pIndex;
3280     SLTG_Pad9 *pPad9;
3281     LPVOID pBlk, pFirstBlk;
3282     SLTG_LibBlk *pLibBlk;
3283     SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
3284     char *pAfterOTIBlks = NULL;
3285     char *pNameTable, *ptr;
3286     int i;
3287     DWORD len, order;
3288     ITypeInfoImpl **ppTypeInfoImpl;
3289
3290     TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
3291
3292
3293     pTypeLibImpl = TypeLibImpl_Constructor();
3294     if (!pTypeLibImpl) return NULL;
3295
3296     pHeader = pLib;
3297
3298     TRACE_(typelib)("header:\n");
3299     TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
3300           pHeader->nrOfFileBlks );
3301     if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
3302         FIXME("Header type magic 0x%08x not supported.\n",
3303               pHeader->SLTG_magic);
3304         return NULL;
3305     }
3306
3307     /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3308     pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
3309
3310     /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3311     pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
3312
3313     /* Next we have a magic block */
3314     pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
3315
3316     /* Let's see if we're still in sync */
3317     if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
3318               sizeof(SLTG_COMPOBJ_MAGIC))) {
3319         FIXME("CompObj magic = %s\n", pMagic->CompObj_magic);
3320         return NULL;
3321     }
3322     if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
3323               sizeof(SLTG_DIR_MAGIC))) {
3324         FIXME("dir magic = %s\n", pMagic->dir_magic);
3325         return NULL;
3326     }
3327
3328     pIndex = (SLTG_Index*)(pMagic+1);
3329
3330     pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
3331
3332     pFirstBlk = (LPVOID)(pPad9 + 1);
3333
3334     /* We'll set up a ptr to the main library block, which is the last one. */
3335
3336     for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3337           pBlkEntry[order].next != 0;
3338           order = pBlkEntry[order].next - 1, i++) {
3339        pBlk = (char*)pBlk + pBlkEntry[order].len;
3340     }
3341     pLibBlk = pBlk;
3342
3343     len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
3344
3345     /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3346        interspersed */
3347
3348     len += 0x40;
3349
3350     /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3351
3352     pOtherTypeInfoBlks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3353                                    sizeof(*pOtherTypeInfoBlks) *
3354                                    pTypeLibImpl->TypeInfoCount);
3355
3356
3357     ptr = (char*)pLibBlk + len;
3358
3359     for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
3360         WORD w, extra;
3361         len = 0;
3362
3363         pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
3364
3365         w = *(WORD*)(ptr + 2);
3366         if(w != 0xffff) {
3367             len += w;
3368             pOtherTypeInfoBlks[i].index_name = HeapAlloc(GetProcessHeap(),0,
3369                                                          w+1);
3370             memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
3371             pOtherTypeInfoBlks[i].index_name[w] = '\0';
3372         }
3373         w = *(WORD*)(ptr + 4 + len);
3374         if(w != 0xffff) {
3375             TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
3376             len += w;
3377             pOtherTypeInfoBlks[i].other_name = HeapAlloc(GetProcessHeap(),0,
3378                                                          w+1);
3379             memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
3380             pOtherTypeInfoBlks[i].other_name[w] = '\0';
3381         }
3382         pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
3383         pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
3384         extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
3385         if(extra) {
3386             pOtherTypeInfoBlks[i].extra = HeapAlloc(GetProcessHeap(),0,
3387                                                     extra);
3388             memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
3389             len += extra;
3390         }
3391         pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
3392         pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
3393         pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
3394         memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
3395         len += sizeof(SLTG_OtherTypeInfo);
3396         ptr += len;
3397     }
3398
3399     pAfterOTIBlks = ptr;
3400
3401     /* Skip this WORD and get the next DWORD */
3402     len = *(DWORD*)(pAfterOTIBlks + 2);
3403
3404     /* Now add this to pLibBLk look at what we're pointing at and
3405        possibly add 0x20, then add 0x216, sprinkle a bit a magic
3406        dust and we should be pointing at the beginning of the name
3407        table */
3408
3409     pNameTable = (char*)pLibBlk + len;
3410
3411    switch(*(WORD*)pNameTable) {
3412    case 0xffff:
3413        break;
3414    case 0x0200:
3415        pNameTable += 0x20;
3416        break;
3417    default:
3418        FIXME("pNameTable jump = %x\n", *(WORD*)pNameTable);
3419        break;
3420    }
3421
3422     pNameTable += 0x216;
3423
3424     pNameTable += 2;
3425
3426     TRACE("Library name is %s\n", pNameTable + pLibBlk->name);
3427
3428     pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
3429
3430
3431     /* Hopefully we now have enough ptrs set up to actually read in
3432        some TypeInfos.  It's not clear which order to do them in, so
3433        I'll just follow the links along the BlkEntry chain and read
3434        them in the order in which they are in the file */
3435
3436     ppTypeInfoImpl = &(pTypeLibImpl->pTypeInfo);
3437
3438     for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3439         pBlkEntry[order].next != 0;
3440         order = pBlkEntry[order].next - 1, i++) {
3441
3442       SLTG_TypeInfoHeader *pTIHeader;
3443       SLTG_TypeInfoTail *pTITail;
3444       SLTG_MemberHeader *pMemHeader;
3445
3446       if(strcmp(pBlkEntry[order].index_string + (char*)pMagic,
3447                 pOtherTypeInfoBlks[i].index_name)) {
3448         FIXME("Index strings don't match\n");
3449         return NULL;
3450       }
3451
3452       pTIHeader = pBlk;
3453       if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
3454         FIXME("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
3455         return NULL;
3456       }
3457       TRACE("pTIHeader->res06 = %x, pTIHeader->res0e = %x, pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
3458         pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
3459
3460       *ppTypeInfoImpl = (ITypeInfoImpl*)ITypeInfo_Constructor();
3461       (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
3462       (*ppTypeInfoImpl)->index = i;
3463       (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
3464                                              pOtherTypeInfoBlks[i].name_offs +
3465                                              pNameTable);
3466       (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
3467       memcpy(&((*ppTypeInfoImpl)->TypeAttr.guid), &pOtherTypeInfoBlks[i].uuid,
3468              sizeof(GUID));
3469       (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
3470       (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
3471       (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
3472       (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
3473         (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
3474
3475       if((pTIHeader->typeflags1 & 7) != 2)
3476         FIXME("typeflags1 = %02x\n", pTIHeader->typeflags1);
3477       if(pTIHeader->typeflags3 != 2)
3478         FIXME("typeflags3 = %02x\n", pTIHeader->typeflags3);
3479
3480       TRACE("TypeInfo %s of kind %s guid %s typeflags %04x\n",
3481             debugstr_w((*ppTypeInfoImpl)->Name),
3482             typekind_desc[pTIHeader->typekind],
3483             debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
3484             (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
3485
3486       pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
3487
3488       pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
3489
3490       (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
3491       (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
3492       (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
3493
3494       switch(pTIHeader->typekind) {
3495       case TKIND_ENUM:
3496         SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3497                          pTIHeader, pTITail);
3498         break;
3499
3500       case TKIND_RECORD:
3501         SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3502                            pTIHeader, pTITail);
3503         break;
3504
3505       case TKIND_INTERFACE:
3506         SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3507                               pTIHeader, pTITail);
3508         break;
3509
3510       case TKIND_COCLASS:
3511         SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3512                             pTIHeader, pTITail);
3513         break;
3514
3515       case TKIND_ALIAS:
3516         SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3517                           pTIHeader, pTITail);
3518         break;
3519
3520       case TKIND_DISPATCH:
3521         SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3522                              pTIHeader, pTITail);
3523         break;
3524
3525       case TKIND_MODULE:
3526         SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3527                            pTIHeader, pTITail);
3528         break;
3529
3530       default:
3531         FIXME("Not processing typekind %d\n", pTIHeader->typekind);
3532         break;
3533
3534       }
3535
3536       if(pTITail) { /* could get cFuncs, cVars and cImplTypes from here
3537                        but we've already set those */
3538 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
3539           X(06);
3540           X(16);
3541           X(18);
3542           X(1a);
3543           X(1e);
3544           X(24);
3545           X(26);
3546           X(2a);
3547           X(2c);
3548           X(2e);
3549           X(30);
3550           X(32);
3551           X(34);
3552       }
3553       ppTypeInfoImpl = &((*ppTypeInfoImpl)->next);
3554       pBlk = (char*)pBlk + pBlkEntry[order].len;
3555     }
3556
3557     if(i != pTypeLibImpl->TypeInfoCount) {
3558       FIXME("Somehow processed %d TypeInfos\n", i);
3559       return NULL;
3560     }
3561
3562     HeapFree(GetProcessHeap(), 0, pOtherTypeInfoBlks);
3563     return (ITypeLib2*)pTypeLibImpl;
3564 }
3565
3566 /* ITypeLib::QueryInterface
3567  */
3568 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
3569         ITypeLib2 * iface,
3570         REFIID riid,
3571         VOID **ppvObject)
3572 {
3573     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3574
3575     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
3576
3577     *ppvObject=NULL;
3578     if(IsEqualIID(riid, &IID_IUnknown) ||
3579        IsEqualIID(riid,&IID_ITypeLib)||
3580        IsEqualIID(riid,&IID_ITypeLib2))
3581     {
3582         *ppvObject = This;
3583     }
3584
3585     if(*ppvObject)
3586     {
3587         ITypeLib2_AddRef(iface);
3588         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
3589         return S_OK;
3590     }
3591     TRACE("-- Interface: E_NOINTERFACE\n");
3592     return E_NOINTERFACE;
3593 }
3594
3595 /* ITypeLib::AddRef
3596  */
3597 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
3598 {
3599     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3600     ULONG ref = InterlockedIncrement(&This->ref);
3601
3602     TRACE("(%p)->ref was %u\n",This, ref - 1);
3603
3604     return ref;
3605 }
3606
3607 /* ITypeLib::Release
3608  */
3609 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
3610 {
3611     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3612     ULONG ref = InterlockedDecrement(&This->ref);
3613
3614     TRACE("(%p)->(%u)\n",This, ref);
3615
3616     if (!ref)
3617     {
3618       TLBImpLib *pImpLib, *pImpLibNext;
3619       TLBCustData *pCustData, *pCustDataNext;
3620       TLBRefType *ref_type;
3621       void *cursor2;
3622       int i;
3623
3624       /* remove cache entry */
3625       if(This->path)
3626       {
3627           TRACE("removing from cache list\n");
3628           EnterCriticalSection(&cache_section);
3629           if (This->next) This->next->prev = This->prev;
3630           if (This->prev) This->prev->next = This->next;
3631           else tlb_cache_first = This->next;
3632           LeaveCriticalSection(&cache_section);
3633           HeapFree(GetProcessHeap(), 0, This->path);
3634       }
3635       TRACE(" destroying ITypeLib(%p)\n",This);
3636
3637       if (This->Name)
3638       {
3639           SysFreeString(This->Name);
3640           This->Name = NULL;
3641       }
3642
3643       if (This->DocString)
3644       {
3645           SysFreeString(This->DocString);
3646           This->DocString = NULL;
3647       }
3648
3649       if (This->HelpFile)
3650       {
3651           SysFreeString(This->HelpFile);
3652           This->HelpFile = NULL;
3653       }
3654
3655       if (This->HelpStringDll)
3656       {
3657           SysFreeString(This->HelpStringDll);
3658           This->HelpStringDll = NULL;
3659       }
3660
3661       for (pCustData = This->pCustData; pCustData; pCustData = pCustDataNext)
3662       {
3663           VariantClear(&pCustData->data);
3664
3665           pCustDataNext = pCustData->next;
3666           TLB_Free(pCustData);
3667       }
3668
3669       for (i = 0; i < This->ctTypeDesc; i++)
3670           if (This->pTypeDesc[i].vt == VT_CARRAY)
3671               TLB_Free(This->pTypeDesc[i].u.lpadesc);
3672
3673       TLB_Free(This->pTypeDesc);
3674
3675       for (pImpLib = This->pImpLibs; pImpLib; pImpLib = pImpLibNext)
3676       {
3677           if (pImpLib->pImpTypeLib)
3678               ITypeLib_Release((ITypeLib *)pImpLib->pImpTypeLib);
3679           TLB_Free(pImpLib->name);
3680
3681           pImpLibNext = pImpLib->next;
3682           TLB_Free(pImpLib);
3683       }
3684
3685       LIST_FOR_EACH_ENTRY_SAFE(ref_type, cursor2, &This->ref_list, TLBRefType, entry)
3686       {
3687           list_remove(&ref_type->entry);
3688           TLB_Free(ref_type);
3689       }
3690
3691       if (This->pTypeInfo) /* can be NULL */
3692           ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
3693       HeapFree(GetProcessHeap(),0,This);
3694       return 0;
3695     }
3696
3697     return ref;
3698 }
3699
3700 /* ITypeLib::GetTypeInfoCount
3701  *
3702  * Returns the number of type descriptions in the type library
3703  */
3704 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
3705 {
3706     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3707     TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
3708     return This->TypeInfoCount;
3709 }
3710
3711 /* ITypeLib::GetTypeInfo
3712  *
3713  * retrieves the specified type description in the library.
3714  */
3715 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
3716     ITypeLib2 *iface,
3717     UINT index,
3718     ITypeInfo **ppTInfo)
3719 {
3720     int i;
3721
3722     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3723     ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
3724
3725     TRACE("(%p)->(index=%d)\n", This, index);
3726
3727     if (!ppTInfo) return E_INVALIDARG;
3728
3729     /* search element n in list */
3730     for(i=0; i < index; i++)
3731     {
3732       pTypeInfo = pTypeInfo->next;
3733       if (!pTypeInfo)
3734       {
3735         TRACE("-- element not found\n");
3736         return TYPE_E_ELEMENTNOTFOUND;
3737       }
3738     }
3739
3740     *ppTInfo = (ITypeInfo *) pTypeInfo;
3741
3742     ITypeInfo_AddRef(*ppTInfo);
3743     TRACE("-- found (%p)\n",*ppTInfo);
3744     return S_OK;
3745 }
3746
3747
3748 /* ITypeLibs::GetTypeInfoType
3749  *
3750  * Retrieves the type of a type description.
3751  */
3752 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
3753     ITypeLib2 *iface,
3754     UINT index,
3755     TYPEKIND *pTKind)
3756 {
3757     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3758     int i;
3759     ITypeInfoImpl *pTInfo = This->pTypeInfo;
3760
3761     if ((ITypeLib2_fnGetTypeInfoCount(iface) < index + 1) || (index < 0))
3762          return TYPE_E_ELEMENTNOTFOUND;
3763
3764     TRACE("(%p) index %d\n", This, index);
3765
3766     if(!pTKind) return E_INVALIDARG;
3767
3768     /* search element n in list */
3769     for(i=0; i < index; i++)
3770     {
3771       if(!pTInfo)
3772       {
3773         TRACE("-- element not found\n");
3774         return TYPE_E_ELEMENTNOTFOUND;
3775       }
3776       pTInfo = pTInfo->next;
3777     }
3778
3779     *pTKind = pTInfo->TypeAttr.typekind;
3780     TRACE("-- found Type (%d)\n", *pTKind);
3781     return S_OK;
3782 }
3783
3784 /* ITypeLib::GetTypeInfoOfGuid
3785  *
3786  * Retrieves the type description that corresponds to the specified GUID.
3787  *
3788  */
3789 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
3790     ITypeLib2 *iface,
3791     REFGUID guid,
3792     ITypeInfo **ppTInfo)
3793 {
3794     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3795     ITypeInfoImpl *pTypeInfo = This->pTypeInfo; /* head of list */
3796
3797     TRACE("(%p)\n\tguid:\t%s)\n",This,debugstr_guid(guid));
3798
3799     if (!pTypeInfo)
3800     {
3801         WARN("-- element not found\n");
3802         return TYPE_E_ELEMENTNOTFOUND;
3803     }
3804
3805     /* search linked list for guid */
3806     while( !IsEqualIID(guid,&pTypeInfo->TypeAttr.guid) )
3807     {
3808       pTypeInfo = pTypeInfo->next;
3809
3810       if (!pTypeInfo)
3811       {
3812         /* end of list reached */
3813         WARN("-- element not found\n");
3814         return TYPE_E_ELEMENTNOTFOUND;
3815       }
3816     }
3817
3818     TRACE("-- found (%p, %s)\n",
3819           pTypeInfo,
3820           debugstr_w(pTypeInfo->Name));
3821
3822     *ppTInfo = (ITypeInfo*)pTypeInfo;
3823     ITypeInfo_AddRef(*ppTInfo);
3824     return S_OK;
3825 }
3826
3827 /* ITypeLib::GetLibAttr
3828  *
3829  * Retrieves the structure that contains the library's attributes.
3830  *
3831  */
3832 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
3833         ITypeLib2 *iface,
3834         LPTLIBATTR *ppTLibAttr)
3835 {
3836     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3837     TRACE("(%p)\n",This);
3838     *ppTLibAttr = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppTLibAttr));
3839     memcpy(*ppTLibAttr, &This->LibAttr, sizeof(**ppTLibAttr));
3840     return S_OK;
3841 }
3842
3843 /* ITypeLib::GetTypeComp
3844  *
3845  * Enables a client compiler to bind to a library's types, variables,
3846  * constants, and global functions.
3847  *
3848  */
3849 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
3850         ITypeLib2 *iface,
3851         ITypeComp **ppTComp)
3852 {
3853     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3854
3855     TRACE("(%p)->(%p)\n",This,ppTComp);
3856     *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
3857     ITypeComp_AddRef(*ppTComp);
3858
3859     return S_OK;
3860 }
3861
3862 /* ITypeLib::GetDocumentation
3863  *
3864  * Retrieves the library's documentation string, the complete Help file name
3865  * and path, and the context identifier for the library Help topic in the Help
3866  * file.
3867  *
3868  * On a successful return all non-null BSTR pointers will have been set,
3869  * possibly to NULL.
3870  */
3871 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
3872     ITypeLib2 *iface,
3873     INT index,
3874     BSTR *pBstrName,
3875     BSTR *pBstrDocString,
3876     DWORD *pdwHelpContext,
3877     BSTR *pBstrHelpFile)
3878 {
3879     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3880
3881     HRESULT result = E_INVALIDARG;
3882
3883     ITypeInfo *pTInfo;
3884
3885
3886     TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
3887         This, index,
3888         pBstrName, pBstrDocString,
3889         pdwHelpContext, pBstrHelpFile);
3890
3891     if(index<0)
3892     {
3893         /* documentation for the typelib */
3894         if(pBstrName)
3895         {
3896             if (This->Name)
3897             {
3898                 if(!(*pBstrName = SysAllocString(This->Name)))
3899                     goto memerr1;
3900             }
3901             else
3902                 *pBstrName = NULL;
3903         }
3904         if(pBstrDocString)
3905         {
3906             if (This->DocString)
3907             {
3908                 if(!(*pBstrDocString = SysAllocString(This->DocString)))
3909                     goto memerr2;
3910             }
3911             else if (This->Name)
3912             {
3913                 if(!(*pBstrDocString = SysAllocString(This->Name)))
3914                     goto memerr2;
3915             }
3916             else
3917                 *pBstrDocString = NULL;
3918         }
3919         if(pdwHelpContext)
3920         {
3921             *pdwHelpContext = This->dwHelpContext;
3922         }
3923         if(pBstrHelpFile)
3924         {
3925             if (This->HelpFile)
3926             {
3927                 if(!(*pBstrHelpFile = SysAllocString(This->HelpFile)))
3928                     goto memerr3;
3929             }
3930             else
3931                 *pBstrHelpFile = NULL;
3932         }
3933
3934         result = S_OK;
3935     }
3936     else
3937     {
3938         /* for a typeinfo */
3939         result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
3940
3941         if(SUCCEEDED(result))
3942         {
3943             result = ITypeInfo_GetDocumentation(pTInfo,
3944                                           MEMBERID_NIL,
3945                                           pBstrName,
3946                                           pBstrDocString,
3947                                           pdwHelpContext, pBstrHelpFile);
3948
3949             ITypeInfo_Release(pTInfo);
3950         }
3951     }
3952     return result;
3953 memerr3:
3954     if (pBstrDocString) SysFreeString (*pBstrDocString);
3955 memerr2:
3956     if (pBstrName) SysFreeString (*pBstrName);
3957 memerr1:
3958     return STG_E_INSUFFICIENTMEMORY;
3959 }
3960
3961 /* ITypeLib::IsName
3962  *
3963  * Indicates whether a passed-in string contains the name of a type or member
3964  * described in the library.
3965  *
3966  */
3967 static HRESULT WINAPI ITypeLib2_fnIsName(
3968         ITypeLib2 *iface,
3969         LPOLESTR szNameBuf,
3970         ULONG lHashVal,
3971         BOOL *pfName)
3972 {
3973     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3974     ITypeInfoImpl *pTInfo;
3975     TLBFuncDesc *pFInfo;
3976     TLBVarDesc *pVInfo;
3977     int i;
3978     UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
3979
3980     TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
3981           pfName);
3982
3983     *pfName=TRUE;
3984     for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
3985         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
3986         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
3987             if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
3988             for(i=0;i<pFInfo->funcdesc.cParams;i++)
3989                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name, nNameBufLen))
3990                     goto ITypeLib2_fnIsName_exit;
3991         }
3992         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
3993             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
3994
3995     }
3996     *pfName=FALSE;
3997
3998 ITypeLib2_fnIsName_exit:
3999     TRACE("(%p)slow! search for %s: %s found!\n", This,
4000           debugstr_w(szNameBuf), *pfName?"NOT":"");
4001
4002     return S_OK;
4003 }
4004
4005 /* ITypeLib::FindName
4006  *
4007  * Finds occurrences of a type description in a type library. This may be used
4008  * to quickly verify that a name exists in a type library.
4009  *
4010  */
4011 static HRESULT WINAPI ITypeLib2_fnFindName(
4012         ITypeLib2 *iface,
4013         LPOLESTR szNameBuf,
4014         ULONG lHashVal,
4015         ITypeInfo **ppTInfo,
4016         MEMBERID *rgMemId,
4017         UINT16 *pcFound)
4018 {
4019     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4020     ITypeInfoImpl *pTInfo;
4021     TLBFuncDesc *pFInfo;
4022     TLBVarDesc *pVInfo;
4023     int i,j = 0;
4024     UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
4025
4026     for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
4027         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4028         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
4029             if(!memcmp(szNameBuf,pFInfo->Name,nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4030             for(i=0;i<pFInfo->funcdesc.cParams;i++) {
4031                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name,nNameBufLen))
4032                     goto ITypeLib2_fnFindName_exit;
4033             }
4034         }
4035         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
4036             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4037         continue;
4038 ITypeLib2_fnFindName_exit:
4039         ITypeInfo_AddRef((ITypeInfo*)pTInfo);
4040         ppTInfo[j]=(LPTYPEINFO)pTInfo;
4041         j++;
4042     }
4043     TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
4044           This, *pcFound, debugstr_w(szNameBuf), j);
4045
4046     *pcFound=j;
4047
4048     return S_OK;
4049 }
4050
4051 /* ITypeLib::ReleaseTLibAttr
4052  *
4053  * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4054  *
4055  */
4056 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
4057         ITypeLib2 *iface,
4058         TLIBATTR *pTLibAttr)
4059 {
4060     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4061     TRACE("freeing (%p)\n",This);
4062     HeapFree(GetProcessHeap(),0,pTLibAttr);
4063
4064 }
4065
4066 /* ITypeLib2::GetCustData
4067  *
4068  * gets the custom data
4069  */
4070 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4071         ITypeLib2 * iface,
4072         REFGUID guid,
4073         VARIANT *pVarVal)
4074 {
4075     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4076     TLBCustData *pCData;
4077
4078     for(pCData=This->pCustData; pCData; pCData = pCData->next)
4079     {
4080       if( IsEqualIID(guid, &pCData->guid)) break;
4081     }
4082
4083     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
4084
4085     if(pCData)
4086     {
4087         VariantInit( pVarVal);
4088         VariantCopy( pVarVal, &pCData->data);
4089         return S_OK;
4090     }
4091     return E_INVALIDARG;  /* FIXME: correct? */
4092 }
4093
4094 /* ITypeLib2::GetLibStatistics
4095  *
4096  * Returns statistics about a type library that are required for efficient
4097  * sizing of hash tables.
4098  *
4099  */
4100 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4101         ITypeLib2 * iface,
4102         ULONG *pcUniqueNames,
4103         ULONG *pcchUniqueNames)
4104 {
4105     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4106
4107     FIXME("(%p): stub!\n", This);
4108
4109     if(pcUniqueNames) *pcUniqueNames=1;
4110     if(pcchUniqueNames) *pcchUniqueNames=1;
4111     return S_OK;
4112 }
4113
4114 /* ITypeLib2::GetDocumentation2
4115  *
4116  * Retrieves the library's documentation string, the complete Help file name
4117  * and path, the localization context to use, and the context ID for the
4118  * library Help topic in the Help file.
4119  *
4120  */
4121 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4122         ITypeLib2 * iface,
4123         INT index,
4124         LCID lcid,
4125         BSTR *pbstrHelpString,
4126         DWORD *pdwHelpStringContext,
4127         BSTR *pbstrHelpStringDll)
4128 {
4129     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4130     HRESULT result;
4131     ITypeInfo *pTInfo;
4132
4133     FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
4134
4135     /* the help string should be obtained from the helpstringdll,
4136      * using the _DLLGetDocumentation function, based on the supplied
4137      * lcid. Nice to do sometime...
4138      */
4139     if(index<0)
4140     {
4141       /* documentation for the typelib */
4142       if(pbstrHelpString)
4143         *pbstrHelpString=SysAllocString(This->DocString);
4144       if(pdwHelpStringContext)
4145         *pdwHelpStringContext=This->dwHelpContext;
4146       if(pbstrHelpStringDll)
4147         *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
4148
4149       result = S_OK;
4150     }
4151     else
4152     {
4153       /* for a typeinfo */
4154       result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
4155
4156       if(SUCCEEDED(result))
4157       {
4158         ITypeInfo2 * pTInfo2;
4159         result = ITypeInfo_QueryInterface(pTInfo,
4160                                           &IID_ITypeInfo2,
4161                                           (LPVOID*) &pTInfo2);
4162
4163         if(SUCCEEDED(result))
4164         {
4165           result = ITypeInfo2_GetDocumentation2(pTInfo2,
4166                                            MEMBERID_NIL,
4167                                            lcid,
4168                                            pbstrHelpString,
4169                                            pdwHelpStringContext,
4170                                            pbstrHelpStringDll);
4171
4172           ITypeInfo2_Release(pTInfo2);
4173         }
4174
4175         ITypeInfo_Release(pTInfo);
4176       }
4177     }
4178     return result;
4179 }
4180
4181 /* ITypeLib2::GetAllCustData
4182  *
4183  * Gets all custom data items for the library.
4184  *
4185  */
4186 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4187         ITypeLib2 * iface,
4188         CUSTDATA *pCustData)
4189 {
4190     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4191     TLBCustData *pCData;
4192     int i;
4193     TRACE("(%p) returning %d items\n", This, This->ctCustData);
4194     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
4195     if(pCustData->prgCustData ){
4196         pCustData->cCustData=This->ctCustData;
4197         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
4198             pCustData->prgCustData[i].guid=pCData->guid;
4199             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
4200         }
4201     }else{
4202         ERR(" OUT OF MEMORY!\n");
4203         return E_OUTOFMEMORY;
4204     }
4205     return S_OK;
4206 }
4207
4208 static const ITypeLib2Vtbl tlbvt = {
4209     ITypeLib2_fnQueryInterface,
4210     ITypeLib2_fnAddRef,
4211     ITypeLib2_fnRelease,
4212     ITypeLib2_fnGetTypeInfoCount,
4213     ITypeLib2_fnGetTypeInfo,
4214     ITypeLib2_fnGetTypeInfoType,
4215     ITypeLib2_fnGetTypeInfoOfGuid,
4216     ITypeLib2_fnGetLibAttr,
4217     ITypeLib2_fnGetTypeComp,
4218     ITypeLib2_fnGetDocumentation,
4219     ITypeLib2_fnIsName,
4220     ITypeLib2_fnFindName,
4221     ITypeLib2_fnReleaseTLibAttr,
4222
4223     ITypeLib2_fnGetCustData,
4224     ITypeLib2_fnGetLibStatistics,
4225     ITypeLib2_fnGetDocumentation2,
4226     ITypeLib2_fnGetAllCustData
4227  };
4228
4229
4230 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
4231 {
4232     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4233
4234     return ITypeLib2_QueryInterface((ITypeLib *)This, riid, ppv);
4235 }
4236
4237 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
4238 {
4239     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4240
4241     return ITypeLib2_AddRef((ITypeLib2 *)This);
4242 }
4243
4244 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
4245 {
4246     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4247
4248     return ITypeLib2_Release((ITypeLib2 *)This);
4249 }
4250
4251 static HRESULT WINAPI ITypeLibComp_fnBind(
4252     ITypeComp * iface,
4253     OLECHAR * szName,
4254     ULONG lHash,
4255     WORD wFlags,
4256     ITypeInfo ** ppTInfo,
4257     DESCKIND * pDescKind,
4258     BINDPTR * pBindPtr)
4259 {
4260     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4261     ITypeInfoImpl *pTypeInfo;
4262
4263     TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4264
4265     *pDescKind = DESCKIND_NONE;
4266     pBindPtr->lptcomp = NULL;
4267     *ppTInfo = NULL;
4268
4269     for (pTypeInfo = This->pTypeInfo; pTypeInfo; pTypeInfo = pTypeInfo->next)
4270     {
4271         TRACE("testing %s\n", debugstr_w(pTypeInfo->Name));
4272
4273         /* FIXME: check wFlags here? */
4274         /* FIXME: we should use a hash table to look this info up using lHash
4275          * instead of an O(n) search */
4276         if ((pTypeInfo->TypeAttr.typekind == TKIND_ENUM) ||
4277             (pTypeInfo->TypeAttr.typekind == TKIND_MODULE))
4278         {
4279             if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name, szName))
4280             {
4281                 *pDescKind = DESCKIND_TYPECOMP;
4282                 pBindPtr->lptcomp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4283                 ITypeComp_AddRef(pBindPtr->lptcomp);
4284                 TRACE("module or enum: %s\n", debugstr_w(szName));
4285                 return S_OK;
4286             }
4287         }
4288
4289         if ((pTypeInfo->TypeAttr.typekind == TKIND_MODULE) ||
4290             (pTypeInfo->TypeAttr.typekind == TKIND_ENUM))
4291         {
4292             ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4293             HRESULT hr;
4294
4295             hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4296             if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
4297             {
4298                 TRACE("found in module or in enum: %s\n", debugstr_w(szName));
4299                 return S_OK;
4300             }
4301         }
4302
4303         if ((pTypeInfo->TypeAttr.typekind == TKIND_COCLASS) &&
4304             (pTypeInfo->TypeAttr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
4305         {
4306             ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4307             HRESULT hr;
4308             ITypeInfo *subtypeinfo;
4309             BINDPTR subbindptr;
4310             DESCKIND subdesckind;
4311
4312             hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
4313                 &subtypeinfo, &subdesckind, &subbindptr);
4314             if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
4315             {
4316                 TYPEDESC tdesc_appobject =
4317                 {
4318                     {
4319                         (TYPEDESC *)pTypeInfo->hreftype
4320                     },
4321                     VT_USERDEFINED
4322                 };
4323                 const VARDESC vardesc_appobject =
4324                 {
4325                     -2,         /* memid */
4326                     NULL,       /* lpstrSchema */
4327                     {
4328                         0       /* oInst */
4329                     },
4330                     {
4331                                 /* ELEMDESC */
4332                         {
4333                                 /* TYPEDESC */
4334                                 {
4335                                     &tdesc_appobject
4336                                 },
4337                                 VT_PTR
4338                         },
4339                     },
4340                     0,          /* wVarFlags */
4341                     VAR_STATIC  /* varkind */
4342                 };
4343
4344                 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
4345
4346                 /* cleanup things filled in by Bind call so we can put our
4347                  * application object data in there instead */
4348                 switch (subdesckind)
4349                 {
4350                 case DESCKIND_FUNCDESC:
4351                     ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
4352                     break;
4353                 case DESCKIND_VARDESC:
4354                     ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
4355                     break;
4356                 default:
4357                     break;
4358                 }
4359                 if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
4360
4361                 if (pTypeInfo->hreftype == -1)
4362                     FIXME("no hreftype for interface %p\n", pTypeInfo);
4363
4364                 hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
4365                 if (FAILED(hr))
4366                     return hr;
4367
4368                 *pDescKind = DESCKIND_IMPLICITAPPOBJ;
4369                 *ppTInfo = (ITypeInfo *)pTypeInfo;
4370                 ITypeInfo_AddRef(*ppTInfo);
4371                 return S_OK;
4372             }
4373         }
4374     }
4375
4376     TRACE("name not found %s\n", debugstr_w(szName));
4377     return S_OK;
4378 }
4379
4380 static HRESULT WINAPI ITypeLibComp_fnBindType(
4381     ITypeComp * iface,
4382     OLECHAR * szName,
4383     ULONG lHash,
4384     ITypeInfo ** ppTInfo,
4385     ITypeComp ** ppTComp)
4386 {
4387     FIXME("(%s, %x, %p, %p): stub\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
4388     return E_NOTIMPL;
4389 }
4390
4391 static const ITypeCompVtbl tlbtcvt =
4392 {
4393
4394     ITypeLibComp_fnQueryInterface,
4395     ITypeLibComp_fnAddRef,
4396     ITypeLibComp_fnRelease,
4397
4398     ITypeLibComp_fnBind,
4399     ITypeLibComp_fnBindType
4400 };
4401
4402 /*================== ITypeInfo(2) Methods ===================================*/
4403 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void)
4404 {
4405     ITypeInfoImpl * pTypeInfoImpl;
4406
4407     pTypeInfoImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeInfoImpl));
4408     if (pTypeInfoImpl)
4409     {
4410       pTypeInfoImpl->lpVtbl = &tinfvt;
4411       pTypeInfoImpl->lpVtblTypeComp = &tcompvt;
4412       pTypeInfoImpl->ref=1;
4413       pTypeInfoImpl->hreftype = -1;
4414       pTypeInfoImpl->TypeAttr.memidConstructor = MEMBERID_NIL;
4415       pTypeInfoImpl->TypeAttr.memidDestructor = MEMBERID_NIL;
4416     }
4417     TRACE("(%p)\n", pTypeInfoImpl);
4418     return (ITypeInfo2*) pTypeInfoImpl;
4419 }
4420
4421 /* ITypeInfo::QueryInterface
4422  */
4423 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
4424         ITypeInfo2 *iface,
4425         REFIID riid,
4426         VOID **ppvObject)
4427 {
4428     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4429
4430     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4431
4432     *ppvObject=NULL;
4433     if(IsEqualIID(riid, &IID_IUnknown) ||
4434             IsEqualIID(riid,&IID_ITypeInfo)||
4435             IsEqualIID(riid,&IID_ITypeInfo2))
4436         *ppvObject = This;
4437
4438     if(*ppvObject){
4439         ITypeInfo_AddRef(iface);
4440         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
4441         return S_OK;
4442     }
4443     TRACE("-- Interface: E_NOINTERFACE\n");
4444     return E_NOINTERFACE;
4445 }
4446
4447 /* ITypeInfo::AddRef
4448  */
4449 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
4450 {
4451     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4452     ULONG ref = InterlockedIncrement(&This->ref);
4453
4454     ITypeLib2_AddRef((ITypeLib2*)This->pTypeLib);
4455
4456     TRACE("(%p)->ref is %u\n",This, ref);
4457     return ref;
4458 }
4459
4460 /* ITypeInfo::Release
4461  */
4462 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
4463 {
4464     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4465     ULONG ref = InterlockedDecrement(&This->ref);
4466
4467     TRACE("(%p)->(%u)\n",This, ref);
4468
4469     if (ref)   {
4470       /* We don't release ITypeLib when ref=0 because
4471          it means that function is called by ITypeLib2_Release */
4472       ITypeLib2_Release((ITypeLib2*)This->pTypeLib);
4473     } else   {
4474       TLBFuncDesc *pFInfo, *pFInfoNext;
4475       TLBVarDesc *pVInfo, *pVInfoNext;
4476       TLBImplType *pImpl, *pImplNext;
4477       TLBCustData *pCustData, *pCustDataNext;
4478
4479       TRACE("destroying ITypeInfo(%p)\n",This);
4480
4481       if (This->no_free_data)
4482           goto finish_free;
4483
4484       if (This->Name)
4485       {
4486           SysFreeString(This->Name);
4487           This->Name = 0;
4488       }
4489
4490       if (This->DocString)
4491       {
4492           SysFreeString(This->DocString);
4493           This->DocString = 0;
4494       }
4495
4496       if (This->DllName)
4497       {
4498           SysFreeString(This->DllName);
4499           This->DllName = 0;
4500       }
4501
4502       for (pFInfo = This->funclist; pFInfo; pFInfo = pFInfoNext)
4503       {
4504           UINT i;
4505           for(i = 0;i < pFInfo->funcdesc.cParams; i++)
4506           {
4507               ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[i];
4508               if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4509               {
4510                   VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4511                   TLB_Free(elemdesc->u.paramdesc.pparamdescex);
4512               }
4513               SysFreeString(pFInfo->pParamDesc[i].Name);
4514           }
4515           TLB_Free(pFInfo->funcdesc.lprgelemdescParam);
4516           TLB_Free(pFInfo->pParamDesc);
4517           for (pCustData = This->pCustData; pCustData; pCustData = pCustDataNext)
4518           {
4519               VariantClear(&pCustData->data);
4520
4521               pCustDataNext = pCustData->next;
4522               TLB_Free(pCustData);
4523           }
4524           if (HIWORD(pFInfo->Entry) != 0 && pFInfo->Entry != (BSTR)-1)
4525               SysFreeString(pFInfo->Entry);
4526           SysFreeString(pFInfo->HelpString);
4527           SysFreeString(pFInfo->Name);
4528
4529           pFInfoNext = pFInfo->next;
4530           TLB_Free(pFInfo);
4531       }
4532       for (pVInfo = This->varlist; pVInfo; pVInfo = pVInfoNext)
4533       {
4534           if (pVInfo->vardesc.varkind == VAR_CONST)
4535           {
4536               VariantClear(pVInfo->vardesc.u.lpvarValue);
4537               TLB_Free(pVInfo->vardesc.u.lpvarValue);
4538           }
4539           SysFreeString(pVInfo->Name);
4540           pVInfoNext = pVInfo->next;
4541           TLB_Free(pVInfo);
4542       }
4543       for(pImpl = This->impltypelist; pImpl; pImpl = pImplNext)
4544       {
4545           for (pCustData = pImpl->pCustData; pCustData; pCustData = pCustDataNext)
4546           {
4547               VariantClear(&pCustData->data);
4548
4549               pCustDataNext = pCustData->next;
4550               TLB_Free(pCustData);
4551           }
4552           pImplNext = pImpl->next;
4553           TLB_Free(pImpl);
4554       }
4555       TLB_Free(This->pCustData);
4556
4557 finish_free:
4558       if (This->next)
4559       {
4560         ITypeInfo_Release((ITypeInfo*)This->next);
4561       }
4562
4563       HeapFree(GetProcessHeap(),0,This);
4564       return 0;
4565     }
4566     return ref;
4567 }
4568
4569 /* ITypeInfo::GetTypeAttr
4570  *
4571  * Retrieves a TYPEATTR structure that contains the attributes of the type
4572  * description.
4573  *
4574  */
4575 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
4576         LPTYPEATTR  *ppTypeAttr)
4577 {
4578     const ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4579     SIZE_T size;
4580
4581     TRACE("(%p)\n",This);
4582
4583     size = sizeof(**ppTypeAttr);
4584     if (This->TypeAttr.typekind == TKIND_ALIAS)
4585         size += TLB_SizeTypeDesc(&This->TypeAttr.tdescAlias, FALSE);
4586
4587     *ppTypeAttr = HeapAlloc(GetProcessHeap(), 0, size);
4588     if (!*ppTypeAttr)
4589         return E_OUTOFMEMORY;
4590
4591     memcpy(*ppTypeAttr, &This->TypeAttr, sizeof(**ppTypeAttr));
4592
4593     if (This->TypeAttr.typekind == TKIND_ALIAS)
4594         TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias,
4595             &This->TypeAttr.tdescAlias, (void *)(*ppTypeAttr + 1));
4596
4597     if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
4598         (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / 4; /* This should include all the inherited
4599                                                                  funcs */
4600         (*ppTypeAttr)->cbSizeVft = 28; /* This is always the size of IDispatch's vtbl */
4601         (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
4602     }
4603     return S_OK;
4604 }
4605
4606 /* ITypeInfo::GetTypeComp
4607  *
4608  * Retrieves the ITypeComp interface for the type description, which enables a
4609  * client compiler to bind to the type description's members.
4610  *
4611  */
4612 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
4613         ITypeComp  * *ppTComp)
4614 {
4615     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4616
4617     TRACE("(%p)->(%p)\n", This, ppTComp);
4618
4619     *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4620     ITypeComp_AddRef(*ppTComp);
4621     return S_OK;
4622 }
4623
4624 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
4625 {
4626     SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
4627     if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4628         size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
4629     return size;
4630 }
4631
4632 static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buffer )
4633 {
4634     memcpy(dest, src, sizeof(ELEMDESC));
4635     *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
4636     if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4637     {
4638         const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
4639         PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
4640         *buffer += sizeof(PARAMDESCEX);
4641         memcpy(pparamdescex_dest, pparamdescex_src, sizeof(PARAMDESCEX));
4642         VariantInit(&pparamdescex_dest->varDefaultValue);
4643         return VariantCopy(&pparamdescex_dest->varDefaultValue,
4644                            (VARIANTARG *)&pparamdescex_src->varDefaultValue);
4645     }
4646     else
4647         dest->u.paramdesc.pparamdescex = NULL;
4648     return S_OK;
4649 }
4650
4651 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
4652 {
4653     if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4654         VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4655 }
4656
4657 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
4658 {
4659     FUNCDESC *dest;
4660     char *buffer;
4661     SIZE_T size = sizeof(*src);
4662     SHORT i;
4663     HRESULT hr;
4664
4665     size += sizeof(*src->lprgscode) * src->cScodes;
4666     size += TLB_SizeElemDesc(&src->elemdescFunc);
4667     for (i = 0; i < src->cParams; i++)
4668     {
4669         size += sizeof(ELEMDESC);
4670         size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
4671     }
4672
4673     dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
4674     if (!dest) return E_OUTOFMEMORY;
4675
4676     memcpy(dest, src, sizeof(FUNCDESC));
4677     buffer = (char *)(dest + 1);
4678
4679     dest->lprgscode = (SCODE *)buffer;
4680     memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
4681     buffer += sizeof(*src->lprgscode) * src->cScodes;
4682
4683     hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
4684     if (FAILED(hr))
4685     {
4686         SysFreeString((BSTR)dest);
4687         return hr;
4688     }
4689
4690     dest->lprgelemdescParam = (ELEMDESC *)buffer;
4691     buffer += sizeof(ELEMDESC) * src->cParams;
4692     for (i = 0; i < src->cParams; i++)
4693     {
4694         hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
4695         if (FAILED(hr))
4696             break;
4697     }
4698     if (FAILED(hr))
4699     {
4700         /* undo the above actions */
4701         for (i = i - 1; i >= 0; i--)
4702             TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
4703         TLB_FreeElemDesc(&dest->elemdescFunc);
4704         SysFreeString((BSTR)dest);
4705         return hr;
4706     }
4707
4708     /* special treatment for dispinterfaces: this makes functions appear
4709      * to return their [retval] value when it is really returning an
4710      * HRESULT */
4711     if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
4712     {
4713         if (dest->cParams &&
4714             (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
4715         {
4716             ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
4717             if (elemdesc->tdesc.vt != VT_PTR)
4718             {
4719                 ERR("elemdesc should have started with VT_PTR instead of:\n");
4720                 if (ERR_ON(ole))
4721                     dump_ELEMDESC(elemdesc);
4722                 return E_UNEXPECTED;
4723             }
4724
4725             /* copy last parameter to the return value. we are using a flat
4726              * buffer so there is no danger of leaking memory in
4727              * elemdescFunc */
4728             dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
4729
4730             /* remove the last parameter */
4731             dest->cParams--;
4732         }
4733         else
4734             /* otherwise this function is made to appear to have no return
4735              * value */
4736             dest->elemdescFunc.tdesc.vt = VT_VOID;
4737
4738     }
4739
4740     *dest_ptr = dest;
4741     return S_OK;
4742 }
4743
4744 HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
4745 {
4746     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4747     const TLBFuncDesc *pFDesc;
4748     int i;
4749
4750     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
4751         ;
4752
4753     if (pFDesc)
4754     {
4755         *ppFuncDesc = &pFDesc->funcdesc;
4756         return S_OK;
4757     }
4758
4759     return TYPE_E_ELEMENTNOTFOUND;
4760 }
4761
4762 /* internal function to make the inherited interfaces' methods appear
4763  * part of the interface */
4764 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
4765     UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
4766 {
4767     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4768     HRESULT hr;
4769     UINT implemented_funcs = 0;
4770
4771     if (funcs)
4772         *funcs = 0;
4773     else
4774         *hrefoffset = DISPATCH_HREF_OFFSET;
4775
4776     if(This->impltypelist)
4777     {
4778         ITypeInfo *pSubTypeInfo;
4779         UINT sub_funcs;
4780
4781         hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
4782         if (FAILED(hr))
4783             return hr;
4784
4785         hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
4786                                                        index,
4787                                                        ppFuncDesc,
4788                                                        &sub_funcs, hrefoffset);
4789         implemented_funcs += sub_funcs;
4790         ITypeInfo_Release(pSubTypeInfo);
4791         if (SUCCEEDED(hr))
4792             return hr;
4793         *hrefoffset += DISPATCH_HREF_OFFSET;
4794     }
4795
4796     if (funcs)
4797         *funcs = implemented_funcs + This->TypeAttr.cFuncs;
4798     else
4799         *hrefoffset = 0;
4800
4801     if (index < implemented_funcs)
4802         return E_INVALIDARG;
4803     return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
4804                                              ppFuncDesc);
4805 }
4806
4807 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
4808 {
4809     TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
4810     while (TRUE)
4811     {
4812         switch (pTypeDesc->vt)
4813         {
4814         case VT_USERDEFINED:
4815             pTypeDesc->u.hreftype += hrefoffset;
4816             return;
4817         case VT_PTR:
4818         case VT_SAFEARRAY:
4819             pTypeDesc = pTypeDesc->u.lptdesc;
4820             break;
4821         case VT_CARRAY:
4822             pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
4823             break;
4824         default:
4825             return;
4826         }
4827     }
4828 }
4829
4830 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc, UINT hrefoffset)
4831 {
4832     SHORT i;
4833     for (i = 0; i < pFuncDesc->cParams; i++)
4834         ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
4835     ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
4836 }
4837
4838 /* ITypeInfo::GetFuncDesc
4839  *
4840  * Retrieves the FUNCDESC structure that contains information about a
4841  * specified function.
4842  *
4843  */
4844 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
4845         LPFUNCDESC  *ppFuncDesc)
4846 {
4847     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4848     const FUNCDESC *internal_funcdesc;
4849     HRESULT hr;
4850     UINT hrefoffset = 0;
4851
4852     TRACE("(%p) index %d\n", This, index);
4853
4854     if (This->TypeAttr.typekind == TKIND_DISPATCH)
4855         hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
4856                                                        &internal_funcdesc, NULL,
4857                                                        &hrefoffset);
4858     else
4859         hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
4860                                                &internal_funcdesc);
4861     if (FAILED(hr))
4862     {
4863         WARN("description for function %d not found\n", index);
4864         return hr;
4865     }
4866
4867     hr = TLB_AllocAndInitFuncDesc(
4868         internal_funcdesc,
4869         ppFuncDesc,
4870         This->TypeAttr.typekind == TKIND_DISPATCH);
4871
4872     if ((This->TypeAttr.typekind == TKIND_DISPATCH) && hrefoffset)
4873         ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
4874
4875     TRACE("-- 0x%08x\n", hr);
4876     return hr;
4877 }
4878
4879 static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
4880 {
4881     VARDESC *dest;
4882     char *buffer;
4883     SIZE_T size = sizeof(*src);
4884     HRESULT hr;
4885
4886     if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
4887     if (src->varkind == VAR_CONST)
4888         size += sizeof(VARIANT);
4889     size += TLB_SizeElemDesc(&src->elemdescVar);
4890
4891     dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
4892     if (!dest) return E_OUTOFMEMORY;
4893
4894     *dest = *src;
4895     buffer = (char *)(dest + 1);
4896     if (src->lpstrSchema)
4897     {
4898         int len;
4899         dest->lpstrSchema = (LPOLESTR)buffer;
4900         len = strlenW(src->lpstrSchema);
4901         memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
4902         buffer += (len + 1) * sizeof(WCHAR);
4903     }
4904
4905     if (src->varkind == VAR_CONST)
4906     {
4907         HRESULT hr;
4908
4909         dest->u.lpvarValue = (VARIANT *)buffer;
4910         *dest->u.lpvarValue = *src->u.lpvarValue;
4911         buffer += sizeof(VARIANT);
4912         VariantInit(dest->u.lpvarValue);
4913         hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
4914         if (FAILED(hr))
4915         {
4916             SysFreeString((BSTR)dest_ptr);
4917             return hr;
4918         }
4919     }
4920     hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
4921     if (FAILED(hr))
4922     {
4923         if (src->varkind == VAR_CONST)
4924             VariantClear(dest->u.lpvarValue);
4925         SysFreeString((BSTR)dest);
4926         return hr;
4927     }
4928     *dest_ptr = dest;
4929     return S_OK;
4930 }
4931
4932 /* ITypeInfo::GetVarDesc
4933  *
4934  * Retrieves a VARDESC structure that describes the specified variable.
4935  *
4936  */
4937 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
4938         LPVARDESC  *ppVarDesc)
4939 {
4940     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4941     int i;
4942     const TLBVarDesc *pVDesc;
4943
4944     TRACE("(%p) index %d\n", This, index);
4945
4946     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
4947         ;
4948
4949     if (pVDesc)
4950         return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
4951
4952     return E_INVALIDARG;
4953 }
4954
4955 /* ITypeInfo_GetNames
4956  *
4957  * Retrieves the variable with the specified member ID (or the name of the
4958  * property or method and its parameters) that correspond to the specified
4959  * function ID.
4960  */
4961 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
4962         BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames)
4963 {
4964     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4965     const TLBFuncDesc *pFDesc;
4966     const TLBVarDesc *pVDesc;
4967     int i;
4968     TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
4969     for(pFDesc=This->funclist; pFDesc && pFDesc->funcdesc.memid != memid; pFDesc=pFDesc->next);
4970     if(pFDesc)
4971     {
4972       /* function found, now return function and parameter names */
4973       for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
4974       {
4975         if(!i)
4976           *rgBstrNames=SysAllocString(pFDesc->Name);
4977         else
4978           rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
4979       }
4980       *pcNames=i;
4981     }
4982     else
4983     {
4984       for(pVDesc=This->varlist; pVDesc && pVDesc->vardesc.memid != memid; pVDesc=pVDesc->next);
4985       if(pVDesc)
4986       {
4987         *rgBstrNames=SysAllocString(pVDesc->Name);
4988         *pcNames=1;
4989       }
4990       else
4991       {
4992         if(This->impltypelist &&
4993            (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
4994           /* recursive search */
4995           ITypeInfo *pTInfo;
4996           HRESULT result;
4997           result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
4998                                           &pTInfo);
4999           if(SUCCEEDED(result))
5000           {
5001             result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
5002             ITypeInfo_Release(pTInfo);
5003             return result;
5004           }
5005           WARN("Could not search inherited interface!\n");
5006         }
5007         else
5008         {
5009           WARN("no names found\n");
5010         }
5011         *pcNames=0;
5012         return TYPE_E_ELEMENTNOTFOUND;
5013       }
5014     }
5015     return S_OK;
5016 }
5017
5018
5019 /* ITypeInfo::GetRefTypeOfImplType
5020  *
5021  * If a type description describes a COM class, it retrieves the type
5022  * description of the implemented interface types. For an interface,
5023  * GetRefTypeOfImplType returns the type information for inherited interfaces,
5024  * if any exist.
5025  *
5026  */
5027 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
5028         ITypeInfo2 *iface,
5029         UINT index,
5030         HREFTYPE  *pRefType)
5031 {
5032     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5033     int i;
5034     HRESULT hr = S_OK;
5035     const TLBImplType *pImpl = This->impltypelist;
5036
5037     TRACE("(%p) index %d\n", This, index);
5038     if (TRACE_ON(ole)) dump_TypeInfo(This);
5039
5040     if(index==(UINT)-1)
5041     {
5042       /* only valid on dual interfaces;
5043          retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5044       */
5045       if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
5046
5047       if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
5048           This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
5049       {
5050         *pRefType = -1;
5051       }
5052       else
5053       {
5054         hr = TYPE_E_ELEMENTNOTFOUND;
5055       }
5056     }
5057     else if(index == 0 && This->TypeAttr.typekind == TKIND_DISPATCH)
5058     {
5059       /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5060       *pRefType = This->pTypeLib->dispatch_href;
5061     }
5062     else
5063     {
5064       /* get element n from linked list */
5065       for(i=0; pImpl && i<index; i++)
5066       {
5067         pImpl = pImpl->next;
5068       }
5069
5070       if (pImpl)
5071         *pRefType = pImpl->hRef;
5072       else
5073         hr = TYPE_E_ELEMENTNOTFOUND;
5074     }
5075
5076     if(TRACE_ON(ole))
5077     {
5078         if(SUCCEEDED(hr))
5079             TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
5080         else
5081             TRACE("FAILURE -- hresult = 0x%08x\n", hr);
5082     }
5083
5084     return hr;
5085 }
5086
5087 /* ITypeInfo::GetImplTypeFlags
5088  *
5089  * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5090  * or base interface in a type description.
5091  */
5092 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
5093         UINT index, INT  *pImplTypeFlags)
5094 {
5095     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5096     int i;
5097     TLBImplType *pImpl;
5098
5099     TRACE("(%p) index %d\n", This, index);
5100     for(i=0, pImpl=This->impltypelist; i<index && pImpl;
5101         i++, pImpl=pImpl->next)
5102         ;
5103     if(i==index && pImpl){
5104         *pImplTypeFlags=pImpl->implflags;
5105         return S_OK;
5106     }
5107     *pImplTypeFlags=0;
5108     return TYPE_E_ELEMENTNOTFOUND;
5109 }
5110
5111 /* GetIDsOfNames
5112  * Maps between member names and member IDs, and parameter names and
5113  * parameter IDs.
5114  */
5115 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
5116         LPOLESTR  *rgszNames, UINT cNames, MEMBERID  *pMemId)
5117 {
5118     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5119     const TLBFuncDesc *pFDesc;
5120     const TLBVarDesc *pVDesc;
5121     HRESULT ret=S_OK;
5122     int i;
5123
5124     TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
5125             cNames);
5126
5127     /* init out parameters in case of failure */
5128     for (i = 0; i < cNames; i++)
5129         pMemId[i] = MEMBERID_NIL;
5130
5131     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
5132         int j;
5133         if(!lstrcmpiW(*rgszNames, pFDesc->Name)) {
5134             if(cNames) *pMemId=pFDesc->funcdesc.memid;
5135             for(i=1; i < cNames; i++){
5136                 for(j=0; j<pFDesc->funcdesc.cParams; j++)
5137                     if(!lstrcmpiW(rgszNames[i],pFDesc->pParamDesc[j].Name))
5138                             break;
5139                 if( j<pFDesc->funcdesc.cParams)
5140                     pMemId[i]=j;
5141                 else
5142                    ret=DISP_E_UNKNOWNNAME;
5143             };
5144             TRACE("-- 0x%08x\n", ret);
5145             return ret;
5146         }
5147     }
5148     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
5149         if(!lstrcmpiW(*rgszNames, pVDesc->Name)) {
5150             if(cNames) *pMemId=pVDesc->vardesc.memid;
5151             return ret;
5152         }
5153     }
5154     /* not found, see if it can be found in an inherited interface */
5155     if(This->impltypelist) {
5156         /* recursive search */
5157         ITypeInfo *pTInfo;
5158         ret=ITypeInfo_GetRefTypeInfo(iface,
5159                 This->impltypelist->hRef, &pTInfo);
5160         if(SUCCEEDED(ret)){
5161             ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
5162             ITypeInfo_Release(pTInfo);
5163             return ret;
5164         }
5165         WARN("Could not search inherited interface!\n");
5166     } else
5167         WARN("no names found\n");
5168     return DISP_E_UNKNOWNNAME;
5169 }
5170
5171 /* ITypeInfo::Invoke
5172  *
5173  * Invokes a method, or accesses a property of an object, that implements the
5174  * interface described by the type description.
5175  */
5176 DWORD
5177 _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
5178     DWORD res;
5179
5180     if (TRACE_ON(ole)) {
5181         int i;
5182         TRACE("Calling %p(",func);
5183         for (i=0;i<nrargs;i++) TRACE("%08x,",args[i]);
5184         TRACE(")\n");
5185     }
5186
5187     switch (callconv) {
5188     case CC_STDCALL:
5189
5190         switch (nrargs) {
5191         case 0:
5192                 res = func();
5193                 break;
5194         case 1:
5195                 res = func(args[0]);
5196                 break;
5197         case 2:
5198                 res = func(args[0],args[1]);
5199                 break;
5200         case 3:
5201                 res = func(args[0],args[1],args[2]);
5202                 break;
5203         case 4:
5204                 res = func(args[0],args[1],args[2],args[3]);
5205                 break;
5206         case 5:
5207                 res = func(args[0],args[1],args[2],args[3],args[4]);
5208                 break;
5209         case 6:
5210                 res = func(args[0],args[1],args[2],args[3],args[4],args[5]);
5211                 break;
5212         case 7:
5213                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
5214                 break;
5215         case 8:
5216                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
5217                 break;
5218         case 9:
5219                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
5220                 break;
5221         case 10:
5222                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
5223                 break;
5224         case 11:
5225                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
5226                 break;
5227         case 12:
5228                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
5229                 break;
5230         case 13:
5231                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
5232                 break;
5233         case 14:
5234                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
5235                 break;
5236         case 15:
5237                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
5238                 break;
5239         case 16:
5240                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15]);
5241                 break;
5242         case 17:
5243                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16]);
5244                 break;
5245         case 18:
5246                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17]);
5247                 break;
5248         case 19:
5249                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18]);
5250                 break;
5251         case 20:
5252                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19]);
5253                 break;
5254         case 21:
5255                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20]);
5256                 break;
5257         case 22:
5258                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21]);
5259                 break;
5260         case 23:
5261                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22]);
5262                 break;
5263         case 24:
5264                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23]);
5265                 break;
5266         case 25:
5267                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24]);
5268                 break;
5269         case 26:
5270                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25]);
5271                 break;
5272         case 27:
5273                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26]);
5274                 break;
5275         case 28:
5276                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27]);
5277                 break;
5278         case 29:
5279                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27],args[28]);
5280                 break;
5281         case 30:
5282                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14],args[15],args[16],args[17],args[18],args[19],args[20],args[21],args[22],args[23],args[24],args[25],args[26],args[27],args[28],args[29]);
5283                 break;
5284         default:
5285                 FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
5286                 res = -1;
5287                 break;
5288         }
5289         break;
5290     default:
5291         FIXME("unsupported calling convention %d\n",callconv);
5292         res = -1;
5293         break;
5294     }
5295     TRACE("returns %08x\n",res);
5296     return res;
5297 }
5298
5299 extern int _argsize(DWORD vt);
5300
5301 static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5302 {
5303     HRESULT hr = S_OK;
5304     ITypeInfo *tinfo2 = NULL;
5305     TYPEATTR *tattr = NULL;
5306
5307     hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
5308     if (hr)
5309     {
5310         ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5311             "hr = 0x%08x\n",
5312               tdesc->u.hreftype, hr);
5313         return hr;
5314     }
5315     hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
5316     if (hr)
5317     {
5318         ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
5319         ITypeInfo_Release(tinfo2);
5320         return hr;
5321     }
5322
5323     switch (tattr->typekind)
5324     {
5325     case TKIND_ENUM:
5326         *vt |= VT_I4;
5327         break;
5328
5329     case TKIND_ALIAS:
5330         tdesc = &tattr->tdescAlias;
5331         hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
5332         break;
5333
5334     case TKIND_INTERFACE:
5335         if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
5336            *vt |= VT_DISPATCH;
5337         else
5338            *vt |= VT_UNKNOWN;
5339         break;
5340
5341     case TKIND_DISPATCH:
5342         *vt |= VT_DISPATCH;
5343         break;
5344
5345     case TKIND_COCLASS:
5346         *vt |= VT_DISPATCH;
5347         break;
5348
5349     case TKIND_RECORD:
5350         FIXME("TKIND_RECORD unhandled.\n");
5351         hr = E_NOTIMPL;
5352         break;
5353
5354     case TKIND_UNION:
5355         FIXME("TKIND_UNION unhandled.\n");
5356         hr = E_NOTIMPL;
5357         break;
5358
5359     default:
5360         FIXME("TKIND %d unhandled.\n",tattr->typekind);
5361         hr = E_NOTIMPL;
5362         break;
5363     }
5364     ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
5365     ITypeInfo_Release(tinfo2);
5366     return hr;
5367 }
5368
5369 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5370 {
5371     HRESULT hr = S_OK;
5372
5373     /* enforce only one level of pointer indirection */
5374     if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
5375     {
5376         tdesc = tdesc->u.lptdesc;
5377
5378         /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5379          * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5380          * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5381         if ((tdesc->vt == VT_USERDEFINED) ||
5382             ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
5383         {
5384             VARTYPE vt_userdefined = 0;
5385             const TYPEDESC *tdesc_userdefined = tdesc;
5386             if (tdesc->vt == VT_PTR)
5387             {
5388                 vt_userdefined = VT_BYREF;
5389                 tdesc_userdefined = tdesc->u.lptdesc;
5390             }
5391             hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
5392             if ((hr == S_OK) &&
5393                 (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
5394                  ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
5395             {
5396                 *vt |= vt_userdefined;
5397                 return S_OK;
5398             }
5399         }
5400         *vt = VT_BYREF;
5401     }
5402
5403     switch (tdesc->vt)
5404     {
5405     case VT_HRESULT:
5406         *vt |= VT_ERROR;
5407         break;
5408     case VT_USERDEFINED:
5409         hr = userdefined_to_variantvt(tinfo, tdesc, vt);
5410         break;
5411     case VT_VOID:
5412     case VT_CARRAY:
5413     case VT_PTR:
5414     case VT_LPSTR:
5415     case VT_LPWSTR:
5416         ERR("cannot convert type %d into variant VT\n", tdesc->vt);
5417         hr = DISP_E_BADVARTYPE;
5418         break;
5419     case VT_SAFEARRAY:
5420         *vt |= VT_ARRAY;
5421         hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
5422         break;
5423     default:
5424         *vt |= tdesc->vt;
5425         break;
5426     }
5427     return hr;
5428 }
5429
5430 /***********************************************************************
5431  *              DispCallFunc (OLEAUT32.@)
5432  *
5433  * Invokes a function of the specifed calling convention, passing the
5434  * specified arguments and returns the result.
5435  *
5436  * PARAMS
5437  *  pvInstance  [I] Optional pointer to the instance whose function to invoke.
5438  *  oVft        [I] The offset in the vtable. See notes.
5439  *  cc          [I] Calling convention of the function to call.
5440  *  vtReturn    [I] The return type of the function.
5441  *  cActuals    [I] Number of parameters.
5442  *  prgvt       [I] The types of the parameters to pass. This is used for sizing only.
5443  *  prgpvarg    [I] The arguments to pass.
5444  *  pvargResult [O] The return value of the function. Can be NULL.
5445  *
5446  * RETURNS
5447  *  Success: S_OK.
5448  *  Failure: HRESULT code.
5449  *
5450  * NOTES
5451  *  The HRESULT return value of this function is not affected by the return
5452  *  value of the user supplied function, which is returned in pvargResult.
5453  *
5454  *  If pvInstance is NULL then a non-object function is to be called and oVft
5455  *  is the address of the function to call.
5456  *
5457  * The cc parameter can be one of the following values:
5458  *|CC_FASTCALL
5459  *|CC_CDECL
5460  *|CC_PASCAL
5461  *|CC_STDCALL
5462  *|CC_FPFASTCALL
5463  *|CC_SYSCALL
5464  *|CC_MPWCDECL
5465  *|CC_MPWPASCAL
5466  *
5467  */
5468 HRESULT WINAPI
5469 DispCallFunc(
5470     void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals,
5471     VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult)
5472 {
5473     int i, argsize, argspos;
5474     DWORD *args;
5475     HRESULT hres;
5476
5477     TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
5478         pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
5479         pvargResult, V_VT(pvargResult));
5480
5481     argsize = 0;
5482     if (pvInstance)
5483         argsize++; /* for This pointer */
5484
5485     for (i=0;i<cActuals;i++)
5486     {
5487         TRACE("arg %d: type %d, size %d\n",i,prgvt[i],_argsize(prgvt[i]));
5488         dump_Variant(prgpvarg[i]);
5489         argsize += _argsize(prgvt[i]);
5490     }
5491     args = HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*argsize);
5492
5493     argspos = 0;
5494     if (pvInstance)
5495     {
5496         args[0] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
5497         argspos++;
5498     }
5499
5500     for (i=0;i<cActuals;i++)
5501     {
5502         VARIANT *arg = prgpvarg[i];
5503         TRACE("Storing arg %d (%d as %d)\n",i,V_VT(arg),prgvt[i]);
5504         if (prgvt[i] == VT_VARIANT)
5505             memcpy(&args[argspos], arg, _argsize(prgvt[i]) * sizeof(DWORD));
5506         else
5507             memcpy(&args[argspos], &V_NONE(arg), _argsize(prgvt[i]) * sizeof(DWORD));
5508         argspos += _argsize(prgvt[i]);
5509     }
5510
5511     if (pvInstance)
5512     {
5513         FARPROC *vtable = *(FARPROC**)pvInstance;
5514         hres = _invoke(vtable[oVft/sizeof(void *)], cc, argsize, args);
5515     }
5516     else
5517         /* if we aren't invoking an object then the function pointer is stored
5518          * in oVft */
5519         hres = _invoke((FARPROC)oVft, cc, argsize, args);
5520
5521     if (pvargResult && (vtReturn != VT_EMPTY))
5522     {
5523         TRACE("Method returned 0x%08x\n",hres);
5524         V_VT(pvargResult) = vtReturn;
5525         V_UI4(pvargResult) = hres;
5526     }
5527
5528     HeapFree(GetProcessHeap(),0,args);
5529     return S_OK;
5530 }
5531
5532 #define INVBUF_ELEMENT_SIZE \
5533     (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
5534 #define INVBUF_GET_ARG_ARRAY(buffer, params) \
5535     ((VARIANTARG *)(buffer))
5536 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
5537     ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
5538 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
5539     ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
5540 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
5541     ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
5542
5543 static HRESULT WINAPI ITypeInfo_fnInvoke(
5544     ITypeInfo2 *iface,
5545     VOID  *pIUnk,
5546     MEMBERID memid,
5547     UINT16 wFlags,
5548     DISPPARAMS  *pDispParams,
5549     VARIANT  *pVarResult,
5550     EXCEPINFO  *pExcepInfo,
5551     UINT  *pArgErr)
5552 {
5553     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5554     int i;
5555     unsigned int var_index;
5556     TYPEKIND type_kind;
5557     HRESULT hres;
5558     const TLBFuncDesc *pFuncInfo;
5559
5560     TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
5561       This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
5562     );
5563
5564     if (!pDispParams)
5565     {
5566         ERR("NULL pDispParams not allowed\n");
5567         return E_INVALIDARG;
5568     }
5569
5570     dump_DispParms(pDispParams);
5571
5572     if (pDispParams->cNamedArgs > pDispParams->cArgs)
5573     {
5574         ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
5575             pDispParams->cNamedArgs, pDispParams->cArgs);
5576         return E_INVALIDARG;
5577     }
5578
5579     /* we do this instead of using GetFuncDesc since it will return a fake
5580      * FUNCDESC for dispinterfaces and we want the real function description */
5581     for (pFuncInfo = This->funclist; pFuncInfo; pFuncInfo=pFuncInfo->next)
5582         if ((memid == pFuncInfo->funcdesc.memid) &&
5583             (wFlags & pFuncInfo->funcdesc.invkind))
5584             break;
5585
5586     if (pFuncInfo) {
5587         const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
5588
5589         if (TRACE_ON(ole))
5590         {
5591             TRACE("invoking:\n");
5592             dump_TLBFuncDescOne(pFuncInfo);
5593         }
5594
5595         switch (func_desc->funckind) {
5596         case FUNC_PUREVIRTUAL:
5597         case FUNC_VIRTUAL: {
5598             void *buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, INVBUF_ELEMENT_SIZE * func_desc->cParams);
5599             VARIANT varresult;
5600             VARIANT retval; /* pointer for storing byref retvals in */
5601             VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
5602             VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
5603             VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
5604             UINT cNamedArgs = pDispParams->cNamedArgs;
5605             DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
5606
5607             hres = S_OK;
5608
5609             if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
5610             {
5611                 if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
5612                 {
5613                     ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
5614                     hres = DISP_E_PARAMNOTFOUND;
5615                     goto func_fail;
5616                 }
5617                 /* ignore the DISPID_PROPERTYPUT named argument from now on */
5618                 cNamedArgs--;
5619                 rgdispidNamedArgs++;
5620             }
5621
5622             if (func_desc->cParamsOpt < 0 && cNamedArgs)
5623             {
5624                 ERR("functions with the vararg attribute do not support named arguments\n");
5625                 hres = DISP_E_NONAMEDARGS;
5626                 goto func_fail;
5627             }
5628
5629             for (i = 0; i < func_desc->cParams; i++)
5630             {
5631                 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
5632                 hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
5633                 if (FAILED(hres))
5634                     goto func_fail;
5635             }
5636
5637             TRACE("changing args\n");
5638             for (i = 0; i < func_desc->cParams; i++)
5639             {
5640                 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5641                 VARIANTARG *src_arg;
5642
5643                 if (cNamedArgs)
5644                 {
5645                     USHORT j;
5646                     src_arg = NULL;
5647                     for (j = 0; j < cNamedArgs; j++)
5648                         if (rgdispidNamedArgs[j] == i)
5649                         {
5650                             src_arg = &pDispParams->rgvarg[j];
5651                             break;
5652                         }
5653                 }
5654                 else
5655                     src_arg = i < pDispParams->cArgs ? &pDispParams->rgvarg[pDispParams->cArgs - 1 - i] : NULL;
5656
5657                 if (wParamFlags & PARAMFLAG_FRETVAL)
5658                 {
5659                     /* under most conditions the caller is not allowed to
5660                      * pass in a dispparam arg in the index of what would be
5661                      * the retval parameter. however, there is an exception
5662                      * where the extra parameter is used in an extra
5663                      * IDispatch::Invoke below */
5664                     if ((i < pDispParams->cArgs) &&
5665                         ((func_desc->cParams != 1) || !pVarResult ||
5666                          !(func_desc->invkind & INVOKE_PROPERTYGET)))
5667                     {
5668                         hres = DISP_E_BADPARAMCOUNT;
5669                         break;
5670                     }
5671
5672                     /* note: this check is placed so that if the caller passes
5673                      * in a VARIANTARG for the retval we just ignore it, like
5674                      * native does */
5675                     if (i == func_desc->cParams - 1)
5676                     {
5677                         VARIANTARG *arg;
5678                         arg = prgpvarg[i] = &rgvarg[i];
5679                         memset(arg, 0, sizeof(*arg));
5680                         V_VT(arg) = rgvt[i];
5681                         memset(&retval, 0, sizeof(retval));
5682                         V_BYREF(arg) = &retval;
5683                     }
5684                     else
5685                     {
5686                         ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
5687                         hres = E_UNEXPECTED;
5688                         break;
5689                     }
5690                 }
5691                 else if (src_arg)
5692                 {
5693                     dump_Variant(src_arg);
5694
5695                     if (rgvt[i] == VT_VARIANT)
5696                         hres = VariantCopy(&rgvarg[i], src_arg);
5697                     else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
5698                     {
5699                         if (rgvt[i] == V_VT(src_arg))
5700                             V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
5701                         else
5702                         {
5703                             VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5704                             hres = VariantCopy(&missing_arg[i], src_arg);
5705                             V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
5706                         }
5707                         V_VT(&rgvarg[i]) = rgvt[i];
5708                     }
5709                     else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
5710                     {
5711                         SAFEARRAY *a;
5712                         SAFEARRAYBOUND bound;
5713                         VARIANT *v;
5714                         LONG j;
5715                         bound.lLbound = 0;
5716                         bound.cElements = pDispParams->cArgs-i;
5717                         if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
5718                         {
5719                             ERR("SafeArrayCreate failed\n");
5720                             break;
5721                         }
5722                         hres = SafeArrayAccessData(a, (LPVOID)&v);
5723                         if (hres != S_OK)
5724                         {
5725                             ERR("SafeArrayAccessData failed with %x\n", hres);
5726                             break;
5727                         }
5728                         for (j = 0; j < bound.cElements; j++)
5729                             VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
5730                         hres = SafeArrayUnaccessData(a);
5731                         if (hres != S_OK)
5732                         {
5733                             ERR("SafeArrayUnaccessData failed with %x\n", hres);
5734                             break;
5735                         }
5736                         V_ARRAY(&rgvarg[i]) = a;
5737                         V_VT(&rgvarg[i]) = rgvt[i];
5738                     }
5739                     else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
5740                     {
5741                         VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5742                         V_VT(&missing_arg[i]) = V_VT(src_arg);
5743                         hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
5744                         V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
5745                         V_VT(&rgvarg[i]) = rgvt[i];
5746                     }
5747                     else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
5748                     {
5749                         V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
5750                         V_VT(&rgvarg[i]) = rgvt[i];
5751                     }
5752                     else
5753                     {
5754                         /* FIXME: this doesn't work for VT_BYREF arguments if
5755                          * they are not the same type as in the paramdesc */
5756                         V_VT(&rgvarg[i]) = V_VT(src_arg);
5757                         hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
5758                         V_VT(&rgvarg[i]) = rgvt[i];
5759                     }
5760
5761                     if (FAILED(hres))
5762                     {
5763                         ERR("failed to convert param %d to %s%s from %s%s\n", i,
5764                             debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
5765                             debugstr_VT(src_arg), debugstr_VF(src_arg));
5766                         break;
5767                     }
5768                     prgpvarg[i] = &rgvarg[i];
5769                 }
5770                 else if (wParamFlags & PARAMFLAG_FOPT)
5771                 {
5772                     VARIANTARG *arg;
5773                     arg = prgpvarg[i] = &rgvarg[i];
5774                     if (wParamFlags & PARAMFLAG_FHASDEFAULT)
5775                     {
5776                         hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
5777                         if (FAILED(hres))
5778                             break;
5779                     }
5780                     else
5781                     {
5782                         VARIANTARG *missing_arg;
5783                         /* if the function wants a pointer to a variant then
5784                          * set that up, otherwise just pass the VT_ERROR in
5785                          * the argument by value */
5786                         if (rgvt[i] & VT_BYREF)
5787                         {
5788                             missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
5789                             V_VT(arg) = VT_VARIANT | VT_BYREF;
5790                             V_VARIANTREF(arg) = missing_arg;
5791                         }
5792                         else
5793                             missing_arg = arg;
5794                         V_VT(missing_arg) = VT_ERROR;
5795                         V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
5796                     }
5797                 }
5798                 else
5799                 {
5800                     hres = DISP_E_BADPARAMCOUNT;
5801                     break;
5802                 }
5803             }
5804             if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5805
5806             /* VT_VOID is a special case for return types, so it is not
5807              * handled in the general function */
5808             if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
5809                 V_VT(&varresult) = VT_EMPTY;
5810             else
5811             {
5812                 V_VT(&varresult) = 0;
5813                 hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
5814                 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5815             }
5816
5817             hres = DispCallFunc(pIUnk, func_desc->oVft, func_desc->callconv,
5818                                 V_VT(&varresult), func_desc->cParams, rgvt,
5819                                 prgpvarg, &varresult);
5820
5821             for (i = 0; i < func_desc->cParams; i++)
5822             {
5823                 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5824                 if (wParamFlags & PARAMFLAG_FRETVAL)
5825                 {
5826                     if (TRACE_ON(ole))
5827                     {
5828                         TRACE("[retval] value: ");
5829                         dump_Variant(prgpvarg[i]);
5830                     }
5831
5832                     if (pVarResult)
5833                     {
5834                         VariantInit(pVarResult);
5835                         /* deref return value */
5836                         hres = VariantCopyInd(pVarResult, prgpvarg[i]);
5837                     }
5838
5839                     /* free data stored in varresult. Note that
5840                      * VariantClear doesn't do what we want because we are
5841                      * working with byref types. */
5842                     /* FIXME: clear safearrays, bstrs, records and
5843                      * variants here too */
5844                     if ((V_VT(prgpvarg[i]) == (VT_UNKNOWN | VT_BYREF)) ||
5845                          (V_VT(prgpvarg[i]) == (VT_DISPATCH | VT_BYREF)))
5846                     {
5847                         if(*V_UNKNOWNREF(prgpvarg[i]))
5848                             IUnknown_Release(*V_UNKNOWNREF(prgpvarg[i]));
5849                     }
5850                     break;
5851                 }
5852                 else if (i < pDispParams->cArgs)
5853                 {
5854                     if (wParamFlags & PARAMFLAG_FOUT)
5855                     {
5856                         VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - i];
5857
5858                         if ((rgvt[i] == VT_BYREF) && (V_VT(arg) != VT_BYREF))
5859                             hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
5860
5861                         if (FAILED(hres))
5862                         {
5863                             ERR("failed to convert param %d to vt %d\n", i,
5864                                 V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - i]));
5865                             break;
5866                         }
5867                     }
5868                     else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
5869                              func_desc->cParamsOpt < 0 &&
5870                              i == func_desc->cParams-1)
5871                     {
5872                         SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
5873                         LONG j, ubound;
5874                         VARIANT *v;
5875                         hres = SafeArrayGetUBound(a, 1, &ubound);
5876                         if (hres != S_OK)
5877                         {
5878                             ERR("SafeArrayGetUBound failed with %x\n", hres);
5879                             break;
5880                         }
5881                         hres = SafeArrayAccessData(a, (LPVOID)&v);
5882                         if (hres != S_OK)
5883                         {
5884                             ERR("SafeArrayAccessData failed with %x\n", hres);
5885                             break;
5886                         }
5887                         for (j = 0; j <= ubound; j++)
5888                             VariantClear(&v[j]);
5889                         hres = SafeArrayUnaccessData(a);
5890                         if (hres != S_OK)
5891                         {
5892                             ERR("SafeArrayUnaccessData failed with %x\n", hres);
5893                             break;
5894                         }
5895                     }
5896                     VariantClear(&rgvarg[i]);
5897                 }
5898                 else if (wParamFlags & PARAMFLAG_FOPT)
5899                 {
5900                     if (wParamFlags & PARAMFLAG_FHASDEFAULT)
5901                         VariantClear(&rgvarg[i]);
5902                 }
5903             }
5904
5905             if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
5906             {
5907                 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
5908                 hres = DISP_E_EXCEPTION;
5909                 if (pExcepInfo)
5910                 {
5911                     IErrorInfo *pErrorInfo;
5912                     pExcepInfo->scode = V_ERROR(&varresult);
5913                     if (GetErrorInfo(0, &pErrorInfo) == S_OK)
5914                     {
5915                         IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
5916                         IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
5917                         IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
5918                         IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
5919
5920                         IErrorInfo_Release(pErrorInfo);
5921                     }
5922                 }
5923             }
5924             if (V_VT(&varresult) != VT_ERROR)
5925             {
5926                 TRACE("varresult value: ");
5927                 dump_Variant(&varresult);
5928
5929                 if (pVarResult)
5930                 {
5931                     VariantClear(pVarResult);
5932                     *pVarResult = varresult;
5933                 }
5934                 else
5935                     VariantClear(&varresult);
5936             }
5937
5938             if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
5939                 (func_desc->invkind & INVOKE_PROPERTYGET) &&
5940                 (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
5941                 (pDispParams->cArgs != 0))
5942             {
5943                 if (V_VT(pVarResult) == VT_DISPATCH)
5944                 {
5945                     IDispatch *pDispatch = V_DISPATCH(pVarResult);
5946                     /* Note: not VariantClear; we still need the dispatch
5947                      * pointer to be valid */
5948                     VariantInit(pVarResult);
5949                     hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
5950                         GetSystemDefaultLCID(), INVOKE_PROPERTYGET,
5951                         pDispParams, pVarResult, pExcepInfo, pArgErr);
5952                     IDispatch_Release(pDispatch);
5953                 }
5954                 else
5955                 {
5956                     VariantClear(pVarResult);
5957                     hres = DISP_E_NOTACOLLECTION;
5958                 }
5959             }
5960
5961 func_fail:
5962             HeapFree(GetProcessHeap(), 0, buffer);
5963             break;
5964         }
5965         case FUNC_DISPATCH:  {
5966            IDispatch *disp;
5967
5968            hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
5969            if (SUCCEEDED(hres)) {
5970                FIXME("Calling Invoke in IDispatch iface. untested!\n");
5971                hres = IDispatch_Invoke(
5972                                      disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
5973                                      pVarResult,pExcepInfo,pArgErr
5974                                      );
5975                if (FAILED(hres))
5976                    FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
5977                IDispatch_Release(disp);
5978            } else
5979                FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
5980            break;
5981         }
5982         default:
5983             FIXME("Unknown function invocation type %d\n", func_desc->funckind);
5984             hres = E_FAIL;
5985             break;
5986         }
5987
5988         TRACE("-- 0x%08x\n", hres);
5989         return hres;
5990
5991     } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
5992         VARDESC *var_desc;
5993
5994         hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
5995         if(FAILED(hres)) return hres;
5996
5997         FIXME("varseek: Found memid, but variable-based invoking not supported\n");
5998         dump_VARDESC(var_desc);
5999         ITypeInfo2_ReleaseVarDesc(iface, var_desc);
6000         return E_NOTIMPL;
6001     }
6002
6003     /* not found, look for it in inherited interfaces */
6004     ITypeInfo2_GetTypeKind(iface, &type_kind);
6005     if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
6006         if(This->impltypelist) {
6007             /* recursive search */
6008             ITypeInfo *pTInfo;
6009             hres = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pTInfo);
6010             if(SUCCEEDED(hres)){
6011                 hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
6012                 ITypeInfo_Release(pTInfo);
6013                 return hres;
6014             }
6015             WARN("Could not search inherited interface!\n");
6016         }
6017     }
6018     ERR("did not find member id %d, flags 0x%x!\n", memid, wFlags);
6019     return DISP_E_MEMBERNOTFOUND;
6020 }
6021
6022 /* ITypeInfo::GetDocumentation
6023  *
6024  * Retrieves the documentation string, the complete Help file name and path,
6025  * and the context ID for the Help topic for a specified type description.
6026  *
6027  * (Can be tested by the Visual Basic Editor in Word for instance.)
6028  */
6029 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
6030         MEMBERID memid, BSTR  *pBstrName, BSTR  *pBstrDocString,
6031         DWORD  *pdwHelpContext, BSTR  *pBstrHelpFile)
6032 {
6033     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6034     const TLBFuncDesc *pFDesc;
6035     const TLBVarDesc *pVDesc;
6036     TRACE("(%p) memid %d Name(%p) DocString(%p)"
6037           " HelpContext(%p) HelpFile(%p)\n",
6038         This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
6039     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6040         if(pBstrName)
6041             *pBstrName=SysAllocString(This->Name);
6042         if(pBstrDocString)
6043             *pBstrDocString=SysAllocString(This->DocString);
6044         if(pdwHelpContext)
6045             *pdwHelpContext=This->dwHelpContext;
6046         if(pBstrHelpFile)
6047             *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
6048         return S_OK;
6049     }else {/* for a member */
6050     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6051         if(pFDesc->funcdesc.memid==memid){
6052           if(pBstrName)
6053             *pBstrName = SysAllocString(pFDesc->Name);
6054           if(pBstrDocString)
6055             *pBstrDocString=SysAllocString(pFDesc->HelpString);
6056           if(pdwHelpContext)
6057             *pdwHelpContext=pFDesc->helpcontext;
6058           return S_OK;
6059         }
6060     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6061         if(pVDesc->vardesc.memid==memid){
6062             if(pBstrName)
6063               *pBstrName = SysAllocString(pVDesc->Name);
6064             if(pBstrDocString)
6065               *pBstrDocString=SysAllocString(pVDesc->HelpString);
6066             if(pdwHelpContext)
6067               *pdwHelpContext=pVDesc->HelpContext;
6068             return S_OK;
6069         }
6070     }
6071
6072     if(This->impltypelist &&
6073        (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
6074         /* recursive search */
6075         ITypeInfo *pTInfo;
6076         HRESULT result;
6077         result = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
6078                                         &pTInfo);
6079         if(SUCCEEDED(result)) {
6080             result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
6081                 pBstrDocString, pdwHelpContext, pBstrHelpFile);
6082             ITypeInfo_Release(pTInfo);
6083             return result;
6084         }
6085         WARN("Could not search inherited interface!\n");
6086     }
6087
6088     WARN("member %d not found\n", memid);
6089     return TYPE_E_ELEMENTNOTFOUND;
6090 }
6091
6092 /*  ITypeInfo::GetDllEntry
6093  *
6094  * Retrieves a description or specification of an entry point for a function
6095  * in a DLL.
6096  */
6097 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
6098         INVOKEKIND invKind, BSTR  *pBstrDllName, BSTR  *pBstrName,
6099         WORD  *pwOrdinal)
6100 {
6101     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6102     const TLBFuncDesc *pFDesc;
6103
6104     TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
6105
6106     if (pBstrDllName) *pBstrDllName = NULL;
6107     if (pBstrName) *pBstrName = NULL;
6108     if (pwOrdinal) *pwOrdinal = 0;
6109
6110     if (This->TypeAttr.typekind != TKIND_MODULE)
6111         return TYPE_E_BADMODULEKIND;
6112
6113     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6114         if(pFDesc->funcdesc.memid==memid){
6115             dump_TypeInfo(This);
6116             if (TRACE_ON(ole))
6117                 dump_TLBFuncDescOne(pFDesc);
6118
6119             if (pBstrDllName)
6120                 *pBstrDllName = SysAllocString(This->DllName);
6121
6122             if (HIWORD(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
6123                 if (pBstrName)
6124                     *pBstrName = SysAllocString(pFDesc->Entry);
6125                 if (pwOrdinal)
6126                     *pwOrdinal = -1;
6127                 return S_OK;
6128             }
6129             if (pBstrName)
6130                 *pBstrName = NULL;
6131             if (pwOrdinal)
6132                 *pwOrdinal = (DWORD)pFDesc->Entry;
6133             return S_OK;
6134         }
6135     return TYPE_E_ELEMENTNOTFOUND;
6136 }
6137
6138 /* internal function to make the inherited interfaces' methods appear
6139  * part of the interface */
6140 static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
6141     HREFTYPE *hRefType, ITypeInfo  **ppTInfo)
6142 {
6143     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6144     HRESULT hr;
6145
6146     TRACE("%p, 0x%x\n", iface, *hRefType);
6147
6148     if (This->impltypelist && (*hRefType & DISPATCH_HREF_MASK))
6149     {
6150         ITypeInfo *pSubTypeInfo;
6151
6152         hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
6153         if (FAILED(hr))
6154             return hr;
6155
6156         hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
6157                                                   hRefType, ppTInfo);
6158         ITypeInfo_Release(pSubTypeInfo);
6159         if (SUCCEEDED(hr))
6160             return hr;
6161     }
6162     *hRefType -= DISPATCH_HREF_OFFSET;
6163
6164     if (!(*hRefType & DISPATCH_HREF_MASK))
6165         return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
6166     else
6167         return E_FAIL;
6168 }
6169
6170 /* ITypeInfo::GetRefTypeInfo
6171  *
6172  * If a type description references other type descriptions, it retrieves
6173  * the referenced type descriptions.
6174  */
6175 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
6176         ITypeInfo2 *iface,
6177         HREFTYPE hRefType,
6178         ITypeInfo  **ppTInfo)
6179 {
6180     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6181     HRESULT result = E_FAIL;
6182
6183     if ((This->hreftype != -1) && (This->hreftype == hRefType))
6184     {
6185         *ppTInfo = (ITypeInfo *)&This->lpVtbl;
6186         ITypeInfo_AddRef(*ppTInfo);
6187         result = S_OK;
6188     }
6189     else if (hRefType == -1 &&
6190         (This->TypeAttr.typekind   == TKIND_DISPATCH) &&
6191         (This->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
6192     {
6193           /* when we meet a DUAL dispinterface, we must create the interface
6194           * version of it.
6195           */
6196           ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
6197
6198
6199           /* the interface version contains the same information as the dispinterface
6200            * copy the contents of the structs.
6201            */
6202           *pTypeInfoImpl = *This;
6203           pTypeInfoImpl->ref = 0;
6204
6205           /* change the type to interface */
6206           pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
6207
6208           *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
6209
6210           /* we use data structures from This, so we need to keep a reference
6211            * to it to stop it being destroyed and signal to the new instance to
6212            * not free its data structures when it is destroyed */
6213           pTypeInfoImpl->no_free_data = TRUE;
6214           pTypeInfoImpl->next = This;
6215           ITypeInfo_AddRef((ITypeInfo*) This);
6216
6217           ITypeInfo_AddRef(*ppTInfo);
6218
6219           result = S_OK;
6220
6221     } else if ((hRefType != -1) && (hRefType & DISPATCH_HREF_MASK) &&
6222         (This->TypeAttr.typekind   == TKIND_DISPATCH) &&
6223         (This->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
6224     {
6225         HREFTYPE href_dispatch = hRefType;
6226         result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
6227     } else {
6228         TLBRefType *ref_type;
6229         LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
6230         {
6231             if(ref_type->reference == hRefType)
6232                 break;
6233         }
6234         if(&ref_type->entry == &This->pTypeLib->ref_list)
6235         {
6236             FIXME("Can't find pRefType for ref %x\n", hRefType);
6237             goto end;
6238         }
6239         if(hRefType != -1) {
6240             ITypeLib *pTLib = NULL;
6241
6242             if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
6243                 UINT Index;
6244                 result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
6245             } else {
6246                 if(ref_type->pImpTLInfo->pImpTypeLib) {
6247                     TRACE("typeinfo in imported typelib that is already loaded\n");
6248                     pTLib = (ITypeLib*)ref_type->pImpTLInfo->pImpTypeLib;
6249                     ITypeLib2_AddRef((ITypeLib*) pTLib);
6250                     result = S_OK;
6251                 } else {
6252                     TRACE("typeinfo in imported typelib that isn't already loaded\n");
6253                     result = LoadRegTypeLib( &ref_type->pImpTLInfo->guid,
6254                                              ref_type->pImpTLInfo->wVersionMajor,
6255                                              ref_type->pImpTLInfo->wVersionMinor,
6256                                              ref_type->pImpTLInfo->lcid,
6257                                              &pTLib);
6258
6259                     if(!SUCCEEDED(result)) {
6260                         BSTR libnam=SysAllocString(ref_type->pImpTLInfo->name);
6261                         result=LoadTypeLib(libnam, &pTLib);
6262                         SysFreeString(libnam);
6263                     }
6264                     if(SUCCEEDED(result)) {
6265                         ref_type->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
6266                         ITypeLib2_AddRef(pTLib);
6267                     }
6268                 }
6269             }
6270             if(SUCCEEDED(result)) {
6271                 if(ref_type->index == TLB_REF_USE_GUID)
6272                     result = ITypeLib2_GetTypeInfoOfGuid(pTLib,
6273                                                          &ref_type->guid,
6274                                                          ppTInfo);
6275                 else
6276                     result = ITypeLib2_GetTypeInfo(pTLib, ref_type->index,
6277                                                    ppTInfo);
6278             }
6279             if (pTLib != NULL)
6280                 ITypeLib2_Release(pTLib);
6281         }
6282     }
6283
6284 end:
6285     TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
6286           SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
6287     return result;
6288 }
6289
6290 /* ITypeInfo::AddressOfMember
6291  *
6292  * Retrieves the addresses of static functions or variables, such as those
6293  * defined in a DLL.
6294  */
6295 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
6296         MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
6297 {
6298     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6299     HRESULT hr;
6300     BSTR dll, entry;
6301     WORD ordinal;
6302     HMODULE module;
6303
6304     TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
6305
6306     hr = ITypeInfo_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
6307     if (FAILED(hr))
6308         return hr;
6309
6310     module = LoadLibraryW(dll);
6311     if (!module)
6312     {
6313         ERR("couldn't load %s\n", debugstr_w(dll));
6314         SysFreeString(dll);
6315         if (entry) SysFreeString(entry);
6316         return STG_E_FILENOTFOUND;
6317     }
6318     /* FIXME: store library somewhere where we can free it */
6319
6320     if (entry)
6321     {
6322         LPSTR entryA;
6323         INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
6324         entryA = HeapAlloc(GetProcessHeap(), 0, len);
6325         WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
6326
6327         *ppv = GetProcAddress(module, entryA);
6328         if (!*ppv)
6329             ERR("function not found %s\n", debugstr_a(entryA));
6330
6331         HeapFree(GetProcessHeap(), 0, entryA);
6332     }
6333     else
6334     {
6335         *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
6336         if (!*ppv)
6337             ERR("function not found %d\n", ordinal);
6338     }
6339
6340     SysFreeString(dll);
6341     if (entry) SysFreeString(entry);
6342
6343     if (!*ppv)
6344         return TYPE_E_DLLFUNCTIONNOTFOUND;
6345
6346     return S_OK;
6347 }
6348
6349 /* ITypeInfo::CreateInstance
6350  *
6351  * Creates a new instance of a type that describes a component object class
6352  * (coclass).
6353  */
6354 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
6355         IUnknown *pOuterUnk, REFIID riid, VOID  **ppvObj)
6356 {
6357     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6358     HRESULT hr;
6359     TYPEATTR *pTA;
6360
6361     TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
6362
6363     *ppvObj = NULL;
6364
6365     if(pOuterUnk)
6366     {
6367         WARN("Not able to aggregate\n");
6368         return CLASS_E_NOAGGREGATION;
6369     }
6370
6371     hr = ITypeInfo_GetTypeAttr(iface, &pTA);
6372     if(FAILED(hr)) return hr;
6373
6374     if(pTA->typekind != TKIND_COCLASS)
6375     {
6376         WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
6377         hr = E_INVALIDARG;
6378         goto end;
6379     }
6380
6381     hr = S_FALSE;
6382     if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
6383     {
6384         IUnknown *pUnk;
6385         hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
6386         TRACE("GetActiveObject rets %08x\n", hr);
6387         if(hr == S_OK)
6388         {
6389             hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
6390             IUnknown_Release(pUnk);
6391         }
6392     }
6393
6394     if(hr != S_OK)
6395         hr = CoCreateInstance(&pTA->guid, NULL,
6396                               CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
6397                               riid, ppvObj);
6398
6399 end:
6400     ITypeInfo_ReleaseTypeAttr(iface, pTA);
6401     return hr;
6402 }
6403
6404 /* ITypeInfo::GetMops
6405  *
6406  * Retrieves marshalling information.
6407  */
6408 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
6409                                 BSTR  *pBstrMops)
6410 {
6411     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6412     FIXME("(%p) stub!\n", This);
6413     return S_OK;
6414 }
6415
6416 /* ITypeInfo::GetContainingTypeLib
6417  *
6418  * Retrieves the containing type library and the index of the type description
6419  * within that type library.
6420  */
6421 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
6422         ITypeLib  * *ppTLib, UINT  *pIndex)
6423 {
6424     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6425
6426     /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
6427     if (pIndex) {
6428       *pIndex=This->index;
6429       TRACE("returning pIndex=%d\n", *pIndex);
6430     }
6431
6432     if (ppTLib) {
6433       *ppTLib=(LPTYPELIB )(This->pTypeLib);
6434       ITypeLib2_AddRef(*ppTLib);
6435       TRACE("returning ppTLib=%p\n", *ppTLib);
6436     }
6437
6438     return S_OK;
6439 }
6440
6441 /* ITypeInfo::ReleaseTypeAttr
6442  *
6443  * Releases a TYPEATTR previously returned by GetTypeAttr.
6444  *
6445  */
6446 static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
6447         TYPEATTR* pTypeAttr)
6448 {
6449     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6450     TRACE("(%p)->(%p)\n", This, pTypeAttr);
6451     HeapFree(GetProcessHeap(), 0, pTypeAttr);
6452 }
6453
6454 /* ITypeInfo::ReleaseFuncDesc
6455  *
6456  * Releases a FUNCDESC previously returned by GetFuncDesc. *
6457  */
6458 static void WINAPI ITypeInfo_fnReleaseFuncDesc(
6459         ITypeInfo2 *iface,
6460         FUNCDESC *pFuncDesc)
6461 {
6462     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6463     SHORT i;
6464
6465     TRACE("(%p)->(%p)\n", This, pFuncDesc);
6466
6467     for (i = 0; i < pFuncDesc->cParams; i++)
6468         TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
6469     TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
6470
6471     SysFreeString((BSTR)pFuncDesc);
6472 }
6473
6474 /* ITypeInfo::ReleaseVarDesc
6475  *
6476  * Releases a VARDESC previously returned by GetVarDesc.
6477  */
6478 static void WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
6479         VARDESC *pVarDesc)
6480 {
6481     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6482     TRACE("(%p)->(%p)\n", This, pVarDesc);
6483
6484     TLB_FreeElemDesc(&pVarDesc->elemdescVar);
6485     if (pVarDesc->varkind == VAR_CONST)
6486         VariantClear(pVarDesc->u.lpvarValue);
6487     SysFreeString((BSTR)pVarDesc);
6488 }
6489
6490 /* ITypeInfo2::GetTypeKind
6491  *
6492  * Returns the TYPEKIND enumeration quickly, without doing any allocations.
6493  *
6494  */
6495 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
6496     TYPEKIND *pTypeKind)
6497 {
6498     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6499     *pTypeKind=This->TypeAttr.typekind;
6500     TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
6501     return S_OK;
6502 }
6503
6504 /* ITypeInfo2::GetTypeFlags
6505  *
6506  * Returns the type flags without any allocations. This returns a DWORD type
6507  * flag, which expands the type flags without growing the TYPEATTR (type
6508  * attribute).
6509  *
6510  */
6511 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
6512 {
6513     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6514     *pTypeFlags=This->TypeAttr.wTypeFlags;
6515     TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
6516     return S_OK;
6517 }
6518
6519 /* ITypeInfo2::GetFuncIndexOfMemId
6520  * Binds to a specific member based on a known DISPID, where the member name
6521  * is not known (for example, when binding to a default member).
6522  *
6523  */
6524 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
6525     MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
6526 {
6527     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6528     const TLBFuncDesc *pFuncInfo;
6529     int i;
6530     HRESULT result;
6531
6532     for(i = 0, pFuncInfo = This->funclist; pFuncInfo; i++, pFuncInfo=pFuncInfo->next)
6533         if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
6534             break;
6535     if(pFuncInfo) {
6536         *pFuncIndex = i;
6537         result = S_OK;
6538     } else
6539         result = TYPE_E_ELEMENTNOTFOUND;
6540
6541     TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
6542           memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6543     return result;
6544 }
6545
6546 /* TypeInfo2::GetVarIndexOfMemId
6547  *
6548  * Binds to a specific member based on a known DISPID, where the member name
6549  * is not known (for example, when binding to a default member).
6550  *
6551  */
6552 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
6553     MEMBERID memid, UINT *pVarIndex)
6554 {
6555     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6556     TLBVarDesc *pVarInfo;
6557     int i;
6558     HRESULT result;
6559     for(i=0, pVarInfo=This->varlist; pVarInfo &&
6560             memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
6561         ;
6562     if(pVarInfo) {
6563         *pVarIndex = i;
6564         result = S_OK;
6565     } else
6566         result = TYPE_E_ELEMENTNOTFOUND;
6567
6568     TRACE("(%p) memid 0x%08x -> %s\n", This,
6569           memid, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6570     return result;
6571 }
6572
6573 /* ITypeInfo2::GetCustData
6574  *
6575  * Gets the custom data
6576  */
6577 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
6578         ITypeInfo2 * iface,
6579         REFGUID guid,
6580         VARIANT *pVarVal)
6581 {
6582     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6583     TLBCustData *pCData;
6584
6585     for(pCData=This->pCustData; pCData; pCData = pCData->next)
6586         if( IsEqualIID(guid, &pCData->guid)) break;
6587
6588     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6589
6590     if(pCData)
6591     {
6592         VariantInit( pVarVal);
6593         VariantCopy( pVarVal, &pCData->data);
6594         return S_OK;
6595     }
6596     return E_INVALIDARG;  /* FIXME: correct? */
6597 }
6598
6599 /* ITypeInfo2::GetFuncCustData
6600  *
6601  * Gets the custom data
6602  */
6603 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
6604         ITypeInfo2 * iface,
6605         UINT index,
6606         REFGUID guid,
6607         VARIANT *pVarVal)
6608 {
6609     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6610     TLBCustData *pCData=NULL;
6611     TLBFuncDesc * pFDesc;
6612     int i;
6613     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6614             pFDesc=pFDesc->next);
6615
6616     if(pFDesc)
6617         for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
6618             if( IsEqualIID(guid, &pCData->guid)) break;
6619
6620     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6621
6622     if(pCData){
6623         VariantInit( pVarVal);
6624         VariantCopy( pVarVal, &pCData->data);
6625         return S_OK;
6626     }
6627     return E_INVALIDARG;  /* FIXME: correct? */
6628 }
6629
6630 /* ITypeInfo2::GetParamCustData
6631  *
6632  * Gets the custom data
6633  */
6634 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
6635         ITypeInfo2 * iface,
6636         UINT indexFunc,
6637         UINT indexParam,
6638         REFGUID guid,
6639         VARIANT *pVarVal)
6640 {
6641     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6642     TLBCustData *pCData=NULL;
6643     TLBFuncDesc * pFDesc;
6644     int i;
6645
6646     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,pFDesc=pFDesc->next);
6647
6648     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
6649         for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
6650                 pCData = pCData->next)
6651             if( IsEqualIID(guid, &pCData->guid)) break;
6652
6653     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6654
6655     if(pCData)
6656     {
6657         VariantInit( pVarVal);
6658         VariantCopy( pVarVal, &pCData->data);
6659         return S_OK;
6660     }
6661     return E_INVALIDARG;  /* FIXME: correct? */
6662 }
6663
6664 /* ITypeInfo2::GetVarCustData
6665  *
6666  * Gets the custom data
6667  */
6668 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
6669         ITypeInfo2 * iface,
6670         UINT index,
6671         REFGUID guid,
6672         VARIANT *pVarVal)
6673 {
6674     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6675     TLBCustData *pCData=NULL;
6676     TLBVarDesc * pVDesc;
6677     int i;
6678
6679     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next);
6680
6681     if(pVDesc)
6682     {
6683       for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
6684       {
6685         if( IsEqualIID(guid, &pCData->guid)) break;
6686       }
6687     }
6688
6689     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6690
6691     if(pCData)
6692     {
6693         VariantInit( pVarVal);
6694         VariantCopy( pVarVal, &pCData->data);
6695         return S_OK;
6696     }
6697     return E_INVALIDARG;  /* FIXME: correct? */
6698 }
6699
6700 /* ITypeInfo2::GetImplCustData
6701  *
6702  * Gets the custom data
6703  */
6704 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
6705         ITypeInfo2 * iface,
6706         UINT index,
6707         REFGUID guid,
6708         VARIANT *pVarVal)
6709 {
6710     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6711     TLBCustData *pCData=NULL;
6712     TLBImplType * pRDesc;
6713     int i;
6714
6715     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++, pRDesc=pRDesc->next);
6716
6717     if(pRDesc)
6718     {
6719       for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
6720       {
6721         if( IsEqualIID(guid, &pCData->guid)) break;
6722       }
6723     }
6724
6725     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6726
6727     if(pCData)
6728     {
6729         VariantInit( pVarVal);
6730         VariantCopy( pVarVal, &pCData->data);
6731         return S_OK;
6732     }
6733     return E_INVALIDARG;  /* FIXME: correct? */
6734 }
6735
6736 /* ITypeInfo2::GetDocumentation2
6737  *
6738  * Retrieves the documentation string, the complete Help file name and path,
6739  * the localization context to use, and the context ID for the library Help
6740  * topic in the Help file.
6741  *
6742  */
6743 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
6744         ITypeInfo2 * iface,
6745         MEMBERID memid,
6746         LCID lcid,
6747         BSTR *pbstrHelpString,
6748         DWORD *pdwHelpStringContext,
6749         BSTR *pbstrHelpStringDll)
6750 {
6751     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6752     const TLBFuncDesc *pFDesc;
6753     const TLBVarDesc *pVDesc;
6754     TRACE("(%p) memid %d lcid(0x%x)  HelpString(%p) "
6755           "HelpStringContext(%p) HelpStringDll(%p)\n",
6756           This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
6757           pbstrHelpStringDll );
6758     /* the help string should be obtained from the helpstringdll,
6759      * using the _DLLGetDocumentation function, based on the supplied
6760      * lcid. Nice to do sometime...
6761      */
6762     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6763         if(pbstrHelpString)
6764             *pbstrHelpString=SysAllocString(This->Name);
6765         if(pdwHelpStringContext)
6766             *pdwHelpStringContext=This->dwHelpStringContext;
6767         if(pbstrHelpStringDll)
6768             *pbstrHelpStringDll=
6769                 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6770         return S_OK;
6771     }else {/* for a member */
6772     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6773         if(pFDesc->funcdesc.memid==memid){
6774              if(pbstrHelpString)
6775                 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
6776             if(pdwHelpStringContext)
6777                 *pdwHelpStringContext=pFDesc->HelpStringContext;
6778             if(pbstrHelpStringDll)
6779                 *pbstrHelpStringDll=
6780                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6781         return S_OK;
6782     }
6783     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6784         if(pVDesc->vardesc.memid==memid){
6785              if(pbstrHelpString)
6786                 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
6787             if(pdwHelpStringContext)
6788                 *pdwHelpStringContext=pVDesc->HelpStringContext;
6789             if(pbstrHelpStringDll)
6790                 *pbstrHelpStringDll=
6791                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6792             return S_OK;
6793         }
6794     }
6795     return TYPE_E_ELEMENTNOTFOUND;
6796 }
6797
6798 /* ITypeInfo2::GetAllCustData
6799  *
6800  * Gets all custom data items for the Type info.
6801  *
6802  */
6803 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
6804         ITypeInfo2 * iface,
6805         CUSTDATA *pCustData)
6806 {
6807     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6808     TLBCustData *pCData;
6809     int i;
6810
6811     TRACE("(%p) returning %d items\n", This, This->ctCustData);
6812
6813     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
6814     if(pCustData->prgCustData ){
6815         pCustData->cCustData=This->ctCustData;
6816         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
6817             pCustData->prgCustData[i].guid=pCData->guid;
6818             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
6819         }
6820     }else{
6821         ERR(" OUT OF MEMORY!\n");
6822         return E_OUTOFMEMORY;
6823     }
6824     return S_OK;
6825 }
6826
6827 /* ITypeInfo2::GetAllFuncCustData
6828  *
6829  * Gets all custom data items for the specified Function
6830  *
6831  */
6832 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
6833         ITypeInfo2 * iface,
6834         UINT index,
6835         CUSTDATA *pCustData)
6836 {
6837     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6838     TLBCustData *pCData;
6839     TLBFuncDesc * pFDesc;
6840     int i;
6841     TRACE("(%p) index %d\n", This, index);
6842     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6843             pFDesc=pFDesc->next)
6844         ;
6845     if(pFDesc){
6846         pCustData->prgCustData =
6847             TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
6848         if(pCustData->prgCustData ){
6849             pCustData->cCustData=pFDesc->ctCustData;
6850             for(i=0, pCData=pFDesc->pCustData; pCData; i++,
6851                     pCData = pCData->next){
6852                 pCustData->prgCustData[i].guid=pCData->guid;
6853                 VariantCopy(& pCustData->prgCustData[i].varValue,
6854                         & pCData->data);
6855             }
6856         }else{
6857             ERR(" OUT OF MEMORY!\n");
6858             return E_OUTOFMEMORY;
6859         }
6860         return S_OK;
6861     }
6862     return TYPE_E_ELEMENTNOTFOUND;
6863 }
6864
6865 /* ITypeInfo2::GetAllParamCustData
6866  *
6867  * Gets all custom data items for the Functions
6868  *
6869  */
6870 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
6871     UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
6872 {
6873     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6874     TLBCustData *pCData=NULL;
6875     TLBFuncDesc * pFDesc;
6876     int i;
6877     TRACE("(%p) index %d\n", This, indexFunc);
6878     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
6879             pFDesc=pFDesc->next)
6880         ;
6881     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams){
6882         pCustData->prgCustData =
6883             TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
6884                     sizeof(CUSTDATAITEM));
6885         if(pCustData->prgCustData ){
6886             pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
6887             for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
6888                     pCData; i++, pCData = pCData->next){
6889                 pCustData->prgCustData[i].guid=pCData->guid;
6890                 VariantCopy(& pCustData->prgCustData[i].varValue,
6891                         & pCData->data);
6892             }
6893         }else{
6894             ERR(" OUT OF MEMORY!\n");
6895             return E_OUTOFMEMORY;
6896         }
6897         return S_OK;
6898     }
6899     return TYPE_E_ELEMENTNOTFOUND;
6900 }
6901
6902 /* ITypeInfo2::GetAllVarCustData
6903  *
6904  * Gets all custom data items for the specified Variable
6905  *
6906  */
6907 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
6908     UINT index, CUSTDATA *pCustData)
6909 {
6910     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6911     TLBCustData *pCData;
6912     TLBVarDesc * pVDesc;
6913     int i;
6914     TRACE("(%p) index %d\n", This, index);
6915     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
6916             pVDesc=pVDesc->next)
6917         ;
6918     if(pVDesc){
6919         pCustData->prgCustData =
6920             TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
6921         if(pCustData->prgCustData ){
6922             pCustData->cCustData=pVDesc->ctCustData;
6923             for(i=0, pCData=pVDesc->pCustData; pCData; i++,
6924                     pCData = pCData->next){
6925                 pCustData->prgCustData[i].guid=pCData->guid;
6926                 VariantCopy(& pCustData->prgCustData[i].varValue,
6927                         & pCData->data);
6928             }
6929         }else{
6930             ERR(" OUT OF MEMORY!\n");
6931             return E_OUTOFMEMORY;
6932         }
6933         return S_OK;
6934     }
6935     return TYPE_E_ELEMENTNOTFOUND;
6936 }
6937
6938 /* ITypeInfo2::GetAllImplCustData
6939  *
6940  * Gets all custom data items for the specified implementation type
6941  *
6942  */
6943 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
6944         ITypeInfo2 * iface,
6945         UINT index,
6946         CUSTDATA *pCustData)
6947 {
6948     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6949     TLBCustData *pCData;
6950     TLBImplType * pRDesc;
6951     int i;
6952     TRACE("(%p) index %d\n", This, index);
6953     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
6954             pRDesc=pRDesc->next)
6955         ;
6956     if(pRDesc){
6957         pCustData->prgCustData =
6958             TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
6959         if(pCustData->prgCustData ){
6960             pCustData->cCustData=pRDesc->ctCustData;
6961             for(i=0, pCData=pRDesc->pCustData; pCData; i++,
6962                     pCData = pCData->next){
6963                 pCustData->prgCustData[i].guid=pCData->guid;
6964                 VariantCopy(& pCustData->prgCustData[i].varValue,
6965                         & pCData->data);
6966             }
6967         }else{
6968             ERR(" OUT OF MEMORY!\n");
6969             return E_OUTOFMEMORY;
6970         }
6971         return S_OK;
6972     }
6973     return TYPE_E_ELEMENTNOTFOUND;
6974 }
6975
6976 static const ITypeInfo2Vtbl tinfvt =
6977 {
6978
6979     ITypeInfo_fnQueryInterface,
6980     ITypeInfo_fnAddRef,
6981     ITypeInfo_fnRelease,
6982
6983     ITypeInfo_fnGetTypeAttr,
6984     ITypeInfo_fnGetTypeComp,
6985     ITypeInfo_fnGetFuncDesc,
6986     ITypeInfo_fnGetVarDesc,
6987     ITypeInfo_fnGetNames,
6988     ITypeInfo_fnGetRefTypeOfImplType,
6989     ITypeInfo_fnGetImplTypeFlags,
6990     ITypeInfo_fnGetIDsOfNames,
6991     ITypeInfo_fnInvoke,
6992     ITypeInfo_fnGetDocumentation,
6993     ITypeInfo_fnGetDllEntry,
6994     ITypeInfo_fnGetRefTypeInfo,
6995     ITypeInfo_fnAddressOfMember,
6996     ITypeInfo_fnCreateInstance,
6997     ITypeInfo_fnGetMops,
6998     ITypeInfo_fnGetContainingTypeLib,
6999     ITypeInfo_fnReleaseTypeAttr,
7000     ITypeInfo_fnReleaseFuncDesc,
7001     ITypeInfo_fnReleaseVarDesc,
7002
7003     ITypeInfo2_fnGetTypeKind,
7004     ITypeInfo2_fnGetTypeFlags,
7005     ITypeInfo2_fnGetFuncIndexOfMemId,
7006     ITypeInfo2_fnGetVarIndexOfMemId,
7007     ITypeInfo2_fnGetCustData,
7008     ITypeInfo2_fnGetFuncCustData,
7009     ITypeInfo2_fnGetParamCustData,
7010     ITypeInfo2_fnGetVarCustData,
7011     ITypeInfo2_fnGetImplTypeCustData,
7012     ITypeInfo2_fnGetDocumentation2,
7013     ITypeInfo2_fnGetAllCustData,
7014     ITypeInfo2_fnGetAllFuncCustData,
7015     ITypeInfo2_fnGetAllParamCustData,
7016     ITypeInfo2_fnGetAllVarCustData,
7017     ITypeInfo2_fnGetAllImplTypeCustData,
7018 };
7019
7020 /******************************************************************************
7021  * CreateDispTypeInfo [OLEAUT32.31]
7022  *
7023  * Build type information for an object so it can be called through an
7024  * IDispatch interface.
7025  *
7026  * RETURNS
7027  *  Success: S_OK. pptinfo contains the created ITypeInfo object.
7028  *  Failure: E_INVALIDARG, if one or more arguments is invalid.
7029  *
7030  * NOTES
7031  *  This call allows an objects methods to be accessed through IDispatch, by
7032  *  building an ITypeInfo object that IDispatch can use to call through.
7033  */
7034 HRESULT WINAPI CreateDispTypeInfo(
7035         INTERFACEDATA *pidata, /* [I] Description of the interface to build type info for */
7036         LCID lcid, /* [I] Locale Id */
7037         ITypeInfo **pptinfo) /* [O] Destination for created ITypeInfo object */
7038 {
7039     ITypeInfoImpl *pTIClass, *pTIIface;
7040     ITypeLibImpl *pTypeLibImpl;
7041     int param, func;
7042     TLBFuncDesc **ppFuncDesc;
7043     TLBRefType *ref;
7044
7045     TRACE("\n");
7046     pTypeLibImpl = TypeLibImpl_Constructor();
7047     if (!pTypeLibImpl) return E_FAIL;
7048
7049     pTIIface = (ITypeInfoImpl*)ITypeInfo_Constructor();
7050     pTIIface->pTypeLib = pTypeLibImpl;
7051     pTIIface->index = 0;
7052     pTIIface->Name = NULL;
7053     pTIIface->dwHelpContext = -1;
7054     memset(&pTIIface->TypeAttr.guid, 0, sizeof(GUID));
7055     pTIIface->TypeAttr.lcid = lcid;
7056     pTIIface->TypeAttr.typekind = TKIND_INTERFACE;
7057     pTIIface->TypeAttr.wMajorVerNum = 0;
7058     pTIIface->TypeAttr.wMinorVerNum = 0;
7059     pTIIface->TypeAttr.cbAlignment = 2;
7060     pTIIface->TypeAttr.cbSizeInstance = -1;
7061     pTIIface->TypeAttr.cbSizeVft = -1;
7062     pTIIface->TypeAttr.cFuncs = 0;
7063     pTIIface->TypeAttr.cImplTypes = 0;
7064     pTIIface->TypeAttr.cVars = 0;
7065     pTIIface->TypeAttr.wTypeFlags = 0;
7066
7067     ppFuncDesc = &pTIIface->funclist;
7068     for(func = 0; func < pidata->cMembers; func++) {
7069         METHODDATA *md = pidata->pmethdata + func;
7070         *ppFuncDesc = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppFuncDesc));
7071         (*ppFuncDesc)->Name = SysAllocString(md->szName);
7072         (*ppFuncDesc)->funcdesc.memid = md->dispid;
7073         (*ppFuncDesc)->funcdesc.lprgscode = NULL;
7074         (*ppFuncDesc)->funcdesc.funckind = FUNC_VIRTUAL;
7075         (*ppFuncDesc)->funcdesc.invkind = md->wFlags;
7076         (*ppFuncDesc)->funcdesc.callconv = md->cc;
7077         (*ppFuncDesc)->funcdesc.cParams = md->cArgs;
7078         (*ppFuncDesc)->funcdesc.cParamsOpt = 0;
7079         (*ppFuncDesc)->funcdesc.oVft = md->iMeth << 2;
7080         (*ppFuncDesc)->funcdesc.cScodes = 0;
7081         (*ppFuncDesc)->funcdesc.wFuncFlags = 0;
7082         (*ppFuncDesc)->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
7083         (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
7084         (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
7085         (*ppFuncDesc)->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7086                                                               md->cArgs * sizeof(ELEMDESC));
7087         (*ppFuncDesc)->pParamDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7088                                               md->cArgs * sizeof(TLBParDesc));
7089         for(param = 0; param < md->cArgs; param++) {
7090             (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
7091             (*ppFuncDesc)->pParamDesc[param].Name = SysAllocString(md->ppdata[param].szName);
7092         }
7093         (*ppFuncDesc)->helpcontext = 0;
7094         (*ppFuncDesc)->HelpStringContext = 0;
7095         (*ppFuncDesc)->HelpString = NULL;
7096         (*ppFuncDesc)->Entry = NULL;
7097         (*ppFuncDesc)->ctCustData = 0;
7098         (*ppFuncDesc)->pCustData = NULL;
7099         (*ppFuncDesc)->next = NULL;
7100         pTIIface->TypeAttr.cFuncs++;
7101         ppFuncDesc = &(*ppFuncDesc)->next;
7102     }
7103
7104     dump_TypeInfo(pTIIface);
7105
7106     pTypeLibImpl->pTypeInfo = pTIIface;
7107     pTypeLibImpl->TypeInfoCount++;
7108
7109     pTIClass = (ITypeInfoImpl*)ITypeInfo_Constructor();
7110     pTIClass->pTypeLib = pTypeLibImpl;
7111     pTIClass->index = 1;
7112     pTIClass->Name = NULL;
7113     pTIClass->dwHelpContext = -1;
7114     memset(&pTIClass->TypeAttr.guid, 0, sizeof(GUID));
7115     pTIClass->TypeAttr.lcid = lcid;
7116     pTIClass->TypeAttr.typekind = TKIND_COCLASS;
7117     pTIClass->TypeAttr.wMajorVerNum = 0;
7118     pTIClass->TypeAttr.wMinorVerNum = 0;
7119     pTIClass->TypeAttr.cbAlignment = 2;
7120     pTIClass->TypeAttr.cbSizeInstance = -1;
7121     pTIClass->TypeAttr.cbSizeVft = -1;
7122     pTIClass->TypeAttr.cFuncs = 0;
7123     pTIClass->TypeAttr.cImplTypes = 1;
7124     pTIClass->TypeAttr.cVars = 0;
7125     pTIClass->TypeAttr.wTypeFlags = 0;
7126
7127     pTIClass->impltypelist = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pTIClass->impltypelist));
7128     pTIClass->impltypelist->hRef = 0;
7129
7130     ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
7131     ref->index = 0;
7132     ref->reference = 0;
7133     ref->pImpTLInfo = TLB_REF_INTERNAL;
7134     list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
7135
7136     dump_TypeInfo(pTIClass);
7137
7138     pTIIface->next = pTIClass;
7139     pTypeLibImpl->TypeInfoCount++;
7140
7141     *pptinfo = (ITypeInfo*)pTIClass;
7142
7143     ITypeInfo_AddRef(*pptinfo);
7144     ITypeLib_Release((ITypeLib *)&pTypeLibImpl->lpVtbl);
7145
7146     return S_OK;
7147
7148 }
7149
7150 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
7151 {
7152     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7153
7154     return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
7155 }
7156
7157 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
7158 {
7159     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7160
7161     return ITypeInfo_AddRef((ITypeInfo *)This);
7162 }
7163
7164 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
7165 {
7166     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7167
7168     return ITypeInfo_Release((ITypeInfo *)This);
7169 }
7170
7171 static HRESULT WINAPI ITypeComp_fnBind(
7172     ITypeComp * iface,
7173     OLECHAR * szName,
7174     ULONG lHash,
7175     WORD wFlags,
7176     ITypeInfo ** ppTInfo,
7177     DESCKIND * pDescKind,
7178     BINDPTR * pBindPtr)
7179 {
7180     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7181     const TLBFuncDesc *pFDesc;
7182     const TLBVarDesc *pVDesc;
7183     HRESULT hr = DISP_E_MEMBERNOTFOUND;
7184
7185     TRACE("(%s, %x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7186
7187     *pDescKind = DESCKIND_NONE;
7188     pBindPtr->lpfuncdesc = NULL;
7189     *ppTInfo = NULL;
7190
7191     for(pFDesc = This->funclist; pFDesc; pFDesc = pFDesc->next)
7192         if (!strcmpiW(pFDesc->Name, szName)) {
7193             if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
7194                 break;
7195             else
7196                 /* name found, but wrong flags */
7197                 hr = TYPE_E_TYPEMISMATCH;
7198         }
7199
7200     if (pFDesc)
7201     {
7202         HRESULT hr = TLB_AllocAndInitFuncDesc(
7203             &pFDesc->funcdesc,
7204             &pBindPtr->lpfuncdesc,
7205             This->TypeAttr.typekind == TKIND_DISPATCH);
7206         if (FAILED(hr))
7207             return hr;
7208         *pDescKind = DESCKIND_FUNCDESC;
7209         *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7210         ITypeInfo_AddRef(*ppTInfo);
7211         return S_OK;
7212     } else {
7213         for(pVDesc = This->varlist; pVDesc; pVDesc = pVDesc->next) {
7214             if (!strcmpiW(pVDesc->Name, szName)) {
7215                 HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
7216                 if (FAILED(hr))
7217                     return hr;
7218                 *pDescKind = DESCKIND_VARDESC;
7219                 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7220                 ITypeInfo_AddRef(*ppTInfo);
7221                 return S_OK;
7222             }
7223         }
7224     }
7225     /* FIXME: search each inherited interface, not just the first */
7226     if (hr == DISP_E_MEMBERNOTFOUND && This->impltypelist) {
7227         /* recursive search */
7228         ITypeInfo *pTInfo;
7229         ITypeComp *pTComp;
7230         HRESULT hr;
7231         hr=ITypeInfo_GetRefTypeInfo((ITypeInfo *)&This->lpVtbl, This->impltypelist->hRef, &pTInfo);
7232         if (SUCCEEDED(hr))
7233         {
7234             hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
7235             ITypeInfo_Release(pTInfo);
7236         }
7237         if (SUCCEEDED(hr))
7238         {
7239             hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7240             ITypeComp_Release(pTComp);
7241             return hr;
7242         }
7243         WARN("Could not search inherited interface!\n");
7244     }
7245     WARN("did not find member with name %s, flags 0x%x!\n", debugstr_w(szName), wFlags);
7246     return hr;
7247 }
7248
7249 static HRESULT WINAPI ITypeComp_fnBindType(
7250     ITypeComp * iface,
7251     OLECHAR * szName,
7252     ULONG lHash,
7253     ITypeInfo ** ppTInfo,
7254     ITypeComp ** ppTComp)
7255 {
7256     TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
7257
7258     /* strange behaviour (does nothing) but like the
7259      * original */
7260
7261     if (!ppTInfo || !ppTComp)
7262         return E_POINTER;
7263
7264     *ppTInfo = NULL;
7265     *ppTComp = NULL;
7266
7267     return S_OK;
7268 }
7269
7270 static const ITypeCompVtbl tcompvt =
7271 {
7272
7273     ITypeComp_fnQueryInterface,
7274     ITypeComp_fnAddRef,
7275     ITypeComp_fnRelease,
7276
7277     ITypeComp_fnBind,
7278     ITypeComp_fnBindType
7279 };