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