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

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