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