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