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