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

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