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