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