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