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

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