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