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  * --------------------------------------------------------------------------------------
   8  * Known problems (2000, Francois Jacques)
   9  *
  10  * - Tested using OLEVIEW (Platform SDK tool) only.
  11  *
  12  * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
  13  *   creating by doing a straight copy of the dispinterface instance and just changing
  14  *   its typekind. Pointed structures aren't copied - only the address of the pointers.
  15  *   So when you release the dispinterface, you delete the vtable-interface structures
  16  *   as well... fortunately, clean up of structures is not implemented.
  17  *
  18  * - locale stuff is partially implemented but hasn't been tested.
  19  *
  20  * - imported typelib should be stored together in a linked list instead of having
  21  *   independant TLBImpLib strucutures in each ITypeInfo. This way, imported libraries
  22  *   are just imported once (major optimization)
  23  *
  24  * - typelib file is still read it's in entirety, but it is released now.
  25  * - some garbage is read from function names on some very rare occasion
  26  *
  27  * --------------------------------------------------------------------------------------
  28  *  Known problems left from previous implementation (1999, Rein Klazes) :
  29  *
  30  * -. Only one format of typelibs is supported
  31  * -. Data structures are straightforward, but slow for look-ups.
  32  * -. (related) nothing is hashed
  33  * -. there are a number of stubs in ITypeLib and ITypeInfo interfaces. Most
  34  *      of them I don't know yet how to implement them.
  35  * -. Most error return values are just guessed not checked with windows
  36  *      behaviour.
  37  * -. didn't bother with a c++ interface
  38  * -. lousy fatal error handling
  39  * -. some methods just return pointers to internal data structures, this is
  40  *      partly laziness, partly I want to check how windows does it.
  41  *
  42  */
  43
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <stdio.h>
  47 #include <ctype.h>
  48 #include "winerror.h"
  49 #include "winreg.h"         /* for HKEY_LOCAL_MACHINE */
  50 #include "winnls.h"         /* for PRIMARYLANGID */
  51 #include "ole.h"
  52 #include "heap.h"
  53 #include "wine/obj_base.h"
  54 #include "debugtools.h"
  55 #include "typelib.h"
  56
  57 DEFAULT_DEBUG_CHANNEL(ole);
  58 DECLARE_DEBUG_CHANNEL(typelib);
  59
  60 /****************************************************************************
  61  *              QueryPathOfRegTypeLib16 [TYPELIB.14]
  62  *
  63  * the path is "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\"
  64  * RETURNS
  65  *      path of typelib
  66  */
  67 HRESULT WINAPI
  68 QueryPathOfRegTypeLib16(
  69         REFGUID guid,   /* [in] referenced guid */
  70         WORD wMaj,      /* [in] major version */
  71         WORD wMin,      /* [in] minor version */
  72         LCID lcid,      /* [in] locale id */
  73         LPBSTR16 path   /* [out] path of typelib */
  74 ) {
  75         char    xguid[80];
  76         char    typelibkey[100],pathname[260];
  77         DWORD   plen;
  78
  79         TRACE("\n");
  80
  81         if (HIWORD(guid)) {
  82             sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win16",
  83                      guid->Data1, guid->Data2, guid->Data3,
  84                      guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
  85                      guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
  86                      wMaj,wMin,lcid);
  87         } else {
  88                 sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
  89                 FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
  90                 return E_FAIL;
  91         }
  92         plen = sizeof(pathname);
  93         if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
  94                 /* try again without lang specific id */
  95                 if (SUBLANGID(lcid))
  96                         return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
  97                 FIXME("key %s not found\n",typelibkey);
  98                 return E_FAIL;
  99         }
 100         *path = SysAllocString16(pathname);
 101         return S_OK;
 102 }
 103
 104 /****************************************************************************
 105  *              QueryPathOfRegTypeLib   [OLEAUT32.164]
 106  * RETURNS
 107  *      path of typelib
 108  */
 109 HRESULT WINAPI
 110 QueryPathOfRegTypeLib(
 111         REFGUID guid,   /* [in] referenced guid */
 112         WORD wMaj,      /* [in] major version */
 113         WORD wMin,      /* [in] minor version */
 114         LCID lcid,      /* [in] locale id */
 115         LPBSTR path )   /* [out] path of typelib */
 116 {
 117     /* don't need to ZeroMemory those arrays since sprintf and RegQueryValue add
 118        string termination character on output strings */
 119
 120     HRESULT hr        = E_FAIL;
 121
 122     DWORD   dwPathLen = _MAX_PATH;
 123     LCID    myLCID    = lcid;
 124
 125     char    szXGUID[80];
 126     char    szTypeLibKey[100];
 127     char    szPath[dwPathLen];
 128
 129     if ( !HIWORD(guid) )
 130     {
 131         sprintf(szXGUID,
 132             "<guid 0x%08lx>",
 133             (DWORD) guid);
 134
 135         FIXME("(%s,%d,%d,0x%04lx,%p),stub!\n", szXGUID, wMaj, wMin, (DWORD)lcid, path);
 136         return E_FAIL;
 137     }
 138
 139     while (hr != S_OK)
 140     {
 141         sprintf(szTypeLibKey,
 142             "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win32",
 143             guid->Data1,    guid->Data2,    guid->Data3,
 144             guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 145             guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
 146             wMaj,
 147             wMin,
 148             myLCID);
 149
 150         if (RegQueryValueA(HKEY_LOCAL_MACHINE, szTypeLibKey, szPath, &dwPathLen))
 151         {
 152             if (!lcid)
 153                 break;
 154             else if (myLCID == lcid)
 155             {
 156                 /* try with sub-langid */
 157                 myLCID = SUBLANGID(lcid);
 158             }
 159             else if (myLCID == SUBLANGID(lcid))
 160             {
 161                 /* try with system langid */
 162                 myLCID = 0;
 163             }
 164             else
 165             {
 166                 break;
 167             }
 168         }
 169         else
 170         {
 171             DWORD len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szPath, dwPathLen, NULL, 0 );
 172             BSTR bstrPath = SysAllocStringLen(NULL,len);
 173
 174             MultiByteToWideChar(CP_ACP,
 175                                 MB_PRECOMPOSED,
 176                                 szPath,
 177                                 dwPathLen,
 178                                 bstrPath,
 179                                 len);
 180            *path = bstrPath;
 181            hr = S_OK;
 182         }
 183     }
 184
 185     if (hr != S_OK)
 186                 TRACE_(typelib)("%s not found\n", szTypeLibKey);
 187
 188     return hr;
 189 }
 190
 191 /******************************************************************************
 192  * CreateTypeLib [OLEAUT32]  creates a typelib
 193  *
 194  * RETURNS
 195  *    Success: S_OK
 196  *    Failure: Status
 197  */
 198 HRESULT WINAPI CreateTypeLib(
 199         SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
 200 ) {
 201     FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
 202     return E_FAIL;
 203 }
 204 /******************************************************************************
 205  * LoadTypeLib [TYPELIB.3]  Loads and registers a type library
 206  * NOTES
 207  *    Docs: OLECHAR FAR* szFile
 208  *    Docs: iTypeLib FAR* FAR* pptLib
 209  *
 210  * RETURNS
 211  *    Success: S_OK
 212  *    Failure: Status
 213  */
 214 HRESULT WINAPI LoadTypeLib16(
 215     LPOLESTR szFile, /* [in] Name of file to load from */
 216     ITypeLib** pptLib) /* [out] Pointer to pointer to loaded type library */
 217 {
 218     FIXME("('%s',%p): stub\n",debugstr_w((LPWSTR)szFile),pptLib);
 219
 220     if (pptLib!=0)
 221       *pptLib=0;
 222
 223     return E_FAIL;
 224 }
 225
 226 /******************************************************************************
 227  *              LoadTypeLib     [OLEAUT32.161]
 228  * Loads and registers a type library
 229  * NOTES
 230  *    Docs: OLECHAR FAR* szFile
 231  *    Docs: iTypeLib FAR* FAR* pptLib
 232  *
 233  * RETURNS
 234  *    Success: S_OK
 235  *    Failure: Status
 236  */
 237 int TLB_ReadTypeLib(PCHAR file, ITypeLib2 **ppTypelib);
 238
 239 HRESULT WINAPI LoadTypeLib(
 240     const OLECHAR *szFile,/* [in] Name of file to load from */
 241     ITypeLib * *pptLib)   /* [out] Pointer to pointer to loaded type library */
 242 {
 243     TRACE("\n");
 244     return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
 245 }
 246
 247 /******************************************************************************
 248  *              LoadTypeLibEx   [OLEAUT32.183]
 249  * Loads and optionally registers a type library
 250  *
 251  * RETURNS
 252  *    Success: S_OK
 253  *    Failure: Status
 254  */
 255 HRESULT WINAPI LoadTypeLibEx(
 256     LPCOLESTR szFile,  /* [in] Name of file to load from */
 257     REGKIND  regkind,  /* [in] Specify kind of registration */
 258     ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
 259 {
 260     LPSTR p;
 261     HRESULT res;
 262     TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
 263
 264     p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
 265
 266     if(regkind != REGKIND_NONE)
 267         FIXME ("registration of typelibs not supported yet!\n");
 268
 269     res= TLB_ReadTypeLib(p, (ITypeLib2**)pptLib);
 270     HeapFree(GetProcessHeap(),0,p);
 271     TRACE(" returns %08lx\n",res);
 272
 273     return res;
 274 }
 275
 276 /******************************************************************************
 277  *              LoadRegTypeLib  [OLEAUT32.162]
 278  */
 279 HRESULT WINAPI LoadRegTypeLib(
 280         REFGUID rguid,          /* [in] referenced guid */
 281         WORD wVerMajor,         /* [in] major version */
 282         WORD wVerMinor,         /* [in] minor version */
 283         LCID lcid,              /* [in] locale id */
 284         ITypeLib **ppTLib)      /* [out] path of typelib */
 285 {
 286     BSTR bstr=NULL;
 287     HRESULT res=QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
 288
 289     if(SUCCEEDED(res))
 290     {
 291         res= LoadTypeLib(bstr, ppTLib);
 292         SysFreeString(bstr);
 293     }
 294
 295     TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
 296
 297     return res;
 298 }
 299
 300
 301 /******************************************************************************
 302  *              RegisterTypeLib [OLEAUT32.163]
 303  * Adds information about a type library to the System Registry
 304  * NOTES
 305  *    Docs: ITypeLib FAR * ptlib
 306  *    Docs: OLECHAR FAR* szFullPath
 307  *    Docs: OLECHAR FAR* szHelpDir
 308  *
 309  * RETURNS
 310  *    Success: S_OK
 311  *    Failure: Status
 312  */
 313 HRESULT WINAPI RegisterTypeLib(
 314      ITypeLib * ptlib,     /* [in] Pointer to the library*/
 315      OLECHAR * szFullPath, /* [in] full Path of the library*/
 316      OLECHAR * szHelpDir)  /* [in] dir to the helpfile for the library,
 317                                                          may be NULL*/
 318 {   FIXME("(%p,%s,%s): stub\n",ptlib, debugstr_w(szFullPath),debugstr_w(szHelpDir));
 319     return S_OK;        /* FIXME: pretend everything is OK */
 320 }
 321
 322
 323 /******************************************************************************
 324  *      UnRegisterTypeLib       [OLEAUT32.186]
 325  * Removes information about a type library from the System Registry
 326  * NOTES
 327  *
 328  * RETURNS
 329  *    Success: S_OK
 330  *    Failure: Status
 331  */
 332 HRESULT WINAPI UnRegisterTypeLib(
 333     REFGUID libid,      /* [in] Guid of the library */
 334         WORD wVerMajor, /* [in] major version */
 335         WORD wVerMinor, /* [in] minor version */
 336         LCID lcid,      /* [in] locale id */
 337         SYSKIND syskind)
 338 {
 339     TRACE("(IID: %s): stub\n",debugstr_guid(libid));
 340     return S_OK;        /* FIXME: pretend everything is OK */
 341 }
 342
 343 /****************************************************************************
 344  *      OaBuildVersion                          (TYPELIB.15)
 345  *
 346  * known TYPELIB.DLL versions:
 347  *
 348  * OLE 2.01 no OaBuildVersion() avail   1993    --      ---
 349  * OLE 2.02                             1993-94 02     3002
 350  * OLE 2.03                                     23      730
 351  * OLE 2.03                                     03     3025
 352  * OLE 2.03 W98 SE orig. file !!        1993-95 10     3024
 353  * OLE 2.1   NT                         1993-95 ??      ???
 354  * OLE 2.3.1 W95                                23      700
 355  * OLE2 4.0  NT4SP6                     1993-98 40     4277
 356  */
 357 DWORD WINAPI OaBuildVersion16(void)
 358 {
 359     /* FIXME: I'd like to return the highest currently known version value
 360      * in case the user didn't force a --winver, but I don't know how
 361      * to retrieve the "versionForced" info from misc/version.c :(
 362      * (this would be useful in other places, too) */
 363     FIXME("Please report to a.mohr@mailto.de if you get version error messages !\n");
 364     switch(GetVersion() & 0x8000ffff)  /* mask off build number */
 365     {
 366     case 0x80000a03:  /* WIN31 */
 367                 return MAKELONG(3027, 3); /* WfW 3.11 */
 368     case 0x80000004:  /* WIN95 */
 369                 return MAKELONG(700, 23); /* Win95A */
 370     case 0x80000a04:  /* WIN98 */
 371                 return MAKELONG(3024, 10); /* W98 SE */
 372     case 0x00000004:  /* NT4 */
 373                 return MAKELONG(4277, 40); /* NT4 SP6 */
 374     default:
 375         FIXME("Version value not known yet. Please investigate it !");
 376                 return 0;
 377     }
 378 }
 379
 380 /* for better debugging info leave the static out for the time being */
 381 #define static
 382
 383 /*======================= ITypeLib implementation =======================*/
 384
 385 typedef struct tagTLBCustData
 386 {
 387     GUID guid;
 388     VARIANT data;
 389     struct tagTLBCustData* next;
 390 } TLBCustData;
 391
 392 /* data structure for import typelibs */
 393 typedef struct tagTLBImpLib
 394 {
 395     int offset;                 /* offset in the file */
 396     GUID guid;                  /* libid */
 397     BSTR name;                  /* name; */
 398
 399         LCID lcid;                                      /* lcid of imported typelib */
 400
 401         WORD wVersionMajor;         /* major version number */
 402     WORD wVersionMinor;         /* minor version number */
 403
 404     struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib */
 405     struct tagTLBImpLib * next;
 406 } TLBImpLib;
 407
 408 /* internal ITypeLib data */
 409 typedef struct tagITypeLibImpl
 410 {
 411     ICOM_VFIELD(ITypeLib2);
 412     UINT ref;
 413     TLIBATTR LibAttr;            /* guid,lcid,syskind,version,flags */
 414
 415     /* strings can be stored in tlb as multibyte strings BUT they are *always*
 416          * exported to the application as a UNICODE string.
 417          */
 418         BSTR Name;
 419     BSTR DocString;
 420     BSTR HelpFile;
 421     BSTR HelpStringDll;
 422     unsigned long  dwHelpContext;
 423     int TypeInfoCount;          /* nr of typeinfo's in librarry */
 424     struct tagITypeInfoImpl *pTypeInfo;   /* linked list of type info data */
 425     int ctCustData;             /* number of items in cust data list */
 426     TLBCustData * pCustData;    /* linked list to cust data; */
 427     TLBImpLib   * pImpLibs;     /* linked list to all imported typelibs */
 428     TYPEDESC * pTypeDesc;       /* array of TypeDescriptions found in the libary */
 429 } ITypeLibImpl;
 430
 431 static struct ICOM_VTABLE(ITypeLib2) tlbvt;
 432
 433 /* ITypeLib methods */
 434 static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength);
 435
 436 /*======================= ITypeInfo implementation =======================*/
 437
 438 /* data for refernced types in a coclass, or an inherited interface */
 439 typedef struct tagTLBRefType
 440 {
 441     GUID guid;              /* guid of the referenced type */
 442                             /* (important if its a imported type) */
 443     HREFTYPE reference;
 444     int flags;
 445     int ctCustData;
 446     TLBCustData * pCustData;/* linked list to custom data; */
 447     TLBImpLib *pImpTLInfo;
 448     struct tagTLBRefType * next;
 449 } TLBRefType;
 450
 451 /* internal Parameter data */
 452 typedef struct tagTLBParDesc
 453 {
 454     BSTR Name;
 455     int ctCustData;
 456     TLBCustData * pCustData;        /* linked list to cust data; */
 457         TLBRefType * pRefType;                  /* linked list to referenced types */
 458 } TLBParDesc;
 459
 460 /* internal Function data */
 461 typedef struct tagTLBFuncDesc
 462 {
 463     FUNCDESC funcdesc;      /* lots of info on the function and its attributes. */
 464     BSTR Name;             /* the name of this function */
 465     TLBParDesc *pParamDesc; /* array with name and custom data */
 466     int helpcontext;
 467     int HelpStringContext;
 468     BSTR HelpString;
 469     BSTR Entry;            /* if its Hiword==0, it numeric; -1 is not present*/
 470     int ctCustData;
 471     TLBCustData * pCustData;        /* linked list to cust data; */
 472     struct tagTLBFuncDesc * next;
 473 } TLBFuncDesc;
 474
 475 /* internal Variable data */
 476 typedef struct tagTLBVarDesc
 477 {
 478     VARDESC vardesc;        /* lots of info on the variable and its attributes. */
 479     BSTR Name;             /* the name of this variable */
 480     int HelpContext;
 481     int HelpStringContext;  /* fixme: where? */
 482     BSTR HelpString;
 483     int ctCustData;
 484     TLBCustData * pCustData;/* linked list to cust data; */
 485     struct tagTLBVarDesc * next;
 486 } TLBVarDesc;
 487
 488 /* internal TypeInfo data */
 489 typedef struct tagITypeInfoImpl
 490 {
 491     ICOM_VFIELD(ITypeInfo2);
 492     UINT ref;
 493     TYPEATTR TypeAttr ;         /* _lots_ of type information. */
 494     ITypeLibImpl * pTypeLib;        /* back pointer to typelib */
 495     int index;                  /* index in this typelib; */
 496     /* type libs seem to store the doc strings in ascii
 497      * so why should we do it in unicode?
 498      */
 499     BSTR Name;
 500     BSTR DocString;
 501     unsigned long  dwHelpContext;
 502     unsigned long  dwHelpStringContext;
 503
 504     /* functions  */
 505     TLBFuncDesc * funclist;     /* linked list with function descriptions */
 506
 507     /* variables  */
 508     TLBVarDesc * varlist;       /* linked list with variable descriptions */
 509
 510     /* Implemented Interfaces  */
 511     TLBRefType * impltypelist;
 512     int ctCustData;
 513     TLBCustData * pCustData;        /* linked list to cust data; */
 514     struct tagITypeInfoImpl * next;
 515 } ITypeInfoImpl;
 516
 517 static struct ICOM_VTABLE(ITypeInfo2) tinfvt;
 518
 519 static ITypeInfo2 * WINAPI ITypeInfo_Constructor();
 520
 521 typedef struct tagTLBContext
 522 {
 523         unsigned int oStart;  /* start of TLB in file */
 524         unsigned int pos;     /* current pos */
 525         unsigned int length;  /* total length */
 526         void *mapping;        /* memory mapping */
 527         TLBSegDir * pTblDir;
 528         ITypeLibImpl* pLibInfo;
 529 } TLBContext;
 530
 531
 532 static void TLB_DoRefType(TLBContext *pcx, int offset, TLBRefType ** pprtd);
 533
 534 /*
 535  debug
 536 */
 537 static void dump_TLBFuncDesc(TLBFuncDesc * pfd)
 538 {
 539         while (pfd)
 540         {
 541           TRACE("%s(%u)\n", debugstr_w(pfd->Name), pfd->funcdesc.cParams);
 542           pfd = pfd->next;
 543         };
 544 }
 545 static void dump_TLBVarDesc(TLBVarDesc * pvd)
 546 {
 547         while (pvd)
 548         {
 549           TRACE("%s\n", debugstr_w(pvd->Name));
 550           pvd = pvd->next;
 551         };
 552 }
 553 static void dump_TLBRefType(TLBRefType * prt)
 554 {
 555         while (prt)
 556         {
 557           TRACE("%s\n", debugstr_guid(&(prt->guid)));
 558           TRACE("  href:0x%08lx\n", prt->reference);
 559           prt = prt->next;
 560         };
 561 }
 562
 563 static void dump_Variant(VARIANT * pvar)
 564 {
 565         TRACE("%p %x\n", pvar, pvar?pvar->vt:0 );
 566         if(!pvar) return;
 567
 568         if (pvar->vt & VT_BYREF)
 569           return dump_Variant(pvar->u.pvarVal);
 570 }
 571
 572 static void dump_DispParms(DISPPARAMS * pdp)
 573 {
 574         dump_Variant( pdp->rgvarg);
 575         TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
 576 }
 577
 578 static char * typekind_desc[] =
 579 {
 580         "TKIND_ENUM",
 581         "TKIND_RECORD",
 582         "TKIND_MODULE",
 583         "TKIND_INTERFACE",
 584         "TKIND_DISPATCH",
 585         "TKIND_COCLASS",
 586         "TKIND_ALIAS",
 587         "TKIND_UNION",
 588         "TKIND_MAX"
 589 };
 590
 591 static void dump_TypeInfo(ITypeInfoImpl * pty)
 592 {
 593     TRACE("%p ref=%u\n", pty, pty->ref);
 594     TRACE("attr:%s\n", debugstr_guid(&(pty->TypeAttr.guid)));
 595     TRACE("kind:%s\n", typekind_desc[pty->TypeAttr.typekind]);
 596     TRACE("fct:%u var:%u impl:%u\n",
 597       pty->TypeAttr.cFuncs, pty->TypeAttr.cVars, pty->TypeAttr.cImplTypes);
 598     TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
 599     TRACE("%s %s\n", debugstr_w(pty->Name), debugstr_w(pty->DocString));
 600     dump_TLBFuncDesc(pty->funclist);
 601     dump_TLBVarDesc(pty->varlist);
 602     dump_TLBRefType(pty->impltypelist);
 603 }
 604
 605 static TYPEDESC stndTypeDesc[VT_LPWSTR+1]=
 606 {
 607     /* VT_LPWSTR is largest type that */
 608     /* may appear in type description*/
 609     {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
 610     {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
 611     {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
 612     {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
 613     {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
 614     {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
 615     {{0},30},{{0},31}
 616 };
 617
 618 static void TLB_abort()
 619 {
 620     DebugBreak();
 621 }
 622 static void * TLB_Alloc(unsigned size)
 623 {
 624     void * ret;
 625     if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
 626         /* FIXME */
 627         ERR("cannot allocate memory\n");
 628     }
 629     return ret;
 630 }
 631
 632 static void TLB_Free(void * ptr)
 633 {
 634     HeapFree(GetProcessHeap(), 0, ptr);
 635 }
 636 /* read function */
 637 DWORD TLB_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
 638 {
 639     TRACE("pos=0x%08x len=0x%08lx 0x%08x 0x%08x 0x%08lx\n",
 640        pcx->pos, count, pcx->oStart, pcx->length, where);
 641
 642     if (where != DO_NOT_SEEK)
 643     {
 644         where += pcx->oStart;
 645         if (where > pcx->length)
 646         {
 647             /* FIXME */
 648             ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
 649             TLB_abort();
 650         }
 651         pcx->pos = where;
 652     }
 653     if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
 654     memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
 655     pcx->pos += count;
 656     return count;
 657 }
 658
 659 static void TLB_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
 660 {
 661     TRACE("%s\n", debugstr_guid(pGuid));
 662
 663     if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
 664         memset(pGuid,0, sizeof(GUID));
 665         return;
 666     }
 667     TLB_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
 668 }
 669
 670 BSTR TLB_ReadName( TLBContext *pcx, int offset)
 671 {
 672     char * name;
 673     TLBNameIntro niName;
 674     int lengthInChars;
 675     WCHAR* pwstring = NULL;
 676     BSTR bstrName = NULL;
 677
 678     TLB_Read(&niName, sizeof(niName), pcx,
 679                                 pcx->pTblDir->pNametab.offset+offset);
 680     niName.namelen &= 0xFF; /* FIXME: correct ? */
 681     name=TLB_Alloc((niName.namelen & 0xff) +1);
 682     TLB_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
 683     name[niName.namelen & 0xff]='\0';
 684
 685     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
 686                                         name, -1, NULL, NULL);
 687
 688     /* no invalid characters in string */
 689     if (lengthInChars)
 690     {
 691         pwstring = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*lengthInChars);
 692
 693         /* don't check for invalid character since this has been done previously */
 694         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, pwstring, lengthInChars);
 695
 696         bstrName = SysAllocStringLen(pwstring, lengthInChars);
 697         lengthInChars = SysStringLen(bstrName);
 698         HeapFree(GetProcessHeap(), 0, pwstring);
 699     }
 700
 701     TRACE("%s %d\n", debugstr_w(bstrName), lengthInChars);
 702     return bstrName;
 703 }
 704
 705 BSTR TLB_ReadString( TLBContext *pcx, int offset)
 706 {
 707     char * string;
 708     INT16 length;
 709     int lengthInChars;
 710     BSTR bstr = NULL;
 711
 712     if(offset<0) return NULL;
 713     TLB_Read(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
 714     if(length <= 0) return 0;
 715     string=TLB_Alloc(length +1);
 716     TLB_Read(string, length, pcx, DO_NOT_SEEK);
 717     string[length]='\0';
 718
 719     lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
 720                                         string, -1, NULL, NULL);
 721
 722     /* no invalid characters in string */
 723     if (lengthInChars)
 724     {
 725         WCHAR* pwstring = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*lengthInChars);
 726
 727         /* don't check for invalid character since this has been done previously */
 728         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, pwstring, lengthInChars);
 729
 730         bstr = SysAllocStringLen(pwstring, lengthInChars);
 731         lengthInChars = SysStringLen(bstr);
 732         HeapFree(GetProcessHeap(), 0, pwstring);
 733     }
 734
 735     TRACE("%s %d\n", debugstr_w(bstr), lengthInChars);
 736     return bstr;
 737 }
 738 /*
 739  * read a value and fill a VARIANT structure
 740  */
 741 static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
 742 {
 743     int size;
 744
 745     TRACE("\n");
 746
 747     if(offset <0) { /* data is packed in here */
 748         pVar->vt = (offset & 0x7c000000 )>> 26;
 749         V_UNION(pVar, iVal) = offset & 0xffff;
 750         return;
 751     }
 752     TLB_Read(&(pVar->vt), sizeof(VARTYPE), pcx,
 753         pcx->pTblDir->pCustData.offset + offset );
 754     TRACE("Vartype = %x\n", pVar->vt);
 755     switch(pVar->vt){
 756         case VT_EMPTY:  /* FIXME: is this right? */
 757         case VT_NULL:   /* FIXME: is this right? */
 758         case VT_I2  :   /* this should not happen */
 759         case VT_I4  :
 760         case VT_R4  :
 761         case VT_ERROR   :
 762         case VT_BOOL    :
 763         case VT_I1  :
 764         case VT_UI1 :
 765         case VT_UI2 :
 766         case VT_UI4 :
 767         case VT_INT :
 768         case VT_UINT    :
 769         case VT_VOID    : /* FIXME: is this right? */
 770         case VT_HRESULT :
 771             size=4; break;
 772         case VT_R8  :
 773         case VT_CY  :
 774         case VT_DATE    :
 775         case VT_I8  :
 776         case VT_UI8 :
 777         case VT_DECIMAL :  /* FIXME: is this right? */
 778         case VT_FILETIME :
 779             size=8;break;
 780             /* pointer types with known behaviour */
 781         case VT_BSTR    :{
 782             char * ptr;
 783             TLB_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
 784             if(size <= 0) {
 785                 FIXME("BSTR length = %d?\n", size);
 786             } else {
 787                 ptr=TLB_Alloc(size);/* allocate temp buffer */
 788                 TLB_Read(ptr, size, pcx, DO_NOT_SEEK); /* read string (ANSI) */
 789                 V_UNION(pVar, bstrVal)=SysAllocStringLen(NULL,size);
 790                 /* FIXME: do we need a AtoW conversion here? */
 791                 V_UNION(pVar, bstrVal[size])=L'\0';
 792                 while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
 793                 TLB_Free(ptr);
 794             }
 795         }
 796         size=-4; break;
 797     /* FIXME: this will not work AT ALL when the variant contains a pointer */
 798         case VT_DISPATCH :
 799         case VT_VARIANT :
 800         case VT_UNKNOWN :
 801         case VT_PTR :
 802         case VT_SAFEARRAY :
 803         case VT_CARRAY  :
 804         case VT_USERDEFINED :
 805         case VT_LPSTR   :
 806         case VT_LPWSTR  :
 807         case VT_BLOB    :
 808         case VT_STREAM  :
 809         case VT_STORAGE :
 810         case VT_STREAMED_OBJECT :
 811         case VT_STORED_OBJECT   :
 812         case VT_BLOB_OBJECT :
 813         case VT_CF  :
 814         case VT_CLSID   :
 815         default:
 816             size=0;
 817             FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
 818                 pVar->vt);
 819     }
 820
 821     if(size>0) /* (big|small) endian correct? */
 822         TLB_Read(&(V_UNION(pVar, iVal)), size, pcx, DO_NOT_SEEK );
 823     return;
 824 }
 825 /*
 826  * create a linked list with custom data
 827  */
 828 static int TLB_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
 829 {
 830     TLBCDGuid entry;
 831     TLBCustData* pNew;
 832     int count=0;
 833
 834     TRACE("\n");
 835
 836     while(offset >=0){
 837         count++;
 838         pNew=TLB_Alloc(sizeof(TLBCustData));
 839         TLB_Read(&entry, sizeof(entry), pcx,
 840             pcx->pTblDir->pCDGuids.offset+offset);
 841         TLB_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
 842         TLB_ReadValue(&(pNew->data), entry.DataOffset, pcx);
 843         /* add new custom data at head of the list */
 844         pNew->next=*ppCustData;
 845         *ppCustData=pNew;
 846         offset = entry.next;
 847     }
 848     return count;
 849 }
 850
 851 static void TLB_GetTdesc(TLBContext *pcx, INT type,TYPEDESC * pTd )
 852 {
 853     if(type <0)
 854         pTd->vt=type & VT_TYPEMASK;
 855     else
 856         *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
 857
 858     TRACE("vt type = %X\n", pTd->vt);
 859 }
 860 static void TLB_DoFuncs(TLBContext *pcx, int cFuncs, int cVars,
 861                           int offset, TLBFuncDesc ** pptfd)
 862 {
 863     /*
 864      * member information is stored in a data structure at offset
 865      * indicated by the memoffset field of the typeinfo structure
 866      * There are several distinctive parts.
 867      * the first part starts with a field that holds the total length
 868      * of this (first) part excluding this field. Then follow the records,
 869      * for each member there is one record.
 870      *
 871      * First entry is always the length of the record (excluding this
 872      * length word).
 873      * Rest of the record depends on the type of the member. If there is
 874      * a field indicating the member type (function variable intereface etc)
 875      * I have not found it yet. At this time we depend on the information
 876      * in the type info and the usual order how things are stored.
 877      *
 878      * Second follows an array sized nrMEM*sizeof(INT) with a memeber id
 879      * for each member;
 880      *
 881      * Third is a equal sized array with file offsets to the name entry
 882      * of each member.
 883      *
 884      * Forth and last (?) part is an array with offsets to the records in the
 885      * first part of this file segment.
 886      */
 887
 888     int infolen, nameoffset, reclength, nrattributes;
 889     char recbuf[512];
 890     TLBFuncRecord * pFuncRec=(TLBFuncRecord *) recbuf;
 891     int i, j;
 892     int recoffset=offset+sizeof(INT);
 893
 894     TRACE("\n");
 895
 896     TLB_Read(&infolen,sizeof(INT), pcx, offset);
 897     for(i=0;i<cFuncs;i++){
 898         *pptfd=TLB_Alloc(sizeof(TLBFuncDesc));
 899     /* name, eventually add to a hash table */
 900         TLB_Read(&nameoffset, sizeof(INT), pcx,
 901             offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
 902         (*pptfd)->Name=TLB_ReadName(pcx, nameoffset);
 903     /* read the function information record */
 904         TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
 905         reclength &=0x1ff;
 906         TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
 907     /* do the attributes */
 908         nrattributes=(reclength-pFuncRec->nrargs*3*sizeof(int)-0x18)
 909             /sizeof(int);
 910         if(nrattributes>0){
 911             (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
 912             if(nrattributes>1){
 913                 (*pptfd)->HelpString = TLB_ReadString(pcx,
 914                                                       pFuncRec->OptAttr[1]) ;
 915                 if(nrattributes>2){
 916                     if(pFuncRec->FKCCIC & 0x2000)
 917                         (*pptfd)->Entry = (WCHAR*) pFuncRec->OptAttr[2] ;
 918                     else
 919                         (*pptfd)->Entry = TLB_ReadString(pcx,
 920                                                          pFuncRec->OptAttr[2]);
 921                     if(nrattributes>5 )
 922                         (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
 923                     if(nrattributes>6 && pFuncRec->FKCCIC & 0x80){
 924                         TLB_CustData(pcx, pFuncRec->OptAttr[6],
 925                                 &(*pptfd)->pCustData);
 926                     }
 927                 }
 928             }
 929         }
 930     /* fill the FuncDesc Structure */
 931         TLB_Read(&(*pptfd)->funcdesc.memid, sizeof(INT), pcx,
 932             offset + infolen + ( i + 1) * sizeof(INT));
 933         (*pptfd)->funcdesc.funckind = (pFuncRec->FKCCIC) & 0x7;
 934         (*pptfd)->funcdesc.invkind = ((pFuncRec->FKCCIC) >>3) & 0xF;
 935         (*pptfd)->funcdesc.callconv = (pFuncRec->FKCCIC) >>8 & 0xF;
 936         (*pptfd)->funcdesc.cParams = pFuncRec->nrargs ;
 937         (*pptfd)->funcdesc.cParamsOpt = pFuncRec->nroargs ;
 938         (*pptfd)->funcdesc.oVft = pFuncRec->VtableOffset ;
 939         (*pptfd)->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags)  ;
 940         TLB_GetTdesc(pcx, pFuncRec->DataType,
 941             &(*pptfd)->funcdesc.elemdescFunc.tdesc) ;
 942
 943         /* do the parameters/arguments */
 944         if(pFuncRec->nrargs){
 945             TLBParameterInfo paraminfo;
 946             (*pptfd)->funcdesc.lprgelemdescParam=
 947                 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
 948             (*pptfd)->pParamDesc=TLB_Alloc(pFuncRec->nrargs *
 949                 sizeof(TLBParDesc));
 950
 951             TLB_Read(&paraminfo,sizeof(paraminfo), pcx, recoffset+reclength -
 952                 pFuncRec->nrargs * sizeof(TLBParameterInfo));
 953             for(j=0;j<pFuncRec->nrargs;j++){
 954                                 TYPEDESC* lpArgTypeDesc = 0;
 955
 956                 TLB_GetTdesc(pcx, paraminfo.DataType,
 957                     &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
 958                 V_UNION(&((*pptfd)->funcdesc.lprgelemdescParam[j]),
 959                     paramdesc.wParamFlags) = paraminfo.Flags;
 960                 (*pptfd)->pParamDesc[j].Name=(void *)paraminfo.oName;
 961
 962                                 /* SEEK value = jump to offset, from there jump to the end of record,
 963                                  * go back by (j-1) arguments
 964                                  */
 965                                 TLB_Read(&paraminfo,sizeof(TLBParameterInfo), pcx,
 966                         recoffset+reclength -
 967                                                 ((pFuncRec->nrargs - j - 1) * sizeof(TLBParameterInfo)));
 968
 969                 lpArgTypeDesc = & ((*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
 970
 971                 while (lpArgTypeDesc != NULL)
 972                 {
 973                    switch (lpArgTypeDesc->vt)
 974                    {
 975                      case VT_PTR:
 976                        lpArgTypeDesc = lpArgTypeDesc->u.lptdesc;
 977                        break;
 978
 979                      case VT_CARRAY:
 980                        lpArgTypeDesc = & (lpArgTypeDesc->u.lpadesc->tdescElem);
 981                        break;
 982
 983                      case VT_USERDEFINED:
 984                        (*pptfd)->pParamDesc[j].pRefType = TLB_Alloc(sizeof(TLBRefType));
 985                        TLB_DoRefType(pcx, lpArgTypeDesc->u.hreftype, &((*pptfd)->pParamDesc[j].pRefType));
 986                        lpArgTypeDesc = NULL;
 987                        break;
 988
 989                      default:
 990                        lpArgTypeDesc = NULL;
 991                    }
 992                 }
 993             }
 994             /* second time around */
 995             for(j=0;j<pFuncRec->nrargs;j++){
 996                 /* name */
 997                 (*pptfd)->pParamDesc[j].Name=
 998                     TLB_ReadName(pcx, (int)(*pptfd)->pParamDesc[j].Name);
 999                 /* default value */
1000                 if((PARAMFLAG_FHASDEFAULT & V_UNION(&((*pptfd)->funcdesc.
1001                     lprgelemdescParam[j]),paramdesc.wParamFlags)) &&
1002                     ((pFuncRec->FKCCIC) & 0x1000)){
1003                     INT *pInt=(INT *)((char *)pFuncRec + reclength -
1004                         (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
1005                     PARAMDESC * pParamDesc= &V_UNION(&((*pptfd)->funcdesc.
1006                         lprgelemdescParam[j]),paramdesc);
1007                     pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
1008                     pParamDesc->pparamdescex->cBytes= sizeof(PARAMDESCEX);
1009                     TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
1010                         pInt[j], pcx);
1011                 }
1012                 /* custom info */
1013                 if(nrattributes>7+j && pFuncRec->FKCCIC & 0x80)
1014                     TLB_CustData(pcx, pFuncRec->OptAttr[7+j],
1015                                                                         &(*pptfd)->pParamDesc[j].pCustData);
1016             }
1017         }
1018     /* scode is not used: archaic win16 stuff FIXME: right? */
1019         (*pptfd)->funcdesc.cScodes = 0 ;
1020         (*pptfd)->funcdesc.lprgscode = NULL ;
1021         pptfd=&((*pptfd)->next);
1022         recoffset += reclength;
1023     }
1024 }
1025 static void TLB_DoVars(TLBContext *pcx, int cFuncs, int cVars,
1026                           int offset, TLBVarDesc ** pptvd)
1027 {
1028     int infolen, nameoffset, reclength;
1029     char recbuf[256];
1030     TLBVarRecord * pVarRec=(TLBVarRecord *) recbuf;
1031     int i;
1032     int recoffset;
1033
1034     TRACE("\n");
1035
1036     TLB_Read(&infolen,sizeof(INT), pcx, offset);
1037     TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen +
1038         ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
1039     recoffset += offset+sizeof(INT);
1040     for(i=0;i<cVars;i++){
1041         *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
1042     /* name, eventually add to a hash table */
1043         TLB_Read(&nameoffset, sizeof(INT), pcx,
1044             offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1045         (*pptvd)->Name=TLB_ReadName(pcx, nameoffset);
1046     /* read the variable information record */
1047         TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
1048         reclength &=0xff;
1049         TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
1050     /* Optional data */
1051         if(reclength >(6*sizeof(INT)) )
1052             (*pptvd)->HelpContext=pVarRec->HelpContext;
1053         if(reclength >(7*sizeof(INT)) )
1054             (*pptvd)->HelpString = TLB_ReadString(pcx, pVarRec->oHelpString) ;
1055         if(reclength >(8*sizeof(INT)) )
1056         if(reclength >(9*sizeof(INT)) )
1057             (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
1058     /* fill the VarDesc Structure */
1059         TLB_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
1060             offset + infolen + ( i + 1) * sizeof(INT));
1061         (*pptvd)->vardesc.varkind = pVarRec->VarKind;
1062         (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
1063         TLB_GetTdesc(pcx, pVarRec->DataType,
1064             &(*pptvd)->vardesc.elemdescVar.tdesc) ;
1065 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
1066         if(pVarRec->VarKind == VAR_CONST ){
1067             V_UNION(&((*pptvd)->vardesc),lpvarValue)=TLB_Alloc(sizeof(VARIANT));
1068             TLB_ReadValue(V_UNION(&((*pptvd)->vardesc),lpvarValue),
1069                 pVarRec->OffsValue, pcx);
1070         }else
1071             V_UNION(&((*pptvd)->vardesc),oInst)=pVarRec->OffsValue;
1072         pptvd=&((*pptvd)->next);
1073         recoffset += reclength;
1074     }
1075 }
1076 /* fill in data for a hreftype (offset). When the refernced type is contained
1077  * in the typelib, its just an (file) offset in the type info base dir.
1078  * If comes from import, its an offset+1 in the ImpInfo table
1079  * */
1080 static void TLB_DoRefType(TLBContext *pcx,
1081                           int offset, TLBRefType ** pprtd)
1082 {
1083     int j;
1084
1085         TRACE("TLB context %p, TLB offset %x\n", pcx, offset);
1086
1087     if(!HREFTYPE_INTHISFILE( offset)) {
1088         /* external typelib */
1089         TLBImpInfo impinfo;
1090         TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
1091
1092         TRACE("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
1093
1094         TLB_Read(&impinfo, sizeof(impinfo), pcx,
1095             pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
1096         for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
1097             if(pImpLib->offset==impinfo.oImpFile) break;
1098             pImpLib=pImpLib->next;
1099         }
1100         if(pImpLib){
1101             (*pprtd)->reference=offset;
1102             (*pprtd)->pImpTLInfo = pImpLib;
1103             TLB_ReadGuid(&(*pprtd)->guid, impinfo.oGuid, pcx);
1104         }else{
1105             ERR("Cannot find a reference\n");
1106             (*pprtd)->reference=-1;
1107             (*pprtd)->pImpTLInfo=(void *)-1;
1108         }
1109     }else{
1110         /* in this typelib */
1111         (*pprtd)->reference=offset;
1112         (*pprtd)->pImpTLInfo=(void *)-2;
1113     }
1114 }
1115
1116 /* process Implemented Interfaces of a com class */
1117 static void TLB_DoImplTypes(TLBContext *pcx, int count,
1118                           int offset, TLBRefType ** pprtd)
1119 {
1120     int i;
1121     TLBRefRecord refrec;
1122
1123     TRACE("\n");
1124
1125     for(i=0;i<count;i++){
1126         if(offset<0) break; /* paranoia */
1127         *pprtd=TLB_Alloc(sizeof(TLBRefType));
1128         TLB_Read(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
1129         TLB_DoRefType(pcx, refrec.reftype, pprtd);
1130         (*pprtd)->flags=refrec.flags;
1131         (*pprtd)->ctCustData=
1132             TLB_CustData(pcx, refrec.oCustData, &(*pprtd)->pCustData);
1133         offset=refrec.onext;
1134         pprtd=&((*pprtd)->next);
1135     }
1136 }
1137 /*
1138  * process a typeinfo record
1139  */
1140 ITypeInfoImpl * TLB_DoTypeInfo(
1141         TLBContext *pcx,
1142         int count,
1143         ITypeLibImpl * pLibInfo)
1144 {
1145     TLBTypeInfoBase tiBase;
1146     ITypeInfoImpl *ptiRet;
1147
1148     TRACE("count=%u\n", count);
1149
1150     ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
1151     TLB_Read(&tiBase, sizeof(tiBase) ,pcx ,
1152         pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
1153 /* this where we are coming from */
1154     ptiRet->pTypeLib = pLibInfo;
1155     ptiRet->index=count;
1156 /* fill in the typeattr fields */
1157     TLB_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
1158     ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid;   /* FIXME: correct? */
1159     ptiRet->TypeAttr.memidConstructor=MEMBERID_NIL ;/* FIXME */
1160     ptiRet->TypeAttr.memidDestructor=MEMBERID_NIL ; /* FIXME */
1161     ptiRet->TypeAttr.lpstrSchema=NULL;              /* reserved */
1162     ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
1163     ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
1164     ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
1165     ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
1166     ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
1167     ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
1168     ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
1169     ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
1170     ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
1171     ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
1172     if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
1173         TLB_GetTdesc(pcx, tiBase.datatype1,
1174             &ptiRet->TypeAttr.tdescAlias) ;
1175
1176 /*  FIXME: */
1177 /*    IDLDESC  idldescType; *//* never saw this one != zero  */
1178
1179 /* name, eventually add to a hash table */
1180     ptiRet->Name=TLB_ReadName(pcx, tiBase.NameOffset);
1181     TRACE("reading %s\n", debugstr_w(ptiRet->Name));
1182     /* help info */
1183     ptiRet->DocString=TLB_ReadString(pcx, tiBase.docstringoffs);
1184     ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
1185     ptiRet->dwHelpContext=tiBase.helpcontext;
1186 /* note: InfoType's Help file and HelpStringDll come from the containing
1187  * library. Further HelpString and Docstring appear to be the same thing :(
1188  */
1189     /* functions */
1190     if(ptiRet->TypeAttr.cFuncs >0 )
1191         TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
1192         tiBase.memoffset, & ptiRet->funclist);
1193     /* variables */
1194     if(ptiRet->TypeAttr.cVars >0 )
1195         TLB_DoVars(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
1196         tiBase.memoffset, & ptiRet->varlist);
1197     if(ptiRet->TypeAttr.cImplTypes >0 ){
1198         switch(ptiRet->TypeAttr.typekind)
1199                 {
1200                 case TKIND_COCLASS:
1201             TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes ,
1202                 tiBase.datatype1, & ptiRet->impltypelist);
1203                         break;
1204                 case TKIND_DISPATCH:
1205             ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
1206
1207             if (tiBase.datatype1 != -1)
1208             {
1209               TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
1210             }
1211             else
1212             {
1213               char* szStdOle     = "stdole2.tlb\0";
1214               int   nStdOleLen = strlen(szStdOle);
1215
1216               ptiRet->impltypelist->guid             = IID_IDispatch;
1217               ptiRet->impltypelist->reference        = -1;
1218               ptiRet->impltypelist->pImpTLInfo       = TLB_Alloc(sizeof(TLBImpLib));
1219               ptiRet->impltypelist->pImpTLInfo->guid = IID_StdOle;
1220               ptiRet->impltypelist->pImpTLInfo->name = SysAllocStringLen(NULL, nStdOleLen  + 1);
1221
1222               MultiByteToWideChar(CP_ACP,
1223                                   MB_PRECOMPOSED,
1224                                   szStdOle,
1225                                   -1,
1226                                   ptiRet->impltypelist->pImpTLInfo->name,
1227                                   SysStringLen(ptiRet->impltypelist->pImpTLInfo->name));
1228
1229               ptiRet->impltypelist->pImpTLInfo->lcid          = 0;
1230               ptiRet->impltypelist->pImpTLInfo->wVersionMajor = 2;
1231               ptiRet->impltypelist->pImpTLInfo->wVersionMinor = 0;
1232             }
1233                         break;
1234                 default:
1235                         ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
1236             TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
1237                         break;
1238                 }
1239     }
1240     ptiRet->ctCustData=
1241         TLB_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
1242
1243     TRACE("%s guid: %s kind:%s\n",
1244        debugstr_w(ptiRet->Name),
1245        debugstr_guid(&ptiRet->TypeAttr.guid),
1246        typekind_desc[ptiRet->TypeAttr.typekind]);
1247
1248     return ptiRet;
1249 }
1250
1251 /****************************************************************************
1252  *      TLB_ReadTypeLib
1253  *
1254  * find the type of the typelib file and map the typelib resource into
1255  * the memory
1256  */
1257 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
1258 int TLB_ReadTypeLib(LPSTR pszFileName, ITypeLib2 **ppTypeLib)
1259 {
1260     int ret = E_FAIL;
1261     DWORD dwSignature = 0;
1262     HFILE hFile;
1263         int nStrLen = strlen(pszFileName);
1264         int i;
1265
1266         PCHAR pszTypeLibIndex = NULL;
1267     PCHAR pszDllName      = NULL;
1268
1269     TRACE("%s\n", pszFileName);
1270
1271     *ppTypeLib = NULL;
1272
1273     /* is it a DLL? */
1274         for (i=0 ; i < nStrLen ; ++i)
1275         {
1276             pszFileName[i] = tolower(pszFileName[i]);
1277         }
1278     pszTypeLibIndex = strstr(pszFileName, ".dll");
1279
1280     /* find if there's a back-slash after .DLL (good sign of the presence of a typelib index) */
1281     if (pszTypeLibIndex)
1282     {
1283       pszTypeLibIndex = strstr(pszTypeLibIndex, "\\");
1284     }
1285
1286     /* is there any thing after trailing back-slash  ? */
1287     if (pszTypeLibIndex && pszTypeLibIndex < pszFileName + nStrLen)
1288     {
1289       /* yes -> it's a index! store DLL name, without the trailing back-slash */
1290       size_t nMemToAlloc = pszTypeLibIndex - pszFileName;
1291
1292       pszDllName = HeapAlloc(GetProcessHeap(),
1293                           HEAP_ZERO_MEMORY,
1294                           nMemToAlloc + 1);
1295
1296       strncpy(pszDllName, pszFileName, nMemToAlloc);
1297
1298       /* move index string pointer pass the backslash */
1299       ++pszTypeLibIndex;
1300     }
1301     else
1302     {
1303       /* No index, reset variable to 1 */
1304       pszDllName = HeapAlloc(GetProcessHeap(),
1305                           HEAP_ZERO_MEMORY,
1306                           nStrLen + 1);
1307
1308       strncpy(pszDllName, pszFileName, nStrLen);
1309
1310       pszTypeLibIndex = "1\0";
1311     }
1312
1313     TRACE("File name without index %s\n", pszDllName);
1314     TRACE("Index of typelib %s\n",        pszTypeLibIndex);
1315
1316
1317     /* check the signature of the file */
1318     hFile = CreateFileA( pszDllName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, -1 );
1319     if (INVALID_HANDLE_VALUE != hFile)
1320     {
1321       HANDLE hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL );
1322       if (hMapping)
1323       {
1324         LPVOID pBase = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
1325         if(pBase)
1326         {
1327           /* first try to load as *.tlb */
1328           dwSignature = *((DWORD*) pBase);
1329           if ( dwSignature == MSFT_SIGNATURE)
1330           {
1331             /* retrieve file size */
1332             DWORD dwTLBLength = GetFileSize(hFile, NULL);
1333
1334             *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
1335           }
1336           UnmapViewOfFile(pBase);
1337         }
1338         CloseHandle(hMapping);
1339       }
1340       CloseHandle(hFile);
1341     }
1342
1343     if( (WORD)dwSignature == IMAGE_DOS_SIGNATURE )
1344     {
1345       /* find the typelibrary resource*/
1346       HINSTANCE hinstDLL = LoadLibraryExA(pszDllName, 0, DONT_RESOLVE_DLL_REFERENCES|
1347                                           LOAD_LIBRARY_AS_DATAFILE|LOAD_WITH_ALTERED_SEARCH_PATH);
1348       if (hinstDLL)
1349       {
1350         HRSRC hrsrc = FindResourceA(hinstDLL, MAKEINTRESOURCEA(atoi(pszTypeLibIndex)), "TYPELIB");
1351         if (hrsrc)
1352         {
1353           HGLOBAL hGlobal = LoadResource(hinstDLL, hrsrc);
1354           if (hGlobal)
1355           {
1356             LPVOID pBase = LockResource(hGlobal);
1357             DWORD  dwTLBLength = SizeofResource(hinstDLL, hrsrc);
1358
1359             if (pBase)
1360             {
1361               /* try to load as incore resource */
1362               dwSignature = *((DWORD*) pBase);
1363               if ( dwSignature == MSFT_SIGNATURE)
1364                   *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
1365               else
1366                 FIXME("Header type magic 0x%08lx not supported.\n",dwSignature);
1367             }
1368             FreeResource( hGlobal );
1369           }
1370         }
1371         FreeLibrary(hinstDLL);
1372       }
1373     }
1374
1375         HeapFree(GetProcessHeap(), 0, pszDllName);
1376
1377     if(*ppTypeLib)
1378       ret = S_OK;
1379     else
1380       ERR("Loading of typelib %s failed with error 0x%08lx\n", pszFileName, GetLastError());
1381
1382     return ret;
1383 }
1384
1385 /*================== ITypeLib(2) Methods ===================================*/
1386
1387 /****************************************************************************
1388  *      ITypeLib2_Constructor
1389  *
1390  * loading a typelib from a in-memory image
1391  */
1392 static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength)
1393 {
1394     TLBContext cx;
1395     long lPSegDir;
1396     TLB2Header tlbHeader;
1397     TLBSegDir tlbSegDir;
1398     ITypeLibImpl * pTypeLibImpl;
1399
1400     TRACE("%p, TLB length = %ld\n", pLib, dwTLBLength);
1401
1402     pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
1403     if (!pTypeLibImpl) return NULL;
1404
1405     ICOM_VTBL(pTypeLibImpl) = &tlbvt;
1406     pTypeLibImpl->ref = 1;
1407
1408     /* get pointer to beginning of typelib data */
1409     cx.pos = 0;
1410     cx.oStart=0;
1411     cx.mapping = pLib;
1412     cx.pLibInfo = pTypeLibImpl;
1413     cx.length = dwTLBLength;
1414
1415     /* read header */
1416     TLB_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
1417     TRACE("header:\n");
1418     TRACE("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
1419     if (memcmp(&tlbHeader.magic1,TLBMAGIC2,4)) {
1420         FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
1421         return NULL;
1422     }
1423     /* there is a small number of information here until the next important
1424      * part:
1425      * the segment directory . Try to calculate the amount of data */
1426     lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
1427
1428     /* now read the segment directory */
1429     TRACE("read segment directory (at %ld)\n",lPSegDir);
1430     TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
1431     cx.pTblDir = &tlbSegDir;
1432
1433     /* just check two entries */
1434     if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
1435     {
1436         ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
1437         HeapFree(GetProcessHeap(),0,pTypeLibImpl);
1438         return NULL;
1439     }
1440
1441     /* now fill our internal data */
1442     /* TLIBATTR fields */
1443     TLB_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
1444     pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;
1445     pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
1446     pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
1447     pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
1448     pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
1449
1450     /* name, eventually add to a hash table */
1451     pTypeLibImpl->Name = TLB_ReadName(&cx, tlbHeader.NameOffset);
1452
1453     /* help info */
1454     pTypeLibImpl->DocString = TLB_ReadString(&cx, tlbHeader.helpstring);
1455     pTypeLibImpl->HelpFile = TLB_ReadString(&cx, tlbHeader.helpfile);
1456
1457     if( tlbHeader.varflags & HELPDLLFLAG)
1458     {
1459             int offset;
1460             TLB_Read(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
1461             pTypeLibImpl->HelpStringDll = TLB_ReadString(&cx, offset);
1462     }
1463
1464     pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
1465
1466     /* custom data */
1467     if(tlbHeader.CustomDataOffset >= 0)
1468     {
1469         pTypeLibImpl->ctCustData = TLB_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
1470     }
1471
1472     /* fill in typedescriptions */
1473     if(tlbSegDir.pTypdescTab.length > 0)
1474     {
1475         int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
1476         INT16 td[4];
1477         pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
1478         TLB_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
1479         for(i=0; i<cTD; )
1480         {
1481             /* FIXME: add several sanity checks here */
1482             pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
1483             if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
1484             {
1485                 /* FIXME: check safearray */
1486                 if(td[3] < 0)
1487                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & stndTypeDesc[td[2]];
1488                 else
1489                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & pTypeLibImpl->pTypeDesc[td[2]/8];
1490             }
1491             else if(td[0] == VT_CARRAY)
1492             {
1493                 /* array descr table here */
1494                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = (void *)((int) td[2]);  /* temp store offset in*/
1495             }
1496             else if(td[0] == VT_USERDEFINED)
1497             {
1498                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),hreftype) = MAKELONG(td[2],td[3]);
1499             }
1500             if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
1501         }
1502
1503         /* second time around to fill the array subscript info */
1504         for(i=0;i<cTD;i++)
1505         {
1506             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
1507             if(tlbSegDir.pArrayDescriptions.offset>0)
1508             {
1509                 TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc));
1510                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
1511
1512                 if(td[1]<0)
1513                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem.vt = td[0] & VT_TYPEMASK;
1514                 else
1515                     V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem = stndTypeDesc[td[0]/8];
1516
1517                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->cDims = td[2];
1518
1519                 for(j = 0; j<td[2]; j++)
1520                 {
1521                     TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].cElements,
1522                         sizeof(INT), &cx, DO_NOT_SEEK);
1523                     TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].lLbound,
1524                         sizeof(INT), &cx, DO_NOT_SEEK);
1525                 }
1526             }
1527             else
1528             {
1529                 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = NULL;
1530                 ERR("didn't find array description data\n");
1531             }
1532         }
1533     }
1534
1535     /* imported type libs */
1536     if(tlbSegDir.pImpFiles.offset>0)
1537     {
1538         TLBImpLib **ppImpLib = &(pTypeLibImpl->pImpLibs);
1539         int oGuid, offset = tlbSegDir.pImpFiles.offset;
1540         UINT16 size;
1541
1542         while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
1543         {
1544             *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
1545             (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
1546             TLB_Read(&oGuid, sizeof(INT), &cx, offset);
1547
1548                         TLB_Read(&(*ppImpLib)->lcid,          sizeof(LCID),   &cx, DO_NOT_SEEK);
1549             TLB_Read(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
1550             TLB_Read(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
1551             TLB_Read(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
1552
1553             size >>= 2;
1554             (*ppImpLib)->name = TLB_Alloc(size+1);
1555             TLB_Read((*ppImpLib)->name, size, &cx, DO_NOT_SEEK);
1556             TLB_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
1557             offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & 0xfffffffc;
1558
1559             ppImpLib = &(*ppImpLib)->next;
1560         }
1561     }
1562
1563     /* type info's */
1564     if(tlbHeader.nrtypeinfos >= 0 )
1565     {
1566         /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
1567         ITypeInfoImpl **ppTI = &(pTypeLibImpl->pTypeInfo);
1568         int i;
1569
1570         for(i = 0; i<(int)tlbHeader.nrtypeinfos; i++)
1571                 {
1572             *ppTI = TLB_DoTypeInfo(&cx, i, pTypeLibImpl);
1573
1574             ppTI = &((*ppTI)->next);
1575             (pTypeLibImpl->TypeInfoCount)++;
1576         }
1577     }
1578
1579     TRACE("(%p)\n", pTypeLibImpl);
1580     return (ITypeLib2*) pTypeLibImpl;
1581 }
1582
1583 /* ITypeLib::QueryInterface
1584  */
1585 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
1586         ITypeLib2 * iface,
1587         REFIID riid,
1588         VOID **ppvObject)
1589 {
1590     ICOM_THIS( ITypeLibImpl, iface);
1591
1592     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
1593
1594     *ppvObject=NULL;
1595     if(IsEqualIID(riid, &IID_IUnknown) ||
1596        IsEqualIID(riid,&IID_ITypeLib)||
1597        IsEqualIID(riid,&IID_ITypeLib2))
1598     {
1599         *ppvObject = This;
1600     }
1601
1602     if(*ppvObject)
1603     {
1604         ITypeLib2_AddRef(iface);
1605         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
1606         return S_OK;
1607     }
1608     TRACE("-- Interface: E_NOINTERFACE\n");
1609     return E_NOINTERFACE;
1610 }
1611
1612 /* ITypeLib::AddRef
1613  */
1614 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
1615 {
1616     ICOM_THIS( ITypeLibImpl, iface);
1617
1618     TRACE("(%p)->ref is %u\n",This, This->ref);
1619
1620     return ++(This->ref);
1621 }
1622
1623 /* ITypeLib::Release
1624  */
1625 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
1626 {
1627     ICOM_THIS( ITypeLibImpl, iface);
1628
1629     TRACE("(%p)->(%u)\n",This, This->ref);
1630
1631     if (!--(This->ref))
1632     {
1633       /* fixme destroy child objects */
1634
1635       TRACE(" destroying ITypeLib(%p)\n",This);
1636
1637           if (This->Name)
1638           {
1639                   SysFreeString(This->Name);
1640                   This->Name = NULL;
1641           }
1642
1643           if (This->DocString)
1644           {
1645                   SysFreeString(This->DocString);
1646                   This->DocString = NULL;
1647           }
1648
1649           if (This->HelpFile)
1650           {
1651                   SysFreeString(This->HelpFile);
1652                   This->HelpFile = NULL;
1653           }
1654
1655           if (This->HelpStringDll)
1656           {
1657                   SysFreeString(This->HelpStringDll);
1658                   This->HelpStringDll = NULL;
1659           }
1660
1661           ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
1662       HeapFree(GetProcessHeap(),0,This);
1663       return 0;
1664     }
1665     return This->ref;
1666 }
1667
1668 /* ITypeLib::GetTypeInfoCount
1669  *
1670  * Returns the number of type descriptions in the type library
1671  */
1672 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
1673 {
1674     ICOM_THIS( ITypeLibImpl, iface);
1675     TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
1676     return This->TypeInfoCount;
1677 }
1678
1679 /* ITypeLib::GetTypeInfo
1680  *
1681  * retrieves the specified type description in the library.
1682  */
1683 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
1684         ITypeLib2 *iface,
1685         UINT index,
1686         ITypeInfo **ppTInfo)
1687 {
1688     int i;
1689     ICOM_THIS( ITypeLibImpl, iface);
1690     ITypeInfoImpl *pTLBTInfo = This->pTypeInfo;
1691
1692     TRACE("(%p)->(index=%d) \n",This, index);
1693
1694     if (!ppTInfo) return E_INVALIDARG;
1695
1696     /* search element n in list */
1697     for(i=0; i < index; i++)
1698     {
1699       pTLBTInfo = pTLBTInfo->next;
1700       if (!pTLBTInfo)
1701       {
1702         TRACE("-- element not found\n");
1703         return TYPE_E_ELEMENTNOTFOUND;
1704       }
1705     }
1706
1707     *ppTInfo = (ITypeInfo *) pTLBTInfo;
1708     ITypeInfo_AddRef(*ppTInfo);
1709     TRACE("-- found (%p)\n",*ppTInfo);
1710     return S_OK;
1711 }
1712
1713 /* ITypeLibs::GetTypeInfoType
1714  *
1715  * Retrieves the type of a type description.
1716  */
1717 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
1718         ITypeLib2 *iface,
1719         UINT index,
1720         TYPEKIND *pTKind)
1721 {
1722     ICOM_THIS( ITypeLibImpl, iface);
1723     int i;
1724     ITypeInfoImpl *pTInfo = This->pTypeInfo;
1725
1726     TRACE("(%p) index %d \n",This, index);
1727
1728     if(!pTKind) return E_INVALIDARG;
1729
1730     /* search element n in list */
1731     for(i=0; i < index; i++)
1732     {
1733       if(!pTInfo)
1734       {
1735         TRACE("-- element not found\n");
1736         return TYPE_E_ELEMENTNOTFOUND;
1737       }
1738       pTInfo = pTInfo->next;
1739     }
1740
1741     *pTKind = pTInfo->TypeAttr.typekind;
1742     TRACE("-- found Type (%d)\n", *pTKind);
1743     return S_OK;
1744 }
1745
1746 /* ITypeLib::GetTypeInfoOfGuid
1747  *
1748  * Retrieves the type description that corresponds to the specified GUID.
1749  *
1750  */
1751 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
1752         ITypeLib2 *iface,
1753         REFGUID guid,
1754         ITypeInfo **ppTInfo)
1755 {
1756     ICOM_THIS( ITypeLibImpl, iface);
1757     ITypeInfoImpl *ppTLBTInfo = This->pTypeInfo; /* head of list */
1758
1759     TRACE("(%p)\n\tguid:\t%s)\n",This,debugstr_guid(guid));
1760
1761     /* serach linked list for guid */
1762     while( !IsEqualIID(guid,&ppTLBTInfo->TypeAttr.guid) )
1763     {
1764       ppTLBTInfo = ppTLBTInfo->next;
1765       if (!ppTLBTInfo)
1766       {
1767         /* end of list reached */
1768         TRACE("-- element not found\n");
1769         return TYPE_E_ELEMENTNOTFOUND;
1770       }
1771     }
1772
1773     TRACE("-- found (%p, %s)\n", ppTLBTInfo, debugstr_w(ppTLBTInfo->Name));
1774
1775     *ppTInfo = (ITypeInfo*)ppTLBTInfo;
1776     ITypeInfo_AddRef(*ppTInfo);
1777     return S_OK;
1778 }
1779
1780 /* ITypeLib::GetLibAttr
1781  *
1782  * Retrieves the structure that contains the library's attributes.
1783  *
1784  */
1785 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
1786         ITypeLib2 *iface,
1787         LPTLIBATTR *ppTLibAttr)
1788 {
1789     ICOM_THIS( ITypeLibImpl, iface);
1790     TRACE("(%p)\n",This);
1791     /* FIXME: must do a copy here */
1792     *ppTLibAttr=&This->LibAttr;
1793     return S_OK;
1794 }
1795
1796 /* ITypeLib::GetTypeComp
1797  *
1798  * Enables a client compiler to bind to a library's types, variables,
1799  * constants, and global functions.
1800  *
1801  */
1802 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
1803         ITypeLib2 *iface,
1804         ITypeComp **ppTComp)
1805 {
1806     ICOM_THIS( ITypeLibImpl, iface);
1807     FIXME("(%p): stub!\n",This);
1808     return E_NOTIMPL;
1809 }
1810
1811 /* ITypeLib::GetDocumentation
1812  *
1813  * Retrieves the library's documentation string, the complete Help file name
1814  * and path, and the context identifier for the library Help topic in the Help
1815  * file.
1816  *
1817  */
1818 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
1819         ITypeLib2 *iface,
1820         INT index,
1821         BSTR *pBstrName,
1822         BSTR *pBstrDocString,
1823         DWORD *pdwHelpContext,
1824         BSTR *pBstrHelpFile)
1825 {
1826         ICOM_THIS( ITypeLibImpl, iface);
1827     HRESULT result;
1828     ITypeInfo *pTInfo;
1829     TRACE("(%p) index %d Name(%p) DocString(%p)"
1830            " HelpContext(%p) HelpFile(%p)\n",
1831         This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
1832     if(index<0){ /* documentation for the typelib */
1833         if(pBstrName)
1834             *pBstrName=SysAllocString(This->Name);
1835         if(pBstrDocString)
1836             *pBstrDocString=SysAllocString(This->DocString);
1837         if(pdwHelpContext)
1838             *pdwHelpContext=This->dwHelpContext;
1839         if(pBstrHelpFile)
1840             *pBstrHelpFile=SysAllocString(This->HelpFile);
1841     }else {/* for a typeinfo */
1842         result=ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
1843         if(SUCCEEDED(result)){
1844             result=ITypeInfo_GetDocumentation(pTInfo, MEMBERID_NIL,  pBstrName,
1845                 pBstrDocString, pdwHelpContext, pBstrHelpFile);
1846             ITypeInfo_Release(pTInfo);
1847         }
1848         if(!SUCCEEDED(result))
1849             return result;
1850     }
1851     return S_OK;
1852 }
1853
1854 /* ITypeLib::IsName
1855  *
1856  * Indicates whether a passed-in string contains the name of a type or member
1857  * described in the library.
1858  *
1859  */
1860 static HRESULT WINAPI ITypeLib2_fnIsName(
1861         ITypeLib2 *iface,
1862         LPOLESTR szNameBuf,
1863         ULONG lHashVal,
1864         BOOL *pfName)
1865 {
1866     ICOM_THIS( ITypeLibImpl, iface);
1867     ITypeInfoImpl *pTInfo;
1868     TLBFuncDesc *pFInfo;
1869     TLBVarDesc *pVInfo;
1870     int i;
1871     UINT nNameBufLen = SysStringLen(szNameBuf);
1872
1873     TRACE("(%p)->(%s,%08lx,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
1874           pfName);
1875
1876     *pfName=TRUE;
1877     for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
1878         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
1879         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
1880             if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
1881             for(i=0;i<pFInfo->funcdesc.cParams;i++)
1882                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name, nNameBufLen))
1883                     goto ITypeLib2_fnIsName_exit;
1884         }
1885         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
1886             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
1887
1888     }
1889     *pfName=FALSE;
1890
1891 ITypeLib2_fnIsName_exit:
1892     TRACE("(%p)slow! search for %s: %s found!\n", This,
1893           debugstr_w(szNameBuf), *pfName?"NOT":"");
1894
1895     return S_OK;
1896 }
1897
1898 /* ITypeLib::FindName
1899  *
1900  * Finds occurrences of a type description in a type library. This may be used
1901  * to quickly verify that a name exists in a type library.
1902  *
1903  */
1904 static HRESULT WINAPI ITypeLib2_fnFindName(
1905         ITypeLib2 *iface,
1906         LPOLESTR szNameBuf,
1907         ULONG lHashVal,
1908         ITypeInfo **ppTInfo,
1909         MEMBERID *rgMemId,
1910         UINT16 *pcFound)
1911 {
1912     ICOM_THIS( ITypeLibImpl, iface);
1913     ITypeInfoImpl *pTInfo;
1914     TLBFuncDesc *pFInfo;
1915     TLBVarDesc *pVInfo;
1916     int i,j = 0;
1917
1918     UINT nNameBufLen = SysStringLen(szNameBuf);
1919
1920     for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
1921         if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
1922         for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
1923             if(!memcmp(szNameBuf,pFInfo->Name,nNameBufLen)) goto ITypeLib2_fnFindName_exit;
1924             for(i=0;i<pFInfo->funcdesc.cParams;i++)
1925                 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name,nNameBufLen))
1926                     goto ITypeLib2_fnFindName_exit;
1927         }
1928         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next) ;
1929             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
1930         continue;
1931 ITypeLib2_fnFindName_exit:
1932         ITypeInfo_AddRef((ITypeInfo*)pTInfo);
1933         ppTInfo[j]=(LPTYPEINFO)pTInfo;
1934         j++;
1935     }
1936     TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
1937           This, *pcFound, debugstr_w(szNameBuf), j);
1938
1939     *pcFound=j;
1940
1941     return S_OK;
1942 }
1943
1944 /* ITypeLib::ReleaseTLibAttr
1945  *
1946  * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
1947  *
1948  */
1949 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
1950         ITypeLib2 *iface,
1951         TLIBATTR *pTLibAttr)
1952 {
1953     ICOM_THIS( ITypeLibImpl, iface);
1954     TRACE("freeing (%p)\n",This);
1955     /* nothing to do */
1956 }
1957
1958 /* ITypeLib2::GetCustData
1959  *
1960  * gets the custom data
1961  */
1962 static HRESULT WINAPI ITypeLib2_fnGetCustData(
1963         ITypeLib2 * iface,
1964         REFGUID guid,
1965         VARIANT *pVarVal)
1966 {
1967     ICOM_THIS( ITypeLibImpl, iface);
1968     TLBCustData *pCData;
1969
1970     for(pCData=This->pCustData; pCData; pCData = pCData->next)
1971     {
1972       if( IsEqualIID(guid, &pCData->guid)) break;
1973     }
1974
1975     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
1976
1977     if(pCData)
1978     {
1979         VariantInit( pVarVal);
1980         VariantCopy( pVarVal, &pCData->data);
1981         return S_OK;
1982     }
1983     return E_INVALIDARG;  /* FIXME: correct? */
1984 }
1985
1986 /* ITypeLib2::GetLibStatistics
1987  *
1988  * Returns statistics about a type library that are required for efficient
1989  * sizing of hash tables.
1990  *
1991  */
1992 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
1993         ITypeLib2 * iface,
1994         ULONG *pcUniqueNames,
1995         ULONG *pcchUniqueNames)
1996 {
1997     ICOM_THIS( ITypeLibImpl, iface);
1998
1999     FIXME("(%p): stub!\n", This);
2000
2001     if(pcUniqueNames) *pcUniqueNames=1;
2002     if(pcchUniqueNames) *pcchUniqueNames=1;
2003     return S_OK;
2004 }
2005
2006 /* ITypeLib2::GetDocumentation2
2007  *
2008  * Retrieves the library's documentation string, the complete Help file name
2009  * and path, the localization context to use, and the context ID for the
2010  * library Help topic in the Help file.
2011  *
2012  */
2013 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
2014         ITypeLib2 * iface,
2015         INT index,
2016         LCID lcid,
2017         BSTR *pbstrHelpString,
2018         DWORD *pdwHelpStringContext,
2019         BSTR *pbstrHelpStringDll)
2020 {
2021     ICOM_THIS( ITypeLibImpl, iface);
2022     HRESULT result;
2023     ITypeInfo *pTInfo;
2024
2025     FIXME("(%p) index %d lcid %ld half implemented stub!\n", This, index, lcid);
2026
2027     /* the help string should be obtained from the helpstringdll,
2028      * using the _DLLGetDocumentation function, based on the supplied
2029      * lcid. Nice to do sometime...
2030      */
2031     if(index<0)
2032     {
2033       /* documentation for the typelib */
2034       if(pbstrHelpString)
2035         *pbstrHelpString=SysAllocString(This->DocString);
2036       if(pdwHelpStringContext)
2037         *pdwHelpStringContext=This->dwHelpContext;
2038       if(pbstrHelpStringDll)
2039         *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
2040     }
2041     else
2042     {
2043       /* for a typeinfo */
2044       result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
2045       if(SUCCEEDED(result))
2046       {
2047         ITypeInfo2 * pTInfo2;
2048         result = ITypeInfo_QueryInterface(pTInfo, &IID_ITypeInfo2, (LPVOID*) &pTInfo2);
2049         if(SUCCEEDED(result))
2050         {
2051           result = ITypeInfo2_GetDocumentation2(pTInfo2, MEMBERID_NIL, lcid,
2052                 pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
2053           ITypeInfo2_Release(pTInfo2);
2054         }
2055         ITypeInfo_Release(pTInfo);
2056       }
2057       if(!SUCCEEDED(result))
2058         return result;
2059     }
2060     return S_OK;
2061 }
2062
2063 /* ITypeLib2::GetAllCustData
2064  *
2065  * Gets all custom data items for the library.
2066  *
2067  */
2068 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
2069         ITypeLib2 * iface,
2070         CUSTDATA *pCustData)
2071 {
2072     ICOM_THIS( ITypeLibImpl, iface);
2073     TLBCustData *pCData;
2074     int i;
2075     TRACE("(%p) returning %d items\n", This, This->ctCustData);
2076     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
2077     if(pCustData->prgCustData ){
2078         pCustData->cCustData=This->ctCustData;
2079         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
2080             pCustData->prgCustData[i].guid=pCData->guid;
2081             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
2082         }
2083     }else{
2084         ERR(" OUT OF MEMORY! \n");
2085         return E_OUTOFMEMORY;
2086     }
2087     return S_OK;
2088 }
2089
2090 static ICOM_VTABLE(ITypeLib2) tlbvt = {
2091     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2092     ITypeLib2_fnQueryInterface,
2093     ITypeLib2_fnAddRef,
2094     ITypeLib2_fnRelease,
2095     ITypeLib2_fnGetTypeInfoCount,
2096     ITypeLib2_fnGetTypeInfo,
2097     ITypeLib2_fnGetTypeInfoType,
2098     ITypeLib2_fnGetTypeInfoOfGuid,
2099     ITypeLib2_fnGetLibAttr,
2100     ITypeLib2_fnGetTypeComp,
2101     ITypeLib2_fnGetDocumentation,
2102     ITypeLib2_fnIsName,
2103     ITypeLib2_fnFindName,
2104     ITypeLib2_fnReleaseTLibAttr,
2105
2106     ITypeLib2_fnGetCustData,
2107     ITypeLib2_fnGetLibStatistics,
2108     ITypeLib2_fnGetDocumentation2,
2109     ITypeLib2_fnGetAllCustData
2110  };
2111
2112 /*================== ITypeInfo(2) Methods ===================================*/
2113 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void)
2114 {
2115     ITypeInfoImpl * pTypeInfoImpl;
2116
2117     pTypeInfoImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeInfoImpl));
2118     if (pTypeInfoImpl)
2119     {
2120       ICOM_VTBL(pTypeInfoImpl) = &tinfvt;
2121       pTypeInfoImpl->ref=1;
2122     }
2123     TRACE("(%p)\n", pTypeInfoImpl);
2124     return (ITypeInfo2*) pTypeInfoImpl;
2125 }
2126
2127 /* ITypeInfo::QueryInterface
2128  */
2129 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
2130         ITypeInfo2 *iface,
2131         REFIID riid,
2132         VOID **ppvObject)
2133 {
2134     ICOM_THIS( ITypeLibImpl, iface);
2135
2136     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
2137
2138     *ppvObject=NULL;
2139     if(IsEqualIID(riid, &IID_IUnknown) ||
2140             IsEqualIID(riid,&IID_ITypeInfo)||
2141             IsEqualIID(riid,&IID_ITypeInfo2))
2142         *ppvObject = This;
2143
2144     if(*ppvObject){
2145         ITypeInfo_AddRef(iface);
2146         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
2147         return S_OK;
2148     }
2149     TRACE("-- Interface: E_NOINTERFACE\n");
2150     return E_NOINTERFACE;
2151 }
2152
2153 /* ITypeInfo::AddRef
2154  */
2155 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
2156 {
2157     ICOM_THIS( ITypeInfoImpl, iface);
2158     TRACE("(%p)->ref is %u\n",This, This->ref);
2159     return ++(This->ref);
2160 }
2161
2162 /* ITypeInfo::Release
2163  */
2164 static ULONG WINAPI ITypeInfo_fnRelease( ITypeInfo2 *iface)
2165 {
2166     ICOM_THIS( ITypeInfoImpl, iface);
2167     TRACE("(%p)->(%u)\n",This, This->ref);
2168
2169
2170     if (!--(This->ref))
2171     {
2172       FIXME("destroy child objects\n");
2173
2174       TRACE(" destroying ITypeInfo(%p)\n",This);
2175           if (This->Name)
2176           {
2177                   SysFreeString(This->Name);
2178                   This->Name = 0;
2179           }
2180
2181           if (This->DocString)
2182           {
2183               SysFreeString(This->DocString);
2184                   This->DocString = 0;
2185           }
2186
2187           if (This->next)
2188           {
2189                 ITypeInfo_Release((ITypeInfo*)This->next);
2190           }
2191
2192       HeapFree(GetProcessHeap(),0,This);
2193       return 0;
2194     }
2195     return This->ref;
2196 }
2197
2198 /* ITypeInfo::GetTypeAttr
2199  *
2200  * Retrieves a TYPEATTR structure that contains the attributes of the type
2201  * description.
2202  *
2203  */
2204 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
2205         LPTYPEATTR  *ppTypeAttr)
2206 {
2207     ICOM_THIS( ITypeInfoImpl, iface);
2208     TRACE("(%p)\n",This);
2209     /* FIXME: must do a copy here */
2210     *ppTypeAttr=&This->TypeAttr;
2211     return S_OK;
2212 }
2213
2214 /* ITypeInfo::GetTypeComp
2215  *
2216  * Retrieves the ITypeComp interface for the type description, which enables a
2217  * client compiler to bind to the type description's members.
2218  *
2219  */
2220 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
2221         ITypeComp  * *ppTComp)
2222 {
2223     ICOM_THIS( ITypeInfoImpl, iface);
2224     FIXME("(%p) stub!\n", This);
2225     return S_OK;
2226 }
2227
2228 /* ITypeInfo::GetFuncDesc
2229  *
2230  * Retrieves the FUNCDESC structure that contains information about a
2231  * specified function.
2232  *
2233  */
2234 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
2235         LPFUNCDESC  *ppFuncDesc)
2236 {
2237     ICOM_THIS( ITypeInfoImpl, iface);
2238     int i;
2239     TLBFuncDesc * pFDesc;
2240     TRACE("(%p) index %d\n", This, index);
2241     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
2242         ;
2243     if(pFDesc){
2244         /* FIXME: must do a copy here */
2245         *ppFuncDesc=&pFDesc->funcdesc;
2246         return S_OK;
2247     }
2248     return E_INVALIDARG;
2249 }
2250
2251 /* ITypeInfo::GetVarDesc
2252  *
2253  * Retrieves a VARDESC structure that describes the specified variable.
2254  *
2255  */
2256 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
2257         LPVARDESC  *ppVarDesc)
2258 {
2259     ICOM_THIS( ITypeInfoImpl, iface);
2260     int i;
2261     TLBVarDesc * pVDesc;
2262     TRACE("(%p) index %d\n", This, index);
2263     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
2264         ;
2265     if(pVDesc){
2266         /* FIXME: must do a copy here */
2267         *ppVarDesc=&pVDesc->vardesc;
2268         return S_OK;
2269     }
2270     return E_INVALIDARG;
2271 }
2272
2273 /* ITypeInfo_GetNames
2274  *
2275  * Retrieves the variable with the specified member ID (or the name of the
2276  * property or method and its parameters) that correspond to the specified
2277  * function ID.
2278  */
2279 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
2280         BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames)
2281 {
2282     ICOM_THIS( ITypeInfoImpl, iface);
2283     TLBFuncDesc * pFDesc;
2284     TLBVarDesc * pVDesc;
2285     int i;
2286     TRACE("(%p) memid=0x%08lx Maxname=%d\n", This, memid, cMaxNames);
2287     for(pFDesc=This->funclist; pFDesc && pFDesc->funcdesc.memid != memid; pFDesc=pFDesc->next);
2288     if(pFDesc)
2289     {
2290       /* function found, now return function and parameter names */
2291       for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
2292       {
2293         if(!i)
2294                   *rgBstrNames=SysAllocString(pFDesc->Name);
2295         else
2296           rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
2297       }
2298       *pcNames=i;
2299     }
2300     else
2301     {
2302       for(pVDesc=This->varlist; pVDesc && pVDesc->vardesc.memid != memid; pVDesc=pVDesc->next);
2303       if(pVDesc)
2304       {
2305         *rgBstrNames=SysAllocString(pVDesc->Name);
2306         *pcNames=1;
2307       }
2308       else
2309       {
2310         if(This->TypeAttr.typekind==TKIND_INTERFACE && This->TypeAttr.cImplTypes )
2311         {
2312           /* recursive search */
2313           ITypeInfo *pTInfo;
2314           HRESULT result;
2315           result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->reference, &pTInfo);
2316           if(SUCCEEDED(result))
2317           {
2318             result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
2319             ITypeInfo_Release(pTInfo);
2320             return result;
2321           }
2322           WARN("Could not search inherited interface!\n");
2323         }
2324         else
2325         {
2326           WARN("no names found\n");
2327         }
2328         *pcNames=0;
2329         return TYPE_E_ELEMENTNOTFOUND;
2330       }
2331     }
2332     return S_OK;
2333 }
2334
2335
2336 /* ITypeInfo::GetRefTypeOfImplType
2337  *
2338  * If a type description describes a COM class, it retrieves the type
2339  * description of the implemented interface types. For an interface,
2340  * GetRefTypeOfImplType returns the type information for inherited interfaces,
2341  * if any exist.
2342  *
2343  */
2344 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
2345         ITypeInfo2 *iface,
2346         UINT index,
2347         HREFTYPE  *pRefType)
2348 {
2349     ICOM_THIS( ITypeInfoImpl, iface);
2350     int(i);
2351     TLBRefType *pIref = This->impltypelist;
2352
2353     TRACE("(%p) index %d\n", This, index);
2354     dump_TypeInfo(This);
2355
2356
2357     if(index==(UINT)-1)
2358     {
2359       /* only valid on dual interfaces;
2360          retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
2361       */
2362       if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
2363
2364       if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
2365           This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
2366       {
2367         *pRefType = -1;
2368       }
2369       else
2370       {
2371         *pRefType = pIref->reference;
2372       }
2373     }
2374     else
2375     {
2376       /* get element n from linked list */
2377       for(i=0; i<index; i++)
2378       {
2379         if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
2380         pIref = pIref->next;
2381       }
2382
2383       *pRefType = pIref->reference;
2384     }
2385
2386     TRACE("-- 0x%08lx %s\n",pIref->reference, debugstr_guid(&pIref->guid) );
2387     return S_OK;
2388
2389 }
2390
2391 /* ITypeInfo::GetImplTypeFlags
2392  *
2393  * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
2394  * or base interface in a type description.
2395  */
2396 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
2397         UINT index, INT  *pImplTypeFlags)
2398 {
2399     ICOM_THIS( ITypeInfoImpl, iface);
2400     int(i);
2401     TLBRefType *pIref;
2402     TRACE("(%p) index %d\n", This, index);
2403     for(i=0, pIref=This->impltypelist; i<index && pIref; i++, pIref=pIref->next)
2404         ;
2405     if(i==index && pIref){
2406         *pImplTypeFlags=pIref->flags;
2407         return S_OK;
2408     }
2409     *pImplTypeFlags=0;
2410     return TYPE_E_ELEMENTNOTFOUND;
2411 }
2412
2413 /* GetIDsOfNames
2414  * Maps between member names and member IDs, and parameter names and
2415  * parameter IDs.
2416  */
2417 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
2418         LPOLESTR  *rgszNames, UINT cNames, MEMBERID  *pMemId)
2419 {
2420     ICOM_THIS( ITypeInfoImpl, iface);
2421     TLBFuncDesc * pFDesc;
2422     TLBVarDesc * pVDesc;
2423     HRESULT ret=S_OK;
2424         UINT nNameLen = SysStringLen(*rgszNames);
2425
2426     TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
2427             cNames);
2428     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
2429         int i, j;
2430         if( !memcmp(*rgszNames, pFDesc->Name, nNameLen)) {
2431             if(cNames) *pMemId=pFDesc->funcdesc.memid;
2432             for(i=1; i < cNames; i++){
2433                                 UINT nParamLen = SysStringLen(rgszNames[i]);
2434                 for(j=0; j<pFDesc->funcdesc.cParams; j++)
2435                     if(memcmp(rgszNames[i],pFDesc->pParamDesc[j].Name, nParamLen))
2436                             break;
2437                 if( j<pFDesc->funcdesc.cParams)
2438                     pMemId[i]=j;
2439                 else
2440                    ret=DISP_E_UNKNOWNNAME;
2441             };
2442             return ret;
2443         }
2444     }
2445     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
2446         if( !memcmp(*rgszNames, pVDesc->Name, nNameLen)) {
2447             if(cNames) *pMemId=pVDesc->vardesc.memid;
2448             return ret;
2449         }
2450     }
2451     /* not found, see if this is and interface with an inheritance */
2452     if(This->TypeAttr.typekind==TKIND_INTERFACE &&
2453             This->TypeAttr.cImplTypes ){
2454         /* recursive search */
2455         ITypeInfo *pTInfo;
2456         ret=ITypeInfo_GetRefTypeInfo(iface,
2457                 This->impltypelist->reference, &pTInfo);
2458         if(SUCCEEDED(ret)){
2459             ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
2460             ITypeInfo_Release(pTInfo);
2461             return ret;
2462         }
2463         WARN("Could not search inherited interface!\n");
2464     } else
2465         WARN("no names found\n");
2466     return DISP_E_UNKNOWNNAME;
2467 }
2468
2469 /* ITypeInfo::Invoke
2470  *
2471  * Invokes a method, or accesses a property of an object, that implements the
2472  * interface described by the type description.
2473  */
2474 static HRESULT WINAPI ITypeInfo_fnInvoke(
2475         ITypeInfo2 *iface,
2476         VOID  *pIUnk,
2477         MEMBERID memid,
2478         UINT16 dwFlags,
2479         DISPPARAMS  *pDispParams,
2480         VARIANT  *pVarResult,
2481         EXCEPINFO  *pExcepInfo,
2482         UINT  *pArgErr)
2483 {
2484     ICOM_THIS( ITypeInfoImpl, iface);
2485     FIXME("(%p)(%p,id=0x%08lx,0x%08x,%p,%p,%p,%p) stub!\n",
2486       This, pIUnk, memid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr );
2487     dump_DispParms(pDispParams);
2488     return S_OK;
2489 }
2490
2491 /* ITypeInfo::GetDocumentation
2492  *
2493  * Retrieves the documentation string, the complete Help file name and path,
2494  * and the context ID for the Help topic for a specified type description.
2495  */
2496 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
2497         MEMBERID memid, BSTR  *pBstrName, BSTR  *pBstrDocString,
2498         DWORD  *pdwHelpContext, BSTR  *pBstrHelpFile)
2499 {
2500     ICOM_THIS( ITypeInfoImpl, iface);
2501     TLBFuncDesc * pFDesc;
2502     TLBVarDesc * pVDesc;
2503     TRACE("(%p) memid %ld Name(%p) DocString(%p)"
2504           " HelpContext(%p) HelpFile(%p)\n",
2505         This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
2506     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
2507         if(pBstrName)
2508             *pBstrName=SysAllocString(This->Name);
2509         if(pBstrDocString)
2510             *pBstrDocString=SysAllocString(This->DocString);
2511         if(pdwHelpContext)
2512             *pdwHelpContext=This->dwHelpContext;
2513         if(pBstrHelpFile)
2514             *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
2515         return S_OK;
2516     }else {/* for a member */
2517     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
2518         if(pFDesc->funcdesc.memid==memid){
2519             return S_OK;
2520         }
2521     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
2522         if(pVDesc->vardesc.memid==memid){
2523             return S_OK;
2524         }
2525     }
2526     return TYPE_E_ELEMENTNOTFOUND;
2527 }
2528
2529 /*  ITypeInfo::GetDllEntry
2530  *
2531  * Retrieves a description or specification of an entry point for a function
2532  * in a DLL.
2533  */
2534 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
2535         INVOKEKIND invKind, BSTR  *pBstrDllName, BSTR  *pBstrName,
2536         WORD  *pwOrdinal)
2537 {
2538     ICOM_THIS( ITypeInfoImpl, iface);
2539     FIXME("(%p) stub!\n", This);
2540     return E_FAIL;
2541 }
2542
2543 /* ITypeInfo::GetRefTypeInfo
2544  *
2545  * If a type description references other type descriptions, it retrieves
2546  * the referenced type descriptions.
2547  */
2548 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
2549         ITypeInfo2 *iface,
2550         HREFTYPE hRefType,
2551         ITypeInfo  **ppTInfo)
2552 {
2553     ICOM_THIS( ITypeInfoImpl, iface);
2554     HRESULT result = E_FAIL;
2555
2556     if(HREFTYPE_INTHISFILE(hRefType))
2557     {
2558       ITypeLib *pTLib;
2559       int Index;
2560       result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
2561       if(SUCCEEDED( result ))
2562       {
2563         result=ITypeLib2_GetTypeInfo(pTLib, HREFTYPE_INDEX(hRefType), ppTInfo);
2564         ITypeLib2_Release(pTLib );
2565       }
2566     }
2567         else if (hRefType == -1 &&
2568              (((ITypeInfoImpl*) This)->TypeAttr.typekind   == TKIND_DISPATCH) &&
2569              (((ITypeInfoImpl*) This)->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
2570     {
2571           /* when we meet a DUAL dispinterface, we must create the interface
2572           * version of it.
2573           */
2574           ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
2575
2576
2577           /* the interface version contains the same information as the dispinterface
2578            * copy the contents of the structs.
2579            */
2580           *pTypeInfoImpl = *This;
2581           pTypeInfoImpl->ref = 1;
2582
2583           /* change the type to interface */
2584           pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
2585
2586       *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
2587
2588           ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
2589
2590       result = S_OK;
2591         }
2592     else
2593     {
2594       /* imported type lib */
2595       TLBRefType   *pRefType     = NULL;
2596
2597       /* search in implemented types */
2598       for( pRefType = This->impltypelist;
2599            pRefType && (pRefType->reference != hRefType);
2600            pRefType = pRefType->next);
2601
2602       if(!pRefType)
2603       {
2604         TYPEATTR*       pMyTypeAttr  = &This->TypeAttr;
2605         unsigned short  cFuncs       = pMyTypeAttr->cFuncs;
2606         unsigned short  cVars        = pMyTypeAttr->cVars;
2607
2608         /* search in arguments */
2609         if (cFuncs > 0)
2610         {
2611           unsigned short  cFuncIndex   = 0;
2612
2613           TLBFuncDesc*    pCurrFunc    = This->funclist;
2614
2615           for (cFuncIndex = 0; !pRefType && cFuncIndex < cFuncs ; ++cFuncIndex)
2616           {
2617             FUNCDESC*  pCurrFuncDesc = &pCurrFunc->funcdesc;
2618
2619             short      cParams       = pCurrFuncDesc->cParams;
2620             short      cParamIndex   = 0;
2621
2622             for (cParamIndex = 0 ;
2623                  !pRefType && cParamIndex < cParams ;
2624                  ++cParamIndex)
2625             {
2626               TLBParDesc* pCurrParamDesc = &(pCurrFunc->pParamDesc[cParamIndex]);
2627
2628               if ( pCurrParamDesc->pRefType && pCurrParamDesc->pRefType->reference == hRefType)
2629               {
2630                 pRefType = pCurrParamDesc->pRefType;
2631                 break; /* also break from outer loop since pRefType != 0 */
2632               }
2633             }
2634
2635             pCurrFunc = pCurrFunc->next;
2636           }
2637         }
2638         /* search in variables */
2639         else if (cVars > 0)
2640         {
2641           FIXME("search hreftype in variables, if any\n");
2642           result = E_INVALIDARG; // FIXME : correct?
2643         }
2644       }
2645
2646       /* href-referenced typeinfo found! */
2647       if (pRefType || hRefType == -1)
2648       {
2649         ITypeLibImpl *pTypeLib = pRefType->pImpTLInfo->pImpTypeLib;
2650
2651         if(pTypeLib)
2652         {
2653           TRACE("typeinfo in imported typelib that is already loaded\n");
2654
2655           result = ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib,
2656                                            &pRefType->guid,
2657                                            ppTInfo);
2658         }
2659         else
2660         {
2661           result = LoadRegTypeLib( &pRefType->pImpTLInfo->guid,
2662                       pRefType->pImpTLInfo->wVersionMajor,
2663                       pRefType->pImpTLInfo->wVersionMinor,
2664                       pRefType->pImpTLInfo->lcid,
2665                       (LPTYPELIB *)&pTypeLib);
2666
2667           if(!SUCCEEDED(result))
2668                   {
2669             BSTR libnam=SysAllocString(pRefType->pImpTLInfo->name);
2670             TRACE("typeinfo in imported typelib that isn't already loaded\n");
2671             result=LoadTypeLib(libnam, (LPTYPELIB *)&pTypeLib);
2672             SysFreeString(libnam);
2673           }
2674           if(SUCCEEDED(result))
2675           {
2676             result=ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
2677             pRefType->pImpTLInfo->pImpTypeLib = pTypeLib;
2678                         ITypeLib2_AddRef((ITypeLib*) pTypeLib);
2679           }
2680         }
2681       }
2682     }
2683
2684     TRACE("(%p) hreftype 0x%04lx loaded %s (%p)\n", This, hRefType,
2685           SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
2686     return result;
2687 }
2688
2689 /* ITypeInfo::AddressOfMember
2690  *
2691  * Retrieves the addresses of static functions or variables, such as those
2692  * defined in a DLL.
2693  */
2694 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
2695         MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
2696 {
2697     ICOM_THIS( ITypeInfoImpl, iface);
2698     FIXME("(%p) stub!\n", This);
2699     return S_OK;
2700 }
2701
2702 /* ITypeInfo::CreateInstance
2703  *
2704  * Creates a new instance of a type that describes a component object class
2705  * (coclass).
2706  */
2707 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
2708         IUnknown *pUnk, REFIID riid, VOID  **ppvObj)
2709 {
2710     ICOM_THIS( ITypeInfoImpl, iface);
2711     FIXME("(%p) stub!\n", This);
2712     return S_OK;
2713 }
2714
2715 /* ITypeInfo::GetMops
2716  *
2717  * Retrieves marshaling information.
2718  */
2719 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
2720                                 BSTR  *pBstrMops)
2721 {
2722     ICOM_THIS( ITypeInfoImpl, iface);
2723     FIXME("(%p) stub!\n", This);
2724     return S_OK;
2725 }
2726
2727 /* ITypeInfo::GetContainingTypeLib
2728  *
2729  * Retrieves the containing type library and the index of the type description
2730  * within that type library.
2731  */
2732 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
2733         ITypeLib  * *ppTLib, UINT  *pIndex)
2734 {
2735     ICOM_THIS( ITypeInfoImpl, iface);
2736     *ppTLib=(LPTYPELIB )(This->pTypeLib);
2737     *pIndex=This->index;
2738     ITypeLib2_AddRef(*ppTLib);
2739     TRACE("(%p) returns (%p) index %d!\n", This, *ppTLib, *pIndex);
2740     return S_OK;
2741 }
2742
2743 /* ITypeInfo::ReleaseTypeAttr
2744  *
2745  * Releases a TYPEATTR previously returned by GetTypeAttr.
2746  *
2747  */
2748 static HRESULT WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
2749         TYPEATTR* pTypeAttr)
2750 {
2751     ICOM_THIS( ITypeInfoImpl, iface);
2752     TRACE("(%p)->(%p)\n", This, pTypeAttr);
2753     return S_OK;
2754 }
2755
2756 /* ITypeInfo::ReleaseFuncDesc
2757  *
2758  * Releases a FUNCDESC previously returned by GetFuncDesc. *
2759  */
2760 static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc(
2761         ITypeInfo2 *iface,
2762         FUNCDESC *pFuncDesc)
2763 {
2764     ICOM_THIS( ITypeInfoImpl, iface);
2765     TRACE("(%p)->(%p)\n", This, pFuncDesc);
2766     return S_OK;
2767 }
2768
2769 /* ITypeInfo::ReleaseVarDesc
2770  *
2771  * Releases a VARDESC previously returned by GetVarDesc.
2772  */
2773 static HRESULT WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
2774         VARDESC *pVarDesc)
2775 {
2776     ICOM_THIS( ITypeInfoImpl, iface);
2777     TRACE("(%p)->(%p)\n", This, pVarDesc);
2778     return S_OK;
2779 }
2780
2781 /* ITypeInfo2::GetTypeKind
2782  *
2783  * Returns the TYPEKIND enumeration quickly, without doing any allocations.
2784  *
2785  */
2786 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
2787     TYPEKIND *pTypeKind)
2788 {
2789     ICOM_THIS( ITypeInfoImpl, iface);
2790     *pTypeKind=This->TypeAttr.typekind;
2791     TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
2792     return S_OK;
2793 }
2794
2795 /* ITypeInfo2::GetTypeFlags
2796  *
2797  * Returns the type flags without any allocations. This returns a DWORD type
2798  * flag, which expands the type flags without growing the TYPEATTR (type
2799  * attribute).
2800  *
2801  */
2802 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 * iface,
2803     UINT *pTypeFlags)
2804 {
2805     ICOM_THIS( ITypeInfoImpl, iface);
2806     *pTypeFlags=This->TypeAttr.wTypeFlags;
2807     TRACE("(%p) flags 0x%04x\n", This,*pTypeFlags);
2808      return S_OK;
2809 }
2810
2811 /* ITypeInfo2::GetFuncIndexOfMemId
2812  * Binds to a specific member based on a known DISPID, where the member name
2813  * is not known (for example, when binding to a default member).
2814  *
2815  */
2816 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
2817     MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
2818 {
2819     ICOM_THIS( ITypeInfoImpl, iface);
2820     TLBFuncDesc *pFuncInfo;
2821     int i;
2822     HRESULT result;
2823     /* FIXME: should check for invKind??? */
2824     for(i=0, pFuncInfo=This->funclist;pFuncInfo &&
2825             memid != pFuncInfo->funcdesc.memid; i++, pFuncInfo=pFuncInfo->next);
2826     if(pFuncInfo){
2827         *pFuncIndex=i;
2828         result= S_OK;
2829     }else{
2830         *pFuncIndex=0;
2831         result=E_INVALIDARG;
2832     }
2833     TRACE("(%p) memid 0x%08lx invKind 0x%04x -> %s\n", This,
2834           memid, invKind, SUCCEEDED(result)? "SUCCES":"FAILED");
2835     return result;
2836 }
2837
2838 /* TypeInfo2::GetVarIndexOfMemId
2839  *
2840  * Binds to a specific member based on a known DISPID, where the member name
2841  * is not known (for example, when binding to a default member).
2842  *
2843  */
2844 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
2845     MEMBERID memid, UINT *pVarIndex)
2846 {
2847     ICOM_THIS( ITypeInfoImpl, iface);
2848     TLBVarDesc *pVarInfo;
2849     int i;
2850     HRESULT result;
2851     for(i=0, pVarInfo=This->varlist; pVarInfo &&
2852             memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
2853         ;
2854     if(pVarInfo){
2855         *pVarIndex=i;
2856         result= S_OK;
2857     }else{
2858         *pVarIndex=0;
2859         result=E_INVALIDARG;
2860     }
2861     TRACE("(%p) memid 0x%08lx -> %s\n", This,
2862           memid, SUCCEEDED(result)? "SUCCES":"FAILED");
2863     return result;
2864 }
2865
2866 /* ITypeInfo2::GetCustData
2867  *
2868  * Gets the custom data
2869  */
2870 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
2871         ITypeInfo2 * iface,
2872         REFGUID guid,
2873         VARIANT *pVarVal)
2874 {
2875     ICOM_THIS( ITypeInfoImpl, iface);
2876     TLBCustData *pCData;
2877
2878     for(pCData=This->pCustData; pCData; pCData = pCData->next)
2879         if( IsEqualIID(guid, &pCData->guid)) break;
2880
2881     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
2882
2883     if(pCData)
2884     {
2885         VariantInit( pVarVal);
2886         VariantCopy( pVarVal, &pCData->data);
2887         return S_OK;
2888     }
2889     return E_INVALIDARG;  /* FIXME: correct? */
2890 }
2891
2892 /* ITypeInfo2::GetFuncCustData
2893  *
2894  * Gets the custom data
2895  */
2896 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
2897         ITypeInfo2 * iface,
2898         UINT index,
2899         REFGUID guid,
2900         VARIANT *pVarVal)
2901 {
2902     ICOM_THIS( ITypeInfoImpl, iface);
2903     TLBCustData *pCData=NULL;
2904     TLBFuncDesc * pFDesc;
2905     int i;
2906     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
2907             pFDesc=pFDesc->next);
2908
2909     if(pFDesc)
2910         for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
2911             if( IsEqualIID(guid, &pCData->guid)) break;
2912
2913     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
2914
2915     if(pCData){
2916         VariantInit( pVarVal);
2917         VariantCopy( pVarVal, &pCData->data);
2918         return S_OK;
2919     }
2920     return E_INVALIDARG;  /* FIXME: correct? */
2921 }
2922
2923 /* ITypeInfo2::GetParamCustData
2924  *
2925  * Gets the custom data
2926  */
2927 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
2928         ITypeInfo2 * iface,
2929         UINT indexFunc,
2930         UINT indexParam,
2931         REFGUID guid,
2932         VARIANT *pVarVal)
2933 {
2934     ICOM_THIS( ITypeInfoImpl, iface);
2935     TLBCustData *pCData=NULL;
2936     TLBFuncDesc * pFDesc;
2937     int i;
2938
2939     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,pFDesc=pFDesc->next);
2940
2941     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
2942         for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
2943                 pCData = pCData->next)
2944             if( IsEqualIID(guid, &pCData->guid)) break;
2945
2946     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
2947
2948     if(pCData)
2949     {
2950         VariantInit( pVarVal);
2951         VariantCopy( pVarVal, &pCData->data);
2952         return S_OK;
2953     }
2954     return E_INVALIDARG;  /* FIXME: correct? */
2955 }
2956
2957 /* ITypeInfo2::GetVarcCustData
2958  *
2959  * Gets the custom data
2960  */
2961 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
2962         ITypeInfo2 * iface,
2963         UINT index,
2964         REFGUID guid,
2965         VARIANT *pVarVal)
2966 {
2967     ICOM_THIS( ITypeInfoImpl, iface);
2968     TLBCustData *pCData=NULL;
2969     TLBVarDesc * pVDesc;
2970     int i;
2971
2972     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next);
2973
2974     if(pVDesc)
2975     {
2976       for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
2977       {
2978         if( IsEqualIID(guid, &pCData->guid)) break;
2979       }
2980     }
2981
2982     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
2983
2984     if(pCData)
2985     {
2986         VariantInit( pVarVal);
2987         VariantCopy( pVarVal, &pCData->data);
2988         return S_OK;
2989     }
2990     return E_INVALIDARG;  /* FIXME: correct? */
2991 }
2992
2993 /* ITypeInfo2::GetImplcCustData
2994  *
2995  * Gets the custom data
2996  */
2997 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
2998         ITypeInfo2 * iface,
2999         UINT index,
3000         REFGUID guid,
3001         VARIANT *pVarVal)
3002 {
3003     ICOM_THIS( ITypeInfoImpl, iface);
3004     TLBCustData *pCData=NULL;
3005     TLBRefType * pRDesc;
3006     int i;
3007
3008     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++, pRDesc=pRDesc->next);
3009
3010     if(pRDesc)
3011     {
3012       for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
3013       {
3014         if( IsEqualIID(guid, &pCData->guid)) break;
3015       }
3016     }
3017
3018     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3019
3020     if(pCData)
3021     {
3022         VariantInit( pVarVal);
3023         VariantCopy( pVarVal, &pCData->data);
3024         return S_OK;
3025     }
3026     return E_INVALIDARG;  /* FIXME: correct? */
3027 }
3028
3029 /* ITypeInfo2::GetDocumentation2
3030  *
3031  * Retrieves the documentation string, the complete Help file name and path,
3032  * the localization context to use, and the context ID for the library Help
3033  * topic in the Help file.
3034  *
3035  */
3036 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
3037         ITypeInfo2 * iface,
3038         MEMBERID memid,
3039         LCID lcid,
3040         BSTR *pbstrHelpString,
3041         DWORD *pdwHelpStringContext,
3042         BSTR *pbstrHelpStringDll)
3043 {
3044     ICOM_THIS( ITypeInfoImpl, iface);
3045     TLBFuncDesc * pFDesc;
3046     TLBVarDesc * pVDesc;
3047     TRACE("(%p) memid %ld lcid(0x%lx)  HelpString(%p) "
3048           "HelpStringContext(%p) HelpStringDll(%p)\n",
3049           This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
3050           pbstrHelpStringDll );
3051     /* the help string should be obtained from the helpstringdll,
3052      * using the _DLLGetDocumentation function, based on the supplied
3053      * lcid. Nice to do sometime...
3054      */
3055     if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
3056         if(pbstrHelpString)
3057             *pbstrHelpString=SysAllocString(This->Name);
3058         if(pdwHelpStringContext)
3059             *pdwHelpStringContext=This->dwHelpStringContext;
3060         if(pbstrHelpStringDll)
3061             *pbstrHelpStringDll=
3062                 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3063         return S_OK;
3064     }else {/* for a member */
3065     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
3066         if(pFDesc->funcdesc.memid==memid){
3067              if(pbstrHelpString)
3068                 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
3069             if(pdwHelpStringContext)
3070                 *pdwHelpStringContext=pFDesc->HelpStringContext;
3071             if(pbstrHelpStringDll)
3072                 *pbstrHelpStringDll=
3073                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3074         return S_OK;
3075     }
3076     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
3077         if(pVDesc->vardesc.memid==memid){
3078              if(pbstrHelpString)
3079                 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
3080             if(pdwHelpStringContext)
3081                 *pdwHelpStringContext=pVDesc->HelpStringContext;
3082             if(pbstrHelpStringDll)
3083                 *pbstrHelpStringDll=
3084                     SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3085             return S_OK;
3086         }
3087     }
3088     return TYPE_E_ELEMENTNOTFOUND;
3089 }
3090
3091 /* ITypeInfo2::GetAllCustData
3092  *
3093  * Gets all custom data items for the Type info.
3094  *
3095  */
3096 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
3097         ITypeInfo2 * iface,
3098         CUSTDATA *pCustData)
3099 {
3100     ICOM_THIS( ITypeInfoImpl, iface);
3101     TLBCustData *pCData;
3102     int i;
3103
3104     TRACE("(%p) returning %d items\n", This, This->ctCustData);
3105
3106     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
3107     if(pCustData->prgCustData ){
3108         pCustData->cCustData=This->ctCustData;
3109         for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
3110             pCustData->prgCustData[i].guid=pCData->guid;
3111             VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
3112         }
3113     }else{
3114         ERR(" OUT OF MEMORY! \n");
3115         return E_OUTOFMEMORY;
3116     }
3117     return S_OK;
3118 }
3119
3120 /* ITypeInfo2::GetAllFuncCustData
3121  *
3122  * Gets all custom data items for the specified Function
3123  *
3124  */
3125 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
3126         ITypeInfo2 * iface,
3127         UINT index,
3128         CUSTDATA *pCustData)
3129 {
3130     ICOM_THIS( ITypeInfoImpl, iface);
3131     TLBCustData *pCData;
3132     TLBFuncDesc * pFDesc;
3133     int i;
3134     TRACE("(%p) index %d\n", This, index);
3135     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
3136             pFDesc=pFDesc->next)
3137         ;
3138     if(pFDesc){
3139         pCustData->prgCustData =
3140             TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
3141         if(pCustData->prgCustData ){
3142             pCustData->cCustData=pFDesc->ctCustData;
3143             for(i=0, pCData=pFDesc->pCustData; pCData; i++,
3144                     pCData = pCData->next){
3145                 pCustData->prgCustData[i].guid=pCData->guid;
3146                 VariantCopy(& pCustData->prgCustData[i].varValue,
3147                         & pCData->data);
3148             }
3149         }else{
3150             ERR(" OUT OF MEMORY! \n");
3151             return E_OUTOFMEMORY;
3152         }
3153         return S_OK;
3154     }
3155     return TYPE_E_ELEMENTNOTFOUND;
3156 }
3157
3158 /* ITypeInfo2::GetAllParamCustData
3159  *
3160  * Gets all custom data items for the Functions
3161  *
3162  */
3163 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
3164     UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
3165 {
3166     ICOM_THIS( ITypeInfoImpl, iface);
3167     TLBCustData *pCData=NULL;
3168     TLBFuncDesc * pFDesc;
3169     int i;
3170     TRACE("(%p) index %d\n", This, indexFunc);
3171     for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
3172             pFDesc=pFDesc->next)
3173         ;
3174     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams){
3175         pCustData->prgCustData =
3176             TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
3177                     sizeof(CUSTDATAITEM));
3178         if(pCustData->prgCustData ){
3179             pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
3180             for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
3181                     pCData; i++, pCData = pCData->next){
3182                 pCustData->prgCustData[i].guid=pCData->guid;
3183                 VariantCopy(& pCustData->prgCustData[i].varValue,
3184                         & pCData->data);
3185             }
3186         }else{
3187             ERR(" OUT OF MEMORY! \n");
3188             return E_OUTOFMEMORY;
3189         }
3190         return S_OK;
3191     }
3192     return TYPE_E_ELEMENTNOTFOUND;
3193 }
3194
3195 /* ITypeInfo2::GetAllVarCustData
3196  *
3197  * Gets all custom data items for the specified Variable
3198  *
3199  */
3200 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
3201     UINT index, CUSTDATA *pCustData)
3202 {
3203     ICOM_THIS( ITypeInfoImpl, iface);
3204     TLBCustData *pCData;
3205     TLBVarDesc * pVDesc;
3206     int i;
3207     TRACE("(%p) index %d\n", This, index);
3208     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
3209             pVDesc=pVDesc->next)
3210         ;
3211     if(pVDesc){
3212         pCustData->prgCustData =
3213             TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
3214         if(pCustData->prgCustData ){
3215             pCustData->cCustData=pVDesc->ctCustData;
3216             for(i=0, pCData=pVDesc->pCustData; pCData; i++,
3217                     pCData = pCData->next){
3218                 pCustData->prgCustData[i].guid=pCData->guid;
3219                 VariantCopy(& pCustData->prgCustData[i].varValue,
3220                         & pCData->data);
3221             }
3222         }else{
3223             ERR(" OUT OF MEMORY! \n");
3224             return E_OUTOFMEMORY;
3225         }
3226         return S_OK;
3227     }
3228     return TYPE_E_ELEMENTNOTFOUND;
3229 }
3230
3231 /* ITypeInfo2::GetAllImplCustData
3232  *
3233  * Gets all custom data items for the specified implementation type
3234  *
3235  */
3236 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
3237         ITypeInfo2 * iface,
3238         UINT index,
3239         CUSTDATA *pCustData)
3240 {
3241     ICOM_THIS( ITypeInfoImpl, iface);
3242     TLBCustData *pCData;
3243     TLBRefType * pRDesc;
3244     int i;
3245     TRACE("(%p) index %d\n", This, index);
3246     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
3247             pRDesc=pRDesc->next)
3248         ;
3249     if(pRDesc){
3250         pCustData->prgCustData =
3251             TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
3252         if(pCustData->prgCustData ){
3253             pCustData->cCustData=pRDesc->ctCustData;
3254             for(i=0, pCData=pRDesc->pCustData; pCData; i++,
3255                     pCData = pCData->next){
3256                 pCustData->prgCustData[i].guid=pCData->guid;
3257                 VariantCopy(& pCustData->prgCustData[i].varValue,
3258                         & pCData->data);
3259             }
3260         }else{
3261             ERR(" OUT OF MEMORY! \n");
3262             return E_OUTOFMEMORY;
3263         }
3264         return S_OK;
3265     }
3266     return TYPE_E_ELEMENTNOTFOUND;
3267 }
3268
3269 static ICOM_VTABLE(ITypeInfo2) tinfvt =
3270 {
3271     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
3272
3273     ITypeInfo_fnQueryInterface,
3274     ITypeInfo_fnAddRef,
3275     ITypeInfo_fnRelease,
3276
3277     ITypeInfo_fnGetTypeAttr,
3278     ITypeInfo_fnGetTypeComp,
3279     ITypeInfo_fnGetFuncDesc,
3280     ITypeInfo_fnGetVarDesc,
3281     ITypeInfo_fnGetNames,
3282     ITypeInfo_fnGetRefTypeOfImplType,
3283     ITypeInfo_fnGetImplTypeFlags,
3284     ITypeInfo_fnGetIDsOfNames,
3285     ITypeInfo_fnInvoke,
3286     ITypeInfo_fnGetDocumentation,
3287     ITypeInfo_fnGetDllEntry,
3288     ITypeInfo_fnGetRefTypeInfo,
3289     ITypeInfo_fnAddressOfMember,
3290     ITypeInfo_fnCreateInstance,
3291     ITypeInfo_fnGetMops,
3292     ITypeInfo_fnGetContainingTypeLib,
3293     ITypeInfo_fnReleaseTypeAttr,
3294     ITypeInfo_fnReleaseFuncDesc,
3295     ITypeInfo_fnReleaseVarDesc,
3296
3297     ITypeInfo2_fnGetTypeKind,
3298     ITypeInfo2_fnGetTypeFlags,
3299     ITypeInfo2_fnGetFuncIndexOfMemId,
3300     ITypeInfo2_fnGetVarIndexOfMemId,
3301     ITypeInfo2_fnGetCustData,
3302     ITypeInfo2_fnGetFuncCustData,
3303     ITypeInfo2_fnGetParamCustData,
3304     ITypeInfo2_fnGetVarCustData,
3305     ITypeInfo2_fnGetImplTypeCustData,
3306     ITypeInfo2_fnGetDocumentation2,
3307     ITypeInfo2_fnGetAllCustData,
3308     ITypeInfo2_fnGetAllFuncCustData,
3309     ITypeInfo2_fnGetAllParamCustData,
3310     ITypeInfo2_fnGetAllVarCustData,
3311     ITypeInfo2_fnGetAllImplTypeCustData,
3312 };