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 HRESULT 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 /* free custom data allocated by MSFT_CustData */
1425 static inline void TLB_FreeCustData(TLBCustData *pCustData)
1426 {
1427     TLBCustData *pCustDataNext;
1428     for (; pCustData; pCustData = pCustDataNext)
1429     {
1430         VariantClear(&pCustData->data);
1431
1432         pCustDataNext = pCustData->next;
1433         TLB_Free(pCustData);
1434     }
1435 }
1436
1437 /**********************************************************************
1438  *
1439  *  Functions for reading MSFT typelibs (those created by CreateTypeLib2)
1440  */
1441 static inline unsigned int MSFT_Tell(const TLBContext *pcx)
1442 {
1443     return pcx->pos;
1444 }
1445
1446 static inline void MSFT_Seek(TLBContext *pcx, long where)
1447 {
1448     if (where != DO_NOT_SEEK)
1449     {
1450         where += pcx->oStart;
1451         if (where > pcx->length)
1452         {
1453             /* FIXME */
1454             ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
1455             TLB_abort();
1456         }
1457         pcx->pos = where;
1458     }
1459 }
1460
1461 /* read function */
1462 static DWORD MSFT_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
1463 {
1464     TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08lx\n",
1465        pcx->pos, count, pcx->oStart, pcx->length, where);
1466
1467     MSFT_Seek(pcx, where);
1468     if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
1469     memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
1470     pcx->pos += count;
1471     return count;
1472 }
1473
1474 static DWORD MSFT_ReadLEDWords(void *buffer,  DWORD count, TLBContext *pcx,
1475                                long where )
1476 {
1477   DWORD ret;
1478
1479   ret = MSFT_Read(buffer, count, pcx, where);
1480   FromLEDWords(buffer, ret);
1481
1482   return ret;
1483 }
1484
1485 static DWORD MSFT_ReadLEWords(void *buffer,  DWORD count, TLBContext *pcx,
1486                               long where )
1487 {
1488   DWORD ret;
1489
1490   ret = MSFT_Read(buffer, count, pcx, where);
1491   FromLEWords(buffer, ret);
1492
1493   return ret;
1494 }
1495
1496 static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
1497 {
1498     if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
1499         memset(pGuid,0, sizeof(GUID));
1500         return;
1501     }
1502     MSFT_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
1503     pGuid->Data1 = FromLEDWord(pGuid->Data1);
1504     pGuid->Data2 = FromLEWord(pGuid->Data2);
1505     pGuid->Data3 = FromLEWord(pGuid->Data3);
1506     TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
1507 }
1508
1509 static HREFTYPE MSFT_ReadHreftype( TLBContext *pcx, int offset )
1510 {
1511     MSFT_NameIntro niName;
1512
1513     if (offset < 0)
1514     {
1515         ERR_(typelib)("bad offset %d\n", offset);
1516         return -1;
1517     }
1518
1519     MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1520                       pcx->pTblDir->pNametab.offset+offset);
1521
1522     return niName.hreftype;
1523 }
1524
1525 static BSTR MSFT_ReadName( TLBContext *pcx, int offset)
1526 {
1527     char * name;
1528     MSFT_NameIntro niName;
1529     int lengthInChars;
1530     BSTR bstrName = NULL;
1531
1532     if (offset < 0)
1533     {
1534         ERR_(typelib)("bad offset %d\n", offset);
1535         return NULL;
1536     }
1537     MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1538                       pcx->pTblDir->pNametab.offset+offset);
1539     niName.namelen &= 0xFF; /* FIXME: correct ? */
1540     name=TLB_Alloc((niName.namelen & 0xff) +1);
1541     MSFT_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
1542     name[niName.namelen & 0xff]='\0';
1543
1544     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1545                                         name, -1, NULL, 0);
1546
1547     /* no invalid characters in string */
1548     if (lengthInChars)
1549     {
1550         bstrName = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1551
1552         /* don't check for invalid character since this has been done previously */
1553         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, bstrName, lengthInChars);
1554     }
1555     TLB_Free(name);
1556
1557     TRACE_(typelib)("%s %d\n", debugstr_w(bstrName), lengthInChars);
1558     return bstrName;
1559 }
1560
1561 static BSTR MSFT_ReadString( TLBContext *pcx, int offset)
1562 {
1563     char * string;
1564     INT16 length;
1565     int lengthInChars;
1566     BSTR bstr = NULL;
1567
1568     if(offset<0) return NULL;
1569     MSFT_ReadLEWords(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
1570     if(length <= 0) return 0;
1571     string=TLB_Alloc(length +1);
1572     MSFT_Read(string, length, pcx, DO_NOT_SEEK);
1573     string[length]='\0';
1574
1575     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1576                                         string, -1, NULL, 0);
1577
1578     /* no invalid characters in string */
1579     if (lengthInChars)
1580     {
1581         bstr = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1582
1583         /* don't check for invalid character since this has been done previously */
1584         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, bstr, lengthInChars);
1585     }
1586     TLB_Free(string);
1587
1588     TRACE_(typelib)("%s %d\n", debugstr_w(bstr), lengthInChars);
1589     return bstr;
1590 }
1591 /*
1592  * read a value and fill a VARIANT structure
1593  */
1594 static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
1595 {
1596     int size;
1597
1598     TRACE_(typelib)("\n");
1599
1600     if(offset <0) { /* data are packed in here */
1601         V_VT(pVar) = (offset & 0x7c000000 )>> 26;
1602         V_I4(pVar) = offset & 0x3ffffff;
1603         return;
1604     }
1605     MSFT_ReadLEWords(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
1606                      pcx->pTblDir->pCustData.offset + offset );
1607     TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
1608     switch (V_VT(pVar)){
1609         case VT_EMPTY:  /* FIXME: is this right? */
1610         case VT_NULL:   /* FIXME: is this right? */
1611         case VT_I2  :   /* this should not happen */
1612         case VT_I4  :
1613         case VT_R4  :
1614         case VT_ERROR   :
1615         case VT_BOOL    :
1616         case VT_I1  :
1617         case VT_UI1 :
1618         case VT_UI2 :
1619         case VT_UI4 :
1620         case VT_INT :
1621         case VT_UINT    :
1622         case VT_VOID    : /* FIXME: is this right? */
1623         case VT_HRESULT :
1624             size=4; break;
1625         case VT_R8  :
1626         case VT_CY  :
1627         case VT_DATE    :
1628         case VT_I8  :
1629         case VT_UI8 :
1630         case VT_DECIMAL :  /* FIXME: is this right? */
1631         case VT_FILETIME :
1632             size=8;break;
1633             /* pointer types with known behaviour */
1634         case VT_BSTR    :{
1635             char * ptr;
1636             MSFT_ReadLEDWords(&size, sizeof(INT), pcx, DO_NOT_SEEK );
1637             if(size < 0) {
1638                 char next;
1639                 DWORD origPos = MSFT_Tell(pcx), nullPos;
1640
1641                 do {
1642                     MSFT_Read(&next, 1, pcx, DO_NOT_SEEK);
1643                 } while (next);
1644                 nullPos = MSFT_Tell(pcx);
1645                 size = nullPos - origPos;
1646                 MSFT_Seek(pcx, origPos);
1647             }
1648             ptr=TLB_Alloc(size);/* allocate temp buffer */
1649             MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);/* read string (ANSI) */
1650             V_BSTR(pVar)=SysAllocStringLen(NULL,size);
1651             /* FIXME: do we need a AtoW conversion here? */
1652             V_UNION(pVar, bstrVal[size])='\0';
1653             while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
1654             TLB_Free(ptr);
1655         }
1656         size=-4; break;
1657     /* FIXME: this will not work AT ALL when the variant contains a pointer */
1658         case VT_DISPATCH :
1659         case VT_VARIANT :
1660         case VT_UNKNOWN :
1661         case VT_PTR :
1662         case VT_SAFEARRAY :
1663         case VT_CARRAY  :
1664         case VT_USERDEFINED :
1665         case VT_LPSTR   :
1666         case VT_LPWSTR  :
1667         case VT_BLOB    :
1668         case VT_STREAM  :
1669         case VT_STORAGE :
1670         case VT_STREAMED_OBJECT :
1671         case VT_STORED_OBJECT   :
1672         case VT_BLOB_OBJECT :
1673         case VT_CF  :
1674         case VT_CLSID   :
1675         default:
1676             size=0;
1677             FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
1678                 V_VT(pVar));
1679     }
1680
1681     if(size>0) /* (big|small) endian correct? */
1682         MSFT_Read(&(V_I2(pVar)), size, pcx, DO_NOT_SEEK );
1683     return;
1684 }
1685 /*
1686  * create a linked list with custom data
1687  */
1688 static int MSFT_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
1689 {
1690     MSFT_CDGuid entry;
1691     TLBCustData* pNew;
1692     int count=0;
1693
1694     TRACE_(typelib)("\n");
1695
1696     while(offset >=0){
1697         count++;
1698         pNew=TLB_Alloc(sizeof(TLBCustData));
1699         MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
1700         MSFT_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
1701         MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
1702         /* add new custom data at head of the list */
1703         pNew->next=*ppCustData;
1704         *ppCustData=pNew;
1705         offset = entry.next;
1706     }
1707     return count;
1708 }
1709
1710 static void MSFT_GetTdesc(TLBContext *pcx, INT type, TYPEDESC *pTd,
1711                           ITypeInfoImpl *pTI)
1712 {
1713     if(type <0)
1714         pTd->vt=type & VT_TYPEMASK;
1715     else
1716         *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
1717
1718     if(pTd->vt == VT_USERDEFINED)
1719       MSFT_DoRefType(pcx, pTI->pTypeLib, pTd->u.hreftype);
1720
1721     TRACE_(typelib)("vt type = %X\n", pTd->vt);
1722 }
1723
1724 static void MSFT_ResolveReferencedTypes(TLBContext *pcx, ITypeInfoImpl *pTI, TYPEDESC *lpTypeDesc)
1725 {
1726     /* resolve referenced type if any */
1727     while (lpTypeDesc)
1728     {
1729         switch (lpTypeDesc->vt)
1730         {
1731         case VT_PTR:
1732             lpTypeDesc = lpTypeDesc->u.lptdesc;
1733             break;
1734
1735         case VT_CARRAY:
1736             lpTypeDesc = & (lpTypeDesc->u.lpadesc->tdescElem);
1737             break;
1738
1739         case VT_USERDEFINED:
1740             MSFT_DoRefType(pcx, pTI->pTypeLib,
1741                            lpTypeDesc->u.hreftype);
1742
1743             lpTypeDesc = NULL;
1744             break;
1745
1746         default:
1747             lpTypeDesc = NULL;
1748         }
1749     }
1750 }
1751
1752 static void
1753 MSFT_DoFuncs(TLBContext*     pcx,
1754             ITypeInfoImpl*  pTI,
1755             int             cFuncs,
1756             int             cVars,
1757             int             offset,
1758             TLBFuncDesc**   pptfd)
1759 {
1760     /*
1761      * member information is stored in a data structure at offset
1762      * indicated by the memoffset field of the typeinfo structure
1763      * There are several distinctive parts.
1764      * The first part starts with a field that holds the total length
1765      * of this (first) part excluding this field. Then follow the records,
1766      * for each member there is one record.
1767      *
1768      * The first entry is always the length of the record (including this
1769      * length word).
1770      * The rest of the record depends on the type of the member. If there is
1771      * a field indicating the member type (function, variable, interface, etc)
1772      * I have not found it yet. At this time we depend on the information
1773      * in the type info and the usual order how things are stored.
1774      *
1775      * Second follows an array sized nrMEM*sizeof(INT) with a member id
1776      * for each member;
1777      *
1778      * Third is an equal sized array with file offsets to the name entry
1779      * of each member.
1780      *
1781      * The fourth and last (?) part is an array with offsets to the records
1782      * in the first part of this file segment.
1783      */
1784
1785     int infolen, nameoffset, reclength, nrattributes, i;
1786     int recoffset = offset + sizeof(INT);
1787
1788     char *recbuf = HeapAlloc(GetProcessHeap(), 0, 0xffff);
1789     MSFT_FuncRecord * pFuncRec=(MSFT_FuncRecord *) recbuf;
1790     TLBFuncDesc *ptfd_prev = NULL;
1791
1792     TRACE_(typelib)("\n");
1793
1794     MSFT_ReadLEDWords(&infolen, sizeof(INT), pcx, offset);
1795
1796     for ( i = 0; i < cFuncs ; i++ )
1797     {
1798         *pptfd = TLB_Alloc(sizeof(TLBFuncDesc));
1799
1800         /* name, eventually add to a hash table */
1801         MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1802                           offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1803
1804         /* nameoffset is sometimes -1 on the second half of a propget/propput
1805          * pair of functions */
1806         if ((nameoffset == -1) && (i > 0))
1807             (*pptfd)->Name = SysAllocString(ptfd_prev->Name);
1808         else
1809             (*pptfd)->Name = MSFT_ReadName(pcx, nameoffset);
1810
1811         /* read the function information record */
1812         MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1813
1814         reclength &= 0xffff;
1815
1816         MSFT_ReadLEDWords(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1817
1818         /* do the attributes */
1819         nrattributes = (reclength - pFuncRec->nrargs * 3 * sizeof(int) - 0x18)
1820                        / sizeof(int);
1821
1822         if ( nrattributes > 0 )
1823         {
1824             (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
1825
1826             if ( nrattributes > 1 )
1827             {
1828                 (*pptfd)->HelpString = MSFT_ReadString(pcx,
1829                                                       pFuncRec->OptAttr[1]) ;
1830
1831                 if ( nrattributes > 2 )
1832                 {
1833                     if ( pFuncRec->FKCCIC & 0x2000 )
1834                     {
1835                        if (HIWORD(pFuncRec->OptAttr[2]) != 0)
1836                            ERR("ordinal 0x%08x invalid, HIWORD != 0\n", pFuncRec->OptAttr[2]);
1837                        (*pptfd)->Entry = (BSTR)pFuncRec->OptAttr[2];
1838                     }
1839                     else
1840                     {
1841                         (*pptfd)->Entry = MSFT_ReadString(pcx,
1842                                                          pFuncRec->OptAttr[2]);
1843                     }
1844                     if( nrattributes > 5 )
1845                     {
1846                         (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
1847
1848                         if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
1849                         {
1850                             MSFT_CustData(pcx,
1851                                           pFuncRec->OptAttr[6],
1852                                           &(*pptfd)->pCustData);
1853                         }
1854                     }
1855                 }
1856                 else
1857                 {
1858                     (*pptfd)->Entry = (BSTR)-1;
1859                 }
1860             }
1861         }
1862
1863         /* fill the FuncDesc Structure */
1864         MSFT_ReadLEDWords( & (*pptfd)->funcdesc.memid, sizeof(INT), pcx,
1865                            offset + infolen + ( i + 1) * sizeof(INT));
1866
1867         (*pptfd)->funcdesc.funckind   =  (pFuncRec->FKCCIC)      & 0x7;
1868         (*pptfd)->funcdesc.invkind    =  (pFuncRec->FKCCIC) >> 3 & 0xF;
1869         (*pptfd)->funcdesc.callconv   =  (pFuncRec->FKCCIC) >> 8 & 0xF;
1870         (*pptfd)->funcdesc.cParams    =   pFuncRec->nrargs  ;
1871         (*pptfd)->funcdesc.cParamsOpt =   pFuncRec->nroargs ;
1872         (*pptfd)->funcdesc.oVft       =   pFuncRec->VtableOffset ;
1873         (*pptfd)->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
1874
1875         MSFT_GetTdesc(pcx,
1876                       pFuncRec->DataType,
1877                       &(*pptfd)->funcdesc.elemdescFunc.tdesc,
1878                       pTI);
1879         MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptfd)->funcdesc.elemdescFunc.tdesc);
1880
1881         /* do the parameters/arguments */
1882         if(pFuncRec->nrargs)
1883         {
1884             int j = 0;
1885             MSFT_ParameterInfo paraminfo;
1886
1887             (*pptfd)->funcdesc.lprgelemdescParam =
1888                 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
1889
1890             (*pptfd)->pParamDesc =
1891                 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
1892
1893             MSFT_ReadLEDWords(&paraminfo, sizeof(paraminfo), pcx,
1894                               recoffset + reclength - pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
1895
1896             for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
1897             {
1898                 ELEMDESC *elemdesc = &(*pptfd)->funcdesc.lprgelemdescParam[j];
1899
1900                 MSFT_GetTdesc(pcx,
1901                               paraminfo.DataType,
1902                               &elemdesc->tdesc,
1903                               pTI);
1904
1905                 elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
1906
1907                 /* name */
1908                 if (paraminfo.oName == -1)
1909                     /* this occurs for [propput] or [propget] methods, so
1910                      * we should just set the name of the parameter to the
1911                      * name of the method. */
1912                     (*pptfd)->pParamDesc[j].Name = SysAllocString((*pptfd)->Name);
1913                 else
1914                     (*pptfd)->pParamDesc[j].Name =
1915                         MSFT_ReadName( pcx, paraminfo.oName );
1916                 TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w((*pptfd)->pParamDesc[j].Name));
1917
1918                 MSFT_ResolveReferencedTypes(pcx, pTI, &elemdesc->tdesc);
1919
1920                 /* default value */
1921                 if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
1922                      (pFuncRec->FKCCIC & 0x1000) )
1923                 {
1924                     INT* pInt = (INT *)((char *)pFuncRec +
1925                                    reclength -
1926                                    (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
1927
1928                     PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
1929
1930                     pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
1931                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
1932
1933                     MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
1934                         pInt[j], pcx);
1935                 }
1936                 else
1937                     elemdesc->u.paramdesc.pparamdescex = NULL;
1938                 /* custom info */
1939                 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
1940                 {
1941                     MSFT_CustData(pcx,
1942                                   pFuncRec->OptAttr[7+j],
1943                                   &(*pptfd)->pParamDesc[j].pCustData);
1944                 }
1945
1946                 /* SEEK value = jump to offset,
1947                  * from there jump to the end of record,
1948                  * go back by (j-1) arguments
1949                  */
1950                 MSFT_ReadLEDWords( &paraminfo ,
1951                            sizeof(MSFT_ParameterInfo), pcx,
1952                            recoffset + reclength - ((pFuncRec->nrargs - j - 1)
1953                                                * sizeof(MSFT_ParameterInfo)));
1954             }
1955         }
1956
1957         /* scode is not used: archaic win16 stuff FIXME: right? */
1958         (*pptfd)->funcdesc.cScodes   = 0 ;
1959         (*pptfd)->funcdesc.lprgscode = NULL ;
1960
1961         ptfd_prev = *pptfd;
1962         pptfd      = & ((*pptfd)->next);
1963         recoffset += reclength;
1964     }
1965     HeapFree(GetProcessHeap(), 0, recbuf);
1966 }
1967
1968 static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
1969                        int cVars, int offset, TLBVarDesc ** pptvd)
1970 {
1971     int infolen, nameoffset, reclength;
1972     char recbuf[256];
1973     MSFT_VarRecord * pVarRec=(MSFT_VarRecord *) recbuf;
1974     int i;
1975     int recoffset;
1976
1977     TRACE_(typelib)("\n");
1978
1979     MSFT_ReadLEDWords(&infolen,sizeof(INT), pcx, offset);
1980     MSFT_ReadLEDWords(&recoffset,sizeof(INT), pcx, offset + infolen +
1981                       ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
1982     recoffset += offset+sizeof(INT);
1983     for(i=0;i<cVars;i++){
1984         *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
1985     /* name, eventually add to a hash table */
1986         MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
1987                           offset + infolen + (2*cFuncs + cVars + i + 1) * sizeof(INT));
1988         (*pptvd)->Name=MSFT_ReadName(pcx, nameoffset);
1989     /* read the variable information record */
1990         MSFT_ReadLEDWords(&reclength, sizeof(INT), pcx, recoffset);
1991         reclength &=0xff;
1992         MSFT_ReadLEDWords(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK);
1993     /* Optional data */
1994         if(reclength >(6*sizeof(INT)) )
1995             (*pptvd)->HelpContext=pVarRec->HelpContext;
1996         if(reclength >(7*sizeof(INT)) )
1997             (*pptvd)->HelpString = MSFT_ReadString(pcx, pVarRec->oHelpString) ;
1998         if(reclength >(8*sizeof(INT)) )
1999         if(reclength >(9*sizeof(INT)) )
2000             (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
2001     /* fill the VarDesc Structure */
2002         MSFT_ReadLEDWords(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
2003                           offset + infolen + (cFuncs + i + 1) * sizeof(INT));
2004         (*pptvd)->vardesc.varkind = pVarRec->VarKind;
2005         (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
2006         MSFT_GetTdesc(pcx, pVarRec->DataType,
2007             &(*pptvd)->vardesc.elemdescVar.tdesc, pTI);
2008 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
2009         if(pVarRec->VarKind == VAR_CONST ){
2010             (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
2011             MSFT_ReadValue((*pptvd)->vardesc.u.lpvarValue,
2012                 pVarRec->OffsValue, pcx);
2013         } else
2014             (*pptvd)->vardesc.u.oInst=pVarRec->OffsValue;
2015         MSFT_ResolveReferencedTypes(pcx, pTI, &(*pptvd)->vardesc.elemdescVar.tdesc);
2016         pptvd=&((*pptvd)->next);
2017         recoffset += reclength;
2018     }
2019 }
2020 /* fill in data for a hreftype (offset). When the referenced type is contained
2021  * in the typelib, it's just an (file) offset in the type info base dir.
2022  * If comes from import, it's an offset+1 in the ImpInfo table
2023  * */
2024 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL,
2025                           int offset)
2026 {
2027     int j;
2028     TLBRefType *ref;
2029
2030     TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
2031
2032     LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
2033     {
2034         if(ref->reference == offset) return;
2035     }
2036
2037     ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
2038     list_add_tail(&pTL->ref_list, &ref->entry);
2039
2040     if(!MSFT_HREFTYPE_INTHISFILE( offset)) {
2041         /* external typelib */
2042         MSFT_ImpInfo impinfo;
2043         TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
2044
2045         TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
2046
2047         MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx,
2048                           pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
2049         for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
2050             if(pImpLib->offset==impinfo.oImpFile) break;
2051             pImpLib=pImpLib->next;
2052         }
2053         if(pImpLib){
2054             ref->reference = offset;
2055             ref->pImpTLInfo = pImpLib;
2056             if(impinfo.flags & MSFT_IMPINFO_OFFSET_IS_GUID) {
2057                 MSFT_ReadGuid(&ref->guid, impinfo.oGuid, pcx);
2058                 TRACE("importing by guid %s\n", debugstr_guid(&ref->guid));
2059                 ref->index = TLB_REF_USE_GUID;
2060             } else
2061                 ref->index = impinfo.oGuid;
2062         }else{
2063             ERR("Cannot find a reference\n");
2064             ref->reference = -1;
2065             ref->pImpTLInfo = TLB_REF_NOT_FOUND;
2066         }
2067     }else{
2068         /* in this typelib */
2069         ref->index = MSFT_HREFTYPE_INDEX(offset);
2070         ref->reference = offset;
2071         ref->pImpTLInfo = TLB_REF_INTERNAL;
2072     }
2073 }
2074
2075 /* process Implemented Interfaces of a com class */
2076 static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
2077                             int offset)
2078 {
2079     int i;
2080     MSFT_RefRecord refrec;
2081     TLBImplType **ppImpl = &pTI->impltypelist;
2082
2083     TRACE_(typelib)("\n");
2084
2085     for(i=0;i<count;i++){
2086         if(offset<0) break; /* paranoia */
2087         *ppImpl=TLB_Alloc(sizeof(**ppImpl));
2088         MSFT_ReadLEDWords(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
2089         MSFT_DoRefType(pcx, pTI->pTypeLib, refrec.reftype);
2090         (*ppImpl)->hRef = refrec.reftype;
2091         (*ppImpl)->implflags=refrec.flags;
2092         (*ppImpl)->ctCustData=
2093             MSFT_CustData(pcx, refrec.oCustData, &(*ppImpl)->pCustData);
2094         offset=refrec.onext;
2095         ppImpl=&((*ppImpl)->next);
2096     }
2097 }
2098 /*
2099  * process a typeinfo record
2100  */
2101 static ITypeInfoImpl * MSFT_DoTypeInfo(
2102     TLBContext *pcx,
2103     int count,
2104     ITypeLibImpl * pLibInfo)
2105 {
2106     MSFT_TypeInfoBase tiBase;
2107     ITypeInfoImpl *ptiRet;
2108
2109     TRACE_(typelib)("count=%u\n", count);
2110
2111     ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
2112     MSFT_ReadLEDWords(&tiBase, sizeof(tiBase) ,pcx ,
2113                       pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
2114
2115 /* this is where we are coming from */
2116     ptiRet->pTypeLib = pLibInfo;
2117     ptiRet->index=count;
2118 /* fill in the typeattr fields */
2119
2120     MSFT_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
2121     ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid;   /* FIXME: correct? */
2122     ptiRet->TypeAttr.lpstrSchema=NULL;              /* reserved */
2123     ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
2124     ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
2125     ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
2126     ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
2127     ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
2128     ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
2129     ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
2130     ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
2131     ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
2132     ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
2133     if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
2134         MSFT_GetTdesc(pcx, tiBase.datatype1,
2135             &ptiRet->TypeAttr.tdescAlias, ptiRet);
2136
2137 /*  FIXME: */
2138 /*    IDLDESC  idldescType; *//* never saw this one != zero  */
2139
2140 /* name, eventually add to a hash table */
2141     ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
2142     ptiRet->hreftype = MSFT_ReadHreftype(pcx, tiBase.NameOffset);
2143     TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
2144     /* help info */
2145     ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
2146     ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
2147     ptiRet->dwHelpContext=tiBase.helpcontext;
2148
2149     if (ptiRet->TypeAttr.typekind == TKIND_MODULE)
2150         ptiRet->DllName = MSFT_ReadString(pcx, tiBase.datatype1);
2151
2152 /* note: InfoType's Help file and HelpStringDll come from the containing
2153  * library. Further HelpString and Docstring appear to be the same thing :(
2154  */
2155     /* functions */
2156     if(ptiRet->TypeAttr.cFuncs >0 )
2157         MSFT_DoFuncs(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2158                     ptiRet->TypeAttr.cVars,
2159                     tiBase.memoffset, & ptiRet->funclist);
2160     /* variables */
2161     if(ptiRet->TypeAttr.cVars >0 )
2162         MSFT_DoVars(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2163                    ptiRet->TypeAttr.cVars,
2164                    tiBase.memoffset, & ptiRet->varlist);
2165     if(ptiRet->TypeAttr.cImplTypes >0 ) {
2166         switch(ptiRet->TypeAttr.typekind)
2167         {
2168         case TKIND_COCLASS:
2169             MSFT_DoImplTypes(pcx, ptiRet, ptiRet->TypeAttr.cImplTypes ,
2170                 tiBase.datatype1);
2171             break;
2172         case TKIND_DISPATCH:
2173             /* This is not -1 when the interface is a non-base dual interface or
2174                when a dispinterface wraps an interface ie the idl 'dispinterface x {interface y;};'.
2175                Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
2176                not this interface.
2177             */
2178
2179             if (tiBase.datatype1 != -1)
2180             {
2181                 ptiRet->impltypelist = TLB_Alloc(sizeof(TLBImplType));
2182                 ptiRet->impltypelist->hRef = tiBase.datatype1;
2183                 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2184             }
2185           break;
2186         default:
2187             ptiRet->impltypelist=TLB_Alloc(sizeof(TLBImplType));
2188             MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2189             ptiRet->impltypelist->hRef = tiBase.datatype1;
2190             break;
2191        }
2192     }
2193     ptiRet->ctCustData=
2194         MSFT_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
2195
2196     TRACE_(typelib)("%s guid: %s kind:%s\n",
2197        debugstr_w(ptiRet->Name),
2198        debugstr_guid(&ptiRet->TypeAttr.guid),
2199        typekind_desc[ptiRet->TypeAttr.typekind]);
2200
2201     return ptiRet;
2202 }
2203
2204 /* Because type library parsing has some degree of overhead, and some apps repeatedly load the same
2205  * typelibs over and over, we cache them here. According to MSDN Microsoft have a similar scheme in
2206  * place. This will cause a deliberate memory leak, but generally losing RAM for cycles is an acceptable
2207  * tradeoff here.
2208  */
2209 static ITypeLibImpl *tlb_cache_first;
2210 static CRITICAL_SECTION cache_section;
2211 static CRITICAL_SECTION_DEBUG cache_section_debug =
2212 {
2213     0, 0, &cache_section,
2214     { &cache_section_debug.ProcessLocksList, &cache_section_debug.ProcessLocksList },
2215       0, 0, { (DWORD_PTR)(__FILE__ ": typelib loader cache") }
2216 };
2217 static CRITICAL_SECTION cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 };
2218
2219
2220 typedef struct TLB_PEFile
2221 {
2222     const IUnknownVtbl *lpvtbl;
2223     LONG refs;
2224     HMODULE dll;
2225     HRSRC typelib_resource;
2226     HGLOBAL typelib_global;
2227     LPVOID typelib_base;
2228 } TLB_PEFile;
2229
2230 static HRESULT WINAPI TLB_PEFile_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2231 {
2232     if (IsEqualIID(riid, &IID_IUnknown))
2233     {
2234         *ppv = iface;
2235         IUnknown_AddRef(iface);
2236         return S_OK;
2237     }
2238     *ppv = NULL;
2239     return E_NOINTERFACE;
2240 }
2241
2242 static ULONG WINAPI TLB_PEFile_AddRef(IUnknown *iface)
2243 {
2244     TLB_PEFile *This = (TLB_PEFile *)iface;
2245     return InterlockedIncrement(&This->refs);
2246 }
2247
2248 static ULONG WINAPI TLB_PEFile_Release(IUnknown *iface)
2249 {
2250     TLB_PEFile *This = (TLB_PEFile *)iface;
2251     ULONG refs = InterlockedDecrement(&This->refs);
2252     if (!refs)
2253     {
2254         if (This->typelib_global)
2255             FreeResource(This->typelib_global);
2256         if (This->dll)
2257             FreeLibrary(This->dll);
2258         HeapFree(GetProcessHeap(), 0, This);
2259     }
2260     return refs;
2261 }
2262
2263 static const IUnknownVtbl TLB_PEFile_Vtable =
2264 {
2265     TLB_PEFile_QueryInterface,
2266     TLB_PEFile_AddRef,
2267     TLB_PEFile_Release
2268 };
2269
2270 static HRESULT TLB_PEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2271 {
2272     TLB_PEFile *This;
2273
2274     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2275     if (!This)
2276         return E_OUTOFMEMORY;
2277
2278     This->lpvtbl = &TLB_PEFile_Vtable;
2279     This->refs = 1;
2280     This->dll = NULL;
2281     This->typelib_resource = NULL;
2282     This->typelib_global = NULL;
2283     This->typelib_base = NULL;
2284
2285     This->dll = LoadLibraryExW(path, 0, DONT_RESOLVE_DLL_REFERENCES |
2286                     LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
2287
2288     if (This->dll)
2289     {
2290         static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
2291         This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
2292         if (This->typelib_resource)
2293         {
2294             This->typelib_global = LoadResource(This->dll, This->typelib_resource);
2295             if (This->typelib_global)
2296             {
2297                 This->typelib_base = LockResource(This->typelib_global);
2298
2299                 if (This->typelib_base)
2300                 {
2301                     *pdwTLBLength = SizeofResource(This->dll, This->typelib_resource);
2302                     *ppBase = This->typelib_base;
2303                     *ppFile = (IUnknown *)&This->lpvtbl;
2304                     return S_OK;
2305                 }
2306             }
2307         }
2308     }
2309
2310     TLB_PEFile_Release((IUnknown *)&This->lpvtbl);
2311     return TYPE_E_CANTLOADLIBRARY;
2312 }
2313
2314
2315 typedef struct TLB_Mapping
2316 {
2317     const IUnknownVtbl *lpvtbl;
2318     LONG refs;
2319     HANDLE file;
2320     HANDLE mapping;
2321     LPVOID typelib_base;
2322 } TLB_Mapping;
2323
2324 static HRESULT WINAPI TLB_Mapping_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2325 {
2326     if (IsEqualIID(riid, &IID_IUnknown))
2327     {
2328         *ppv = iface;
2329         IUnknown_AddRef(iface);
2330         return S_OK;
2331     }
2332     *ppv = NULL;
2333     return E_NOINTERFACE;
2334 }
2335
2336 static ULONG WINAPI TLB_Mapping_AddRef(IUnknown *iface)
2337 {
2338     TLB_Mapping *This = (TLB_Mapping *)iface;
2339     return InterlockedIncrement(&This->refs);
2340 }
2341
2342 static ULONG WINAPI TLB_Mapping_Release(IUnknown *iface)
2343 {
2344     TLB_Mapping *This = (TLB_Mapping *)iface;
2345     ULONG refs = InterlockedDecrement(&This->refs);
2346     if (!refs)
2347     {
2348         if (This->typelib_base)
2349             UnmapViewOfFile(This->typelib_base);
2350         if (This->mapping)
2351             CloseHandle(This->mapping);
2352         if (This->file != INVALID_HANDLE_VALUE)
2353             CloseHandle(This->file);
2354         HeapFree(GetProcessHeap(), 0, This);
2355     }
2356     return refs;
2357 }
2358
2359 static const IUnknownVtbl TLB_Mapping_Vtable =
2360 {
2361     TLB_Mapping_QueryInterface,
2362     TLB_Mapping_AddRef,
2363     TLB_Mapping_Release
2364 };
2365
2366 static HRESULT TLB_Mapping_Open(LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2367 {
2368     TLB_Mapping *This;
2369
2370     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2371     if (!This)
2372         return E_OUTOFMEMORY;
2373
2374     This->lpvtbl = &TLB_Mapping_Vtable;
2375     This->refs = 1;
2376     This->file = INVALID_HANDLE_VALUE;
2377     This->mapping = NULL;
2378     This->typelib_base = NULL;
2379
2380     This->file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2381     if (INVALID_HANDLE_VALUE != This->file)
2382     {
2383         This->mapping = CreateFileMappingW(This->file, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
2384         if (This->mapping)
2385         {
2386             This->typelib_base = MapViewOfFile(This->mapping, FILE_MAP_READ, 0, 0, 0);
2387             if(This->typelib_base)
2388             {
2389                 /* retrieve file size */
2390                 *pdwTLBLength = GetFileSize(This->file, NULL);
2391                 *ppBase = This->typelib_base;
2392                 *ppFile = (IUnknown *)&This->lpvtbl;
2393                 return S_OK;
2394             }
2395         }
2396     }
2397
2398     IUnknown_Release((IUnknown *)&This->lpvtbl);
2399     return TYPE_E_CANTLOADLIBRARY;
2400 }
2401
2402 /****************************************************************************
2403  *      TLB_ReadTypeLib
2404  *
2405  * find the type of the typelib file and map the typelib resource into
2406  * the memory
2407  */
2408 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
2409 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2410 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
2411 {
2412     ITypeLibImpl *entry;
2413     HRESULT ret;
2414     INT index = 1;
2415     LPWSTR index_str, file = (LPWSTR)pszFileName;
2416     LPVOID pBase = NULL;
2417     DWORD dwTLBLength = 0;
2418     IUnknown *pFile = NULL;
2419
2420     *ppTypeLib = NULL;
2421
2422     index_str = strrchrW(pszFileName, '\\');
2423     if(index_str && *++index_str != '\0')
2424     {
2425         LPWSTR end_ptr;
2426         long idx = strtolW(index_str, &end_ptr, 10);
2427         if(*end_ptr == '\0')
2428         {
2429             int str_len = index_str - pszFileName - 1;
2430             index = idx;
2431             file = HeapAlloc(GetProcessHeap(), 0, (str_len + 1) * sizeof(WCHAR));
2432             memcpy(file, pszFileName, str_len * sizeof(WCHAR));
2433             file[str_len] = 0;
2434         }
2435     }
2436
2437     if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
2438     {
2439         if(strchrW(file, '\\'))
2440         {
2441             lstrcpyW(pszPath, file);
2442         }
2443         else
2444         {
2445             int len = GetSystemDirectoryW(pszPath, cchPath);
2446             pszPath[len] = '\\';
2447             memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR));
2448         }
2449     }
2450
2451     if(file != pszFileName) HeapFree(GetProcessHeap(), 0, file);
2452
2453     TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
2454
2455     /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2456     EnterCriticalSection(&cache_section);
2457     for (entry = tlb_cache_first; entry != NULL; entry = entry->next)
2458     {
2459         if (!strcmpiW(entry->path, pszPath) && entry->index == index)
2460         {
2461             TRACE("cache hit\n");
2462             *ppTypeLib = (ITypeLib2*)entry;
2463             ITypeLib_AddRef(*ppTypeLib);
2464             LeaveCriticalSection(&cache_section);
2465             return S_OK;
2466         }
2467     }
2468     LeaveCriticalSection(&cache_section);
2469
2470     /* now actually load and parse the typelib */
2471
2472     ret = TLB_PEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2473     if (ret == TYPE_E_CANTLOADLIBRARY)
2474         ret = TLB_Mapping_Open(pszPath, &pBase, &dwTLBLength, &pFile);
2475     if (SUCCEEDED(ret))
2476     {
2477         if (dwTLBLength >= 4)
2478         {
2479             DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2480             if (dwSignature == MSFT_SIGNATURE)
2481                 *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2482             else if (dwSignature == SLTG_SIGNATURE)
2483                 *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2484             else
2485             {
2486                 FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
2487                 ret = TYPE_E_CANTLOADLIBRARY;
2488             }
2489         }
2490         else
2491             ret = TYPE_E_CANTLOADLIBRARY;
2492         IUnknown_Release(pFile);
2493     }
2494
2495     if(*ppTypeLib) {
2496         ITypeLibImpl *impl = (ITypeLibImpl*)*ppTypeLib;
2497
2498         TRACE("adding to cache\n");
2499         impl->path = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath)+1) * sizeof(WCHAR));
2500         lstrcpyW(impl->path, pszPath);
2501         /* We should really canonicalise the path here. */
2502         impl->index = index;
2503
2504         /* FIXME: check if it has added already in the meantime */
2505         EnterCriticalSection(&cache_section);
2506         if ((impl->next = tlb_cache_first) != NULL) impl->next->prev = impl;
2507         impl->prev = NULL;
2508         tlb_cache_first = impl;
2509         LeaveCriticalSection(&cache_section);
2510         ret = S_OK;
2511     } else
2512         ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
2513
2514     return ret;
2515 }
2516
2517 /*================== ITypeLib(2) Methods ===================================*/
2518
2519 static ITypeLibImpl* TypeLibImpl_Constructor(void)
2520 {
2521     ITypeLibImpl* pTypeLibImpl;
2522
2523     pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
2524     if (!pTypeLibImpl) return NULL;
2525
2526     pTypeLibImpl->lpVtbl = &tlbvt;
2527     pTypeLibImpl->lpVtblTypeComp = &tlbtcvt;
2528     pTypeLibImpl->ref = 1;
2529
2530     list_init(&pTypeLibImpl->ref_list);
2531     pTypeLibImpl->dispatch_href = -1;
2532
2533     return pTypeLibImpl;
2534 }
2535
2536 /****************************************************************************
2537  *      ITypeLib2_Constructor_MSFT
2538  *
2539  * loading an MSFT typelib from an in-memory image
2540  */
2541 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
2542 {
2543     TLBContext cx;
2544     long lPSegDir;
2545     MSFT_Header tlbHeader;
2546     MSFT_SegDir tlbSegDir;
2547     ITypeLibImpl * pTypeLibImpl;
2548
2549     TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
2550
2551     pTypeLibImpl = TypeLibImpl_Constructor();
2552     if (!pTypeLibImpl) return NULL;
2553
2554     /* get pointer to beginning of typelib data */
2555     cx.pos = 0;
2556     cx.oStart=0;
2557     cx.mapping = pLib;
2558     cx.pLibInfo = pTypeLibImpl;
2559     cx.length = dwTLBLength;
2560
2561     /* read header */
2562     MSFT_ReadLEDWords((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
2563     TRACE_(typelib)("header:\n");
2564     TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
2565     if (tlbHeader.magic1 != MSFT_SIGNATURE) {
2566         FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
2567         return NULL;
2568     }
2569     TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
2570
2571     /* there is a small amount of information here until the next important
2572      * part:
2573      * the segment directory . Try to calculate the amount of data */
2574     lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
2575
2576     /* now read the segment directory */
2577     TRACE("read segment directory (at %ld)\n",lPSegDir);
2578     MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
2579     cx.pTblDir = &tlbSegDir;
2580
2581     /* just check two entries */
2582     if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
2583     {
2584         ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
2585         HeapFree(GetProcessHeap(),0,pTypeLibImpl);
2586         return NULL;
2587     }
2588
2589     /* now fill our internal data */
2590     /* TLIBATTR fields */
2591     MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
2592
2593     /*    pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;*/
2594     /* Windows seems to have zero here, is this correct? */
2595     if(SUBLANGID(tlbHeader.lcid) == SUBLANG_NEUTRAL)
2596       pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(tlbHeader.lcid),0),0);
2597     else
2598       pTypeLibImpl->LibAttr.lcid = 0;
2599
2600     pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
2601     pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
2602     pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
2603     pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
2604
2605     /* name, eventually add to a hash table */
2606     pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
2607
2608     /* help info */
2609     pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
2610     pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
2611
2612     if( tlbHeader.varflags & HELPDLLFLAG)
2613     {
2614             int offset;
2615             MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
2616             pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
2617     }
2618
2619     pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
2620
2621     /* custom data */
2622     if(tlbHeader.CustomDataOffset >= 0)
2623     {
2624         pTypeLibImpl->ctCustData = MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
2625     }
2626
2627     /* fill in typedescriptions */
2628     if(tlbSegDir.pTypdescTab.length > 0)
2629     {
2630         int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
2631         INT16 td[4];
2632         pTypeLibImpl->ctTypeDesc = cTD;
2633         pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
2634         MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
2635         for(i=0; i<cTD; )
2636         {
2637             /* FIXME: add several sanity checks here */
2638             pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
2639             if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
2640             {
2641                 /* FIXME: check safearray */
2642                 if(td[3] < 0)
2643                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
2644                 else
2645                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
2646             }
2647             else if(td[0] == VT_CARRAY)
2648             {
2649                 /* array descr table here */
2650                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
2651             }
2652             else if(td[0] == VT_USERDEFINED)
2653             {
2654                 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
2655             }
2656             if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
2657         }
2658
2659         /* second time around to fill the array subscript info */
2660         for(i=0;i<cTD;i++)
2661         {
2662             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
2663             if(tlbSegDir.pArrayDescriptions.offset>0)
2664             {
2665                 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
2666                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
2667
2668                 if(td[1]<0)
2669                     pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
2670                 else
2671                     pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = stndTypeDesc[td[0]/8];
2672
2673                 pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
2674
2675                 for(j = 0; j<td[2]; j++)
2676                 {
2677                     MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
2678                                       sizeof(INT), &cx, DO_NOT_SEEK);
2679                     MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
2680                                       sizeof(INT), &cx, DO_NOT_SEEK);
2681                 }
2682             }
2683             else
2684             {
2685                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
2686                 ERR("didn't find array description data\n");
2687             }
2688         }
2689     }
2690
2691     /* imported type libs */
2692     if(tlbSegDir.pImpFiles.offset>0)
2693     {
2694         TLBImpLib **ppImpLib = &(pTypeLibImpl->pImpLibs);
2695         int oGuid, offset = tlbSegDir.pImpFiles.offset;
2696         UINT16 size;
2697
2698         while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
2699         {
2700             char *name;
2701             DWORD len;
2702
2703             *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
2704             (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
2705             MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
2706
2707             MSFT_ReadLEDWords(&(*ppImpLib)->lcid,         sizeof(LCID),   &cx, DO_NOT_SEEK);
2708             MSFT_ReadLEWords(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
2709             MSFT_ReadLEWords(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
2710             MSFT_ReadLEWords(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
2711
2712             size >>= 2;
2713             name = TLB_Alloc(size+1);
2714             MSFT_Read(name, size, &cx, DO_NOT_SEEK);
2715             len = MultiByteToWideChar(CP_ACP, 0, name, -1, NULL, 0 );
2716             (*ppImpLib)->name = TLB_Alloc(len * sizeof(WCHAR));
2717             MultiByteToWideChar(CP_ACP, 0, name, -1, (*ppImpLib)->name, len );
2718             TLB_Free(name);
2719
2720             MSFT_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
2721             offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
2722
2723             ppImpLib = &(*ppImpLib)->next;
2724         }
2725     }
2726
2727     pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
2728     if(pTypeLibImpl->dispatch_href != -1)
2729         MSFT_DoRefType(&cx, pTypeLibImpl, pTypeLibImpl->dispatch_href);
2730
2731     /* type info's */
2732     if(tlbHeader.nrtypeinfos >= 0 )
2733     {
2734         /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
2735         ITypeInfoImpl **ppTI = &(pTypeLibImpl->pTypeInfo);
2736         int i;
2737
2738         for(i = 0; i < tlbHeader.nrtypeinfos; i++)
2739         {
2740             *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
2741
2742             ppTI = &((*ppTI)->next);
2743             (pTypeLibImpl->TypeInfoCount)++;
2744         }
2745     }
2746
2747     TRACE("(%p)\n", pTypeLibImpl);
2748     return (ITypeLib2*) pTypeLibImpl;
2749 }
2750
2751
2752 static BSTR TLB_MultiByteToBSTR(const char *ptr)
2753 {
2754     DWORD len;
2755     WCHAR *nameW;
2756     BSTR ret;
2757
2758     len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
2759     nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2760     MultiByteToWideChar(CP_ACP, 0, ptr, -1, nameW, len);
2761     ret = SysAllocString(nameW);
2762     HeapFree(GetProcessHeap(), 0, nameW);
2763     return ret;
2764 }
2765
2766 static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
2767 {
2768   char b[3];
2769   int i;
2770   short s;
2771
2772   if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
2773     FIXME("Can't parse guid %s\n", debugstr_guid(guid));
2774     return FALSE;
2775   }
2776
2777   guid->Data4[0] = s >> 8;
2778   guid->Data4[1] = s & 0xff;
2779
2780   b[2] = '\0';
2781   for(i = 0; i < 6; i++) {
2782     memcpy(b, str + 24 + 2 * i, 2);
2783     guid->Data4[i + 2] = strtol(b, NULL, 16);
2784   }
2785   return TRUE;
2786 }
2787
2788 static WORD SLTG_ReadString(const char *ptr, BSTR *pBstr)
2789 {
2790     WORD bytelen;
2791     DWORD len;
2792     WCHAR *nameW;
2793
2794     *pBstr = NULL;
2795     bytelen = *(const WORD*)ptr;
2796     if(bytelen == 0xffff) return 2;
2797     len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
2798     nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2799     len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, nameW, len);
2800     *pBstr = SysAllocStringLen(nameW, len);
2801     HeapFree(GetProcessHeap(), 0, nameW);
2802     return bytelen + 2;
2803 }
2804
2805 static WORD SLTG_ReadStringA(const char *ptr, char **str)
2806 {
2807     WORD bytelen;
2808
2809     *str = NULL;
2810     bytelen = *(const WORD*)ptr;
2811     if(bytelen == 0xffff) return 2;
2812     *str = HeapAlloc(GetProcessHeap(), 0, bytelen + 1);
2813     memcpy(*str, ptr + 2, bytelen);
2814     (*str)[bytelen] = '\0';
2815     return bytelen + 2;
2816 }
2817
2818 static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
2819 {
2820     char *ptr = pLibBlk;
2821     WORD w;
2822
2823     if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
2824         FIXME("libblk magic = %04x\n", w);
2825         return 0;
2826     }
2827
2828     ptr += 6;
2829     if((w = *(WORD*)ptr) != 0xffff) {
2830         FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
2831         ptr += w;
2832     }
2833     ptr += 2;
2834
2835     ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
2836
2837     ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
2838
2839     pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
2840     ptr += 4;
2841
2842     pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
2843     ptr += 2;
2844
2845     if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
2846         pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
2847     else
2848         pTypeLibImpl->LibAttr.lcid = 0;
2849     ptr += 2;
2850
2851     ptr += 4; /* skip res12 */
2852
2853     pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
2854     ptr += 2;
2855
2856     pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
2857     ptr += 2;
2858
2859     pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
2860     ptr += 2;
2861
2862     memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
2863     ptr += sizeof(GUID);
2864
2865     return ptr - (char*)pLibBlk;
2866 }
2867
2868 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
2869 typedef struct
2870 {
2871     unsigned int num;
2872     HREFTYPE refs[1];
2873 } sltg_ref_lookup_t;
2874
2875 static HRESULT sltg_get_typelib_ref(const sltg_ref_lookup_t *table, DWORD typeinfo_ref,
2876                                     HREFTYPE *typelib_ref)
2877 {
2878     if(typeinfo_ref < table->num)
2879     {
2880         *typelib_ref = table->refs[typeinfo_ref];
2881         return S_OK;
2882     }
2883
2884     ERR("Unable to find reference\n");
2885     *typelib_ref = -1;
2886     return E_FAIL;
2887 }
2888
2889 static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
2890 {
2891     BOOL done = FALSE;
2892
2893     while(!done) {
2894         if((*pType & 0xe00) == 0xe00) {
2895             pTD->vt = VT_PTR;
2896             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2897                                        sizeof(TYPEDESC));
2898             pTD = pTD->u.lptdesc;
2899         }
2900         switch(*pType & 0x3f) {
2901         case VT_PTR:
2902             pTD->vt = VT_PTR;
2903             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2904                                        sizeof(TYPEDESC));
2905             pTD = pTD->u.lptdesc;
2906             break;
2907
2908         case VT_USERDEFINED:
2909             pTD->vt = VT_USERDEFINED;
2910             sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
2911             done = TRUE;
2912             break;
2913
2914         case VT_CARRAY:
2915           {
2916             /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
2917                array */
2918
2919             SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
2920
2921             pTD->vt = VT_CARRAY;
2922             pTD->u.lpadesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2923                                 sizeof(ARRAYDESC) +
2924                                 (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
2925             pTD->u.lpadesc->cDims = pSA->cDims;
2926             memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
2927                    pSA->cDims * sizeof(SAFEARRAYBOUND));
2928
2929             pTD = &pTD->u.lpadesc->tdescElem;
2930             break;
2931           }
2932
2933         case VT_SAFEARRAY:
2934           {
2935             /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
2936                useful? */
2937
2938             pType++;
2939             pTD->vt = VT_SAFEARRAY;
2940             pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2941                                        sizeof(TYPEDESC));
2942             pTD = pTD->u.lptdesc;
2943             break;
2944           }
2945         default:
2946             pTD->vt = *pType & 0x3f;
2947             done = TRUE;
2948             break;
2949         }
2950         pType++;
2951     }
2952     return pType;
2953 }
2954
2955 static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
2956                          ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
2957 {
2958     /* Handle [in/out] first */
2959     if((*pType & 0xc000) == 0xc000)
2960         pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
2961     else if(*pType & 0x8000)
2962         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
2963     else if(*pType & 0x4000)
2964         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
2965     else
2966         pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
2967
2968     if(*pType & 0x2000)
2969         pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
2970
2971     if(*pType & 0x80)
2972         pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
2973
2974     return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
2975 }
2976
2977
2978 static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
2979                         char *pNameTable)
2980 {
2981     int ref;
2982     char *name;
2983     TLBRefType *ref_type;
2984     sltg_ref_lookup_t *table;
2985     HREFTYPE typelib_ref;
2986
2987     if(pRef->magic != SLTG_REF_MAGIC) {
2988         FIXME("Ref magic = %x\n", pRef->magic);
2989         return NULL;
2990     }
2991     name = ( (char*)(&pRef->names) + pRef->number);
2992
2993     table = HeapAlloc(GetProcessHeap(), 0, sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
2994     table->num = pRef->number >> 3;
2995
2996     /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
2997
2998     /* We don't want the first href to be 0 */
2999     typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
3000
3001     for(ref = 0; ref < pRef->number >> 3; ref++) {
3002         char *refname;
3003         unsigned int lib_offs, type_num;
3004
3005         ref_type = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref_type));
3006
3007         name += SLTG_ReadStringA(name, &refname);
3008         if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
3009             FIXME("Can't sscanf ref\n");
3010         if(lib_offs != 0xffff) {
3011             TLBImpLib **import = &pTL->pImpLibs;
3012
3013             while(*import) {
3014                 if((*import)->offset == lib_offs)
3015                     break;
3016                 import = &(*import)->next;
3017             }
3018             if(!*import) {
3019                 char fname[MAX_PATH+1];
3020                 int len;
3021
3022                 *import = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3023                                     sizeof(**import));
3024                 (*import)->offset = lib_offs;
3025                 TLB_GUIDFromString( pNameTable + lib_offs + 4,
3026                                     &(*import)->guid);
3027                 if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
3028                           &(*import)->wVersionMajor,
3029                           &(*import)->wVersionMinor,
3030                           &(*import)->lcid, fname) != 4) {
3031                   FIXME("can't sscanf ref %s\n",
3032                         pNameTable + lib_offs + 40);
3033                 }
3034                 len = strlen(fname);
3035                 if(fname[len-1] != '#')
3036                     FIXME("fname = %s\n", fname);
3037                 fname[len-1] = '\0';
3038                 (*import)->name = TLB_MultiByteToBSTR(fname);
3039             }
3040             ref_type->pImpTLInfo = *import;
3041
3042             /* Store a reference to IDispatch */
3043             if(pTL->dispatch_href == -1 && IsEqualGUID(&(*import)->guid, &IID_StdOle) && type_num == 4)
3044                 pTL->dispatch_href = typelib_ref;
3045
3046         } else { /* internal ref */
3047           ref_type->pImpTLInfo = TLB_REF_INTERNAL;
3048         }
3049         ref_type->reference = typelib_ref;
3050         ref_type->index = type_num;
3051
3052         HeapFree(GetProcessHeap(), 0, refname);
3053         list_add_tail(&pTL->ref_list, &ref_type->entry);
3054
3055         table->refs[ref] = typelib_ref;
3056         typelib_ref += 4;
3057     }
3058     if((BYTE)*name != SLTG_REF_MAGIC)
3059       FIXME("End of ref block magic = %x\n", *name);
3060     dump_TLBRefType(pTL);
3061     return table;
3062 }
3063
3064 static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
3065                           BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
3066 {
3067     SLTG_ImplInfo *info;
3068     TLBImplType **ppImplType = &pTI->impltypelist;
3069     /* I don't really get this structure, usually it's 0x16 bytes
3070        long, but iuser.tlb contains some that are 0x18 bytes long.
3071        That's ok because we can use the next ptr to jump to the next
3072        one. But how do we know the length of the last one?  The WORD
3073        at offs 0x8 might be the clue.  For now I'm just assuming that
3074        the last one is the regular 0x16 bytes. */
3075
3076     info = (SLTG_ImplInfo*)pBlk;
3077     while(1) {
3078         *ppImplType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3079                                 sizeof(**ppImplType));
3080         sltg_get_typelib_ref(ref_lookup, info->ref, &(*ppImplType)->hRef);
3081         (*ppImplType)->implflags = info->impltypeflags;
3082         pTI->TypeAttr.cImplTypes++;
3083         ppImplType = &(*ppImplType)->next;
3084
3085         if(info->next == 0xffff)
3086             break;
3087         if(OneOnly)
3088             FIXME("Interface inheriting more than one interface\n");
3089         info = (SLTG_ImplInfo*)(pBlk + info->next);
3090     }
3091     info++; /* see comment at top of function */
3092     return (char*)info;
3093 }
3094
3095 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
3096                         const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3097 {
3098   TLBVarDesc **ppVarDesc = &pTI->varlist;
3099   BSTR bstrPrevName = NULL;
3100   SLTG_Variable *pItem;
3101   unsigned short i;
3102   WORD *pType;
3103   char buf[300];
3104
3105   for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
3106       pItem = (SLTG_Variable *)(pBlk + pItem->next), i++) {
3107
3108       *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3109                              sizeof(**ppVarDesc));
3110       (*ppVarDesc)->vardesc.memid = pItem->memid;
3111
3112       if (pItem->magic != SLTG_VAR_MAGIC &&
3113           pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
3114           FIXME_(typelib)("var magic = %02x\n", pItem->magic);
3115           return;
3116       }
3117
3118       if (pItem->name == 0xfffe)
3119         (*ppVarDesc)->Name = SysAllocString(bstrPrevName);
3120       else
3121         (*ppVarDesc)->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
3122
3123       TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
3124       TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
3125
3126       if (pItem->flags & 0x40) {
3127         TRACE_(typelib)("VAR_DISPATCH\n");
3128         (*ppVarDesc)->vardesc.varkind = VAR_DISPATCH;
3129       }
3130       else if (pItem->flags & 0x10) {
3131         TRACE_(typelib)("VAR_CONST\n");
3132         (*ppVarDesc)->vardesc.varkind = VAR_CONST;
3133         (*ppVarDesc)->vardesc.u.lpvarValue = HeapAlloc(GetProcessHeap(), 0,
3134                                                        sizeof(VARIANT));
3135         V_VT((*ppVarDesc)->vardesc.u.lpvarValue) = VT_INT;
3136         V_UNION((*ppVarDesc)->vardesc.u.lpvarValue, intVal) =
3137           *(INT*)(pBlk + pItem->byte_offs);
3138       }
3139       else {
3140         TRACE_(typelib)("VAR_PERINSTANCE\n");
3141         (*ppVarDesc)->vardesc.u.oInst = pItem->byte_offs;
3142         (*ppVarDesc)->vardesc.varkind = VAR_PERINSTANCE;
3143       }
3144
3145       if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
3146         (*ppVarDesc)->vardesc.wVarFlags = pItem->varflags;
3147
3148       if (pItem->flags & 0x80)
3149         (*ppVarDesc)->vardesc.wVarFlags |= VARFLAG_FREADONLY;
3150
3151       if(pItem->flags & 0x02)
3152           pType = &pItem->type;
3153       else
3154           pType = (WORD*)(pBlk + pItem->type);
3155
3156       if (pItem->flags & ~0xd2)
3157         FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xd2);
3158
3159       SLTG_DoElem(pType, pBlk,
3160                   &(*ppVarDesc)->vardesc.elemdescVar, ref_lookup);
3161
3162       dump_TypeDesc(&(*ppVarDesc)->vardesc.elemdescVar.tdesc, buf);
3163
3164       bstrPrevName = (*ppVarDesc)->Name;
3165       ppVarDesc = &((*ppVarDesc)->next);
3166   }
3167   pTI->TypeAttr.cVars = cVars;
3168 }
3169
3170 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
3171                          unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3172 {
3173     SLTG_Function *pFunc;
3174     unsigned short i;
3175     TLBFuncDesc **ppFuncDesc = &pTI->funclist;
3176
3177     for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs;
3178         pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++) {
3179
3180         int param;
3181         WORD *pType, *pArg;
3182
3183         *ppFuncDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3184                                 sizeof(**ppFuncDesc));
3185
3186         switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
3187         case SLTG_FUNCTION_MAGIC:
3188             (*ppFuncDesc)->funcdesc.funckind = FUNC_PUREVIRTUAL;
3189             break;
3190         case SLTG_DISPATCH_FUNCTION_MAGIC:
3191             (*ppFuncDesc)->funcdesc.funckind = FUNC_DISPATCH;
3192             break;
3193         case SLTG_STATIC_FUNCTION_MAGIC:
3194             (*ppFuncDesc)->funcdesc.funckind = FUNC_STATIC;
3195             break;
3196         default:
3197             FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
3198             HeapFree(GetProcessHeap(), 0, *ppFuncDesc);
3199             *ppFuncDesc = NULL;
3200             return;
3201         }
3202         (*ppFuncDesc)->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
3203
3204         (*ppFuncDesc)->funcdesc.memid = pFunc->dispid;
3205         (*ppFuncDesc)->funcdesc.invkind = pFunc->inv >> 4;
3206         (*ppFuncDesc)->funcdesc.callconv = pFunc->nacc & 0x7;
3207         (*ppFuncDesc)->funcdesc.cParams = pFunc->nacc >> 3;
3208         (*ppFuncDesc)->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
3209         (*ppFuncDesc)->funcdesc.oVft = pFunc->vtblpos;
3210
3211         if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
3212             (*ppFuncDesc)->funcdesc.wFuncFlags = pFunc->funcflags;
3213
3214         if(pFunc->retnextopt & 0x80)
3215             pType = &pFunc->rettype;
3216         else
3217             pType = (WORD*)(pBlk + pFunc->rettype);
3218
3219         SLTG_DoElem(pType, pBlk, &(*ppFuncDesc)->funcdesc.elemdescFunc, ref_lookup);
3220
3221         (*ppFuncDesc)->funcdesc.lprgelemdescParam =
3222           HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3223                     (*ppFuncDesc)->funcdesc.cParams * sizeof(ELEMDESC));
3224         (*ppFuncDesc)->pParamDesc =
3225           HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3226                     (*ppFuncDesc)->funcdesc.cParams * sizeof(TLBParDesc));
3227
3228         pArg = (WORD*)(pBlk + pFunc->arg_off);
3229
3230         for(param = 0; param < (*ppFuncDesc)->funcdesc.cParams; param++) {
3231             char *paramName = pNameTable + *pArg;
3232             BOOL HaveOffs;
3233             /* If arg type follows then paramName points to the 2nd
3234                letter of the name, else the next WORD is an offset to
3235                the arg type and paramName points to the first letter.
3236                So let's take one char off paramName and see if we're
3237                pointing at an alpha-numeric char.  However if *pArg is
3238                0xffff or 0xfffe then the param has no name, the former
3239                meaning that the next WORD is the type, the latter
3240                meaning that the next WORD is an offset to the type. */
3241
3242             HaveOffs = FALSE;
3243             if(*pArg == 0xffff)
3244                 paramName = NULL;
3245             else if(*pArg == 0xfffe) {
3246                 paramName = NULL;
3247                 HaveOffs = TRUE;
3248             }
3249             else if(paramName[-1] && !isalnum(paramName[-1]))
3250                 HaveOffs = TRUE;
3251
3252             pArg++;
3253
3254             if(HaveOffs) { /* the next word is an offset to type */
3255                 pType = (WORD*)(pBlk + *pArg);
3256                 SLTG_DoElem(pType, pBlk,
3257                             &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3258                 pArg++;
3259             } else {
3260                 if(paramName)
3261                   paramName--;
3262                 pArg = SLTG_DoElem(pArg, pBlk,
3263                                    &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param], ref_lookup);
3264             }
3265
3266             /* Are we an optional param ? */
3267             if((*ppFuncDesc)->funcdesc.cParams - param <=
3268                (*ppFuncDesc)->funcdesc.cParamsOpt)
3269               (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
3270
3271             if(paramName) {
3272                 (*ppFuncDesc)->pParamDesc[param].Name =
3273                   TLB_MultiByteToBSTR(paramName);
3274             }
3275         }
3276
3277         ppFuncDesc = &((*ppFuncDesc)->next);
3278         if(pFunc->next == 0xffff) break;
3279     }
3280     pTI->TypeAttr.cFuncs = cFuncs;
3281 }
3282
3283 static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
3284                                 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3285                                 SLTG_TypeInfoTail *pTITail)
3286 {
3287     char *pFirstItem, *pNextItem;
3288     sltg_ref_lookup_t *ref_lookup = NULL;
3289
3290     if(pTIHeader->href_table != 0xffffffff) {
3291         ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3292                     pNameTable);
3293     }
3294
3295     pFirstItem = pNextItem = pBlk;
3296
3297     if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3298         pNextItem = SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
3299     }
3300     HeapFree(GetProcessHeap(), 0, ref_lookup);
3301 }
3302
3303
3304 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
3305                                   char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3306                                   const SLTG_TypeInfoTail *pTITail)
3307 {
3308     char *pFirstItem, *pNextItem;
3309     sltg_ref_lookup_t *ref_lookup = NULL;
3310
3311     if(pTIHeader->href_table != 0xffffffff) {
3312         ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3313                     pNameTable);
3314     }
3315
3316     pFirstItem = pNextItem = pBlk;
3317
3318     if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3319         pNextItem = SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
3320     }
3321
3322     if (pTITail->funcs_off != 0xffff)
3323         SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3324
3325     HeapFree(GetProcessHeap(), 0, ref_lookup);
3326
3327     if (TRACE_ON(typelib))
3328         dump_TLBFuncDesc(pTI->funclist);
3329 }
3330
3331 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
3332                                const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3333                                const SLTG_TypeInfoTail *pTITail)
3334 {
3335   SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3336 }
3337
3338 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
3339                               char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3340                               const SLTG_TypeInfoTail *pTITail)
3341 {
3342   WORD *pType;
3343   sltg_ref_lookup_t *ref_lookup = NULL;
3344
3345   if (pTITail->simple_alias) {
3346     /* if simple alias, no more processing required */
3347     pTI->TypeAttr.tdescAlias.vt = pTITail->tdescalias_vt;
3348     return;
3349   }
3350
3351   if(pTIHeader->href_table != 0xffffffff) {
3352       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3353                   pNameTable);
3354   }
3355
3356   /* otherwise it is an offset to a type */
3357   pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
3358
3359   SLTG_DoType(pType, pBlk, &pTI->TypeAttr.tdescAlias, ref_lookup);
3360
3361   HeapFree(GetProcessHeap(), 0, ref_lookup);
3362 }
3363
3364 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
3365                                  char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3366                                  const SLTG_TypeInfoTail *pTITail)
3367 {
3368   sltg_ref_lookup_t *ref_lookup = NULL;
3369   if (pTIHeader->href_table != 0xffffffff)
3370       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3371                                   pNameTable);
3372
3373   if (pTITail->vars_off != 0xffff)
3374     SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3375
3376   if (pTITail->funcs_off != 0xffff)
3377     SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3378
3379   /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3380    * of dispinterface functons including the IDispatch ones, so
3381    * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3382   pTI->TypeAttr.cbSizeVft = pTI->TypeAttr.cFuncs * sizeof(void *);
3383
3384   HeapFree(GetProcessHeap(), 0, ref_lookup);
3385   if (TRACE_ON(typelib))
3386       dump_TLBFuncDesc(pTI->funclist);
3387 }
3388
3389 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
3390                              const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3391                              const SLTG_TypeInfoTail *pTITail)
3392 {
3393   SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3394 }
3395
3396 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
3397                                char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3398                                const SLTG_TypeInfoTail *pTITail)
3399 {
3400   sltg_ref_lookup_t *ref_lookup = NULL;
3401   if (pTIHeader->href_table != 0xffffffff)
3402       ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3403                                   pNameTable);
3404
3405   if (pTITail->vars_off != 0xffff)
3406     SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3407
3408   if (pTITail->funcs_off != 0xffff)
3409     SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3410   HeapFree(GetProcessHeap(), 0, ref_lookup);
3411 }
3412
3413 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3414    managable copy of it into this */
3415 typedef struct {
3416   WORD small_no;
3417   char *index_name;
3418   char *other_name;
3419   WORD res1a;
3420   WORD name_offs;
3421   WORD more_bytes;
3422   char *extra;
3423   WORD res20;
3424   DWORD helpcontext;
3425   WORD res26;
3426   GUID uuid;
3427 } SLTG_InternalOtherTypeInfo;
3428
3429 /****************************************************************************
3430  *      ITypeLib2_Constructor_SLTG
3431  *
3432  * loading a SLTG typelib from an in-memory image
3433  */
3434 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
3435 {
3436     ITypeLibImpl *pTypeLibImpl;
3437     SLTG_Header *pHeader;
3438     SLTG_BlkEntry *pBlkEntry;
3439     SLTG_Magic *pMagic;
3440     SLTG_Index *pIndex;
3441     SLTG_Pad9 *pPad9;
3442     LPVOID pBlk, pFirstBlk;
3443     SLTG_LibBlk *pLibBlk;
3444     SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
3445     char *pAfterOTIBlks = NULL;
3446     char *pNameTable, *ptr;
3447     int i;
3448     DWORD len, order;
3449     ITypeInfoImpl **ppTypeInfoImpl;
3450
3451     TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
3452
3453
3454     pTypeLibImpl = TypeLibImpl_Constructor();
3455     if (!pTypeLibImpl) return NULL;
3456
3457     pHeader = pLib;
3458
3459     TRACE_(typelib)("header:\n");
3460     TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
3461           pHeader->nrOfFileBlks );
3462     if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
3463         FIXME("Header type magic 0x%08x not supported.\n",
3464               pHeader->SLTG_magic);
3465         return NULL;
3466     }
3467
3468     /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3469     pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
3470
3471     /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3472     pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
3473
3474     /* Next we have a magic block */
3475     pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
3476
3477     /* Let's see if we're still in sync */
3478     if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
3479               sizeof(SLTG_COMPOBJ_MAGIC))) {
3480         FIXME("CompObj magic = %s\n", pMagic->CompObj_magic);
3481         return NULL;
3482     }
3483     if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
3484               sizeof(SLTG_DIR_MAGIC))) {
3485         FIXME("dir magic = %s\n", pMagic->dir_magic);
3486         return NULL;
3487     }
3488
3489     pIndex = (SLTG_Index*)(pMagic+1);
3490
3491     pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
3492
3493     pFirstBlk = (LPVOID)(pPad9 + 1);
3494
3495     /* We'll set up a ptr to the main library block, which is the last one. */
3496
3497     for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3498           pBlkEntry[order].next != 0;
3499           order = pBlkEntry[order].next - 1, i++) {
3500        pBlk = (char*)pBlk + pBlkEntry[order].len;
3501     }
3502     pLibBlk = pBlk;
3503
3504     len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
3505
3506     /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3507        interspersed */
3508
3509     len += 0x40;
3510
3511     /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3512
3513     pOtherTypeInfoBlks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3514                                    sizeof(*pOtherTypeInfoBlks) *
3515                                    pTypeLibImpl->TypeInfoCount);
3516
3517
3518     ptr = (char*)pLibBlk + len;
3519
3520     for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
3521         WORD w, extra;
3522         len = 0;
3523
3524         pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
3525
3526         w = *(WORD*)(ptr + 2);
3527         if(w != 0xffff) {
3528             len += w;
3529             pOtherTypeInfoBlks[i].index_name = HeapAlloc(GetProcessHeap(),0,
3530                                                          w+1);
3531             memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
3532             pOtherTypeInfoBlks[i].index_name[w] = '\0';
3533         }
3534         w = *(WORD*)(ptr + 4 + len);
3535         if(w != 0xffff) {
3536             TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
3537             len += w;
3538             pOtherTypeInfoBlks[i].other_name = HeapAlloc(GetProcessHeap(),0,
3539                                                          w+1);
3540             memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
3541             pOtherTypeInfoBlks[i].other_name[w] = '\0';
3542         }
3543         pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
3544         pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
3545         extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
3546         if(extra) {
3547             pOtherTypeInfoBlks[i].extra = HeapAlloc(GetProcessHeap(),0,
3548                                                     extra);
3549             memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
3550             len += extra;
3551         }
3552         pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
3553         pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
3554         pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
3555         memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
3556         len += sizeof(SLTG_OtherTypeInfo);
3557         ptr += len;
3558     }
3559
3560     pAfterOTIBlks = ptr;
3561
3562     /* Skip this WORD and get the next DWORD */
3563     len = *(DWORD*)(pAfterOTIBlks + 2);
3564
3565     /* Now add this to pLibBLk look at what we're pointing at and
3566        possibly add 0x20, then add 0x216, sprinkle a bit a magic
3567        dust and we should be pointing at the beginning of the name
3568        table */
3569
3570     pNameTable = (char*)pLibBlk + len;
3571
3572    switch(*(WORD*)pNameTable) {
3573    case 0xffff:
3574        break;
3575    case 0x0200:
3576        pNameTable += 0x20;
3577        break;
3578    default:
3579        FIXME("pNameTable jump = %x\n", *(WORD*)pNameTable);
3580        break;
3581    }
3582
3583     pNameTable += 0x216;
3584
3585     pNameTable += 2;
3586
3587     TRACE("Library name is %s\n", pNameTable + pLibBlk->name);
3588
3589     pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
3590
3591
3592     /* Hopefully we now have enough ptrs set up to actually read in
3593        some TypeInfos.  It's not clear which order to do them in, so
3594        I'll just follow the links along the BlkEntry chain and read
3595        them in the order in which they are in the file */
3596
3597     ppTypeInfoImpl = &(pTypeLibImpl->pTypeInfo);
3598
3599     for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3600         pBlkEntry[order].next != 0;
3601         order = pBlkEntry[order].next - 1, i++) {
3602
3603       SLTG_TypeInfoHeader *pTIHeader;
3604       SLTG_TypeInfoTail *pTITail;
3605       SLTG_MemberHeader *pMemHeader;
3606
3607       if(strcmp(pBlkEntry[order].index_string + (char*)pMagic,
3608                 pOtherTypeInfoBlks[i].index_name)) {
3609         FIXME("Index strings don't match\n");
3610         return NULL;
3611       }
3612
3613       pTIHeader = pBlk;
3614       if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
3615         FIXME("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
3616         return NULL;
3617       }
3618       TRACE("pTIHeader->res06 = %x, pTIHeader->res0e = %x, pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
3619         pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
3620
3621       *ppTypeInfoImpl = (ITypeInfoImpl*)ITypeInfo_Constructor();
3622       (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
3623       (*ppTypeInfoImpl)->index = i;
3624       (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
3625                                              pOtherTypeInfoBlks[i].name_offs +
3626                                              pNameTable);
3627       (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
3628       (*ppTypeInfoImpl)->TypeAttr.guid = pOtherTypeInfoBlks[i].uuid;
3629       (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
3630       (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
3631       (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
3632       (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
3633         (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
3634
3635       if((pTIHeader->typeflags1 & 7) != 2)
3636         FIXME("typeflags1 = %02x\n", pTIHeader->typeflags1);
3637       if(pTIHeader->typeflags3 != 2)
3638         FIXME("typeflags3 = %02x\n", pTIHeader->typeflags3);
3639
3640       TRACE("TypeInfo %s of kind %s guid %s typeflags %04x\n",
3641             debugstr_w((*ppTypeInfoImpl)->Name),
3642             typekind_desc[pTIHeader->typekind],
3643             debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
3644             (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
3645
3646       pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
3647
3648       pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
3649
3650       (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
3651       (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
3652       (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
3653
3654       switch(pTIHeader->typekind) {
3655       case TKIND_ENUM:
3656         SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3657                          pTIHeader, pTITail);
3658         break;
3659
3660       case TKIND_RECORD:
3661         SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3662                            pTIHeader, pTITail);
3663         break;
3664
3665       case TKIND_INTERFACE:
3666         SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3667                               pTIHeader, pTITail);
3668         break;
3669
3670       case TKIND_COCLASS:
3671         SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3672                             pTIHeader, pTITail);
3673         break;
3674
3675       case TKIND_ALIAS:
3676         SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3677                           pTIHeader, pTITail);
3678         break;
3679
3680       case TKIND_DISPATCH:
3681         SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3682                              pTIHeader, pTITail);
3683         break;
3684
3685       case TKIND_MODULE:
3686         SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
3687                            pTIHeader, pTITail);
3688         break;
3689
3690       default:
3691         FIXME("Not processing typekind %d\n", pTIHeader->typekind);
3692         break;
3693
3694       }
3695
3696       if(pTITail) { /* could get cFuncs, cVars and cImplTypes from here
3697                        but we've already set those */
3698 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
3699           X(06);
3700           X(16);
3701           X(18);
3702           X(1a);
3703           X(1e);
3704           X(24);
3705           X(26);
3706           X(2a);
3707           X(2c);
3708           X(2e);
3709           X(30);
3710           X(32);
3711           X(34);
3712       }
3713       ppTypeInfoImpl = &((*ppTypeInfoImpl)->next);
3714       pBlk = (char*)pBlk + pBlkEntry[order].len;
3715     }
3716
3717     if(i != pTypeLibImpl->TypeInfoCount) {
3718       FIXME("Somehow processed %d TypeInfos\n", i);
3719       return NULL;
3720     }
3721
3722     HeapFree(GetProcessHeap(), 0, pOtherTypeInfoBlks);
3723     return (ITypeLib2*)pTypeLibImpl;
3724 }
3725
3726 /* ITypeLib::QueryInterface
3727  */
3728 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
3729         ITypeLib2 * iface,
3730         REFIID riid,
3731         VOID **ppvObject)
3732 {
3733     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3734
3735     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
3736
3737     *ppvObject=NULL;
3738     if(IsEqualIID(riid, &IID_IUnknown) ||
3739        IsEqualIID(riid,&IID_ITypeLib)||
3740        IsEqualIID(riid,&IID_ITypeLib2))
3741     {
3742         *ppvObject = This;
3743     }
3744
3745     if(*ppvObject)
3746     {
3747         ITypeLib2_AddRef(iface);
3748         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
3749         return S_OK;
3750     }
3751     TRACE("-- Interface: E_NOINTERFACE\n");
3752     return E_NOINTERFACE;
3753 }
3754
3755 /* ITypeLib::AddRef
3756  */
3757 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
3758 {
3759     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3760     ULONG ref = InterlockedIncrement(&This->ref);
3761
3762     TRACE("(%p)->ref was %u\n",This, ref - 1);
3763
3764     return ref;
3765 }
3766
3767 /* ITypeLib::Release
3768  */
3769 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
3770 {
3771     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3772     ULONG ref = InterlockedDecrement(&This->ref);
3773
3774     TRACE("(%p)->(%u)\n",This, ref);
3775
3776     if (!ref)
3777     {
3778       TLBImpLib *pImpLib, *pImpLibNext;
3779       TLBCustData *pCustData, *pCustDataNext;
3780       TLBRefType *ref_type;
3781       void *cursor2;
3782       int i;
3783
3784       /* remove cache entry */
3785       if(This->path)
3786       {
3787           TRACE("removing from cache list\n");
3788           EnterCriticalSection(&cache_section);
3789           if (This->next) This->next->prev = This->prev;
3790           if (This->prev) This->prev->next = This->next;
3791           else tlb_cache_first = This->next;
3792           LeaveCriticalSection(&cache_section);
3793           HeapFree(GetProcessHeap(), 0, This->path);
3794       }
3795       TRACE(" destroying ITypeLib(%p)\n",This);
3796
3797       if (This->Name)
3798       {
3799           SysFreeString(This->Name);
3800           This->Name = NULL;
3801       }
3802
3803       if (This->DocString)
3804       {
3805           SysFreeString(This->DocString);
3806           This->DocString = NULL;
3807       }
3808
3809       if (This->HelpFile)
3810       {
3811           SysFreeString(This->HelpFile);
3812           This->HelpFile = NULL;
3813       }
3814
3815       if (This->HelpStringDll)
3816       {
3817           SysFreeString(This->HelpStringDll);
3818           This->HelpStringDll = NULL;
3819       }
3820
3821       for (pCustData = This->pCustData; pCustData; pCustData = pCustDataNext)
3822       {
3823           VariantClear(&pCustData->data);
3824
3825           pCustDataNext = pCustData->next;
3826           TLB_Free(pCustData);
3827       }
3828
3829       for (i = 0; i < This->ctTypeDesc; i++)
3830           if (This->pTypeDesc[i].vt == VT_CARRAY)
3831               TLB_Free(This->pTypeDesc[i].u.lpadesc);
3832
3833       TLB_Free(This->pTypeDesc);
3834
3835       for (pImpLib = This->pImpLibs; pImpLib; pImpLib = pImpLibNext)
3836       {
3837           if (pImpLib->pImpTypeLib)
3838               ITypeLib_Release((ITypeLib *)pImpLib->pImpTypeLib);
3839           TLB_Free(pImpLib->name);
3840
3841           pImpLibNext = pImpLib->next;
3842           TLB_Free(pImpLib);
3843       }
3844
3845       LIST_FOR_EACH_ENTRY_SAFE(ref_type, cursor2, &This->ref_list, TLBRefType, entry)
3846       {
3847           list_remove(&ref_type->entry);
3848           TLB_Free(ref_type);
3849       }
3850
3851       if (This->pTypeInfo) /* can be NULL */
3852           ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
3853       HeapFree(GetProcessHeap(),0,This);
3854       return 0;
3855     }
3856
3857     return ref;
3858 }
3859
3860 /* ITypeLib::GetTypeInfoCount
3861  *
3862  * Returns the number of type descriptions in the type library
3863  */
3864 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
3865 {
3866     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3867     TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
3868     return This->TypeInfoCount;
3869 }
3870
3871 /* ITypeLib::GetTypeInfo
3872  *
3873  * retrieves the specified type description in the library.
3874  */
3875 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
3876     ITypeLib2 *iface,
3877     UINT index,
3878     ITypeInfo **ppTInfo)
3879 {
3880     int i;
3881
3882     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3883     ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
3884
3885     TRACE("(%p)->(index=%d)\n", This, index);
3886
3887     if (!ppTInfo) return E_INVALIDARG;
3888
3889     /* search element n in list */
3890     for(i=0; i < index; i++)
3891     {
3892       pTypeInfo = pTypeInfo->next;
3893       if (!pTypeInfo)
3894       {
3895         TRACE("-- element not found\n");
3896         return TYPE_E_ELEMENTNOTFOUND;
3897       }
3898     }
3899
3900     *ppTInfo = (ITypeInfo *) pTypeInfo;
3901
3902     ITypeInfo_AddRef(*ppTInfo);
3903     TRACE("-- found (%p)\n",*ppTInfo);
3904     return S_OK;
3905 }
3906
3907
3908 /* ITypeLibs::GetTypeInfoType
3909  *
3910  * Retrieves the type of a type description.
3911  */
3912 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
3913     ITypeLib2 *iface,
3914     UINT index,
3915     TYPEKIND *pTKind)
3916 {
3917     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3918     int i;
3919     ITypeInfoImpl *pTInfo = This->pTypeInfo;
3920
3921     if (ITypeLib2_fnGetTypeInfoCount(iface) < index + 1)
3922          return TYPE_E_ELEMENTNOTFOUND;
3923
3924     TRACE("(%p) index %d\n", This, index);
3925
3926     if(!pTKind) return E_INVALIDARG;
3927
3928     /* search element n in list */
3929     for(i=0; i < index; i++)
3930     {
3931       if(!pTInfo)
3932       {
3933         TRACE("-- element not found\n");
3934         return TYPE_E_ELEMENTNOTFOUND;
3935       }
3936       pTInfo = pTInfo->next;
3937     }
3938
3939     *pTKind = pTInfo->TypeAttr.typekind;
3940     TRACE("-- found Type (%d)\n", *pTKind);
3941     return S_OK;
3942 }
3943
3944 /* ITypeLib::GetTypeInfoOfGuid
3945  *
3946  * Retrieves the type description that corresponds to the specified GUID.
3947  *
3948  */
3949 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
3950     ITypeLib2 *iface,
3951     REFGUID guid,
3952     ITypeInfo **ppTInfo)
3953 {
3954     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3955     ITypeInfoImpl *pTypeInfo = This->pTypeInfo; /* head of list */
3956
3957     TRACE("(%p)\n\tguid:\t%s)\n",This,debugstr_guid(guid));
3958
3959     if (!pTypeInfo)
3960     {
3961         WARN("-- element not found\n");
3962         return TYPE_E_ELEMENTNOTFOUND;
3963     }
3964
3965     /* search linked list for guid */
3966     while( !IsEqualIID(guid,&pTypeInfo->TypeAttr.guid) )
3967     {
3968       pTypeInfo = pTypeInfo->next;
3969
3970       if (!pTypeInfo)
3971       {
3972         /* end of list reached */
3973         WARN("-- element not found\n");
3974         return TYPE_E_ELEMENTNOTFOUND;
3975       }
3976     }
3977
3978     TRACE("-- found (%p, %s)\n",
3979           pTypeInfo,
3980           debugstr_w(pTypeInfo->Name));
3981
3982     *ppTInfo = (ITypeInfo*)pTypeInfo;
3983     ITypeInfo_AddRef(*ppTInfo);
3984     return S_OK;
3985 }
3986
3987 /* ITypeLib::GetLibAttr
3988  *
3989  * Retrieves the structure that contains the library's attributes.
3990  *
3991  */
3992 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
3993         ITypeLib2 *iface,
3994         LPTLIBATTR *ppTLibAttr)
3995 {
3996     ITypeLibImpl *This = (ITypeLibImpl *)iface;
3997     TRACE("(%p)\n",This);
3998     *ppTLibAttr = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppTLibAttr));
3999     **ppTLibAttr = This->LibAttr;
4000     return S_OK;
4001 }
4002
4003 /* ITypeLib::GetTypeComp
4004  *
4005  * Enables a client compiler to bind to a library's types, variables,
4006  * constants, and global functions.
4007  *
4008  */
4009 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4010         ITypeLib2 *iface,
4011         ITypeComp **ppTComp)
4012 {
4013     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4014
4015     TRACE("(%p)->(%p)\n",This,ppTComp);
4016     *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4017     ITypeComp_AddRef(*ppTComp);
4018
4019     return S_OK;
4020 }
4021
4022 /* ITypeLib::GetDocumentation
4023  *
4024  * Retrieves the library's documentation string, the complete Help file name
4025  * and path, and the context identifier for the library Help topic in the Help
4026  * file.
4027  *
4028  * On a successful return all non-null BSTR pointers will have been set,
4029  * possibly to NULL.
4030  */
4031 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4032     ITypeLib2 *iface,
4033     INT index,
4034     BSTR *pBstrName,
4035     BSTR *pBstrDocString,
4036     DWORD *pdwHelpContext,
4037     BSTR *pBstrHelpFile)
4038 {
4039     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4040
4041     HRESULT result = E_INVALIDARG;
4042
4043     ITypeInfo *pTInfo;
4044
4045
4046     TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
4047         This, index,
4048         pBstrName, pBstrDocString,
4049         pdwHelpContext, pBstrHelpFile);
4050
4051     if(index<0)
4052     {
4053         /* documentation for the typelib */
4054         if(pBstrName)
4055         {
4056             if (This->Name)
4057             {
4058                 if(!(*pBstrName = SysAllocString(This->Name)))
4059                     goto memerr1;
4060             }
4061             else
4062                 *pBstrName = NULL;
4063         }
4064         if(pBstrDocString)
4065         {
4066             if (This->DocString)
4067             {
4068                 if(!(*pBstrDocString = SysAllocString(This->DocString)))
4069                     goto memerr2;
4070             }
4071             else if (This->Name)
4072             {
4073                 if(!(*pBstrDocString = SysAllocString(This->Name)))
4074                     goto memerr2;
4075             }
4076             else
4077                 *pBstrDocString = NULL;
4078         }
4079         if(pdwHelpContext)
4080         {
4081             *pdwHelpContext = This->dwHelpContext;
4082         }
4083         if(pBstrHelpFile)
4084         {
4085             if (This->HelpFile)
4086             {
4087                 if(!(*pBstrHelpFile = SysAllocString(This->HelpFile)))
4088                     goto memerr3;
4089             }
4090             else
4091                 *pBstrHelpFile = NULL;
4092         }
4093
4094         result = S_OK;
4095     }
4096     else
4097     {
4098         /* for a typeinfo */
4099         result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
4100
4101         if(SUCCEEDED(result))
4102         {
4103             result = ITypeInfo_GetDocumentation(pTInfo,
4104                                           MEMBERID_NIL,
4105                                           pBstrName,
4106                                           pBstrDocString,
4107                                           pdwHelpContext, pBstrHelpFile);
4108
4109             ITypeInfo_Release(pTInfo);
4110         }
4111     }
4112     return result;
4113 memerr3:
4114     if (pBstrDocString) SysFreeString (*pBstrDocString);
4115 memerr2:
4116     if (pBstrName) SysFreeString (*pBstrName);
4117 memerr1:
4118     return STG_E_INSUFFICIENTMEMORY;
4119 }
4120
4121 /* ITypeLib::IsName
4122  *
4123  * Indicates whether a passed-in string contains the name of a type or member
4124  * described in the library.
4125  *
4126  */
4127 static HRESULT WINAPI ITypeLib2_fnIsName(
4128         ITypeLib2 *iface,
4129         LPOLESTR szNameBuf,
4130         ULONG lHashVal,
4131         BOOL *pfName)
4132 {
4133     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4134     ITypeInfoImpl *pTInfo;
4135     TLBFuncDesc *pFInfo;
4136     TLBVarDesc *pVInfo;
4137     int i;
4138     UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
4139
4140     TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
4141           pfName);
4142
4143     *pfName=TRUE;
4144     for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
4145         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4146         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
4147             if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4148             for(i=0;i<pFInfo->funcdesc.cParams;i++)
4149                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name, nNameBufLen))
4150                     goto ITypeLib2_fnIsName_exit;
4151         }
4152         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
4153             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4154
4155     }
4156     *pfName=FALSE;
4157
4158 ITypeLib2_fnIsName_exit:
4159     TRACE("(%p)slow! search for %s: %s found!\n", This,
4160           debugstr_w(szNameBuf), *pfName?"NOT":"");
4161
4162     return S_OK;
4163 }
4164
4165 /* ITypeLib::FindName
4166  *
4167  * Finds occurrences of a type description in a type library. This may be used
4168  * to quickly verify that a name exists in a type library.
4169  *
4170  */
4171 static HRESULT WINAPI ITypeLib2_fnFindName(
4172         ITypeLib2 *iface,
4173         LPOLESTR szNameBuf,
4174         ULONG lHashVal,
4175         ITypeInfo **ppTInfo,
4176         MEMBERID *rgMemId,
4177         UINT16 *pcFound)
4178 {
4179     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4180     ITypeInfoImpl *pTInfo;
4181     TLBFuncDesc *pFInfo;
4182     TLBVarDesc *pVInfo;
4183     int i,j = 0;
4184     UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR);
4185
4186     for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
4187         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4188         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
4189             if(!memcmp(szNameBuf,pFInfo->Name,nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4190             for(i=0;i<pFInfo->funcdesc.cParams;i++) {
4191                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name,nNameBufLen))
4192                     goto ITypeLib2_fnFindName_exit;
4193             }
4194         }
4195         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
4196             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
4197         continue;
4198 ITypeLib2_fnFindName_exit:
4199         ITypeInfo_AddRef((ITypeInfo*)pTInfo);
4200         ppTInfo[j]=(LPTYPEINFO)pTInfo;
4201         j++;
4202     }
4203     TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
4204           This, *pcFound, debugstr_w(szNameBuf), j);
4205
4206     *pcFound=j;
4207
4208     return S_OK;
4209 }
4210
4211 /* ITypeLib::ReleaseTLibAttr
4212  *
4213  * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4214  *
4215  */
4216 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
4217         ITypeLib2 *iface,
4218         TLIBATTR *pTLibAttr)
4219 {
4220     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4221     TRACE("freeing (%p)\n",This);
4222     HeapFree(GetProcessHeap(),0,pTLibAttr);
4223
4224 }
4225
4226 /* ITypeLib2::GetCustData
4227  *
4228  * gets the custom data
4229  */
4230 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4231         ITypeLib2 * iface,
4232         REFGUID guid,
4233         VARIANT *pVarVal)
4234 {
4235     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4236     TLBCustData *pCData;
4237
4238     for(pCData=This->pCustData; pCData; pCData = pCData->next)
4239     {
4240       if( IsEqualIID(guid, &pCData->guid)) break;
4241     }
4242
4243     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
4244
4245     if(pCData)
4246     {
4247         VariantInit( pVarVal);
4248         VariantCopy( pVarVal, &pCData->data);
4249         return S_OK;
4250     }
4251     return E_INVALIDARG;  /* FIXME: correct? */
4252 }
4253
4254 /* ITypeLib2::GetLibStatistics
4255  *
4256  * Returns statistics about a type library that are required for efficient
4257  * sizing of hash tables.
4258  *
4259  */
4260 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4261         ITypeLib2 * iface,
4262         ULONG *pcUniqueNames,
4263         ULONG *pcchUniqueNames)
4264 {
4265     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4266
4267     FIXME("(%p): stub!\n", This);
4268
4269     if(pcUniqueNames) *pcUniqueNames=1;
4270     if(pcchUniqueNames) *pcchUniqueNames=1;
4271     return S_OK;
4272 }
4273
4274 /* ITypeLib2::GetDocumentation2
4275  *
4276  * Retrieves the library's documentation string, the complete Help file name
4277  * and path, the localization context to use, and the context ID for the
4278  * library Help topic in the Help file.
4279  *
4280  */
4281 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4282         ITypeLib2 * iface,
4283         INT index,
4284         LCID lcid,
4285         BSTR *pbstrHelpString,
4286         DWORD *pdwHelpStringContext,
4287         BSTR *pbstrHelpStringDll)
4288 {
4289     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4290     HRESULT result;
4291     ITypeInfo *pTInfo;
4292
4293     FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
4294
4295     /* the help string should be obtained from the helpstringdll,
4296      * using the _DLLGetDocumentation function, based on the supplied
4297      * lcid. Nice to do sometime...
4298      */
4299     if(index<0)
4300     {
4301       /* documentation for the typelib */
4302       if(pbstrHelpString)
4303         *pbstrHelpString=SysAllocString(This->DocString);
4304       if(pdwHelpStringContext)
4305         *pdwHelpStringContext=This->dwHelpContext;
4306       if(pbstrHelpStringDll)
4307         *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
4308
4309       result = S_OK;
4310     }
4311     else
4312     {
4313       /* for a typeinfo */
4314       result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
4315
4316       if(SUCCEEDED(result))
4317       {
4318         ITypeInfo2 * pTInfo2;
4319         result = ITypeInfo_QueryInterface(pTInfo,
4320                                           &IID_ITypeInfo2,
4321                                           (LPVOID*) &pTInfo2);
4322
4323         if(SUCCEEDED(result))
4324         {
4325           result = ITypeInfo2_GetDocumentation2(pTInfo2,
4326                                            MEMBERID_NIL,
4327                                            lcid,
4328                                            pbstrHelpString,
4329                                            pdwHelpStringContext,
4330                                            pbstrHelpStringDll);
4331
4332           ITypeInfo2_Release(pTInfo2);
4333         }
4334
4335         ITypeInfo_Release(pTInfo);
4336       }
4337     }
4338     return result;
4339 }
4340
4341 /* ITypeLib2::GetAllCustData
4342  *
4343  * Gets all custom data items for the library.
4344  *
4345  */
4346 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4347         ITypeLib2 * iface,
4348         CUSTDATA *pCustData)
4349 {
4350     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4351     TLBCustData *pCData;
4352     int i;
4353     TRACE("(%p) returning %d items\n", This, This->ctCustData);
4354     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
4355     if(pCustData->prgCustData ){
4356         pCustData->cCustData=This->ctCustData;
4357         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
4358             pCustData->prgCustData[i].guid=pCData->guid;
4359             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
4360         }
4361     }else{
4362         ERR(" OUT OF MEMORY!\n");
4363         return E_OUTOFMEMORY;
4364     }
4365     return S_OK;
4366 }
4367
4368 static const ITypeLib2Vtbl tlbvt = {
4369     ITypeLib2_fnQueryInterface,
4370     ITypeLib2_fnAddRef,
4371     ITypeLib2_fnRelease,
4372     ITypeLib2_fnGetTypeInfoCount,
4373     ITypeLib2_fnGetTypeInfo,
4374     ITypeLib2_fnGetTypeInfoType,
4375     ITypeLib2_fnGetTypeInfoOfGuid,
4376     ITypeLib2_fnGetLibAttr,
4377     ITypeLib2_fnGetTypeComp,
4378     ITypeLib2_fnGetDocumentation,
4379     ITypeLib2_fnIsName,
4380     ITypeLib2_fnFindName,
4381     ITypeLib2_fnReleaseTLibAttr,
4382
4383     ITypeLib2_fnGetCustData,
4384     ITypeLib2_fnGetLibStatistics,
4385     ITypeLib2_fnGetDocumentation2,
4386     ITypeLib2_fnGetAllCustData
4387  };
4388
4389
4390 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
4391 {
4392     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4393
4394     return ITypeLib2_QueryInterface((ITypeLib *)This, riid, ppv);
4395 }
4396
4397 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
4398 {
4399     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4400
4401     return ITypeLib2_AddRef((ITypeLib2 *)This);
4402 }
4403
4404 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
4405 {
4406     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4407
4408     return ITypeLib2_Release((ITypeLib2 *)This);
4409 }
4410
4411 static HRESULT WINAPI ITypeLibComp_fnBind(
4412     ITypeComp * iface,
4413     OLECHAR * szName,
4414     ULONG lHash,
4415     WORD wFlags,
4416     ITypeInfo ** ppTInfo,
4417     DESCKIND * pDescKind,
4418     BINDPTR * pBindPtr)
4419 {
4420     ITypeLibImpl *This = impl_from_ITypeComp(iface);
4421     ITypeInfoImpl *pTypeInfo;
4422
4423     TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4424
4425     *pDescKind = DESCKIND_NONE;
4426     pBindPtr->lptcomp = NULL;
4427     *ppTInfo = NULL;
4428
4429     for (pTypeInfo = This->pTypeInfo; pTypeInfo; pTypeInfo = pTypeInfo->next)
4430     {
4431         TRACE("testing %s\n", debugstr_w(pTypeInfo->Name));
4432
4433         /* FIXME: check wFlags here? */
4434         /* FIXME: we should use a hash table to look this info up using lHash
4435          * instead of an O(n) search */
4436         if ((pTypeInfo->TypeAttr.typekind == TKIND_ENUM) ||
4437             (pTypeInfo->TypeAttr.typekind == TKIND_MODULE))
4438         {
4439             if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name, szName))
4440             {
4441                 *pDescKind = DESCKIND_TYPECOMP;
4442                 pBindPtr->lptcomp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4443                 ITypeComp_AddRef(pBindPtr->lptcomp);
4444                 TRACE("module or enum: %s\n", debugstr_w(szName));
4445                 return S_OK;
4446             }
4447         }
4448
4449         if ((pTypeInfo->TypeAttr.typekind == TKIND_MODULE) ||
4450             (pTypeInfo->TypeAttr.typekind == TKIND_ENUM))
4451         {
4452             ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4453             HRESULT hr;
4454
4455             hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4456             if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
4457             {
4458                 TRACE("found in module or in enum: %s\n", debugstr_w(szName));
4459                 return S_OK;
4460             }
4461         }
4462
4463         if ((pTypeInfo->TypeAttr.typekind == TKIND_COCLASS) &&
4464             (pTypeInfo->TypeAttr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
4465         {
4466             ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4467             HRESULT hr;
4468             ITypeInfo *subtypeinfo;
4469             BINDPTR subbindptr;
4470             DESCKIND subdesckind;
4471
4472             hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
4473                 &subtypeinfo, &subdesckind, &subbindptr);
4474             if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
4475             {
4476                 TYPEDESC tdesc_appobject =
4477                 {
4478                     {
4479                         (TYPEDESC *)pTypeInfo->hreftype
4480                     },
4481                     VT_USERDEFINED
4482                 };
4483                 const VARDESC vardesc_appobject =
4484                 {
4485                     -2,         /* memid */
4486                     NULL,       /* lpstrSchema */
4487                     {
4488                         0       /* oInst */
4489                     },
4490                     {
4491                                 /* ELEMDESC */
4492                         {
4493                                 /* TYPEDESC */
4494                                 {
4495                                     &tdesc_appobject
4496                                 },
4497                                 VT_PTR
4498                         },
4499                     },
4500                     0,          /* wVarFlags */
4501                     VAR_STATIC  /* varkind */
4502                 };
4503
4504                 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
4505
4506                 /* cleanup things filled in by Bind call so we can put our
4507                  * application object data in there instead */
4508                 switch (subdesckind)
4509                 {
4510                 case DESCKIND_FUNCDESC:
4511                     ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
4512                     break;
4513                 case DESCKIND_VARDESC:
4514                     ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
4515                     break;
4516                 default:
4517                     break;
4518                 }
4519                 if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
4520
4521                 if (pTypeInfo->hreftype == -1)
4522                     FIXME("no hreftype for interface %p\n", pTypeInfo);
4523
4524                 hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
4525                 if (FAILED(hr))
4526                     return hr;
4527
4528                 *pDescKind = DESCKIND_IMPLICITAPPOBJ;
4529                 *ppTInfo = (ITypeInfo *)pTypeInfo;
4530                 ITypeInfo_AddRef(*ppTInfo);
4531                 return S_OK;
4532             }
4533         }
4534     }
4535
4536     TRACE("name not found %s\n", debugstr_w(szName));
4537     return S_OK;
4538 }
4539
4540 static HRESULT WINAPI ITypeLibComp_fnBindType(
4541     ITypeComp * iface,
4542     OLECHAR * szName,
4543     ULONG lHash,
4544     ITypeInfo ** ppTInfo,
4545     ITypeComp ** ppTComp)
4546 {
4547     FIXME("(%s, %x, %p, %p): stub\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
4548     return E_NOTIMPL;
4549 }
4550
4551 static const ITypeCompVtbl tlbtcvt =
4552 {
4553
4554     ITypeLibComp_fnQueryInterface,
4555     ITypeLibComp_fnAddRef,
4556     ITypeLibComp_fnRelease,
4557
4558     ITypeLibComp_fnBind,
4559     ITypeLibComp_fnBindType
4560 };
4561
4562 /*================== ITypeInfo(2) Methods ===================================*/
4563 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void)
4564 {
4565     ITypeInfoImpl * pTypeInfoImpl;
4566
4567     pTypeInfoImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeInfoImpl));
4568     if (pTypeInfoImpl)
4569     {
4570       pTypeInfoImpl->lpVtbl = &tinfvt;
4571       pTypeInfoImpl->lpVtblTypeComp = &tcompvt;
4572       pTypeInfoImpl->ref=1;
4573       pTypeInfoImpl->hreftype = -1;
4574       pTypeInfoImpl->TypeAttr.memidConstructor = MEMBERID_NIL;
4575       pTypeInfoImpl->TypeAttr.memidDestructor = MEMBERID_NIL;
4576     }
4577     TRACE("(%p)\n", pTypeInfoImpl);
4578     return (ITypeInfo2*) pTypeInfoImpl;
4579 }
4580
4581 /* ITypeInfo::QueryInterface
4582  */
4583 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
4584         ITypeInfo2 *iface,
4585         REFIID riid,
4586         VOID **ppvObject)
4587 {
4588     ITypeLibImpl *This = (ITypeLibImpl *)iface;
4589
4590     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4591
4592     *ppvObject=NULL;
4593     if(IsEqualIID(riid, &IID_IUnknown) ||
4594             IsEqualIID(riid,&IID_ITypeInfo)||
4595             IsEqualIID(riid,&IID_ITypeInfo2))
4596         *ppvObject = This;
4597
4598     if(*ppvObject){
4599         ITypeInfo_AddRef(iface);
4600         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
4601         return S_OK;
4602     }
4603     TRACE("-- Interface: E_NOINTERFACE\n");
4604     return E_NOINTERFACE;
4605 }
4606
4607 /* ITypeInfo::AddRef
4608  */
4609 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
4610 {
4611     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4612     ULONG ref = InterlockedIncrement(&This->ref);
4613
4614     ITypeLib2_AddRef((ITypeLib2*)This->pTypeLib);
4615
4616     TRACE("(%p)->ref is %u\n",This, ref);
4617     return ref;
4618 }
4619
4620 /* ITypeInfo::Release
4621  */
4622 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
4623 {
4624     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4625     ULONG ref = InterlockedDecrement(&This->ref);
4626
4627     TRACE("(%p)->(%u)\n",This, ref);
4628
4629     if (ref)   {
4630       /* We don't release ITypeLib when ref=0 because
4631          it means that function is called by ITypeLib2_Release */
4632       ITypeLib2_Release((ITypeLib2*)This->pTypeLib);
4633     } else   {
4634       TLBFuncDesc *pFInfo, *pFInfoNext;
4635       TLBVarDesc *pVInfo, *pVInfoNext;
4636       TLBImplType *pImpl, *pImplNext;
4637
4638       TRACE("destroying ITypeInfo(%p)\n",This);
4639
4640       if (This->no_free_data)
4641           goto finish_free;
4642
4643       if (This->Name)
4644       {
4645           SysFreeString(This->Name);
4646           This->Name = 0;
4647       }
4648
4649       if (This->DocString)
4650       {
4651           SysFreeString(This->DocString);
4652           This->DocString = 0;
4653       }
4654
4655       if (This->DllName)
4656       {
4657           SysFreeString(This->DllName);
4658           This->DllName = 0;
4659       }
4660
4661       for (pFInfo = This->funclist; pFInfo; pFInfo = pFInfoNext)
4662       {
4663           UINT i;
4664           for(i = 0;i < pFInfo->funcdesc.cParams; i++)
4665           {
4666               ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[i];
4667               if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4668               {
4669                   VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4670                   TLB_Free(elemdesc->u.paramdesc.pparamdescex);
4671               }
4672               SysFreeString(pFInfo->pParamDesc[i].Name);
4673           }
4674           TLB_Free(pFInfo->funcdesc.lprgelemdescParam);
4675           TLB_Free(pFInfo->pParamDesc);
4676           TLB_FreeCustData(pFInfo->pCustData);
4677           if (HIWORD(pFInfo->Entry) != 0 && pFInfo->Entry != (BSTR)-1)
4678               SysFreeString(pFInfo->Entry);
4679           SysFreeString(pFInfo->HelpString);
4680           SysFreeString(pFInfo->Name);
4681
4682           pFInfoNext = pFInfo->next;
4683           TLB_Free(pFInfo);
4684       }
4685       for (pVInfo = This->varlist; pVInfo; pVInfo = pVInfoNext)
4686       {
4687           if (pVInfo->vardesc.varkind == VAR_CONST)
4688           {
4689               VariantClear(pVInfo->vardesc.u.lpvarValue);
4690               TLB_Free(pVInfo->vardesc.u.lpvarValue);
4691           }
4692           TLB_FreeCustData(pVInfo->pCustData);
4693           SysFreeString(pVInfo->Name);
4694           pVInfoNext = pVInfo->next;
4695           TLB_Free(pVInfo);
4696       }
4697       for(pImpl = This->impltypelist; pImpl; pImpl = pImplNext)
4698       {
4699           TLB_FreeCustData(pImpl->pCustData);
4700           pImplNext = pImpl->next;
4701           TLB_Free(pImpl);
4702       }
4703       TLB_FreeCustData(This->pCustData);
4704
4705 finish_free:
4706       if (This->next)
4707       {
4708         ITypeInfo_Release((ITypeInfo*)This->next);
4709       }
4710
4711       HeapFree(GetProcessHeap(),0,This);
4712       return 0;
4713     }
4714     return ref;
4715 }
4716
4717 /* ITypeInfo::GetTypeAttr
4718  *
4719  * Retrieves a TYPEATTR structure that contains the attributes of the type
4720  * description.
4721  *
4722  */
4723 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
4724         LPTYPEATTR  *ppTypeAttr)
4725 {
4726     const ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4727     SIZE_T size;
4728
4729     TRACE("(%p)\n",This);
4730
4731     size = sizeof(**ppTypeAttr);
4732     if (This->TypeAttr.typekind == TKIND_ALIAS)
4733         size += TLB_SizeTypeDesc(&This->TypeAttr.tdescAlias, FALSE);
4734
4735     *ppTypeAttr = HeapAlloc(GetProcessHeap(), 0, size);
4736     if (!*ppTypeAttr)
4737         return E_OUTOFMEMORY;
4738
4739     **ppTypeAttr = This->TypeAttr;
4740
4741     if (This->TypeAttr.typekind == TKIND_ALIAS)
4742         TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias,
4743             &This->TypeAttr.tdescAlias, (void *)(*ppTypeAttr + 1));
4744
4745     if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
4746         (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / 4; /* This should include all the inherited
4747                                                                  funcs */
4748         (*ppTypeAttr)->cbSizeVft = 28; /* This is always the size of IDispatch's vtbl */
4749         (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
4750     }
4751     return S_OK;
4752 }
4753
4754 /* ITypeInfo::GetTypeComp
4755  *
4756  * Retrieves the ITypeComp interface for the type description, which enables a
4757  * client compiler to bind to the type description's members.
4758  *
4759  */
4760 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
4761         ITypeComp  * *ppTComp)
4762 {
4763     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4764
4765     TRACE("(%p)->(%p)\n", This, ppTComp);
4766
4767     *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4768     ITypeComp_AddRef(*ppTComp);
4769     return S_OK;
4770 }
4771
4772 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
4773 {
4774     SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
4775     if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4776         size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
4777     return size;
4778 }
4779
4780 static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buffer )
4781 {
4782     *dest = *src;
4783     *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
4784     if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4785     {
4786         const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
4787         PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
4788         *buffer += sizeof(PARAMDESCEX);
4789         *pparamdescex_dest = *pparamdescex_src;
4790         VariantInit(&pparamdescex_dest->varDefaultValue);
4791         return VariantCopy(&pparamdescex_dest->varDefaultValue,
4792                            (VARIANTARG *)&pparamdescex_src->varDefaultValue);
4793     }
4794     else
4795         dest->u.paramdesc.pparamdescex = NULL;
4796     return S_OK;
4797 }
4798
4799 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
4800 {
4801     if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
4802         VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
4803 }
4804
4805 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
4806 {
4807     FUNCDESC *dest;
4808     char *buffer;
4809     SIZE_T size = sizeof(*src);
4810     SHORT i;
4811     HRESULT hr;
4812
4813     size += sizeof(*src->lprgscode) * src->cScodes;
4814     size += TLB_SizeElemDesc(&src->elemdescFunc);
4815     for (i = 0; i < src->cParams; i++)
4816     {
4817         size += sizeof(ELEMDESC);
4818         size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
4819     }
4820
4821     dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
4822     if (!dest) return E_OUTOFMEMORY;
4823
4824     *dest = *src;
4825     if (dispinterface)    /* overwrite funckind */
4826         dest->funckind = FUNC_DISPATCH;
4827     buffer = (char *)(dest + 1);
4828
4829     dest->lprgscode = (SCODE *)buffer;
4830     memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
4831     buffer += sizeof(*src->lprgscode) * src->cScodes;
4832
4833     hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
4834     if (FAILED(hr))
4835     {
4836         SysFreeString((BSTR)dest);
4837         return hr;
4838     }
4839
4840     dest->lprgelemdescParam = (ELEMDESC *)buffer;
4841     buffer += sizeof(ELEMDESC) * src->cParams;
4842     for (i = 0; i < src->cParams; i++)
4843     {
4844         hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
4845         if (FAILED(hr))
4846             break;
4847     }
4848     if (FAILED(hr))
4849     {
4850         /* undo the above actions */
4851         for (i = i - 1; i >= 0; i--)
4852             TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
4853         TLB_FreeElemDesc(&dest->elemdescFunc);
4854         SysFreeString((BSTR)dest);
4855         return hr;
4856     }
4857
4858     /* special treatment for dispinterfaces: this makes functions appear
4859      * to return their [retval] value when it is really returning an
4860      * HRESULT */
4861     if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
4862     {
4863         if (dest->cParams &&
4864             (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
4865         {
4866             ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
4867             if (elemdesc->tdesc.vt != VT_PTR)
4868             {
4869                 ERR("elemdesc should have started with VT_PTR instead of:\n");
4870                 if (ERR_ON(ole))
4871                     dump_ELEMDESC(elemdesc);
4872                 return E_UNEXPECTED;
4873             }
4874
4875             /* copy last parameter to the return value. we are using a flat
4876              * buffer so there is no danger of leaking memory in
4877              * elemdescFunc */
4878             dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
4879
4880             /* remove the last parameter */
4881             dest->cParams--;
4882         }
4883         else
4884             /* otherwise this function is made to appear to have no return
4885              * value */
4886             dest->elemdescFunc.tdesc.vt = VT_VOID;
4887
4888     }
4889
4890     *dest_ptr = dest;
4891     return S_OK;
4892 }
4893
4894 HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
4895 {
4896     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4897     const TLBFuncDesc *pFDesc;
4898     int i;
4899
4900     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
4901         ;
4902
4903     if (pFDesc)
4904     {
4905         *ppFuncDesc = &pFDesc->funcdesc;
4906         return S_OK;
4907     }
4908
4909     return TYPE_E_ELEMENTNOTFOUND;
4910 }
4911
4912 /* internal function to make the inherited interfaces' methods appear
4913  * part of the interface */
4914 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
4915     UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
4916 {
4917     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4918     HRESULT hr;
4919     UINT implemented_funcs = 0;
4920
4921     if (funcs)
4922         *funcs = 0;
4923     else
4924         *hrefoffset = DISPATCH_HREF_OFFSET;
4925
4926     if(This->impltypelist)
4927     {
4928         ITypeInfo *pSubTypeInfo;
4929         UINT sub_funcs;
4930
4931         hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
4932         if (FAILED(hr))
4933             return hr;
4934
4935         hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
4936                                                        index,
4937                                                        ppFuncDesc,
4938                                                        &sub_funcs, hrefoffset);
4939         implemented_funcs += sub_funcs;
4940         ITypeInfo_Release(pSubTypeInfo);
4941         if (SUCCEEDED(hr))
4942             return hr;
4943         *hrefoffset += DISPATCH_HREF_OFFSET;
4944     }
4945
4946     if (funcs)
4947         *funcs = implemented_funcs + This->TypeAttr.cFuncs;
4948     else
4949         *hrefoffset = 0;
4950
4951     if (index < implemented_funcs)
4952         return E_INVALIDARG;
4953     return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
4954                                              ppFuncDesc);
4955 }
4956
4957 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
4958 {
4959     TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
4960     while (TRUE)
4961     {
4962         switch (pTypeDesc->vt)
4963         {
4964         case VT_USERDEFINED:
4965             pTypeDesc->u.hreftype += hrefoffset;
4966             return;
4967         case VT_PTR:
4968         case VT_SAFEARRAY:
4969             pTypeDesc = pTypeDesc->u.lptdesc;
4970             break;
4971         case VT_CARRAY:
4972             pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
4973             break;
4974         default:
4975             return;
4976         }
4977     }
4978 }
4979
4980 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc, UINT hrefoffset)
4981 {
4982     SHORT i;
4983     for (i = 0; i < pFuncDesc->cParams; i++)
4984         ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
4985     ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
4986 }
4987
4988 /* ITypeInfo::GetFuncDesc
4989  *
4990  * Retrieves the FUNCDESC structure that contains information about a
4991  * specified function.
4992  *
4993  */
4994 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
4995         LPFUNCDESC  *ppFuncDesc)
4996 {
4997     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
4998     const FUNCDESC *internal_funcdesc;
4999     HRESULT hr;
5000     UINT hrefoffset = 0;
5001
5002     TRACE("(%p) index %d\n", This, index);
5003
5004     if (This->TypeAttr.typekind == TKIND_DISPATCH)
5005         hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
5006                                                        &internal_funcdesc, NULL,
5007                                                        &hrefoffset);
5008     else
5009         hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
5010                                                &internal_funcdesc);
5011     if (FAILED(hr))
5012     {
5013         WARN("description for function %d not found\n", index);
5014         return hr;
5015     }
5016
5017     hr = TLB_AllocAndInitFuncDesc(
5018         internal_funcdesc,
5019         ppFuncDesc,
5020         This->TypeAttr.typekind == TKIND_DISPATCH);
5021
5022     if ((This->TypeAttr.typekind == TKIND_DISPATCH) && hrefoffset)
5023         ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
5024
5025     TRACE("-- 0x%08x\n", hr);
5026     return hr;
5027 }
5028
5029 static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
5030 {
5031     VARDESC *dest;
5032     char *buffer;
5033     SIZE_T size = sizeof(*src);
5034     HRESULT hr;
5035
5036     if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
5037     if (src->varkind == VAR_CONST)
5038         size += sizeof(VARIANT);
5039     size += TLB_SizeElemDesc(&src->elemdescVar);
5040
5041     dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
5042     if (!dest) return E_OUTOFMEMORY;
5043
5044     *dest = *src;
5045     buffer = (char *)(dest + 1);
5046     if (src->lpstrSchema)
5047     {
5048         int len;
5049         dest->lpstrSchema = (LPOLESTR)buffer;
5050         len = strlenW(src->lpstrSchema);
5051         memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
5052         buffer += (len + 1) * sizeof(WCHAR);
5053     }
5054
5055     if (src->varkind == VAR_CONST)
5056     {
5057         HRESULT hr;
5058
5059         dest->u.lpvarValue = (VARIANT *)buffer;
5060         *dest->u.lpvarValue = *src->u.lpvarValue;
5061         buffer += sizeof(VARIANT);
5062         VariantInit(dest->u.lpvarValue);
5063         hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
5064         if (FAILED(hr))
5065         {
5066             SysFreeString((BSTR)dest_ptr);
5067             return hr;
5068         }
5069     }
5070     hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
5071     if (FAILED(hr))
5072     {
5073         if (src->varkind == VAR_CONST)
5074             VariantClear(dest->u.lpvarValue);
5075         SysFreeString((BSTR)dest);
5076         return hr;
5077     }
5078     *dest_ptr = dest;
5079     return S_OK;
5080 }
5081
5082 /* ITypeInfo::GetVarDesc
5083  *
5084  * Retrieves a VARDESC structure that describes the specified variable.
5085  *
5086  */
5087 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
5088         LPVARDESC  *ppVarDesc)
5089 {
5090     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5091     int i;
5092     const TLBVarDesc *pVDesc;
5093
5094     TRACE("(%p) index %d\n", This, index);
5095
5096     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
5097         ;
5098
5099     if (pVDesc)
5100         return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
5101
5102     return E_INVALIDARG;
5103 }
5104
5105 /* ITypeInfo_GetNames
5106  *
5107  * Retrieves the variable with the specified member ID (or the name of the
5108  * property or method and its parameters) that correspond to the specified
5109  * function ID.
5110  */
5111 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
5112         BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames)
5113 {
5114     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5115     const TLBFuncDesc *pFDesc;
5116     const TLBVarDesc *pVDesc;
5117     int i;
5118     TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
5119     for(pFDesc=This->funclist; pFDesc && pFDesc->funcdesc.memid != memid; pFDesc=pFDesc->next);
5120     if(pFDesc)
5121     {
5122       /* function found, now return function and parameter names */
5123       for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
5124       {
5125         if(!i)
5126           *rgBstrNames=SysAllocString(pFDesc->Name);
5127         else
5128           rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
5129       }
5130       *pcNames=i;
5131     }
5132     else
5133     {
5134       for(pVDesc=This->varlist; pVDesc && pVDesc->vardesc.memid != memid; pVDesc=pVDesc->next);
5135       if(pVDesc)
5136       {
5137         *rgBstrNames=SysAllocString(pVDesc->Name);
5138         *pcNames=1;
5139       }
5140       else
5141       {
5142         if(This->impltypelist &&
5143            (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
5144           /* recursive search */
5145           ITypeInfo *pTInfo;
5146           HRESULT result;
5147           result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
5148                                           &pTInfo);
5149           if(SUCCEEDED(result))
5150           {
5151             result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
5152             ITypeInfo_Release(pTInfo);
5153             return result;
5154           }
5155           WARN("Could not search inherited interface!\n");
5156         }
5157         else
5158         {
5159           WARN("no names found\n");
5160         }
5161         *pcNames=0;
5162         return TYPE_E_ELEMENTNOTFOUND;
5163       }
5164     }
5165     return S_OK;
5166 }
5167
5168
5169 /* ITypeInfo::GetRefTypeOfImplType
5170  *
5171  * If a type description describes a COM class, it retrieves the type
5172  * description of the implemented interface types. For an interface,
5173  * GetRefTypeOfImplType returns the type information for inherited interfaces,
5174  * if any exist.
5175  *
5176  */
5177 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
5178         ITypeInfo2 *iface,
5179         UINT index,
5180         HREFTYPE  *pRefType)
5181 {
5182     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5183     int i;
5184     HRESULT hr = S_OK;
5185     const TLBImplType *pImpl = This->impltypelist;
5186
5187     TRACE("(%p) index %d\n", This, index);
5188     if (TRACE_ON(ole)) dump_TypeInfo(This);
5189
5190     if(index==(UINT)-1)
5191     {
5192       /* only valid on dual interfaces;
5193          retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5194       */
5195       if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
5196
5197       if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
5198           This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
5199       {
5200         *pRefType = -1;
5201       }
5202       else
5203       {
5204         hr = TYPE_E_ELEMENTNOTFOUND;
5205       }
5206     }
5207     else if(index == 0 && This->TypeAttr.typekind == TKIND_DISPATCH)
5208     {
5209       /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5210       *pRefType = This->pTypeLib->dispatch_href;
5211     }
5212     else
5213     {
5214       /* get element n from linked list */
5215       for(i=0; pImpl && i<index; i++)
5216       {
5217         pImpl = pImpl->next;
5218       }
5219
5220       if (pImpl)
5221         *pRefType = pImpl->hRef;
5222       else
5223         hr = TYPE_E_ELEMENTNOTFOUND;
5224     }
5225
5226     if(TRACE_ON(ole))
5227     {
5228         if(SUCCEEDED(hr))
5229             TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
5230         else
5231             TRACE("FAILURE -- hresult = 0x%08x\n", hr);
5232     }
5233
5234     return hr;
5235 }
5236
5237 /* ITypeInfo::GetImplTypeFlags
5238  *
5239  * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5240  * or base interface in a type description.
5241  */
5242 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
5243         UINT index, INT  *pImplTypeFlags)
5244 {
5245     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5246     int i;
5247     TLBImplType *pImpl;
5248
5249     TRACE("(%p) index %d\n", This, index);
5250     for(i=0, pImpl=This->impltypelist; i<index && pImpl;
5251         i++, pImpl=pImpl->next)
5252         ;
5253     if(i==index && pImpl){
5254         *pImplTypeFlags=pImpl->implflags;
5255         return S_OK;
5256     }
5257     *pImplTypeFlags=0;
5258     return TYPE_E_ELEMENTNOTFOUND;
5259 }
5260
5261 /* GetIDsOfNames
5262  * Maps between member names and member IDs, and parameter names and
5263  * parameter IDs.
5264  */
5265 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
5266         LPOLESTR  *rgszNames, UINT cNames, MEMBERID  *pMemId)
5267 {
5268     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5269     const TLBFuncDesc *pFDesc;
5270     const TLBVarDesc *pVDesc;
5271     HRESULT ret=S_OK;
5272     int i;
5273
5274     TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
5275             cNames);
5276
5277     /* init out parameters in case of failure */
5278     for (i = 0; i < cNames; i++)
5279         pMemId[i] = MEMBERID_NIL;
5280
5281     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
5282         int j;
5283         if(!lstrcmpiW(*rgszNames, pFDesc->Name)) {
5284             if(cNames) *pMemId=pFDesc->funcdesc.memid;
5285             for(i=1; i < cNames; i++){
5286                 for(j=0; j<pFDesc->funcdesc.cParams; j++)
5287                     if(!lstrcmpiW(rgszNames[i],pFDesc->pParamDesc[j].Name))
5288                             break;
5289                 if( j<pFDesc->funcdesc.cParams)
5290                     pMemId[i]=j;
5291                 else
5292                    ret=DISP_E_UNKNOWNNAME;
5293             };
5294             TRACE("-- 0x%08x\n", ret);
5295             return ret;
5296         }
5297     }
5298     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
5299         if(!lstrcmpiW(*rgszNames, pVDesc->Name)) {
5300             if(cNames) *pMemId=pVDesc->vardesc.memid;
5301             return ret;
5302         }
5303     }
5304     /* not found, see if it can be found in an inherited interface */
5305     if(This->impltypelist) {
5306         /* recursive search */
5307         ITypeInfo *pTInfo;
5308         ret=ITypeInfo_GetRefTypeInfo(iface,
5309                 This->impltypelist->hRef, &pTInfo);
5310         if(SUCCEEDED(ret)){
5311             ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
5312             ITypeInfo_Release(pTInfo);
5313             return ret;
5314         }
5315         WARN("Could not search inherited interface!\n");
5316     } else
5317         WARN("no names found\n");
5318     return DISP_E_UNKNOWNNAME;
5319 }
5320
5321 /* ITypeInfo::Invoke
5322  *
5323  * Invokes a method, or accesses a property of an object, that implements the
5324  * interface described by the type description.
5325  */
5326 DWORD
5327 _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
5328     DWORD res;
5329
5330     if (TRACE_ON(ole)) {
5331         int i;
5332         TRACE("Calling %p(",func);
5333         for (i=0;i<nrargs;i++) TRACE("%08x,",args[i]);
5334         TRACE(")\n");
5335     }
5336
5337     switch (callconv) {
5338     case CC_STDCALL:
5339
5340         switch (nrargs) {
5341         case 0:
5342                 res = func();
5343                 break;
5344         case 1:
5345                 res = func(args[0]);
5346                 break;
5347         case 2:
5348                 res = func(args[0],args[1]);
5349                 break;
5350         case 3:
5351                 res = func(args[0],args[1],args[2]);
5352                 break;
5353         case 4:
5354                 res = func(args[0],args[1],args[2],args[3]);
5355                 break;
5356         case 5:
5357                 res = func(args[0],args[1],args[2],args[3],args[4]);
5358                 break;
5359         case 6:
5360                 res = func(args[0],args[1],args[2],args[3],args[4],args[5]);
5361                 break;
5362         case 7:
5363                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
5364                 break;
5365         case 8:
5366                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7]);
5367                 break;
5368         case 9:
5369                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8]);
5370                 break;
5371         case 10:
5372                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
5373                 break;
5374         case 11:
5375                 res = func(args[0],args[1],args[2],args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
5376                 break;
5377         case 12:
5378                 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]);
5379                 break;
5380         case 13:
5381                 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]);
5382                 break;
5383         case 14:
5384                 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]);
5385                 break;
5386         case 15:
5387                 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]);
5388                 break;
5389         case 16:
5390                 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]);
5391                 break;
5392         case 17:
5393                 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]);
5394                 break;
5395         case 18:
5396                 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]);
5397                 break;
5398         case 19:
5399                 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]);
5400                 break;
5401         case 20:
5402                 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]);
5403                 break;
5404         case 21:
5405                 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]);
5406                 break;
5407         case 22:
5408                 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]);
5409                 break;
5410         case 23:
5411                 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]);
5412                 break;
5413         case 24:
5414                 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]);
5415                 break;
5416         case 25:
5417                 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]);
5418                 break;
5419         case 26:
5420                 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]);
5421                 break;
5422         case 27:
5423                 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]);
5424                 break;
5425         case 28:
5426                 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]);
5427                 break;
5428         case 29:
5429                 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]);
5430                 break;
5431         case 30:
5432                 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]);
5433                 break;
5434         default:
5435                 FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
5436                 res = -1;
5437                 break;
5438         }
5439         break;
5440     default:
5441         FIXME("unsupported calling convention %d\n",callconv);
5442         res = -1;
5443         break;
5444     }
5445     TRACE("returns %08x\n",res);
5446     return res;
5447 }
5448
5449 extern int _argsize(DWORD vt);
5450
5451 static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5452 {
5453     HRESULT hr = S_OK;
5454     ITypeInfo *tinfo2 = NULL;
5455     TYPEATTR *tattr = NULL;
5456
5457     hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
5458     if (hr)
5459     {
5460         ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5461             "hr = 0x%08x\n",
5462               tdesc->u.hreftype, hr);
5463         return hr;
5464     }
5465     hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
5466     if (hr)
5467     {
5468         ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
5469         ITypeInfo_Release(tinfo2);
5470         return hr;
5471     }
5472
5473     switch (tattr->typekind)
5474     {
5475     case TKIND_ENUM:
5476         *vt |= VT_I4;
5477         break;
5478
5479     case TKIND_ALIAS:
5480         tdesc = &tattr->tdescAlias;
5481         hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
5482         break;
5483
5484     case TKIND_INTERFACE:
5485         if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
5486            *vt |= VT_DISPATCH;
5487         else
5488            *vt |= VT_UNKNOWN;
5489         break;
5490
5491     case TKIND_DISPATCH:
5492         *vt |= VT_DISPATCH;
5493         break;
5494
5495     case TKIND_COCLASS:
5496         *vt |= VT_DISPATCH;
5497         break;
5498
5499     case TKIND_RECORD:
5500         FIXME("TKIND_RECORD unhandled.\n");
5501         hr = E_NOTIMPL;
5502         break;
5503
5504     case TKIND_UNION:
5505         FIXME("TKIND_UNION unhandled.\n");
5506         hr = E_NOTIMPL;
5507         break;
5508
5509     default:
5510         FIXME("TKIND %d unhandled.\n",tattr->typekind);
5511         hr = E_NOTIMPL;
5512         break;
5513     }
5514     ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
5515     ITypeInfo_Release(tinfo2);
5516     return hr;
5517 }
5518
5519 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5520 {
5521     HRESULT hr = S_OK;
5522
5523     /* enforce only one level of pointer indirection */
5524     if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
5525     {
5526         tdesc = tdesc->u.lptdesc;
5527
5528         /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5529          * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5530          * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5531         if ((tdesc->vt == VT_USERDEFINED) ||
5532             ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
5533         {
5534             VARTYPE vt_userdefined = 0;
5535             const TYPEDESC *tdesc_userdefined = tdesc;
5536             if (tdesc->vt == VT_PTR)
5537             {
5538                 vt_userdefined = VT_BYREF;
5539                 tdesc_userdefined = tdesc->u.lptdesc;
5540             }
5541             hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
5542             if ((hr == S_OK) &&
5543                 (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
5544                  ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
5545             {
5546                 *vt |= vt_userdefined;
5547                 return S_OK;
5548             }
5549         }
5550         *vt = VT_BYREF;
5551     }
5552
5553     switch (tdesc->vt)
5554     {
5555     case VT_HRESULT:
5556         *vt |= VT_ERROR;
5557         break;
5558     case VT_USERDEFINED:
5559         hr = userdefined_to_variantvt(tinfo, tdesc, vt);
5560         break;
5561     case VT_VOID:
5562     case VT_CARRAY:
5563     case VT_PTR:
5564     case VT_LPSTR:
5565     case VT_LPWSTR:
5566         ERR("cannot convert type %d into variant VT\n", tdesc->vt);
5567         hr = DISP_E_BADVARTYPE;
5568         break;
5569     case VT_SAFEARRAY:
5570         *vt |= VT_ARRAY;
5571         hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
5572         break;
5573     default:
5574         *vt |= tdesc->vt;
5575         break;
5576     }
5577     return hr;
5578 }
5579
5580 /***********************************************************************
5581  *              DispCallFunc (OLEAUT32.@)
5582  *
5583  * Invokes a function of the specifed calling convention, passing the
5584  * specified arguments and returns the result.
5585  *
5586  * PARAMS
5587  *  pvInstance  [I] Optional pointer to the instance whose function to invoke.
5588  *  oVft        [I] The offset in the vtable. See notes.
5589  *  cc          [I] Calling convention of the function to call.
5590  *  vtReturn    [I] The return type of the function.
5591  *  cActuals    [I] Number of parameters.
5592  *  prgvt       [I] The types of the parameters to pass. This is used for sizing only.
5593  *  prgpvarg    [I] The arguments to pass.
5594  *  pvargResult [O] The return value of the function. Can be NULL.
5595  *
5596  * RETURNS
5597  *  Success: S_OK.
5598  *  Failure: HRESULT code.
5599  *
5600  * NOTES
5601  *  The HRESULT return value of this function is not affected by the return
5602  *  value of the user supplied function, which is returned in pvargResult.
5603  *
5604  *  If pvInstance is NULL then a non-object function is to be called and oVft
5605  *  is the address of the function to call.
5606  *
5607  * The cc parameter can be one of the following values:
5608  *|CC_FASTCALL
5609  *|CC_CDECL
5610  *|CC_PASCAL
5611  *|CC_STDCALL
5612  *|CC_FPFASTCALL
5613  *|CC_SYSCALL
5614  *|CC_MPWCDECL
5615  *|CC_MPWPASCAL
5616  *
5617  */
5618 HRESULT WINAPI
5619 DispCallFunc(
5620     void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals,
5621     VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult)
5622 {
5623     int i, argsize, argspos;
5624     DWORD *args;
5625     HRESULT hres;
5626
5627     TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
5628         pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
5629         pvargResult, V_VT(pvargResult));
5630
5631     argsize = 0;
5632     if (pvInstance)
5633         argsize++; /* for This pointer */
5634
5635     for (i=0;i<cActuals;i++)
5636     {
5637         TRACE("arg %d: type %d, size %d\n",i,prgvt[i],_argsize(prgvt[i]));
5638         dump_Variant(prgpvarg[i]);
5639         argsize += _argsize(prgvt[i]);
5640     }
5641     args = HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*argsize);
5642
5643     argspos = 0;
5644     if (pvInstance)
5645     {
5646         args[0] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
5647         argspos++;
5648     }
5649
5650     for (i=0;i<cActuals;i++)
5651     {
5652         VARIANT *arg = prgpvarg[i];
5653         TRACE("Storing arg %d (%d as %d)\n",i,V_VT(arg),prgvt[i]);
5654         if (prgvt[i] == VT_VARIANT)
5655             memcpy(&args[argspos], arg, _argsize(prgvt[i]) * sizeof(DWORD));
5656         else
5657             memcpy(&args[argspos], &V_NONE(arg), _argsize(prgvt[i]) * sizeof(DWORD));
5658         argspos += _argsize(prgvt[i]);
5659     }
5660
5661     if (pvInstance)
5662     {
5663         FARPROC *vtable = *(FARPROC**)pvInstance;
5664         hres = _invoke(vtable[oVft/sizeof(void *)], cc, argsize, args);
5665     }
5666     else
5667         /* if we aren't invoking an object then the function pointer is stored
5668          * in oVft */
5669         hres = _invoke((FARPROC)oVft, cc, argsize, args);
5670
5671     if (pvargResult && (vtReturn != VT_EMPTY))
5672     {
5673         TRACE("Method returned 0x%08x\n",hres);
5674         V_VT(pvargResult) = vtReturn;
5675         V_UI4(pvargResult) = hres;
5676     }
5677
5678     HeapFree(GetProcessHeap(),0,args);
5679     return S_OK;
5680 }
5681
5682 #define INVBUF_ELEMENT_SIZE \
5683     (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
5684 #define INVBUF_GET_ARG_ARRAY(buffer, params) \
5685     ((VARIANTARG *)(buffer))
5686 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
5687     ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
5688 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
5689     ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
5690 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
5691     ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
5692
5693 static HRESULT WINAPI ITypeInfo_fnInvoke(
5694     ITypeInfo2 *iface,
5695     VOID  *pIUnk,
5696     MEMBERID memid,
5697     UINT16 wFlags,
5698     DISPPARAMS  *pDispParams,
5699     VARIANT  *pVarResult,
5700     EXCEPINFO  *pExcepInfo,
5701     UINT  *pArgErr)
5702 {
5703     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5704     int i;
5705     unsigned int var_index;
5706     TYPEKIND type_kind;
5707     HRESULT hres;
5708     const TLBFuncDesc *pFuncInfo;
5709
5710     TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
5711       This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
5712     );
5713
5714     if (!pDispParams)
5715     {
5716         ERR("NULL pDispParams not allowed\n");
5717         return E_INVALIDARG;
5718     }
5719
5720     dump_DispParms(pDispParams);
5721
5722     if (pDispParams->cNamedArgs > pDispParams->cArgs)
5723     {
5724         ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
5725             pDispParams->cNamedArgs, pDispParams->cArgs);
5726         return E_INVALIDARG;
5727     }
5728
5729     /* we do this instead of using GetFuncDesc since it will return a fake
5730      * FUNCDESC for dispinterfaces and we want the real function description */
5731     for (pFuncInfo = This->funclist; pFuncInfo; pFuncInfo=pFuncInfo->next)
5732         if ((memid == pFuncInfo->funcdesc.memid) &&
5733             (wFlags & pFuncInfo->funcdesc.invkind))
5734             break;
5735
5736     if (pFuncInfo) {
5737         const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
5738
5739         if (TRACE_ON(ole))
5740         {
5741             TRACE("invoking:\n");
5742             dump_TLBFuncDescOne(pFuncInfo);
5743         }
5744
5745         switch (func_desc->funckind) {
5746         case FUNC_PUREVIRTUAL:
5747         case FUNC_VIRTUAL: {
5748             void *buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, INVBUF_ELEMENT_SIZE * func_desc->cParams);
5749             VARIANT varresult;
5750             VARIANT retval; /* pointer for storing byref retvals in */
5751             VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
5752             VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
5753             VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
5754             UINT cNamedArgs = pDispParams->cNamedArgs;
5755             DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
5756
5757             hres = S_OK;
5758
5759             if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
5760             {
5761                 if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
5762                 {
5763                     ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
5764                     hres = DISP_E_PARAMNOTFOUND;
5765                     goto func_fail;
5766                 }
5767                 /* ignore the DISPID_PROPERTYPUT named argument from now on */
5768                 cNamedArgs--;
5769                 rgdispidNamedArgs++;
5770             }
5771
5772             if (func_desc->cParamsOpt < 0 && cNamedArgs)
5773             {
5774                 ERR("functions with the vararg attribute do not support named arguments\n");
5775                 hres = DISP_E_NONAMEDARGS;
5776                 goto func_fail;
5777             }
5778
5779             for (i = 0; i < func_desc->cParams; i++)
5780             {
5781                 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
5782                 hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
5783                 if (FAILED(hres))
5784                     goto func_fail;
5785             }
5786
5787             TRACE("changing args\n");
5788             for (i = 0; i < func_desc->cParams; i++)
5789             {
5790                 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5791                 VARIANTARG *src_arg;
5792
5793                 if (cNamedArgs)
5794                 {
5795                     USHORT j;
5796                     src_arg = NULL;
5797                     for (j = 0; j < cNamedArgs; j++)
5798                         if (rgdispidNamedArgs[j] == i)
5799                         {
5800                             src_arg = &pDispParams->rgvarg[j];
5801                             break;
5802                         }
5803                 }
5804                 else
5805                     src_arg = i < pDispParams->cArgs ? &pDispParams->rgvarg[pDispParams->cArgs - 1 - i] : NULL;
5806
5807                 if (wParamFlags & PARAMFLAG_FRETVAL)
5808                 {
5809                     /* under most conditions the caller is not allowed to
5810                      * pass in a dispparam arg in the index of what would be
5811                      * the retval parameter. however, there is an exception
5812                      * where the extra parameter is used in an extra
5813                      * IDispatch::Invoke below */
5814                     if ((i < pDispParams->cArgs) &&
5815                         ((func_desc->cParams != 1) || !pVarResult ||
5816                          !(func_desc->invkind & INVOKE_PROPERTYGET)))
5817                     {
5818                         hres = DISP_E_BADPARAMCOUNT;
5819                         break;
5820                     }
5821
5822                     /* note: this check is placed so that if the caller passes
5823                      * in a VARIANTARG for the retval we just ignore it, like
5824                      * native does */
5825                     if (i == func_desc->cParams - 1)
5826                     {
5827                         VARIANTARG *arg;
5828                         arg = prgpvarg[i] = &rgvarg[i];
5829                         memset(arg, 0, sizeof(*arg));
5830                         V_VT(arg) = rgvt[i];
5831                         memset(&retval, 0, sizeof(retval));
5832                         V_BYREF(arg) = &retval;
5833                     }
5834                     else
5835                     {
5836                         ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
5837                         hres = E_UNEXPECTED;
5838                         break;
5839                     }
5840                 }
5841                 else if (src_arg)
5842                 {
5843                     dump_Variant(src_arg);
5844
5845                     if (rgvt[i] == VT_VARIANT)
5846                         hres = VariantCopy(&rgvarg[i], src_arg);
5847                     else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
5848                     {
5849                         if (rgvt[i] == V_VT(src_arg))
5850                             V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
5851                         else
5852                         {
5853                             VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5854                             hres = VariantCopy(&missing_arg[i], src_arg);
5855                             V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
5856                         }
5857                         V_VT(&rgvarg[i]) = rgvt[i];
5858                     }
5859                     else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
5860                     {
5861                         SAFEARRAY *a;
5862                         SAFEARRAYBOUND bound;
5863                         VARIANT *v;
5864                         LONG j;
5865                         bound.lLbound = 0;
5866                         bound.cElements = pDispParams->cArgs-i;
5867                         if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
5868                         {
5869                             ERR("SafeArrayCreate failed\n");
5870                             break;
5871                         }
5872                         hres = SafeArrayAccessData(a, (LPVOID)&v);
5873                         if (hres != S_OK)
5874                         {
5875                             ERR("SafeArrayAccessData failed with %x\n", hres);
5876                             break;
5877                         }
5878                         for (j = 0; j < bound.cElements; j++)
5879                             VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
5880                         hres = SafeArrayUnaccessData(a);
5881                         if (hres != S_OK)
5882                         {
5883                             ERR("SafeArrayUnaccessData failed with %x\n", hres);
5884                             break;
5885                         }
5886                         V_ARRAY(&rgvarg[i]) = a;
5887                         V_VT(&rgvarg[i]) = rgvt[i];
5888                     }
5889                     else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
5890                     {
5891                         VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
5892                         V_VT(&missing_arg[i]) = V_VT(src_arg);
5893                         hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
5894                         V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
5895                         V_VT(&rgvarg[i]) = rgvt[i];
5896                     }
5897                     else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
5898                     {
5899                         V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
5900                         V_VT(&rgvarg[i]) = rgvt[i];
5901                     }
5902                     else
5903                     {
5904                         /* FIXME: this doesn't work for VT_BYREF arguments if
5905                          * they are not the same type as in the paramdesc */
5906                         V_VT(&rgvarg[i]) = V_VT(src_arg);
5907                         hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
5908                         V_VT(&rgvarg[i]) = rgvt[i];
5909                     }
5910
5911                     if (FAILED(hres))
5912                     {
5913                         ERR("failed to convert param %d to %s%s from %s%s\n", i,
5914                             debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
5915                             debugstr_VT(src_arg), debugstr_VF(src_arg));
5916                         break;
5917                     }
5918                     prgpvarg[i] = &rgvarg[i];
5919                 }
5920                 else if (wParamFlags & PARAMFLAG_FOPT)
5921                 {
5922                     VARIANTARG *arg;
5923                     arg = prgpvarg[i] = &rgvarg[i];
5924                     if (wParamFlags & PARAMFLAG_FHASDEFAULT)
5925                     {
5926                         hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
5927                         if (FAILED(hres))
5928                             break;
5929                     }
5930                     else
5931                     {
5932                         VARIANTARG *missing_arg;
5933                         /* if the function wants a pointer to a variant then
5934                          * set that up, otherwise just pass the VT_ERROR in
5935                          * the argument by value */
5936                         if (rgvt[i] & VT_BYREF)
5937                         {
5938                             missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
5939                             V_VT(arg) = VT_VARIANT | VT_BYREF;
5940                             V_VARIANTREF(arg) = missing_arg;
5941                         }
5942                         else
5943                             missing_arg = arg;
5944                         V_VT(missing_arg) = VT_ERROR;
5945                         V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
5946                     }
5947                 }
5948                 else
5949                 {
5950                     hres = DISP_E_BADPARAMCOUNT;
5951                     break;
5952                 }
5953             }
5954             if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5955
5956             /* VT_VOID is a special case for return types, so it is not
5957              * handled in the general function */
5958             if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
5959                 V_VT(&varresult) = VT_EMPTY;
5960             else
5961             {
5962                 V_VT(&varresult) = 0;
5963                 hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
5964                 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
5965             }
5966
5967             hres = DispCallFunc(pIUnk, func_desc->oVft, func_desc->callconv,
5968                                 V_VT(&varresult), func_desc->cParams, rgvt,
5969                                 prgpvarg, &varresult);
5970
5971             for (i = 0; i < func_desc->cParams; i++)
5972             {
5973                 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
5974                 if (wParamFlags & PARAMFLAG_FRETVAL)
5975                 {
5976                     if (TRACE_ON(ole))
5977                     {
5978                         TRACE("[retval] value: ");
5979                         dump_Variant(prgpvarg[i]);
5980                     }
5981
5982                     if (pVarResult)
5983                     {
5984                         VariantInit(pVarResult);
5985                         /* deref return value */
5986                         hres = VariantCopyInd(pVarResult, prgpvarg[i]);
5987                     }
5988
5989                     /* free data stored in varresult. Note that
5990                      * VariantClear doesn't do what we want because we are
5991                      * working with byref types. */
5992                     /* FIXME: clear safearrays, bstrs, records and
5993                      * variants here too */
5994                     if ((V_VT(prgpvarg[i]) == (VT_UNKNOWN | VT_BYREF)) ||
5995                          (V_VT(prgpvarg[i]) == (VT_DISPATCH | VT_BYREF)))
5996                     {
5997                         if(*V_UNKNOWNREF(prgpvarg[i]))
5998                             IUnknown_Release(*V_UNKNOWNREF(prgpvarg[i]));
5999                     }
6000                     break;
6001                 }
6002                 else if (i < pDispParams->cArgs)
6003                 {
6004                     if (wParamFlags & PARAMFLAG_FOUT)
6005                     {
6006                         VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - i];
6007
6008                         if ((rgvt[i] == VT_BYREF) && (V_VT(arg) != VT_BYREF))
6009                             hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
6010
6011                         if (FAILED(hres))
6012                         {
6013                             ERR("failed to convert param %d to vt %d\n", i,
6014                                 V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - i]));
6015                             break;
6016                         }
6017                     }
6018                     else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
6019                              func_desc->cParamsOpt < 0 &&
6020                              i == func_desc->cParams-1)
6021                     {
6022                         SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
6023                         LONG j, ubound;
6024                         VARIANT *v;
6025                         hres = SafeArrayGetUBound(a, 1, &ubound);
6026                         if (hres != S_OK)
6027                         {
6028                             ERR("SafeArrayGetUBound failed with %x\n", hres);
6029                             break;
6030                         }
6031                         hres = SafeArrayAccessData(a, (LPVOID)&v);
6032                         if (hres != S_OK)
6033                         {
6034                             ERR("SafeArrayAccessData failed with %x\n", hres);
6035                             break;
6036                         }
6037                         for (j = 0; j <= ubound; j++)
6038                             VariantClear(&v[j]);
6039                         hres = SafeArrayUnaccessData(a);
6040                         if (hres != S_OK)
6041                         {
6042                             ERR("SafeArrayUnaccessData failed with %x\n", hres);
6043                             break;
6044                         }
6045                     }
6046                     VariantClear(&rgvarg[i]);
6047                 }
6048                 else if (wParamFlags & PARAMFLAG_FOPT)
6049                 {
6050                     if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6051                         VariantClear(&rgvarg[i]);
6052                 }
6053             }
6054
6055             if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
6056             {
6057                 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
6058                 hres = DISP_E_EXCEPTION;
6059                 if (pExcepInfo)
6060                 {
6061                     IErrorInfo *pErrorInfo;
6062                     pExcepInfo->scode = V_ERROR(&varresult);
6063                     if (GetErrorInfo(0, &pErrorInfo) == S_OK)
6064                     {
6065                         IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
6066                         IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
6067                         IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
6068                         IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
6069
6070                         IErrorInfo_Release(pErrorInfo);
6071                     }
6072                 }
6073             }
6074             if (V_VT(&varresult) != VT_ERROR)
6075             {
6076                 TRACE("varresult value: ");
6077                 dump_Variant(&varresult);
6078
6079                 if (pVarResult)
6080                 {
6081                     VariantClear(pVarResult);
6082                     *pVarResult = varresult;
6083                 }
6084                 else
6085                     VariantClear(&varresult);
6086             }
6087
6088             if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
6089                 (func_desc->invkind & INVOKE_PROPERTYGET) &&
6090                 (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
6091                 (pDispParams->cArgs != 0))
6092             {
6093                 if (V_VT(pVarResult) == VT_DISPATCH)
6094                 {
6095                     IDispatch *pDispatch = V_DISPATCH(pVarResult);
6096                     /* Note: not VariantClear; we still need the dispatch
6097                      * pointer to be valid */
6098                     VariantInit(pVarResult);
6099                     hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
6100                         GetSystemDefaultLCID(), INVOKE_PROPERTYGET,
6101                         pDispParams, pVarResult, pExcepInfo, pArgErr);
6102                     IDispatch_Release(pDispatch);
6103                 }
6104                 else
6105                 {
6106                     VariantClear(pVarResult);
6107                     hres = DISP_E_NOTACOLLECTION;
6108                 }
6109             }
6110
6111 func_fail:
6112             HeapFree(GetProcessHeap(), 0, buffer);
6113             break;
6114         }
6115         case FUNC_DISPATCH:  {
6116            IDispatch *disp;
6117
6118            hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
6119            if (SUCCEEDED(hres)) {
6120                FIXME("Calling Invoke in IDispatch iface. untested!\n");
6121                hres = IDispatch_Invoke(
6122                                      disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
6123                                      pVarResult,pExcepInfo,pArgErr
6124                                      );
6125                if (FAILED(hres))
6126                    FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
6127                IDispatch_Release(disp);
6128            } else
6129                FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
6130            break;
6131         }
6132         default:
6133             FIXME("Unknown function invocation type %d\n", func_desc->funckind);
6134             hres = E_FAIL;
6135             break;
6136         }
6137
6138         TRACE("-- 0x%08x\n", hres);
6139         return hres;
6140
6141     } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
6142         VARDESC *var_desc;
6143
6144         hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
6145         if(FAILED(hres)) return hres;
6146
6147         FIXME("varseek: Found memid, but variable-based invoking not supported\n");
6148         dump_VARDESC(var_desc);
6149         ITypeInfo2_ReleaseVarDesc(iface, var_desc);
6150         return E_NOTIMPL;
6151     }
6152
6153     /* not found, look for it in inherited interfaces */
6154     ITypeInfo2_GetTypeKind(iface, &type_kind);
6155     if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
6156         if(This->impltypelist) {
6157             /* recursive search */
6158             ITypeInfo *pTInfo;
6159             hres = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pTInfo);
6160             if(SUCCEEDED(hres)){
6161                 hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
6162                 ITypeInfo_Release(pTInfo);
6163                 return hres;
6164             }
6165             WARN("Could not search inherited interface!\n");
6166         }
6167     }
6168     ERR("did not find member id %d, flags 0x%x!\n", memid, wFlags);
6169     return DISP_E_MEMBERNOTFOUND;
6170 }
6171
6172 /* ITypeInfo::GetDocumentation
6173  *
6174  * Retrieves the documentation string, the complete Help file name and path,
6175  * and the context ID for the Help topic for a specified type description.
6176  *
6177  * (Can be tested by the Visual Basic Editor in Word for instance.)
6178  */
6179 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
6180         MEMBERID memid, BSTR  *pBstrName, BSTR  *pBstrDocString,
6181         DWORD  *pdwHelpContext, BSTR  *pBstrHelpFile)
6182 {
6183     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6184     const TLBFuncDesc *pFDesc;
6185     const TLBVarDesc *pVDesc;
6186     TRACE("(%p) memid %d Name(%p) DocString(%p)"
6187           " HelpContext(%p) HelpFile(%p)\n",
6188         This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
6189     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6190         if(pBstrName)
6191             *pBstrName=SysAllocString(This->Name);
6192         if(pBstrDocString)
6193             *pBstrDocString=SysAllocString(This->DocString);
6194         if(pdwHelpContext)
6195             *pdwHelpContext=This->dwHelpContext;
6196         if(pBstrHelpFile)
6197             *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
6198         return S_OK;
6199     }else {/* for a member */
6200     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6201         if(pFDesc->funcdesc.memid==memid){
6202           if(pBstrName)
6203             *pBstrName = SysAllocString(pFDesc->Name);
6204           if(pBstrDocString)
6205             *pBstrDocString=SysAllocString(pFDesc->HelpString);
6206           if(pdwHelpContext)
6207             *pdwHelpContext=pFDesc->helpcontext;
6208           return S_OK;
6209         }
6210     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6211         if(pVDesc->vardesc.memid==memid){
6212             if(pBstrName)
6213               *pBstrName = SysAllocString(pVDesc->Name);
6214             if(pBstrDocString)
6215               *pBstrDocString=SysAllocString(pVDesc->HelpString);
6216             if(pdwHelpContext)
6217               *pdwHelpContext=pVDesc->HelpContext;
6218             return S_OK;
6219         }
6220     }
6221
6222     if(This->impltypelist &&
6223        (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
6224         /* recursive search */
6225         ITypeInfo *pTInfo;
6226         HRESULT result;
6227         result = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
6228                                         &pTInfo);
6229         if(SUCCEEDED(result)) {
6230             result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
6231                 pBstrDocString, pdwHelpContext, pBstrHelpFile);
6232             ITypeInfo_Release(pTInfo);
6233             return result;
6234         }
6235         WARN("Could not search inherited interface!\n");
6236     }
6237
6238     WARN("member %d not found\n", memid);
6239     return TYPE_E_ELEMENTNOTFOUND;
6240 }
6241
6242 /*  ITypeInfo::GetDllEntry
6243  *
6244  * Retrieves a description or specification of an entry point for a function
6245  * in a DLL.
6246  */
6247 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
6248         INVOKEKIND invKind, BSTR  *pBstrDllName, BSTR  *pBstrName,
6249         WORD  *pwOrdinal)
6250 {
6251     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6252     const TLBFuncDesc *pFDesc;
6253
6254     TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
6255
6256     if (pBstrDllName) *pBstrDllName = NULL;
6257     if (pBstrName) *pBstrName = NULL;
6258     if (pwOrdinal) *pwOrdinal = 0;
6259
6260     if (This->TypeAttr.typekind != TKIND_MODULE)
6261         return TYPE_E_BADMODULEKIND;
6262
6263     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6264         if(pFDesc->funcdesc.memid==memid){
6265             dump_TypeInfo(This);
6266             if (TRACE_ON(ole))
6267                 dump_TLBFuncDescOne(pFDesc);
6268
6269             if (pBstrDllName)
6270                 *pBstrDllName = SysAllocString(This->DllName);
6271
6272             if (HIWORD(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
6273                 if (pBstrName)
6274                     *pBstrName = SysAllocString(pFDesc->Entry);
6275                 if (pwOrdinal)
6276                     *pwOrdinal = -1;
6277                 return S_OK;
6278             }
6279             if (pBstrName)
6280                 *pBstrName = NULL;
6281             if (pwOrdinal)
6282                 *pwOrdinal = (DWORD)pFDesc->Entry;
6283             return S_OK;
6284         }
6285     return TYPE_E_ELEMENTNOTFOUND;
6286 }
6287
6288 /* internal function to make the inherited interfaces' methods appear
6289  * part of the interface */
6290 static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
6291     HREFTYPE *hRefType, ITypeInfo  **ppTInfo)
6292 {
6293     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6294     HRESULT hr;
6295
6296     TRACE("%p, 0x%x\n", iface, *hRefType);
6297
6298     if (This->impltypelist && (*hRefType & DISPATCH_HREF_MASK))
6299     {
6300         ITypeInfo *pSubTypeInfo;
6301
6302         hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef, &pSubTypeInfo);
6303         if (FAILED(hr))
6304             return hr;
6305
6306         hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
6307                                                   hRefType, ppTInfo);
6308         ITypeInfo_Release(pSubTypeInfo);
6309         if (SUCCEEDED(hr))
6310             return hr;
6311     }
6312     *hRefType -= DISPATCH_HREF_OFFSET;
6313
6314     if (!(*hRefType & DISPATCH_HREF_MASK))
6315         return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
6316     else
6317         return E_FAIL;
6318 }
6319
6320 /* ITypeInfo::GetRefTypeInfo
6321  *
6322  * If a type description references other type descriptions, it retrieves
6323  * the referenced type descriptions.
6324  */
6325 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
6326         ITypeInfo2 *iface,
6327         HREFTYPE hRefType,
6328         ITypeInfo  **ppTInfo)
6329 {
6330     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6331     HRESULT result = E_FAIL;
6332
6333     if ((This->hreftype != -1) && (This->hreftype == hRefType))
6334     {
6335         *ppTInfo = (ITypeInfo *)&This->lpVtbl;
6336         ITypeInfo_AddRef(*ppTInfo);
6337         result = S_OK;
6338     }
6339     else if (hRefType == -1 &&
6340         (This->TypeAttr.typekind   == TKIND_DISPATCH) &&
6341         (This->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
6342     {
6343           /* when we meet a DUAL dispinterface, we must create the interface
6344           * version of it.
6345           */
6346           ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
6347
6348
6349           /* the interface version contains the same information as the dispinterface
6350            * copy the contents of the structs.
6351            */
6352           *pTypeInfoImpl = *This;
6353           pTypeInfoImpl->ref = 0;
6354
6355           /* change the type to interface */
6356           pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
6357
6358           *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
6359
6360           /* we use data structures from This, so we need to keep a reference
6361            * to it to stop it being destroyed and signal to the new instance to
6362            * not free its data structures when it is destroyed */
6363           pTypeInfoImpl->no_free_data = TRUE;
6364           pTypeInfoImpl->next = This;
6365           ITypeInfo_AddRef((ITypeInfo*) This);
6366
6367           ITypeInfo_AddRef(*ppTInfo);
6368
6369           result = S_OK;
6370
6371     } else if ((hRefType != -1) && (hRefType & DISPATCH_HREF_MASK) &&
6372         (This->TypeAttr.typekind   == TKIND_DISPATCH) &&
6373         (This->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
6374     {
6375         HREFTYPE href_dispatch = hRefType;
6376         result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
6377     } else {
6378         TLBRefType *ref_type;
6379         LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
6380         {
6381             if(ref_type->reference == hRefType)
6382                 break;
6383         }
6384         if(&ref_type->entry == &This->pTypeLib->ref_list)
6385         {
6386             FIXME("Can't find pRefType for ref %x\n", hRefType);
6387             goto end;
6388         }
6389         if(hRefType != -1) {
6390             ITypeLib *pTLib = NULL;
6391
6392             if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
6393                 UINT Index;
6394                 result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
6395             } else {
6396                 if(ref_type->pImpTLInfo->pImpTypeLib) {
6397                     TRACE("typeinfo in imported typelib that is already loaded\n");
6398                     pTLib = (ITypeLib*)ref_type->pImpTLInfo->pImpTypeLib;
6399                     ITypeLib2_AddRef(pTLib);
6400                     result = S_OK;
6401                 } else {
6402                     TRACE("typeinfo in imported typelib that isn't already loaded\n");
6403                     result = LoadRegTypeLib( &ref_type->pImpTLInfo->guid,
6404                                              ref_type->pImpTLInfo->wVersionMajor,
6405                                              ref_type->pImpTLInfo->wVersionMinor,
6406                                              ref_type->pImpTLInfo->lcid,
6407                                              &pTLib);
6408
6409                     if(!SUCCEEDED(result)) {
6410                         BSTR libnam=SysAllocString(ref_type->pImpTLInfo->name);
6411                         result=LoadTypeLib(libnam, &pTLib);
6412                         SysFreeString(libnam);
6413                     }
6414                     if(SUCCEEDED(result)) {
6415                         ref_type->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
6416                         ITypeLib2_AddRef(pTLib);
6417                     }
6418                 }
6419             }
6420             if(SUCCEEDED(result)) {
6421                 if(ref_type->index == TLB_REF_USE_GUID)
6422                     result = ITypeLib2_GetTypeInfoOfGuid(pTLib,
6423                                                          &ref_type->guid,
6424                                                          ppTInfo);
6425                 else
6426                     result = ITypeLib2_GetTypeInfo(pTLib, ref_type->index,
6427                                                    ppTInfo);
6428             }
6429             if (pTLib != NULL)
6430                 ITypeLib2_Release(pTLib);
6431         }
6432     }
6433
6434 end:
6435     TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
6436           SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
6437     return result;
6438 }
6439
6440 /* ITypeInfo::AddressOfMember
6441  *
6442  * Retrieves the addresses of static functions or variables, such as those
6443  * defined in a DLL.
6444  */
6445 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
6446         MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
6447 {
6448     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6449     HRESULT hr;
6450     BSTR dll, entry;
6451     WORD ordinal;
6452     HMODULE module;
6453
6454     TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
6455
6456     hr = ITypeInfo_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
6457     if (FAILED(hr))
6458         return hr;
6459
6460     module = LoadLibraryW(dll);
6461     if (!module)
6462     {
6463         ERR("couldn't load %s\n", debugstr_w(dll));
6464         SysFreeString(dll);
6465         if (entry) SysFreeString(entry);
6466         return STG_E_FILENOTFOUND;
6467     }
6468     /* FIXME: store library somewhere where we can free it */
6469
6470     if (entry)
6471     {
6472         LPSTR entryA;
6473         INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
6474         entryA = HeapAlloc(GetProcessHeap(), 0, len);
6475         WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
6476
6477         *ppv = GetProcAddress(module, entryA);
6478         if (!*ppv)
6479             ERR("function not found %s\n", debugstr_a(entryA));
6480
6481         HeapFree(GetProcessHeap(), 0, entryA);
6482     }
6483     else
6484     {
6485         *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
6486         if (!*ppv)
6487             ERR("function not found %d\n", ordinal);
6488     }
6489
6490     SysFreeString(dll);
6491     if (entry) SysFreeString(entry);
6492
6493     if (!*ppv)
6494         return TYPE_E_DLLFUNCTIONNOTFOUND;
6495
6496     return S_OK;
6497 }
6498
6499 /* ITypeInfo::CreateInstance
6500  *
6501  * Creates a new instance of a type that describes a component object class
6502  * (coclass).
6503  */
6504 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
6505         IUnknown *pOuterUnk, REFIID riid, VOID  **ppvObj)
6506 {
6507     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6508     HRESULT hr;
6509     TYPEATTR *pTA;
6510
6511     TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
6512
6513     *ppvObj = NULL;
6514
6515     if(pOuterUnk)
6516     {
6517         WARN("Not able to aggregate\n");
6518         return CLASS_E_NOAGGREGATION;
6519     }
6520
6521     hr = ITypeInfo_GetTypeAttr(iface, &pTA);
6522     if(FAILED(hr)) return hr;
6523
6524     if(pTA->typekind != TKIND_COCLASS)
6525     {
6526         WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
6527         hr = E_INVALIDARG;
6528         goto end;
6529     }
6530
6531     hr = S_FALSE;
6532     if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
6533     {
6534         IUnknown *pUnk;
6535         hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
6536         TRACE("GetActiveObject rets %08x\n", hr);
6537         if(hr == S_OK)
6538         {
6539             hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
6540             IUnknown_Release(pUnk);
6541         }
6542     }
6543
6544     if(hr != S_OK)
6545         hr = CoCreateInstance(&pTA->guid, NULL,
6546                               CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
6547                               riid, ppvObj);
6548
6549 end:
6550     ITypeInfo_ReleaseTypeAttr(iface, pTA);
6551     return hr;
6552 }
6553
6554 /* ITypeInfo::GetMops
6555  *
6556  * Retrieves marshalling information.
6557  */
6558 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
6559                                 BSTR  *pBstrMops)
6560 {
6561     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6562     FIXME("(%p) stub!\n", This);
6563     return S_OK;
6564 }
6565
6566 /* ITypeInfo::GetContainingTypeLib
6567  *
6568  * Retrieves the containing type library and the index of the type description
6569  * within that type library.
6570  */
6571 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
6572         ITypeLib  * *ppTLib, UINT  *pIndex)
6573 {
6574     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6575
6576     /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
6577     if (pIndex) {
6578       *pIndex=This->index;
6579       TRACE("returning pIndex=%d\n", *pIndex);
6580     }
6581
6582     if (ppTLib) {
6583       *ppTLib=(LPTYPELIB )(This->pTypeLib);
6584       ITypeLib2_AddRef(*ppTLib);
6585       TRACE("returning ppTLib=%p\n", *ppTLib);
6586     }
6587
6588     return S_OK;
6589 }
6590
6591 /* ITypeInfo::ReleaseTypeAttr
6592  *
6593  * Releases a TYPEATTR previously returned by GetTypeAttr.
6594  *
6595  */
6596 static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
6597         TYPEATTR* pTypeAttr)
6598 {
6599     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6600     TRACE("(%p)->(%p)\n", This, pTypeAttr);
6601     HeapFree(GetProcessHeap(), 0, pTypeAttr);
6602 }
6603
6604 /* ITypeInfo::ReleaseFuncDesc
6605  *
6606  * Releases a FUNCDESC previously returned by GetFuncDesc. *
6607  */
6608 static void WINAPI ITypeInfo_fnReleaseFuncDesc(
6609         ITypeInfo2 *iface,
6610         FUNCDESC *pFuncDesc)
6611 {
6612     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6613     SHORT i;
6614
6615     TRACE("(%p)->(%p)\n", This, pFuncDesc);
6616
6617     for (i = 0; i < pFuncDesc->cParams; i++)
6618         TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
6619     TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
6620
6621     SysFreeString((BSTR)pFuncDesc);
6622 }
6623
6624 /* ITypeInfo::ReleaseVarDesc
6625  *
6626  * Releases a VARDESC previously returned by GetVarDesc.
6627  */
6628 static void WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
6629         VARDESC *pVarDesc)
6630 {
6631     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6632     TRACE("(%p)->(%p)\n", This, pVarDesc);
6633
6634     TLB_FreeElemDesc(&pVarDesc->elemdescVar);
6635     if (pVarDesc->varkind == VAR_CONST)
6636         VariantClear(pVarDesc->u.lpvarValue);
6637     SysFreeString((BSTR)pVarDesc);
6638 }
6639
6640 /* ITypeInfo2::GetTypeKind
6641  *
6642  * Returns the TYPEKIND enumeration quickly, without doing any allocations.
6643  *
6644  */
6645 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
6646     TYPEKIND *pTypeKind)
6647 {
6648     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6649     *pTypeKind=This->TypeAttr.typekind;
6650     TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
6651     return S_OK;
6652 }
6653
6654 /* ITypeInfo2::GetTypeFlags
6655  *
6656  * Returns the type flags without any allocations. This returns a DWORD type
6657  * flag, which expands the type flags without growing the TYPEATTR (type
6658  * attribute).
6659  *
6660  */
6661 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
6662 {
6663     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6664     *pTypeFlags=This->TypeAttr.wTypeFlags;
6665     TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
6666     return S_OK;
6667 }
6668
6669 /* ITypeInfo2::GetFuncIndexOfMemId
6670  * Binds to a specific member based on a known DISPID, where the member name
6671  * is not known (for example, when binding to a default member).
6672  *
6673  */
6674 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
6675     MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
6676 {
6677     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6678     const TLBFuncDesc *pFuncInfo;
6679     int i;
6680     HRESULT result;
6681
6682     for(i = 0, pFuncInfo = This->funclist; pFuncInfo; i++, pFuncInfo=pFuncInfo->next)
6683         if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
6684             break;
6685     if(pFuncInfo) {
6686         *pFuncIndex = i;
6687         result = S_OK;
6688     } else
6689         result = TYPE_E_ELEMENTNOTFOUND;
6690
6691     TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
6692           memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6693     return result;
6694 }
6695
6696 /* TypeInfo2::GetVarIndexOfMemId
6697  *
6698  * Binds to a specific member based on a known DISPID, where the member name
6699  * is not known (for example, when binding to a default member).
6700  *
6701  */
6702 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
6703     MEMBERID memid, UINT *pVarIndex)
6704 {
6705     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6706     TLBVarDesc *pVarInfo;
6707     int i;
6708     HRESULT result;
6709     for(i=0, pVarInfo=This->varlist; pVarInfo &&
6710             memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
6711         ;
6712     if(pVarInfo) {
6713         *pVarIndex = i;
6714         result = S_OK;
6715     } else
6716         result = TYPE_E_ELEMENTNOTFOUND;
6717
6718     TRACE("(%p) memid 0x%08x -> %s\n", This,
6719           memid, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
6720     return result;
6721 }
6722
6723 /* ITypeInfo2::GetCustData
6724  *
6725  * Gets the custom data
6726  */
6727 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
6728         ITypeInfo2 * iface,
6729         REFGUID guid,
6730         VARIANT *pVarVal)
6731 {
6732     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6733     TLBCustData *pCData;
6734
6735     for(pCData=This->pCustData; pCData; pCData = pCData->next)
6736         if( IsEqualIID(guid, &pCData->guid)) break;
6737
6738     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6739
6740     if(pCData)
6741     {
6742         VariantInit( pVarVal);
6743         VariantCopy( pVarVal, &pCData->data);
6744         return S_OK;
6745     }
6746     return E_INVALIDARG;  /* FIXME: correct? */
6747 }
6748
6749 /* ITypeInfo2::GetFuncCustData
6750  *
6751  * Gets the custom data
6752  */
6753 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
6754         ITypeInfo2 * iface,
6755         UINT index,
6756         REFGUID guid,
6757         VARIANT *pVarVal)
6758 {
6759     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6760     TLBCustData *pCData=NULL;
6761     TLBFuncDesc * pFDesc;
6762     int i;
6763     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6764             pFDesc=pFDesc->next);
6765
6766     if(pFDesc)
6767         for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
6768             if( IsEqualIID(guid, &pCData->guid)) break;
6769
6770     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6771
6772     if(pCData){
6773         VariantInit( pVarVal);
6774         VariantCopy( pVarVal, &pCData->data);
6775         return S_OK;
6776     }
6777     return E_INVALIDARG;  /* FIXME: correct? */
6778 }
6779
6780 /* ITypeInfo2::GetParamCustData
6781  *
6782  * Gets the custom data
6783  */
6784 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
6785         ITypeInfo2 * iface,
6786         UINT indexFunc,
6787         UINT indexParam,
6788         REFGUID guid,
6789         VARIANT *pVarVal)
6790 {
6791     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6792     TLBCustData *pCData=NULL;
6793     TLBFuncDesc * pFDesc;
6794     int i;
6795
6796     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,pFDesc=pFDesc->next);
6797
6798     if(pFDesc && indexParam<pFDesc->funcdesc.cParams)
6799         for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
6800                 pCData = pCData->next)
6801             if( IsEqualIID(guid, &pCData->guid)) break;
6802
6803     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6804
6805     if(pCData)
6806     {
6807         VariantInit( pVarVal);
6808         VariantCopy( pVarVal, &pCData->data);
6809         return S_OK;
6810     }
6811     return E_INVALIDARG;  /* FIXME: correct? */
6812 }
6813
6814 /* ITypeInfo2::GetVarCustData
6815  *
6816  * Gets the custom data
6817  */
6818 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
6819         ITypeInfo2 * iface,
6820         UINT index,
6821         REFGUID guid,
6822         VARIANT *pVarVal)
6823 {
6824     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6825     TLBCustData *pCData=NULL;
6826     TLBVarDesc * pVDesc;
6827     int i;
6828
6829     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next);
6830
6831     if(pVDesc)
6832     {
6833       for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
6834       {
6835         if( IsEqualIID(guid, &pCData->guid)) break;
6836       }
6837     }
6838
6839     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6840
6841     if(pCData)
6842     {
6843         VariantInit( pVarVal);
6844         VariantCopy( pVarVal, &pCData->data);
6845         return S_OK;
6846     }
6847     return E_INVALIDARG;  /* FIXME: correct? */
6848 }
6849
6850 /* ITypeInfo2::GetImplCustData
6851  *
6852  * Gets the custom data
6853  */
6854 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
6855         ITypeInfo2 * iface,
6856         UINT index,
6857         REFGUID guid,
6858         VARIANT *pVarVal)
6859 {
6860     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6861     TLBCustData *pCData=NULL;
6862     TLBImplType * pRDesc;
6863     int i;
6864
6865     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++, pRDesc=pRDesc->next);
6866
6867     if(pRDesc)
6868     {
6869       for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
6870       {
6871         if( IsEqualIID(guid, &pCData->guid)) break;
6872       }
6873     }
6874
6875     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
6876
6877     if(pCData)
6878     {
6879         VariantInit( pVarVal);
6880         VariantCopy( pVarVal, &pCData->data);
6881         return S_OK;
6882     }
6883     return E_INVALIDARG;  /* FIXME: correct? */
6884 }
6885
6886 /* ITypeInfo2::GetDocumentation2
6887  *
6888  * Retrieves the documentation string, the complete Help file name and path,
6889  * the localization context to use, and the context ID for the library Help
6890  * topic in the Help file.
6891  *
6892  */
6893 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
6894         ITypeInfo2 * iface,
6895         MEMBERID memid,
6896         LCID lcid,
6897         BSTR *pbstrHelpString,
6898         DWORD *pdwHelpStringContext,
6899         BSTR *pbstrHelpStringDll)
6900 {
6901     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6902     const TLBFuncDesc *pFDesc;
6903     const TLBVarDesc *pVDesc;
6904     TRACE("(%p) memid %d lcid(0x%x)  HelpString(%p) "
6905           "HelpStringContext(%p) HelpStringDll(%p)\n",
6906           This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
6907           pbstrHelpStringDll );
6908     /* the help string should be obtained from the helpstringdll,
6909      * using the _DLLGetDocumentation function, based on the supplied
6910      * lcid. Nice to do sometime...
6911      */
6912     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6913         if(pbstrHelpString)
6914             *pbstrHelpString=SysAllocString(This->Name);
6915         if(pdwHelpStringContext)
6916             *pdwHelpStringContext=This->dwHelpStringContext;
6917         if(pbstrHelpStringDll)
6918             *pbstrHelpStringDll=
6919                 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6920         return S_OK;
6921     }else {/* for a member */
6922     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
6923         if(pFDesc->funcdesc.memid==memid){
6924              if(pbstrHelpString)
6925                 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
6926             if(pdwHelpStringContext)
6927                 *pdwHelpStringContext=pFDesc->HelpStringContext;
6928             if(pbstrHelpStringDll)
6929                 *pbstrHelpStringDll=
6930                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6931         return S_OK;
6932     }
6933     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
6934         if(pVDesc->vardesc.memid==memid){
6935              if(pbstrHelpString)
6936                 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
6937             if(pdwHelpStringContext)
6938                 *pdwHelpStringContext=pVDesc->HelpStringContext;
6939             if(pbstrHelpStringDll)
6940                 *pbstrHelpStringDll=
6941                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
6942             return S_OK;
6943         }
6944     }
6945     return TYPE_E_ELEMENTNOTFOUND;
6946 }
6947
6948 /* ITypeInfo2::GetAllCustData
6949  *
6950  * Gets all custom data items for the Type info.
6951  *
6952  */
6953 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
6954         ITypeInfo2 * iface,
6955         CUSTDATA *pCustData)
6956 {
6957     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6958     TLBCustData *pCData;
6959     int i;
6960
6961     TRACE("(%p) returning %d items\n", This, This->ctCustData);
6962
6963     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
6964     if(pCustData->prgCustData ){
6965         pCustData->cCustData=This->ctCustData;
6966         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
6967             pCustData->prgCustData[i].guid=pCData->guid;
6968             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
6969         }
6970     }else{
6971         ERR(" OUT OF MEMORY!\n");
6972         return E_OUTOFMEMORY;
6973     }
6974     return S_OK;
6975 }
6976
6977 /* ITypeInfo2::GetAllFuncCustData
6978  *
6979  * Gets all custom data items for the specified Function
6980  *
6981  */
6982 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
6983         ITypeInfo2 * iface,
6984         UINT index,
6985         CUSTDATA *pCustData)
6986 {
6987     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6988     TLBCustData *pCData;
6989     TLBFuncDesc * pFDesc;
6990     int i;
6991     TRACE("(%p) index %d\n", This, index);
6992     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
6993             pFDesc=pFDesc->next)
6994         ;
6995     if(pFDesc){
6996         pCustData->prgCustData =
6997             TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
6998         if(pCustData->prgCustData ){
6999             pCustData->cCustData=pFDesc->ctCustData;
7000             for(i=0, pCData=pFDesc->pCustData; pCData; i++,
7001                     pCData = pCData->next){
7002                 pCustData->prgCustData[i].guid=pCData->guid;
7003                 VariantCopy(& pCustData->prgCustData[i].varValue,
7004                         & pCData->data);
7005             }
7006         }else{
7007             ERR(" OUT OF MEMORY!\n");
7008             return E_OUTOFMEMORY;
7009         }
7010         return S_OK;
7011     }
7012     return TYPE_E_ELEMENTNOTFOUND;
7013 }
7014
7015 /* ITypeInfo2::GetAllParamCustData
7016  *
7017  * Gets all custom data items for the Functions
7018  *
7019  */
7020 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
7021     UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
7022 {
7023     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7024     TLBCustData *pCData=NULL;
7025     TLBFuncDesc * pFDesc;
7026     int i;
7027     TRACE("(%p) index %d\n", This, indexFunc);
7028     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
7029             pFDesc=pFDesc->next)
7030         ;
7031     if(pFDesc && indexParam<pFDesc->funcdesc.cParams){
7032         pCustData->prgCustData =
7033             TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
7034                     sizeof(CUSTDATAITEM));
7035         if(pCustData->prgCustData ){
7036             pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
7037             for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
7038                     pCData; i++, pCData = pCData->next){
7039                 pCustData->prgCustData[i].guid=pCData->guid;
7040                 VariantCopy(& pCustData->prgCustData[i].varValue,
7041                         & pCData->data);
7042             }
7043         }else{
7044             ERR(" OUT OF MEMORY!\n");
7045             return E_OUTOFMEMORY;
7046         }
7047         return S_OK;
7048     }
7049     return TYPE_E_ELEMENTNOTFOUND;
7050 }
7051
7052 /* ITypeInfo2::GetAllVarCustData
7053  *
7054  * Gets all custom data items for the specified Variable
7055  *
7056  */
7057 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
7058     UINT index, CUSTDATA *pCustData)
7059 {
7060     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7061     TLBCustData *pCData;
7062     TLBVarDesc * pVDesc;
7063     int i;
7064     TRACE("(%p) index %d\n", This, index);
7065     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
7066             pVDesc=pVDesc->next)
7067         ;
7068     if(pVDesc){
7069         pCustData->prgCustData =
7070             TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
7071         if(pCustData->prgCustData ){
7072             pCustData->cCustData=pVDesc->ctCustData;
7073             for(i=0, pCData=pVDesc->pCustData; pCData; i++,
7074                     pCData = pCData->next){
7075                 pCustData->prgCustData[i].guid=pCData->guid;
7076                 VariantCopy(& pCustData->prgCustData[i].varValue,
7077                         & pCData->data);
7078             }
7079         }else{
7080             ERR(" OUT OF MEMORY!\n");
7081             return E_OUTOFMEMORY;
7082         }
7083         return S_OK;
7084     }
7085     return TYPE_E_ELEMENTNOTFOUND;
7086 }
7087
7088 /* ITypeInfo2::GetAllImplCustData
7089  *
7090  * Gets all custom data items for the specified implementation type
7091  *
7092  */
7093 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
7094         ITypeInfo2 * iface,
7095         UINT index,
7096         CUSTDATA *pCustData)
7097 {
7098     ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7099     TLBCustData *pCData;
7100     TLBImplType * pRDesc;
7101     int i;
7102     TRACE("(%p) index %d\n", This, index);
7103     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
7104             pRDesc=pRDesc->next)
7105         ;
7106     if(pRDesc){
7107         pCustData->prgCustData =
7108             TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
7109         if(pCustData->prgCustData ){
7110             pCustData->cCustData=pRDesc->ctCustData;
7111             for(i=0, pCData=pRDesc->pCustData; pCData; i++,
7112                     pCData = pCData->next){
7113                 pCustData->prgCustData[i].guid=pCData->guid;
7114                 VariantCopy(& pCustData->prgCustData[i].varValue,
7115                         & pCData->data);
7116             }
7117         }else{
7118             ERR(" OUT OF MEMORY!\n");
7119             return E_OUTOFMEMORY;
7120         }
7121         return S_OK;
7122     }
7123     return TYPE_E_ELEMENTNOTFOUND;
7124 }
7125
7126 static const ITypeInfo2Vtbl tinfvt =
7127 {
7128
7129     ITypeInfo_fnQueryInterface,
7130     ITypeInfo_fnAddRef,
7131     ITypeInfo_fnRelease,
7132
7133     ITypeInfo_fnGetTypeAttr,
7134     ITypeInfo_fnGetTypeComp,
7135     ITypeInfo_fnGetFuncDesc,
7136     ITypeInfo_fnGetVarDesc,
7137     ITypeInfo_fnGetNames,
7138     ITypeInfo_fnGetRefTypeOfImplType,
7139     ITypeInfo_fnGetImplTypeFlags,
7140     ITypeInfo_fnGetIDsOfNames,
7141     ITypeInfo_fnInvoke,
7142     ITypeInfo_fnGetDocumentation,
7143     ITypeInfo_fnGetDllEntry,
7144     ITypeInfo_fnGetRefTypeInfo,
7145     ITypeInfo_fnAddressOfMember,
7146     ITypeInfo_fnCreateInstance,
7147     ITypeInfo_fnGetMops,
7148     ITypeInfo_fnGetContainingTypeLib,
7149     ITypeInfo_fnReleaseTypeAttr,
7150     ITypeInfo_fnReleaseFuncDesc,
7151     ITypeInfo_fnReleaseVarDesc,
7152
7153     ITypeInfo2_fnGetTypeKind,
7154     ITypeInfo2_fnGetTypeFlags,
7155     ITypeInfo2_fnGetFuncIndexOfMemId,
7156     ITypeInfo2_fnGetVarIndexOfMemId,
7157     ITypeInfo2_fnGetCustData,
7158     ITypeInfo2_fnGetFuncCustData,
7159     ITypeInfo2_fnGetParamCustData,
7160     ITypeInfo2_fnGetVarCustData,
7161     ITypeInfo2_fnGetImplTypeCustData,
7162     ITypeInfo2_fnGetDocumentation2,
7163     ITypeInfo2_fnGetAllCustData,
7164     ITypeInfo2_fnGetAllFuncCustData,
7165     ITypeInfo2_fnGetAllParamCustData,
7166     ITypeInfo2_fnGetAllVarCustData,
7167     ITypeInfo2_fnGetAllImplTypeCustData,
7168 };
7169
7170 /******************************************************************************
7171  * CreateDispTypeInfo [OLEAUT32.31]
7172  *
7173  * Build type information for an object so it can be called through an
7174  * IDispatch interface.
7175  *
7176  * RETURNS
7177  *  Success: S_OK. pptinfo contains the created ITypeInfo object.
7178  *  Failure: E_INVALIDARG, if one or more arguments is invalid.
7179  *
7180  * NOTES
7181  *  This call allows an objects methods to be accessed through IDispatch, by
7182  *  building an ITypeInfo object that IDispatch can use to call through.
7183  */
7184 HRESULT WINAPI CreateDispTypeInfo(
7185         INTERFACEDATA *pidata, /* [I] Description of the interface to build type info for */
7186         LCID lcid, /* [I] Locale Id */
7187         ITypeInfo **pptinfo) /* [O] Destination for created ITypeInfo object */
7188 {
7189     ITypeInfoImpl *pTIClass, *pTIIface;
7190     ITypeLibImpl *pTypeLibImpl;
7191     int param, func;
7192     TLBFuncDesc **ppFuncDesc;
7193     TLBRefType *ref;
7194
7195     TRACE("\n");
7196     pTypeLibImpl = TypeLibImpl_Constructor();
7197     if (!pTypeLibImpl) return E_FAIL;
7198
7199     pTIIface = (ITypeInfoImpl*)ITypeInfo_Constructor();
7200     pTIIface->pTypeLib = pTypeLibImpl;
7201     pTIIface->index = 0;
7202     pTIIface->Name = NULL;
7203     pTIIface->dwHelpContext = -1;
7204     memset(&pTIIface->TypeAttr.guid, 0, sizeof(GUID));
7205     pTIIface->TypeAttr.lcid = lcid;
7206     pTIIface->TypeAttr.typekind = TKIND_INTERFACE;
7207     pTIIface->TypeAttr.wMajorVerNum = 0;
7208     pTIIface->TypeAttr.wMinorVerNum = 0;
7209     pTIIface->TypeAttr.cbAlignment = 2;
7210     pTIIface->TypeAttr.cbSizeInstance = -1;
7211     pTIIface->TypeAttr.cbSizeVft = -1;
7212     pTIIface->TypeAttr.cFuncs = 0;
7213     pTIIface->TypeAttr.cImplTypes = 0;
7214     pTIIface->TypeAttr.cVars = 0;
7215     pTIIface->TypeAttr.wTypeFlags = 0;
7216
7217     ppFuncDesc = &pTIIface->funclist;
7218     for(func = 0; func < pidata->cMembers; func++) {
7219         METHODDATA *md = pidata->pmethdata + func;
7220         *ppFuncDesc = HeapAlloc(GetProcessHeap(), 0, sizeof(**ppFuncDesc));
7221         (*ppFuncDesc)->Name = SysAllocString(md->szName);
7222         (*ppFuncDesc)->funcdesc.memid = md->dispid;
7223         (*ppFuncDesc)->funcdesc.lprgscode = NULL;
7224         (*ppFuncDesc)->funcdesc.funckind = FUNC_VIRTUAL;
7225         (*ppFuncDesc)->funcdesc.invkind = md->wFlags;
7226         (*ppFuncDesc)->funcdesc.callconv = md->cc;
7227         (*ppFuncDesc)->funcdesc.cParams = md->cArgs;
7228         (*ppFuncDesc)->funcdesc.cParamsOpt = 0;
7229         (*ppFuncDesc)->funcdesc.oVft = md->iMeth << 2;
7230         (*ppFuncDesc)->funcdesc.cScodes = 0;
7231         (*ppFuncDesc)->funcdesc.wFuncFlags = 0;
7232         (*ppFuncDesc)->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
7233         (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
7234         (*ppFuncDesc)->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
7235         (*ppFuncDesc)->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7236                                                               md->cArgs * sizeof(ELEMDESC));
7237         (*ppFuncDesc)->pParamDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7238                                               md->cArgs * sizeof(TLBParDesc));
7239         for(param = 0; param < md->cArgs; param++) {
7240             (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
7241             (*ppFuncDesc)->pParamDesc[param].Name = SysAllocString(md->ppdata[param].szName);
7242         }
7243         (*ppFuncDesc)->helpcontext = 0;
7244         (*ppFuncDesc)->HelpStringContext = 0;
7245         (*ppFuncDesc)->HelpString = NULL;
7246         (*ppFuncDesc)->Entry = NULL;
7247         (*ppFuncDesc)->ctCustData = 0;
7248         (*ppFuncDesc)->pCustData = NULL;
7249         (*ppFuncDesc)->next = NULL;
7250         pTIIface->TypeAttr.cFuncs++;
7251         ppFuncDesc = &(*ppFuncDesc)->next;
7252     }
7253
7254     dump_TypeInfo(pTIIface);
7255
7256     pTypeLibImpl->pTypeInfo = pTIIface;
7257     pTypeLibImpl->TypeInfoCount++;
7258
7259     pTIClass = (ITypeInfoImpl*)ITypeInfo_Constructor();
7260     pTIClass->pTypeLib = pTypeLibImpl;
7261     pTIClass->index = 1;
7262     pTIClass->Name = NULL;
7263     pTIClass->dwHelpContext = -1;
7264     memset(&pTIClass->TypeAttr.guid, 0, sizeof(GUID));
7265     pTIClass->TypeAttr.lcid = lcid;
7266     pTIClass->TypeAttr.typekind = TKIND_COCLASS;
7267     pTIClass->TypeAttr.wMajorVerNum = 0;
7268     pTIClass->TypeAttr.wMinorVerNum = 0;
7269     pTIClass->TypeAttr.cbAlignment = 2;
7270     pTIClass->TypeAttr.cbSizeInstance = -1;
7271     pTIClass->TypeAttr.cbSizeVft = -1;
7272     pTIClass->TypeAttr.cFuncs = 0;
7273     pTIClass->TypeAttr.cImplTypes = 1;
7274     pTIClass->TypeAttr.cVars = 0;
7275     pTIClass->TypeAttr.wTypeFlags = 0;
7276
7277     pTIClass->impltypelist = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pTIClass->impltypelist));
7278     pTIClass->impltypelist->hRef = 0;
7279
7280     ref = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ref));
7281     ref->index = 0;
7282     ref->reference = 0;
7283     ref->pImpTLInfo = TLB_REF_INTERNAL;
7284     list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
7285
7286     dump_TypeInfo(pTIClass);
7287
7288     pTIIface->next = pTIClass;
7289     pTypeLibImpl->TypeInfoCount++;
7290
7291     *pptinfo = (ITypeInfo*)pTIClass;
7292
7293     ITypeInfo_AddRef(*pptinfo);
7294     ITypeLib_Release((ITypeLib *)&pTypeLibImpl->lpVtbl);
7295
7296     return S_OK;
7297
7298 }
7299
7300 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
7301 {
7302     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7303
7304     return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
7305 }
7306
7307 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
7308 {
7309     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7310
7311     return ITypeInfo_AddRef((ITypeInfo *)This);
7312 }
7313
7314 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
7315 {
7316     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7317
7318     return ITypeInfo_Release((ITypeInfo *)This);
7319 }
7320
7321 static HRESULT WINAPI ITypeComp_fnBind(
7322     ITypeComp * iface,
7323     OLECHAR * szName,
7324     ULONG lHash,
7325     WORD wFlags,
7326     ITypeInfo ** ppTInfo,
7327     DESCKIND * pDescKind,
7328     BINDPTR * pBindPtr)
7329 {
7330     ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7331     const TLBFuncDesc *pFDesc;
7332     const TLBVarDesc *pVDesc;
7333     HRESULT hr = DISP_E_MEMBERNOTFOUND;
7334
7335     TRACE("(%s, %x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7336
7337     *pDescKind = DESCKIND_NONE;
7338     pBindPtr->lpfuncdesc = NULL;
7339     *ppTInfo = NULL;
7340
7341     for(pFDesc = This->funclist; pFDesc; pFDesc = pFDesc->next)
7342         if (!strcmpiW(pFDesc->Name, szName)) {
7343             if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
7344                 break;
7345             else
7346                 /* name found, but wrong flags */
7347                 hr = TYPE_E_TYPEMISMATCH;
7348         }
7349
7350     if (pFDesc)
7351     {
7352         HRESULT hr = TLB_AllocAndInitFuncDesc(
7353             &pFDesc->funcdesc,
7354             &pBindPtr->lpfuncdesc,
7355             This->TypeAttr.typekind == TKIND_DISPATCH);
7356         if (FAILED(hr))
7357             return hr;
7358         *pDescKind = DESCKIND_FUNCDESC;
7359         *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7360         ITypeInfo_AddRef(*ppTInfo);
7361         return S_OK;
7362     } else {
7363         for(pVDesc = This->varlist; pVDesc; pVDesc = pVDesc->next) {
7364             if (!strcmpiW(pVDesc->Name, szName)) {
7365                 HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
7366                 if (FAILED(hr))
7367                     return hr;
7368                 *pDescKind = DESCKIND_VARDESC;
7369                 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7370                 ITypeInfo_AddRef(*ppTInfo);
7371                 return S_OK;
7372             }
7373         }
7374     }
7375     /* FIXME: search each inherited interface, not just the first */
7376     if (hr == DISP_E_MEMBERNOTFOUND && This->impltypelist) {
7377         /* recursive search */
7378         ITypeInfo *pTInfo;
7379         ITypeComp *pTComp;
7380         HRESULT hr;
7381         hr=ITypeInfo_GetRefTypeInfo((ITypeInfo *)&This->lpVtbl, This->impltypelist->hRef, &pTInfo);
7382         if (SUCCEEDED(hr))
7383         {
7384             hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
7385             ITypeInfo_Release(pTInfo);
7386         }
7387         if (SUCCEEDED(hr))
7388         {
7389             hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7390             ITypeComp_Release(pTComp);
7391             return hr;
7392         }
7393         WARN("Could not search inherited interface!\n");
7394     }
7395     WARN("did not find member with name %s, flags 0x%x!\n", debugstr_w(szName), wFlags);
7396     return hr;
7397 }
7398
7399 static HRESULT WINAPI ITypeComp_fnBindType(
7400     ITypeComp * iface,
7401     OLECHAR * szName,
7402     ULONG lHash,
7403     ITypeInfo ** ppTInfo,
7404     ITypeComp ** ppTComp)
7405 {
7406     TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
7407
7408     /* strange behaviour (does nothing) but like the
7409      * original */
7410
7411     if (!ppTInfo || !ppTComp)
7412         return E_POINTER;
7413
7414     *ppTInfo = NULL;
7415     *ppTComp = NULL;
7416
7417     return S_OK;
7418 }
7419
7420 static const ITypeCompVtbl tcompvt =
7421 {
7422
7423     ITypeComp_fnQueryInterface,
7424     ITypeComp_fnAddRef,
7425     ITypeComp_fnRelease,
7426
7427     ITypeComp_fnBind,
7428     ITypeComp_fnBindType
7429 };