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