Changeset 2022 for trunk/src

Timestamp:

Dec 8, 1999, 8:59:58 PM (26 years ago)

Author:

davidr

Message:

New parser for typelibs

File:

• trunk/src/oleaut32/typelib.cpp (modified) (4 diffs)

trunk/src/oleaut32/typelib.cpp

@@ -1 @@
-/* $Id: typelib.cpp,v 1.5 1999-11-09 11:04:33 bird Exp $ */
-/*
- *      TYPELIB
- *
- *      Copyright 1997  Marcus Meissner
- *                    1999  Rein Klazes
- *
- * Copyright 1999 Sander van Leeuwen (WINE OS/2 Port 990815)
- *
- * Project Odin Software License can be found in LICENSE.TXT
- *
- * there is much left to do here before it can be usefull for real world
- * programs
- * know problems:
- * -. Only one format of typelibs is supported
- * -. All testing until sofar is done using special written windows programs
- * -. Data structures are straightforward, but slow for look-ups.
- * -. (related) nothing is hashed
- * -. a typelib is always read in its entirely into memory and never released.
- * -. there are a number of stubs in ITypeLib and ITypeInfo interfaces. Most
- *      of them I don't know yet how to implement them.
- * -. Most error return values are just guessed not checked with windows
- *      behaviour.
- * -. all locale stuf ignored
- * -. move stuf to wine/dlls
- * -. didn't bother with a c++ interface
- * -. lousy fatal error handling
- * -. some methods just return pointers to internal data structures, this is
- *      partly laziness, partly I want to check how windows does it.
- *
- */
+/* $Id: typelib.cpp,v 1.6 1999-12-08 19:59:58 davidr Exp $ */
+
+typedef enum tagREGKIND
+{
+    REGKIND_DEFAULT,
+    REGKIND_REGISTER,
+    REGKIND_NONE
+} REGKIND;
 
 #include "oleaut32.h"
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include "windef.h"
-#include "winerror.h"
-#include "winreg.h"
-#include "oleauto.h"
-#include "winnls.h"
-#include "wine/winbase16.h"
-#include "heap.h"
-#include "wine/obj_base.h"
-#include "debugtools.h"
-#include "winversion.h"
-/* FIXME: get rid of these */
-typedef struct ITypeInfoVtbl ITypeLib_VTable, *LPTYPEINFO_VTABLE ;
-typedef struct ITypeLibVtbl *LPTYPELIB_VTABLE  ;
-#include "typelib.h"
-
-DEFAULT_DEBUG_CHANNEL(ole)
-DECLARE_DEBUG_CHANNEL(typelib)
-
-
-/****************************************************************************
- *              QueryPathOfRegTypeLib   [OLEAUT32.164]
- * RETURNS
- *      path of typelib
- */
-HRESULT WINAPI
-QueryPathOfRegTypeLib(
-        REFGUID guid,   /* [in] referenced guid */
-        WORD wMaj,      /* [in] major version */
-        WORD wMin,      /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        LPBSTR path     /* [out] path of typelib */
-) {
-        char    xguid[80];
-        char    typelibkey[100],pathname[260];
-        DWORD   plen;
-
-
-        if (HIWORD(guid)) {
-                WINE_StringFromCLSID(guid,xguid);
-                sprintf(typelibkey,"SOFTWARE\\Classes\\Typelib\\%s\\%d.%d\\%lx\\win32",
-                        xguid,wMaj,wMin,lcid
-                );
-        } else {
-                sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
-                FIXME_(ole)("(%s,%d,%d,0x%04lx,%p),stub!\n",xguid,wMaj,wMin,(DWORD)lcid,path);
-                return E_FAIL;
-        }
-        plen = sizeof(pathname);
-        if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,(LPLONG)&plen)) {
-                /* try again without lang specific id */
-                if (SUBLANGID(lcid))
-                        return QueryPathOfRegTypeLib(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
-                FIXME_(ole)("key %s not found\n",typelibkey);
-                return E_FAIL;
-        }
-        *path = HEAP_strdupAtoW(GetProcessHeap(),0,pathname);
-        return S_OK;
-}
-
-/******************************************************************************
- * LoadTypeLib [TYPELIB.3]  Loads and registers a type library
- * NOTES
- *    Docs: OLECHAR FAR* szFile
- *    Docs: iTypeLib FAR* FAR* pptLib
- *
- * RETURNS
- *    Success: S_OK
- *    Failure: Status
- */
-HRESULT WINAPI LoadTypeLib16(
-    OLECHAR *szFile, /* [in] Name of file to load from */
-    void * *pptLib) /* [out] Pointer to pointer to loaded type library */
-{
-    FIXME_(ole)("('%s',%p): stub\n",debugstr_w((LPWSTR)szFile),pptLib);
-
-    if (pptLib!=0)
-      *pptLib=0;
-
-    return E_FAIL;
-}
-
-/******************************************************************************
- *              LoadTypeLib     [OLEAUT32.161]
- * Loads and registers a type library
- * NOTES
- *    Docs: OLECHAR FAR* szFile
- *    Docs: iTypeLib FAR* FAR* pptLib
- *
- * RETURNS
- *    Success: S_OK
- *    Failure: Status
- */
-int TLB_ReadTypeLib(PCHAR file, ITypeLib **ppTypelib);
+#include "olectl.h"
+#include "oList.h"      // linked list template
+#include "itypelib.h"
+
+// ======================================================================
+// Local Data
+// ======================================================================
+static TYPEDESC stndTypeDesc[VT_LPWSTR+1] =
+{   /* VT_LPWSTR is largest type that */
+    /* may appear in type description*/
+    {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
+    {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
+    {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
+    {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
+    {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
+    {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
+    {{0},30},{{0},31}
+};
+
+// ======================================================================
+// Public API's
+// ======================================================================
+
+// ----------------------------------------------------------------------
+// QueryPathOfRegTypeLib()                              [OLEAUT32.164]
+//
+// Retrieves the path of a registered type library.
+// ----------------------------------------------------------------------
+HRESULT WINAPI QueryPathOfRegTypeLib(
+    REFGUID             guid,   /* [in] referenced guid */
+    WORD                wMaj,   /* [in] major version */
+    WORD                wMin,   /* [in] minor version */
+    LCID                lcid,   /* [in] locale id */
+    LPBSTR              path)   /* [out] path of typelib */
+{
+    char        xguid[80];
+    char        typelibkey[100];
+    char        pathname[260];
+    DWORD       plen;
+
+    dprintf(("OLEAUT32: QueryPathOfRegTypeLib()"));
+
+    if (HIWORD(guid))
+    {
+        WINE_StringFromCLSID(guid, xguid);
+        sprintf(typelibkey,
+            "SOFTWARE\\Classes\\Typelib\\%s\\%d.%d\\%lx\\win32",
+                xguid, wMaj, wMin, lcid);
+    }
+    else
+    {
+        sprintf(xguid, "<guid 0x%08lx>", (DWORD)guid);
+        dprintf(("OLEAUT32: QueryPathOfRegTypeLib(%s,%d,%d,0x%04lx,%p) - stub!",
+            xguid, wMaj, wMin, (DWORD)lcid, path));
+        return E_FAIL;
+    }
+    plen = sizeof(pathname);
+    if (RegQueryValueA(HKEY_LOCAL_MACHINE, typelibkey, pathname, (LPLONG)&plen))
+    {
+        /* try again without lang specific id */
+        if (SUBLANGID(lcid))
+            return QueryPathOfRegTypeLib(guid, wMaj, wMin, PRIMARYLANGID(lcid), path);
+
+        dprintf(("OLEAUT32: QueryPathOfRegTypeLib() - key \"%s\" not found", typelibkey));
+        return E_FAIL;
+    }
+    *path = HEAP_strdupAtoW(GetProcessHeap(), 0, pathname);
+    return S_OK;
+}
+
+// ----------------------------------------------------------------------
+// LoadTypeLibEx()                                      [OLEAUT32.183]
+//
+// Loads a type library & optionally registers it in the system registry.
+// * If file is a standalone type library - load it directly.
+// * If the file is a DLL or EXE then load the module, and extract the TYPELIB
+//   resource from it. The default is the first TYPELIB resource - subsequent
+//   TYPELIBs may be accessed by appending an integer index to szFile
+// * If neither of the above, the library is parsed into a filebased Moniker. 
+//   No idea of what/when/where/how to do this yet ;-)
+//
+// If the library (guid, etc) is already loaded return the loaded ITypeLib
+// and incr. its ref count.
+// ----------------------------------------------------------------------
+HRESULT WINAPI LoadTypeLibEx(
+    LPCOLESTR           szFile,
+    REGKIND             regkind,
+    ITypeLib * *        ppTlib)
+{
+    HANDLE              hHeap = GetProcessHeap();
+    char *              szFileA;
+    HRESULT             rc;
+
+    szFileA = HEAP_strdupWtoA(hHeap, 0, szFile);
+    dprintf(("OLEAUT32: LoadTypeLibEx(%s)", szFileA));
+
+    // Sanity check...
+    if (ppTlib == 0)
+    {
+        HeapFree(hHeap, 0, szFileA);
+        return E_POINTER;
+    }
+
+    *ppTlib = 0;
+
+    TypeLibExtract      extractor(szFileA);
+
+    if (!extractor.Valid())
+    {
+        HeapFree(hHeap, 0, szFileA);
+        dprintf(("  Invalid typelib file"));
+        return E_FAIL;
+    }
+
+    rc = extractor.MakeITypeLib((ITypeLibImpl * *)ppTlib);
+
+    HeapFree(hHeap, 0, szFileA); 
+
+    return rc;
+}
+
+// ----------------------------------------------------------------------
+// LoadTypeLib()                                        [OLEAUT32.161]
+//
+// Loads a type library & registers it in the system registry.
+// ----------------------------------------------------------------------
 HRESULT WINAPI LoadTypeLib(
-    OLECHAR *szFile,   /* [in] Name of file to load from */
-    ITypeLib * *pptLib) /* [out] Pointer to pointer to loaded type library */
-{
-    LPSTR p;
-    HRESULT res;
-    TRACE_(typelib)("('%s',%p)\n",debugstr_w(szFile),pptLib);
-
-    p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
-    res= TLB_ReadTypeLib(p, pptLib);
-    /* XXX need to free p ?? */
-
-    TRACE_(typelib)(" returns %ld\n",res);
+    LPCOLESTR           szFile,         /* [in] Name of file to load from */
+    ITypeLib * *        ppTLib)         /* [out] Pointer to pointer to loaded type library */
+{
+    HRESULT             res;
+
+    dprintf(("OLEAUT32: LoadTypeLib()"));
+
+    return LoadTypeLibEx(szFile, REGKIND_DEFAULT, ppTLib);
+}
+
+// ----------------------------------------------------------------------
+// LoadRegTypeLib()                                     [OLEAUT32.162]
+//
+// Use system registry information to locate and load a type library.
+// ----------------------------------------------------------------------
+HRESULT WINAPI LoadRegTypeLib(
+    REFGUID             rguid,          /* [in] referenced guid */
+    WORD                wVerMajor,      /* [in] major version */
+    WORD                wVerMinor,      /* [in] minor version */
+    LCID                lcid,           /* [in] locale id */
+    ITypeLib * *        ppTLib          /* [out] path of typelib */
+)
+{
+    BSTR                bstr = NULL;
+    HRESULT             res;
+
+    dprintf(("OLEAUT32: LoadRegTypeLib()"));
+
+    res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
+
+    if (SUCCEEDED(res))
+    {
+        res = LoadTypeLibEx(bstr, REGKIND_NONE, ppTLib);
+        SysFreeString(bstr);
+    }
 
     return res;
 }
 
-/******************************************************************************
- *              LoadRegTypeLib  [OLEAUT32.162]
- */
-HRESULT WINAPI LoadRegTypeLib(
-        REFGUID rguid,  /* [in] referenced guid */
-        WORD wVerMajor, /* [in] major version */
-        WORD wVerMinor, /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        ITypeLib **ppTLib       /* [out] path of typelib */
-) {
-    BSTR bstr=NULL;
-    HRESULT res=QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor,
-                    lcid, &bstr);
-    if(SUCCEEDED(res)){
-        res= LoadTypeLib(bstr, ppTLib);
-        SysFreeString(bstr);
-    }
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)rguid,xriid);
-        TRACE_(typelib)("(IID: %s) load %s (%p)\n",xriid,
-                SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
-    }
-    return res;
-}
-
-
-/******************************************************************************
- *              RegisterTypeLib [OLEAUT32.163]
- * Adds information about a type library to the System Registry
- * NOTES
- *    Docs: ITypeLib FAR * ptlib
- *    Docs: OLECHAR FAR* szFullPath
- *    Docs: OLECHAR FAR* szHelpDir
- *
- * RETURNS
- *    Success: S_OK
- *    Failure: Status
- */
+// ----------------------------------------------------------------------
+// RegisterTypeLib()                                    [OLEAUT32.163]
+//
+// Adds information about a type library to the System Registry
+// ----------------------------------------------------------------------
 HRESULT WINAPI RegisterTypeLib(
-     ITypeLib * ptlib,      /*[in] Pointer to the library*/
-     OLECHAR * szFullPath, /*[in] full Path of the library*/
-     OLECHAR * szHelpDir)  /*[in] dir to the helpfile for the library,
+    ITypeLib *          ptlib,          /* [in] Pointer to the library*/
+    OLECHAR *           szFullPath,     /* [in] full Path of the library*/
+    OLECHAR *           szHelpDir)      /* [in] dir to the helpfile for the library,
                                                          may be NULL*/
-{   FIXME_(ole)("(%p,%s,%s): stub\n",ptlib, debugstr_w(szFullPath),debugstr_w(szHelpDir));
+{
+    dprintf(("OLEAUT32: RegisterTypeLib() - stub\n"));
+
     return S_OK;        /* FIXME: pretend everything is OK */
 }
 
-
-/******************************************************************************
- *      UnRegisterTypeLib       [OLEAUT32.186]
- * Removes information about a type library from the System Registry
- * NOTES
- *
- * RETURNS
- *    Success: S_OK
- *    Failure: Status
- */
+// ----------------------------------------------------------------------
+// UnRegisterTypeLib()                                  [OLEAUT32.186]
+// 
+// Removes information about a type library from the System Registry
+// ----------------------------------------------------------------------
 HRESULT WINAPI UnRegisterTypeLib(
-    REFGUID libid,      /* [in] Guid of the library */
-        WORD wVerMajor, /* [in] major version */
-        WORD wVerMinor, /* [in] minor version */
-        LCID lcid,      /* [in] locale id */
-        SYSKIND syskind)
-{
-    char xriid[50];
-    WINE_StringFromCLSID((LPCLSID)libid,xriid);
-    TRACE_(typelib)("(IID: %s): stub\n",xriid);
+    REFGUID             libid,          /* [in] Guid of the library */
+    WORD                wVerMajor,      /* [in] major version */
+    WORD                wVerMinor,      /* [in] minor version */
+    LCID                lcid,           /* [in] locale id */
+    SYSKIND             syskind)
+{
+    dprintf(("OLEAUT32: UnRegisterTypeLib() - stub"));
+
     return S_OK;        /* FIXME: pretend everything is OK */
 }
 
-
-/* for better debugging info leave the static out for the time being */
-#define static
-
-/*=======================Itypelib methods ===============================*/
-/* ITypeLib methods */
-static HRESULT WINAPI ITypeLib_fnQueryInterface( LPTYPELIB This, REFIID riid,
-    VOID **ppvObject);
-static ULONG WINAPI ITypeLib_fnAddRef( LPTYPELIB This);
-static ULONG WINAPI ITypeLib_fnRelease( LPTYPELIB This);
-static UINT WINAPI ITypeLib_fnGetTypeInfoCount( LPTYPELIB This);
-static HRESULT WINAPI ITypeLib_fnGetTypeInfo( LPTYPELIB This, UINT index,
-    ITypeInfo **ppTInfo);
-
-static HRESULT WINAPI ITypeLib_fnGetTypeInfoType( LPTYPELIB This, UINT index,
-    TYPEKIND *pTKind);
-
-static HRESULT WINAPI ITypeLib_fnGetTypeInfoOfGuid( LPTYPELIB This, REFGUID guid,
-    ITypeInfo **ppTinfo);
-
-static HRESULT WINAPI ITypeLib_fnGetLibAttr( LPTYPELIB This,
-    LPTLIBATTR *ppTLibAttr);
-
-static HRESULT WINAPI ITypeLib_fnGetTypeComp( LPTYPELIB This,
-    ITypeComp **ppTComp);
-
-static HRESULT WINAPI ITypeLib_fnGetDocumentation( LPTYPELIB This, INT index,
-    BSTR *pBstrName, BSTR *pBstrDocString, DWORD *pdwHelpContext,
-    BSTR *pBstrHelpFile);
-
-static HRESULT WINAPI ITypeLib_fnIsName( LPTYPELIB This, LPOLESTR szNameBuf,
-    ULONG lHashVal, BOOL *pfName);
-
-static HRESULT WINAPI ITypeLib_fnFindName( LPTYPELIB This, LPOLESTR szNameBuf,
-    ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, UINT16 *pcFound);
-
-static VOID WINAPI ITypeLib_fnReleaseTLibAttr( LPTYPELIB This,
-                TLIBATTR *pTLibAttr);
-
-static HRESULT WINAPI ITypeLib2_fnGetCustData( ITypeLib * This, REFGUID guid,
-        VARIANT *pVarVal);
-
-static HRESULT WINAPI ITypeLib2_fnGetLibStatistics( ITypeLib * This,
-        UINT *pcUniqueNames, UINT *pcchUniqueNames);
-
-static HRESULT WINAPI ITypeLib2_fnGetDocumentation2( ITypeLib * This,
-        INT index, LCID lcid, BSTR *pbstrHelpString,
-        INT *pdwHelpStringContext, BSTR *pbstrHelpStringDll);
-
-static HRESULT WINAPI ITypeLib2_fnGetAllCustData( ITypeLib * This,
-        CUSTDATA *pCustData);
-static ICOM_VTABLE(ITypeLib) tlbvt = {
-    ITypeLib_fnQueryInterface,
-    ITypeLib_fnAddRef,
-    ITypeLib_fnRelease,
-    ITypeLib_fnGetTypeInfoCount,
-    ITypeLib_fnGetTypeInfo,
-    ITypeLib_fnGetTypeInfoType,
-    ITypeLib_fnGetTypeInfoOfGuid,
-    ITypeLib_fnGetLibAttr,
-    ITypeLib_fnGetTypeComp,
-    ITypeLib_fnGetDocumentation,
-    ITypeLib_fnIsName,
-    ITypeLib_fnFindName,
-    ITypeLib_fnReleaseTLibAttr,
-    ITypeLib2_fnGetCustData,
-    ITypeLib2_fnGetLibStatistics,
-    ITypeLib2_fnGetDocumentation2,
-    ITypeLib2_fnGetAllCustData
- };
-/* TypeInfo Methods */
-
-static HRESULT WINAPI ITypeInfo_fnQueryInterface( LPTYPEINFO This, REFIID riid,
-    VOID **ppvObject);
-static ULONG WINAPI ITypeInfo_fnAddRef( LPTYPEINFO This);
-static ULONG WINAPI ITypeInfo_fnRelease( LPTYPEINFO This);
-static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( LPTYPEINFO This,
-        LPTYPEATTR  *ppTypeAttr);
-
-static HRESULT WINAPI ITypeInfo_fnGetTypeComp( LPTYPEINFO This,
-        ITypeComp  * *ppTComp);
-
-static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( LPTYPEINFO This, UINT index,
-        LPFUNCDESC  *ppFuncDesc);
-
-static HRESULT WINAPI ITypeInfo_fnGetVarDesc( LPTYPEINFO This, UINT index,
-        LPVARDESC  *ppVarDesc);
-
-static HRESULT WINAPI ITypeInfo_fnGetNames( LPTYPEINFO This, MEMBERID memid,
-        BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames);
-
-
-static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType( LPTYPEINFO This,
-        UINT index, HREFTYPE  *pRefType);
-
-static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( LPTYPEINFO This,
-        UINT index, INT  *pImplTypeFlags);
-
-static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( LPTYPEINFO This,
-        LPOLESTR  *rgszNames, UINT cNames, MEMBERID  *pMemId);
-
-static HRESULT WINAPI ITypeInfo_fnInvoke( LPTYPEINFO This, VOID  *pIUnk,
-        MEMBERID memid, UINT16 dwFlags, DISPPARAMS  *pDispParams,
-        VARIANT  *pVarResult, EXCEPINFO  *pExcepInfo, UINT  *pArgErr);
-
-static HRESULT WINAPI ITypeInfo_fnGetDocumentation( LPTYPEINFO This,
-        MEMBERID memid, BSTR  *pBstrName, BSTR  *pBstrDocString,
-        DWORD  *pdwHelpContext, BSTR  *pBstrHelpFile);
-
-static HRESULT WINAPI ITypeInfo_fnGetDllEntry( LPTYPEINFO This,
-        MEMBERID memid, INVOKEKIND invKind, BSTR  *pBstrDllName,
-        BSTR  *pBstrName, WORD  *pwOrdinal);
-
-static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo( LPTYPEINFO This,
-        HREFTYPE hRefType, ITypeInfo  * *ppTInfo);
-
-static HRESULT WINAPI ITypeInfo_fnAddressOfMember( LPTYPEINFO This,
-        MEMBERID memid, INVOKEKIND invKind, PVOID *ppv);
-
-static HRESULT WINAPI ITypeInfo_fnCreateInstance( LPTYPEINFO This,
-        IUnknown *pUnk, REFIID riid, VOID  * *ppvObj);
-
-static HRESULT WINAPI ITypeInfo_fnGetMops( LPTYPEINFO This, MEMBERID memid,
-        BSTR  *pBstrMops);
-
-
-static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( LPTYPEINFO This,
-        ITypeLib  * *ppTLib, UINT  *pIndex);
-
-static HRESULT WINAPI ITypeInfo_fnReleaseTypeAttr( LPTYPEINFO This,
-        TYPEATTR *pTypeAttr);
-
-static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc( LPTYPEINFO This,
-        FUNCDESC *pFuncDesc);
-
-static HRESULT WINAPI ITypeInfo_fnReleaseVarDesc( LPTYPEINFO This,
-        VARDESC *pVarDesc);
-/* itypeinfo2 methods */
-static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo * This,
-    TYPEKIND *pTypeKind);
-static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo * This,
-    UINT *pTypeFlags);
-static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo * This,
-    MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex);
-static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo * This,
-    MEMBERID memid, UINT *pVarIndex);
-static HRESULT WINAPI ITypeInfo2_fnGetCustData( ITypeInfo * This,
-    REFGUID guid, VARIANT *pVarVal);
-static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData( ITypeInfo * This,
-    UINT index, REFGUID guid, VARIANT *pVarVal);
-static HRESULT WINAPI ITypeInfo2_fnGetParamCustData( ITypeInfo * This,
-    UINT indexFunc, UINT indexParam, REFGUID guid, VARIANT *pVarVal);
-static HRESULT WINAPI ITypeInfo2_fnGetVarCustData( ITypeInfo * This,
-    UINT index, REFGUID guid, VARIANT *pVarVal);
-static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData( ITypeInfo * This,
-    UINT index, REFGUID guid, VARIANT *pVarVal);
-static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2( ITypeInfo * This,
-    MEMBERID memid, LCID lcid, BSTR *pbstrHelpString,
-    INT *pdwHelpStringContext, BSTR *pbstrHelpStringDll);
-static HRESULT WINAPI ITypeInfo2_fnGetAllCustData( ITypeInfo * This,
-    CUSTDATA *pCustData);
-static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData( ITypeInfo * This,
-    UINT index, CUSTDATA *pCustData);
-static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo * This,
-    UINT indexFunc, UINT indexParam, CUSTDATA *pCustData);
-static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo * This,
-    UINT index, CUSTDATA *pCustData);
-static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData( ITypeInfo * This,
-    UINT index, CUSTDATA *pCustData);
-
-static ICOM_VTABLE(ITypeInfo) tinfvt = {
-    ITypeInfo_fnQueryInterface,
-    ITypeInfo_fnAddRef,
-    ITypeInfo_fnRelease,
-    ITypeInfo_fnGetTypeAttr,
-    ITypeInfo_fnGetTypeComp,
-    ITypeInfo_fnGetFuncDesc,
-    ITypeInfo_fnGetVarDesc,
-    ITypeInfo_fnGetNames,
-    ITypeInfo_fnGetRefTypeOfImplType,
-    ITypeInfo_fnGetImplTypeFlags,
-    ITypeInfo_fnGetIDsOfNames,
-    ITypeInfo_fnInvoke,
-    ITypeInfo_fnGetDocumentation,
-    ITypeInfo_fnGetDllEntry,
-    ITypeInfo_fnGetRefTypeInfo,
-    ITypeInfo_fnAddressOfMember,
-    ITypeInfo_fnCreateInstance,
-    ITypeInfo_fnGetMops,
-    ITypeInfo_fnGetContainingTypeLib,
-    ITypeInfo_fnReleaseTypeAttr,
-    ITypeInfo_fnReleaseFuncDesc,
-    ITypeInfo_fnReleaseVarDesc,
-
-    ITypeInfo2_fnGetTypeKind,
-    ITypeInfo2_fnGetTypeFlags,
-    ITypeInfo2_fnGetFuncIndexOfMemId,
-    ITypeInfo2_fnGetVarIndexOfMemId,
-    ITypeInfo2_fnGetCustData,
-    ITypeInfo2_fnGetFuncCustData,
-    ITypeInfo2_fnGetParamCustData,
-    ITypeInfo2_fnGetVarCustData,
-    ITypeInfo2_fnGetImplTypeCustData,
-    ITypeInfo2_fnGetDocumentation2,
-    ITypeInfo2_fnGetAllCustData,
-    ITypeInfo2_fnGetAllFuncCustData,
-    ITypeInfo2_fnGetAllParamCustData,
-    ITypeInfo2_fnGetAllVarCustData,
-    ITypeInfo2_fnGetAllImplTypeCustData,
-
-};
-
-static TYPEDESC stndTypeDesc[VT_LPWSTR+1]={/* VT_LPWSTR is largest type that */
-                                                                                /* may appear in type description*/
-        {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
-        {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
-    {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
-        {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
-    {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
-        {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
-    {{0},30},{{0},31}};
-
-static void TLB_abort()
-{
-                *((int *)0)=0;
-}
-static void * TLB_Alloc(unsigned size)
-{
-    void * ret;
-    if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
-        /* FIXME */
-        ERR_(ole)("cannot allocate memory\n");
-    }
-    return ret;
-}
-
-/* candidate for a more global appearance... */
-static BSTR  TLB_DupAtoBstr(PCHAR Astr)
-{
-    int len;
-    BSTR bstr;
-    DWORD *pdw  ;
-    if(!Astr)
-        return NULL;
-    len=strlen(Astr);
-    pdw = (DWORD *)TLB_Alloc((len+3)*sizeof(OLECHAR));
-    pdw[0]=(len)*sizeof(OLECHAR);
-    bstr=(BSTR)&( pdw[1]);
-    lstrcpyAtoW( bstr, Astr);
-    TRACE_(typelib)("copying %s to (%p)\n", Astr, bstr);
-    return bstr;
-}
-
-static void TLB_Free(void * ptr)
-{
-    HeapFree(GetProcessHeap(), 0, ptr);
-}
-/* read function */
-DWORD TLB_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
-{
-        DWORD bytesread=0;
-
-        if ((   where != DO_NOT_SEEK &&
-                (0xffffffff == SetFilePointer( pcx->hFile, where, 0,FILE_BEGIN))
-            ) ||
-            !ReadFile(pcx->hFile, buffer, count, &bytesread, NULL)
-        ) {
-        /* FIXME */
-                ERR_(typelib)("read error is 0x%lx reading %ld bytes at 0x%lx\n",
-                            GetLastError(), count, where);
-                TLB_abort();
-                exit(1);
-        }
-        return bytesread;
-}
-
-static void TLB_ReadGuid( GUID *pGuid, int offset,   TLBContext *pcx)
-{
-    if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
-        memset(pGuid,0, sizeof(GUID));
-        return;
-    }
-    TLB_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
-}
-
-PCHAR TLB_ReadName( TLBContext *pcx, int offset)
-{
-    char * name;
-    TLBNameIntro niName;
-    TLB_Read(&niName, sizeof(niName), pcx,
-                                pcx->pTblDir->pNametab.offset+offset);
-    niName.namelen &= 0xFF; /* FIXME: correct ? */
-    name=(char *)TLB_Alloc((niName.namelen & 0xff) +1);
-    TLB_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
-    name[niName.namelen & 0xff]='\0';
-    return name;
-}
-PCHAR TLB_ReadString( TLBContext *pcx, int offset)
-{
-    char * string;
-    INT16 length;
-    if(offset<0) return NULL;
-    TLB_Read(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
-    if(length <= 0) return 0;
-    string=(char *)TLB_Alloc(length +1);
-    TLB_Read(string, length, pcx, DO_NOT_SEEK);
-    string[length]='\0';
-    return string;
-}
-/*
- * read a value and fill a VARIANT structure
- */
-static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
-{
-    int size;
-    if(offset <0) { /* data is packed in here */
-        pVar->vt = (offset & 0x7c000000 )>> 26;
+// ======================================================================
+// Class functions.
+// ======================================================================
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::TypeLibExtract
+// ----------------------------------------------------------------------
+TypeLibExtract::TypeLibExtract(char * szName) : m_fValid(0), m_hHeap(GetProcessHeap())
+{
+    if ((Load(szName) == S_OK)
+        && (EstablishPointers() == S_OK))
+    {
+        m_fValid = TRUE;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::~TypeLibExtract
+// ----------------------------------------------------------------------
+TypeLibExtract::~TypeLibExtract()
+{
+    m_fValid = 0;
+
+    if (m_pTypeLib)
+        HeapFree(m_hHeap, 0, m_pTypeLib);
+
+    m_hHeap = 0;
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::EstablishPointers()
+// ----------------------------------------------------------------------
+HRESULT TypeLibExtract::EstablishPointers()
+{
+    // Locate segment directory...
+    m_pHeader = (TLB2Header *)m_pTypeLib;
+    if (m_pHeader->varflags & HELPDLLFLAG)
+    {
+        m_pHelpStringOff = (ULONG *)(m_pHeader + 1);
+        m_pTypeInfoDir = m_pHelpStringOff + 1;
+    }
+    else
+    {
+        m_pHelpStringOff = 0;
+        m_pTypeInfoDir = (ULONG *)(m_pHeader + 1);
+    }
+    m_pSegDir = (TLBSegDir *)(m_pTypeInfoDir + m_pHeader->nrtypeinfos);
+
+    // Segment directory sanity check...
+    if (m_pSegDir->pTypeInfoTab.res0c != 0x0F || m_pSegDir->pImpInfo.res0c != 0x0F)
+    {
+        dprintf(("  Segment directory sanity check failed!"));
+        return E_FAIL;
+    }
+
+//    m_pLib
+    if (m_pSegDir->pImpInfo.offset > 0)
+        m_pImpInfo = (TLBImpInfo *)((char *)m_pTypeLib + m_pSegDir->pImpInfo.offset);
+    else
+        m_pImpInfo = 0;
+
+    if (m_pSegDir->pRefTab.offset > 0)
+        m_pRef = (TLBRefRecord *)((char *)m_pTypeLib + m_pSegDir->pRefTab.offset);
+    else
+        m_pRef = 0;
+
+    if (m_pSegDir->pGuidTab.offset > 0)
+        m_pGUID = (GUID *)((char *)m_pTypeLib + m_pSegDir->pGuidTab.offset);
+    else
+        m_pGUID = 0;
+
+    if (m_pSegDir->pNameTab.offset > 0)
+        m_pName = (TLBName *)((char *)m_pTypeLib + m_pSegDir->pNameTab.offset);
+    else
+        m_pName = 0;
+
+    if (m_pSegDir->pStringTab.offset > 0)
+        m_pString = (TLBString *)((char *)m_pTypeLib + m_pSegDir->pStringTab.offset);
+    else
+        m_pString = 0;
+
+    if (m_pSegDir->pTypedescTab.offset > 0)
+        m_pTypedesc = (TLBTypedesc *)((char *)m_pTypeLib + m_pSegDir->pTypedescTab.offset);
+    else
+        m_pTypedesc = 0;
+
+    if (m_pSegDir->pTypedescTab.offset > 0)
+        m_pArray = (TLBArray *)((char *)m_pTypeLib + m_pSegDir->pTypedescTab.offset);
+    else
+        m_pArray = 0;
+
+    if (m_pSegDir->pCustData.offset > 0)
+        m_pCustData = (void *)((char *)m_pTypeLib + m_pSegDir->pCustData.offset);
+    else
+        m_pCustData = 0;
+
+    if (m_pSegDir->pCDGuids.offset > 0)
+        m_pCDGuid = (TLBCDGuid *)((char *)m_pTypeLib + m_pSegDir->pCDGuids.offset);
+    else
+        m_pCDGuid = 0;
+
+    if (m_pSegDir->pImpFiles.offset > 0)
+        m_pImpFile = (TLBImpFile *)((char *)m_pTypeLib + m_pSegDir->pImpFiles.offset);
+    else
+        m_pImpFile = 0;
+
+    if (m_pSegDir->pTypeInfoTab.offset > 0)
+        m_pTypeInfo = (TLBTypeInfoBase *)((char *)m_pTypeLib + m_pSegDir->pTypeInfoTab.offset);
+    else
+        m_pTypeInfo = 0;
+
+    return S_OK;
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::Read
+//
+// If 'where' is != DO_NOT_SEEK then seek to 'where'.
+// Read 'count' bytes from 'hfile' into 'buffer'
+// ----------------------------------------------------------------------
+BOOL TypeLibExtract::Read(HANDLE hFile, void * buffer, DWORD count, DWORD * pBytesRead, long where)
+{
+    if (where != DO_NOT_SEEK)
+    {
+        if (0xffffffff == SetFilePointer(hFile, where, 0, FILE_BEGIN))
+            return FALSE;
+    }
+    return ReadFile(hFile, buffer, count, pBytesRead, NULL);
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::GetTypedesc
+// ----------------------------------------------------------------------
+void TypeLibExtract::GetTypedesc(int type, TYPEDESC * pTd)
+{
+    if (type < 0)
+        pTd->vt = type & VT_TYPEMASK;
+    else
+        *pTd = *m_pITypeLib->pTypedesc[type / (sizeof(TLBTypedesc))];
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseGuid
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseGuid(int offset, GUID * pGuid)
+{
+    if (offset < 0)
+    {
+        memset(pGuid, 0, sizeof(GUID));
+    }
+    else
+    {
+        memcpy(pGuid, (char *)m_pGUID + offset, sizeof(GUID));
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseArray
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseArray(int offset, TLBArray * pArray)
+{
+    if (offset < 0)
+    {
+        memset(pArray, 0, sizeof(TLBArray));
+    }
+    else
+    {
+        memcpy(pArray, (char *)m_pGUID + offset, sizeof(TLBArray));
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseName
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseName(int offset, char * * ppName)
+{
+    char *      p;
+
+    if (offset < 0)
+    {
+        *ppName = 0;
+    }
+    else
+    {
+        TLBName *       pName = (TLBName *)((char *)m_pName + offset);
+        int             nameLen = pName->namelen & 0xff;
+
+        p = (char *)HeapAlloc(m_hHeap, 0, nameLen + 1);
+        memcpy(p, pName->name, nameLen);
+        p[nameLen] = 0;
+
+        *ppName = p;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseString
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseString(int offset, char * * ppString)
+{
+    char *      p;
+
+    if (offset < 0)
+    {
+        *ppString = 0;
+    }
+    else
+    {
+        TLBString *     pString = (TLBString *)((char *)m_pString + offset);
+        int             stringLen = pString->stringlen;
+
+        p = (char *)HeapAlloc(m_hHeap, 0, stringLen + 1);
+
+        memcpy(p, pString->string, stringLen);
+        p[stringLen] = 0;
+
+        *ppString = p;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseValue
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseValue(int offset, VARIANT * pVar)
+{
+    int         size;
+
+    if (offset < 0) /* data is packed in here */
+    {
+        pVar->vt = (offset & 0x7c000000) >> 26;
         V_UNION(pVar, iVal) = offset & 0xffff;
         return;
     }
-    TLB_Read(&(pVar->vt), sizeof(VARTYPE), pcx,
-        pcx->pTblDir->pCustData.offset + offset );
-    switch(pVar->vt){
+
+    VARTYPE *   pVarType = (VARTYPE *)((char *)m_pCustData + offset);
+
+    pVar->vt = *pVarType;
+
+    switch(pVar->vt)
+    {
         case VT_EMPTY:  /* FIXME: is this right? */
         case VT_NULL:   /* FIXME: is this right? */
@@ -554 +463 @@
         case VT_VOID    : /* FIXME: is this right? */
         case VT_HRESULT :
-            size=4; break;
+            size=4;
+            break;
+
         case VT_R8  :
         case VT_CY  :
@@ -562 +473 @@
         case VT_DECIMAL :  /* FIXME: is this right? */
         case VT_FILETIME :
-            size=8;break;
+            size=8;
+            break;
+
             /* pointer types with known behaviour */
-        case VT_BSTR    :{
-            char * ptr;
-            TLB_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
-            ptr=(char *)TLB_Alloc(size);/* allocate temp buffer */
-            TLB_Read(ptr, size, pcx, DO_NOT_SEEK ); /* read string (ANSI) */
-            V_UNION(pVar, bstrVal)=SysAllocStringLen(NULL,size);
-            /* FIXME: do we need a AtoW conversion here? */
-            V_UNION(pVar, bstrVal[size])=L'\0';
-            while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
-            TLB_Free(ptr);
-        }
-            size=-4; break;
+        case VT_BSTR    :
+        {
+            INT *       pStringLen = (INT *)(pVarType + 1);
+            char *      pString = (char *)(pStringLen + 1);
+
+            // Allocate BSTR container and then convert directly into it...
+//???A Fix
+            V_UNION(pVar, bstrVal) = SysAllocStringLen(NULL, *pStringLen);
+            AsciiToUnicodeN(pString, V_UNION(pVar, bstrVal), *pStringLen);
+            return;
+        }
+
     /* FIXME: this will not work AT ALL when the variant contains a pointer */
         case VT_DISPATCH :
@@ -595 +508 @@
         case VT_CLSID   :
         default:
-            size=0;
-            FIXME_(ole)("VARTYPE %d is not supported, setting pointer to NULL\n",
-                pVar->vt);
-    }
-
-    if(size>0) /* (big|small) endian correct? */
-        TLB_Read(&(V_UNION(pVar, iVal)), size, pcx, DO_NOT_SEEK );
-        return ;
-}
-/*
- * create a linked list with custom data
- */
-static int TLB_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
-{
-    TLBCDGuid entry;
-    TLBCustData* pNew;
-    int count=0;
-    while(offset >=0){
-        count++;
-        pNew=(TLBCustData* )TLB_Alloc(sizeof(TLBCustData));
-        TLB_Read(&entry, sizeof(entry), pcx,
-            pcx->pTblDir->pCDGuids.offset+offset);
-        TLB_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
-        TLB_ReadValue(&(pNew->data), entry.DataOffset, pcx);
-        /* add new custom data at head of the list */
-        pNew->next=*ppCustData;
-        *ppCustData=pNew;
-        offset = entry.next;
-    }
-    return count;
-}
-
-static void TLB_GetTdesc(TLBContext *pcx, INT type,TYPEDESC * pTd )
-{
-    if(type <0)
-        pTd->vt=type & VT_TYPEMASK;
-    else
-        *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
-}
-static void TLB_DoFuncs(TLBContext *pcx, int cFuncs, int cVars,
-                          int offset, TLBFuncDesc ** pptfd)
-{
-    /*
-     * member information is stored in a data structure at offset
-     * indicated by the memoffset field of the typeinfo structure
-     * There are several distinctive parts.
-     * the first part starts with a field that holds the total length
-     * of this (first) part excluding this field. Then follow the records,
-     * for each member there is one record.
-     *
-     * First entry is always the length of the record (excluding this
-     * length word).
-     * Rest of the record depends on the type of the member. If there is
-     * a field indicating the member type (function variable intereface etc)
-     * I have not found it yet. At this time we depend on the information
-     * in the type info and the usual order how things are stored.
-     *
-     * Second follows an array sized nrMEM*sizeof(INT) with a memeber id
-     * for each member;
-     *
-     * Third is a equal sized array with file offsets to the name entry
-     * of each member.
-     *
-     * Forth and last (?) part is an array with offsets to the records in the
-     * first part of this file segment.
+            size = 0;
+            dprintf(("OLEAUT32: VARTYPE %d is not supported, setting pointer to NULL\n", pVar->vt));
+    }
+
+    if (size > 0) /* (big|small) endian correct? */
+        memcpy(&(V_UNION(pVar, iVal)), (pVarType + 1), size);
+
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseCustomData
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseCustomData(int offset, oList<TLBCustData *> * pCustomData)
+{
+    TLBCDGuid *         pCDGuid;
+    TLBCustData *       pNew;
+
+    while (offset >=0)
+    {
+        pCDGuid = (TLBCDGuid *)((char *)m_pCDGuid + offset);
+        pNew = new TLBCustData;
+
+        ParseGuid(pCDGuid->GuidOffset, &(pNew->guid));
+        ParseValue(pCDGuid->DataOffset, &(pNew->data));
+
+        pCustomData->AddAtEnd(pNew);
+        offset  =  pCDGuid->next;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseTypeInfo
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseTypeInfo(ITypeInfoImpl * pTypeInfo, TLBTypeInfoBase * pBase)
+{
+    /* fill in the typeattr fields */
+    ParseGuid(pBase->posguid, &pTypeInfo->TypeAttr.guid);
+    pTypeInfo->TypeAttr.lcid = m_pITypeLib->LibAttr.lcid;   /* FIXME: correct? */
+    pTypeInfo->TypeAttr.memidConstructor = MEMBERID_NIL ;/* FIXME */
+    pTypeInfo->TypeAttr.memidDestructor = MEMBERID_NIL ; /* FIXME */
+    pTypeInfo->TypeAttr.lpstrSchema = NULL;              /* reserved */
+    pTypeInfo->TypeAttr.cbSizeInstance = pBase->size;
+    pTypeInfo->TypeAttr.typekind = (tagTYPEKIND)(pBase->typekind & 0xF);
+    pTypeInfo->TypeAttr.cFuncs = LOWORD(pBase->cElement);
+    pTypeInfo->TypeAttr.cVars = HIWORD(pBase->cElement);
+    pTypeInfo->TypeAttr.cbAlignment = (pBase->typekind >> 11 )& 0x1F; /* more flags here ? */
+    pTypeInfo->TypeAttr.wTypeFlags = pBase->flags;
+    pTypeInfo->TypeAttr.wMajorVerNum = LOWORD(pBase->version);
+    pTypeInfo->TypeAttr.wMinorVerNum = HIWORD(pBase->version);
+    pTypeInfo->TypeAttr.cImplTypes = pBase->cImplTypes;
+    pTypeInfo->TypeAttr.cbSizeVft = pBase->cbSizeVft; // FIXME: this is only the non inherited part
+    if (pTypeInfo->TypeAttr.typekind  == TKIND_ALIAS)
+        GetTypedesc(pBase->datatype1, &pTypeInfo->TypeAttr.tdescAlias) ;
+
+    /*  FIXME: */
+    /*    IDLDESC  idldescType; *//* never saw this one ! =  zero  */
+
+    /* name, eventually add to a hash table */
+    ParseName(pBase->NameOffset, &pTypeInfo->szName);
+
+    dprintf(("  -> typeinfo \"%s\"\n", pTypeInfo->szName));
+
+    /* help info */
+    ParseString(pBase->docstringoffs, &pTypeInfo->szDocString);
+    pTypeInfo->lHelpStringContext = pBase->helpstringcontext;
+    pTypeInfo->lHelpContext = pBase->helpcontext;
+    /* note: InfoType's Help file and HelpStringDll come from the containing
+     * library. Further HelpString and Docstring appear to be the same thing :(
      */
 
-    int infolen, nameoffset, reclength, nrattributes;
-    char recbuf[512];
-    TLBFuncRecord * pFuncRec=(TLBFuncRecord *) recbuf;
-    int i, j;
-    int recoffset=offset+sizeof(INT);
-    TLB_Read(&infolen,sizeof(INT), pcx, offset);
-    for(i=0;i<cFuncs;i++){
-        *pptfd=(TLBFuncDesc*)TLB_Alloc(sizeof(TLBFuncDesc));
-    /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset, sizeof(INT), pcx,
-            offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
-        (*pptfd)->Name=TLB_ReadName(pcx, nameoffset);
-    /* read the function information record */
-        TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
-        reclength &=0x1ff;
-        TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
-    /* do the attributes */
-        nrattributes=(reclength-pFuncRec->nrargs*3*sizeof(int)-0x18)
-            /sizeof(int);
-        if(nrattributes>0){
-            (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
-            if(nrattributes>1){
-                (*pptfd)->HelpString = TLB_ReadString(pcx,
-                                                      pFuncRec->OptAttr[1]) ;
-                if(nrattributes>2){
-                    if(pFuncRec->FKCCIC & 0x2000)
-                        (*pptfd)->Entry = (char *) pFuncRec->OptAttr[2] ;
-                    else
-                        (*pptfd)->Entry = TLB_ReadString(pcx,
-                                                         pFuncRec->OptAttr[2]);
-                    if(nrattributes>5 )
-                        (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
-                    if(nrattributes>6 && pFuncRec->FKCCIC & 0x80){
-                        TLB_CustData(pcx, pFuncRec->OptAttr[6],
-                                &(*pptfd)->pCustData);
-                    }
+    // Functions/
+    ParseMembers(pTypeInfo, pBase);
+
+    // ImplTypes {DR: not sure this is OK yet}
+    if (pTypeInfo->TypeAttr.typekind == TKIND_COCLASS)
+        ParseImplemented(pTypeInfo, pBase);
+
+    // RefTypes {DR: not sure this is OK yet}
+    else if (pTypeInfo->TypeAttr.typekind != TKIND_DISPATCH)
+    {
+        TLBRefType *    pNew = new TLBRefType;
+        ParseReference(pBase->datatype1, pNew);
+        pTypeInfo->pImplements.AddAtEnd(pNew);
+
+    }
+
+    // Load Custom data
+    ParseCustomData(pBase->oCustData, &pTypeInfo->pCustData);
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseReference
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseReference(int offset, TLBRefType * pNew)
+{
+    int j;
+
+    if(!HREFTYPE_INTHISFILE( offset))
+    {
+        /* external typelib */
+        TLBImpInfo *    pImpInfo = (TLBImpInfo *)((char *)m_pImpInfo + (offset & 0xfffffffc));
+        oListIter<TLBImpLib *>  itrImpLib(m_pITypeLib->pImpLibs);
+
+        // We have already loaded the external typelibs so
+        // loop thru them to find the one we want.
+        for (itrImpLib.MoveStart(); itrImpLib.IsValid(); itrImpLib.MoveNext())
+        {
+
+            if (itrImpLib.Element()->offset == pImpInfo->oImpFile)
+            {
+                pNew->reference = offset;
+                pNew->pImpTLInfo = itrImpLib.Element();
+                ParseGuid(pImpInfo->oGuid, &pNew->guid);
+                return;
+            }
+        }
+        dprintf((" WARNING: Cannot find a reference\n"));
+        pNew->reference = -1;
+        pNew->pImpTLInfo = (TLBImpLib *)-1;
+    }
+    else
+    {
+        /* in this typelib */
+        pNew->reference = offset;
+        pNew->pImpTLInfo = (TLBImpLib *)-2;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseImplemented
+//
+// Process Implemented Interfaces of a com class
+// ----------------------------------------------------------------------
+void TypeLibExtract::ParseImplemented(ITypeInfoImpl * pTypeInfo, TLBTypeInfoBase * pBase)
+{
+    TLBRefRecord *      pRefRec;
+    TLBRefType *        pNew;
+    int                 ii;
+    int                 offset;
+
+    offset = pBase->datatype1;
+    for (ii = 0; ii < pTypeInfo->TypeAttr.cImplTypes; ii++)
+    {
+        if (offset < 0)
+            break; /* paranoia */
+
+        pRefRec = (TLBRefRecord *)((char *)m_pRef + offset);
+        pNew = new TLBRefType;
+
+        ParseReference(pRefRec->reftype, pNew);
+        pNew->flags = pRefRec->flags;
+
+        // Custom data
+        ParseCustomData(pRefRec->oCustData, &pNew->pCustData);
+
+        pTypeInfo->pImplements.AddAtEnd(pNew);
+
+        offset = pRefRec->onext;
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::ParseMembers
+//
+// Member information is stored in a data structure at offset
+// indicated by the memoffset field of the typeinfo structure
+// There are several distinctive parts.
+// the first part starts with a field that holds the total length
+// of this (first) part excluding this field. Then follow the records,
+// for each member there is one record.
+//
+// First entry is always the length of the record (excluding this
+// length word).
+// Rest of the record depends on the type of the member. If there is
+// a field indicating the member type (function variable intereface etc)
+// I have not found it yet. At this time we depend on the information
+// in the type info and the usual order how things are stored.
+//
+// Second follows an array sized nrMEM*sizeof(INT) with a memeber id
+// for each member;
+//
+// Third is a equal sized array with file offsets to the name entry
+// of each member.
+//
+// Forth and last (?) part is an array with offsets to the records in the
+// first part of this file segment.
+//
+// ----------------------------------------------------------------------
+void    TypeLibExtract::ParseMembers(ITypeInfoImpl * pTypeInfo, TLBTypeInfoBase * pBase)
+{
+    TLBFuncRecord *     pFuncRec;
+    TLBVarRecord *      pVarRec;
+    int                 ii;
+    int                 jj;
+    int                 iAttrCount;
+    INT *               pInfoLen;
+    INT *               pNameOff;
+    INT *               pMemberID;
+    INT *               pMemberOff;
+
+    // Map ptrs to sections of the typeinfo record...
+    pInfoLen = (INT *)((char *)m_pTypeLib + pBase->memoffset);
+    pFuncRec = (TLBFuncRecord *)(pInfoLen + 1);
+    pMemberID = (INT *)((char *)pFuncRec + *pInfoLen);
+    pNameOff = pMemberID + pTypeInfo->TypeAttr.cFuncs + pTypeInfo->TypeAttr.cVars;
+    pMemberOff = pNameOff + pTypeInfo->TypeAttr.cFuncs + pTypeInfo->TypeAttr.cVars;
+
+    // loop through each function...
+    for (ii = 0; ii < pTypeInfo->TypeAttr.cFuncs; ii++)
+    {
+        TLBFuncDesc *   pNew;
+
+        pNew = new TLBFuncDesc;
+        ParseName(pNameOff[ii], &pNew->szName);
+
+        dprintf(("    -> function \"%s\"\n", pNew->szName));
+
+        // decode optional attributes
+        iAttrCount = (pFuncRec->recsize
+                        - pFuncRec->nrargs * 3 * sizeof(int) - 0x18) / sizeof(int);
+
+        if (iAttrCount > 0)
+            pNew->helpcontext = pFuncRec->OptAttr[0] ;
+
+        if (iAttrCount > 1)
+            ParseString(pFuncRec->OptAttr[1], &pNew->szHelpString);
+
+        if (iAttrCount > 2)
+        {
+            if (pFuncRec->FKCCIC & 0x2000)
+                pNew->szEntry = (char *) pFuncRec->OptAttr[2] ;
+            else
+                ParseString(pFuncRec->OptAttr[2], &pNew->szEntry);
+        }
+
+        if (iAttrCount > 5 )
+            pNew->lHelpStringContext = pFuncRec->OptAttr[5] ;
+
+        if (iAttrCount > 6 && pFuncRec->FKCCIC & 0x80)
+            ParseCustomData(pFuncRec->OptAttr[6], &pNew->pCustData);
+
+        // fill the FuncDesc Structure
+        pNew->funcdesc.memid = pMemberID[ii];
+        pNew->funcdesc.funckind = (tagFUNCKIND)((pFuncRec->FKCCIC) & 0x7);
+        pNew->funcdesc.invkind = (tagINVOKEKIND)(((pFuncRec->FKCCIC) >>3) & 0xF);
+        pNew->funcdesc.callconv = (tagCALLCONV)((pFuncRec->FKCCIC) >>8 & 0xF);
+        pNew->funcdesc.cParams = pFuncRec->nrargs ;
+        pNew->funcdesc.cParamsOpt = pFuncRec->nroargs ;
+        pNew->funcdesc.oVft = pFuncRec->VtableOffset ;
+        pNew->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags)  ;
+        GetTypedesc(pFuncRec->DataType, &pNew->funcdesc.elemdescFunc.tdesc) ;
+
+        // do the parameters/arguments 
+        if (pFuncRec->nrargs)
+        {
+            TLBParameterInfo *  pParam;
+
+            pNew->funcdesc.lprgelemdescParam = new ELEMDESC[pFuncRec->nrargs];
+            pNew->pParamDesc = new TLBParDesc[pFuncRec->nrargs];
+
+            pParam = (TLBParameterInfo *)((char *)pFuncRec + pFuncRec->recsize -
+                pFuncRec->nrargs * sizeof(TLBParameterInfo));
+
+            for(jj = 0 ; jj < pFuncRec->nrargs; jj++)
+            {
+                GetTypedesc(pParam->DataType, &pNew->funcdesc.lprgelemdescParam[jj].tdesc);
+                    
+                V_UNION(&(pNew->funcdesc.lprgelemdescParam[jj]),
+                    paramdesc.wParamFlags)  =  pParam->Flags;
+                // Name
+                ParseName(pParam->oName, &pNew->pParamDesc[jj].szName);
+                dprintf(("      -> param \"%s\"\n", pNew->pParamDesc[jj].szName));
+
+                // default value
+                if ((PARAMFLAG_FHASDEFAULT & V_UNION(&(pNew->funcdesc.
+                    lprgelemdescParam[jj]),paramdesc.wParamFlags)) &&
+                    ((pFuncRec->FKCCIC) & 0x1000))
+                {
+                    INT *pInt = (INT *)((char *)pFuncRec + pFuncRec->recsize -
+                        (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
+                    PARAMDESC * pParamDesc =  &V_UNION(&(pNew->funcdesc.
+                        lprgelemdescParam[jj]),paramdesc);
+                    pParamDesc->pparamdescex  = new PARAMDESCEX;
+                    pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
+                    ParseValue(pInt[jj], &(pParamDesc->pparamdescex->varDefaultValue));
                 }
+
+                // custom info
+                if (iAttrCount > 7 + jj && pFuncRec->FKCCIC & 0x80)
+                    ParseCustomData(pFuncRec->OptAttr[7 + jj], &pNew->pParamDesc[jj].pCustData);
+
+                pParam++;       // Next record.
             }
+        }
+
+        /* scode is not used: archaic win16 stuff FIXME: right? */
+        pNew->funcdesc.cScodes = 0 ;
+        pNew->funcdesc.lprgscode = NULL ;
+
+        // Store
+        pTypeInfo->pFunctions.AddAtEnd(pNew);
+
+        // Next record...
+        pFuncRec = (TLBFuncRecord *)((char *)pFuncRec + pFuncRec->recsize);
+    }
+
+    // Wine calc's for this ptr were b**ll***s
+    pVarRec = (TLBVarRecord *)pFuncRec;
+
+    for (ii = 0; ii < pTypeInfo->TypeAttr.cVars; ii++)
+    {
+        TLBVarDesc *    pNew;
+
+        pNew = new TLBVarDesc;
+
+        // name, eventually add to a hash table 
+        ParseName(pNameOff[ii], &pNew->szName);
+        dprintf(("    -> variable \"%s\"\n", pNew->szName));
+
+        // Optional data
+        if (pVarRec->recsize > (6 * sizeof(INT)) )
+            pNew->lHelpContext = pVarRec->HelpContext;
+
+        if (pVarRec->recsize > (7 * sizeof(INT)) )
+            ParseString(pVarRec->oHelpString, &pNew->szHelpString);
+
+        if (pVarRec->recsize > (8 * sizeof(INT)) )
+            ;
+
+        if (pVarRec->recsize > (9 * sizeof(INT)) )
+            pNew->lHelpStringContext = pVarRec->HelpStringContext;
+
+        // fill the VarDesc Structure
+        pNew->vardesc.memid = pMemberID[ii];
+        pNew->vardesc.varkind = (tagVARKIND)pVarRec->VarKind;
+        pNew->vardesc.wVarFlags = pVarRec->Flags;
+        GetTypedesc(pVarRec->DataType, &pNew->vardesc.elemdescVar.tdesc) ;
+        /*   pNew->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
+        if (pVarRec->VarKind == VAR_CONST )
+        {
+            V_UNION(&(pNew->vardesc), lpvarValue) = new VARIANT;
+            ParseValue(pVarRec->OffsValue, V_UNION(&(pNew->vardesc), lpvarValue));
         }
-    /* fill the FuncDesc Structure */
-        TLB_Read(&(*pptfd)->funcdesc.memid, sizeof(INT), pcx,
-            offset + infolen + ( i + 1) * sizeof(INT));
-        (*pptfd)->funcdesc.funckind = (tagFUNCKIND)((pFuncRec->FKCCIC) & 0x7);
-        (*pptfd)->funcdesc.invkind = (tagINVOKEKIND)(((pFuncRec->FKCCIC) >>3) & 0xF);
-        (*pptfd)->funcdesc.callconv = (tagCALLCONV)((pFuncRec->FKCCIC) >>8 & 0xF);
-        (*pptfd)->funcdesc.cParams = pFuncRec->nrargs ;
-        (*pptfd)->funcdesc.cParamsOpt = pFuncRec->nroargs ;
-        (*pptfd)->funcdesc.oVft = pFuncRec->VtableOffset ;
-        (*pptfd)->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags)  ;
-        TLB_GetTdesc(pcx, pFuncRec->DataType,
-            &(*pptfd)->funcdesc.elemdescFunc.tdesc) ;
-
-        /* do the parameters/arguments */
-        if(pFuncRec->nrargs){
-            TLBParameterInfo paraminfo;
-            (*pptfd)->funcdesc.lprgelemdescParam=(ELEMDESC*)
-                TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
-            (*pptfd)->pParamDesc=(TLBParDesc*)TLB_Alloc(pFuncRec->nrargs *
-                sizeof(TLBParDesc));
-
-            TLB_Read(&paraminfo,sizeof(paraminfo), pcx, recoffset+reclength -
-                pFuncRec->nrargs * sizeof(TLBParameterInfo));
-            for(j=0;j<pFuncRec->nrargs;j++){
-                TLB_GetTdesc(pcx, paraminfo.DataType,
-                    &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
-                V_UNION(&((*pptfd)->funcdesc.lprgelemdescParam[j]),
-                    paramdesc.wParamFlags) = paraminfo.Flags;
-                (*pptfd)->pParamDesc[j].Name=(char *)paraminfo.oName;
-                TLB_Read(&paraminfo,sizeof(TLBParameterInfo), pcx,
-                        DO_NOT_SEEK);
-            }
-            /* second time around */
-            for(j=0;j<pFuncRec->nrargs;j++){
-                /* name */
-                (*pptfd)->pParamDesc[j].Name=
-                    TLB_ReadName(pcx, (int)(*pptfd)->pParamDesc[j].Name);
-                /* default value */
-                if((PARAMFLAG_FHASDEFAULT & V_UNION(&((*pptfd)->funcdesc.
-                    lprgelemdescParam[j]),paramdesc.wParamFlags)) &&
-                    ((pFuncRec->FKCCIC) & 0x1000)){
-                    INT *pInt=(INT *)((char *)pFuncRec + reclength -
-                        (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
-                    PARAMDESC * pParamDesc= &V_UNION(&((*pptfd)->funcdesc.
-                        lprgelemdescParam[j]),paramdesc);
-                    pParamDesc->pparamdescex = (tagPARAMDESCEX*)TLB_Alloc(sizeof(PARAMDESCEX));
-                    pParamDesc->pparamdescex->cBytes= sizeof(PARAMDESCEX);
-                    TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
-                        pInt[j], pcx);
-                }
-                /* custom info */
-                if(nrattributes>7+j && pFuncRec->FKCCIC & 0x80)
-                    TLB_CustData(pcx, pFuncRec->OptAttr[7+j],
-                                                                        &(*pptfd)->pParamDesc[j].pCustData);
-            }
+        else
+            V_UNION(&(pNew->vardesc), oInst) = pVarRec->OffsValue;
+
+        // Store
+        pTypeInfo->pVariables.AddAtEnd(pNew);
+
+        // Next record...
+        pVarRec = (TLBVarRecord *)((char *)pVarRec + pVarRec->recsize);
+    }
+}
+
+// ----------------------------------------------------------------------
+// LoadSub
+//
+// Callback handler function for the EnumResourceNamesA function...
+// ----------------------------------------------------------------------
+static BOOL     WIN32API LoadSub(HANDLE hMod, LPCTSTR pResType, LPTSTR pResName, LONG lParm)
+{
+    dprintf((" LoadSub called"));
+    HRSRC       hRsrc;
+    HGLOBAL     hData;
+
+    hRsrc = FindResourceA(hMod, pResName, pResType);
+    hData =  LoadResource(hMod, hRsrc);
+    *((void **)lParm) = LockResource(hData);
+    return FALSE;
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::Load
+//
+// Search for & load the TYPELIB into memory.
+// ----------------------------------------------------------------------
+HRESULT TypeLibExtract::Load(char * szFile)
+{
+    ULONG               lStart;                 // Start of typelib in file
+    ULONG               lReadLen;               // Size of data read from file
+    ULONG               lFileSize;              // Size of file
+    char                buf[5];
+    OFSTRUCT            ofStruct;
+    HANDLE              hFile;
+    HRESULT             rc;
+
+    dprintf(("OLEAUT32: TypeLibExtract::Load()"));
+
+    // Open file
+    if ((hFile = OpenFile(szFile, &ofStruct, OF_READ)) == HFILE_ERROR)
+    {
+        dprintf(("  Error opening file - 0x%08x", GetLastError()));
+        return E_ACCESSDENIED;
+    }
+
+    lStart = 0;
+
+    // Read first four byts of file to identify it...
+    if (!Read(hFile, (void *)buf, 4, &lReadLen, lStart))
+    {
+        CloseHandle(hFile);
+        dprintf(("  Failed to read file start bytes"));
+        return E_FAIL;
+    }
+
+    // Check to see if this is a type 1 typelib...
+    if ((buf[0] == 'S') && (buf[1] == 'L') && (buf[2] == 'T') && (buf[3] == 'G'))
+    {
+        dprintf(("  File identified as TYPE1 TYPELIB - not supported yet :-("));
+        CloseHandle(hFile);
+        return E_FAIL;
+    }
+
+    // Check to see if this is a type 2 typelib...
+    if ((buf[0] == 'M') && (buf[1] == 'S') && (buf[2] == 'F') && (buf[3] == 'T'))
+    {
+        // Get typelib file size...
+        lFileSize = GetFileSize(hFile, NULL);
+        dprintf(("  File identified as TYPE2 TYPELIB - Loading image (%lu bytes)...", lFileSize));
+
+        m_pTypeLib = HeapAlloc(m_hHeap, 0, lFileSize);
+        if (!m_pTypeLib)
+        {
+            CloseHandle(hFile);
+            dprintf(("  Failed to allocate a memory pool for typelib image"));
+            return E_OUTOFMEMORY;
+        }
+
+        // Read whole file into memory...
+        if (!Read(hFile, m_pTypeLib, lFileSize, &lReadLen, lStart))
+        {
+            CloseHandle(hFile);
+            dprintf(("  Failed to read typelib"));
+            HeapFree(m_hHeap, 0, m_pTypeLib);
+            return E_FAIL;
+        }
+
+        // Return buffer...
+        CloseHandle(hFile);
+        return S_OK;
+    }
+
+    // Done with file handle...
+    CloseHandle(hFile);
+
+    HINSTANCE           hInst;
+
+    // Check to see if this is a module...
+    hInst = CoLoadLibrary(szFile, TRUE);
+    if (hInst)
+    {
+        // Yup - use EnumResourceNames to locate & load resource.
+        EnumResourceNamesA(hInst, "TYPELIB", LoadSub, (LONG)&m_pTypeLib);
+    }
+
+    if (!m_pTypeLib)
+    {
+        dprintf(("  No TYPELIB resources found..."));
+        return E_FAIL;
+    }
+
+    return S_OK;
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::DumpHeader
+//
+// Drop a debug print of the header content to the ODIN log.
+// ----------------------------------------------------------------------
+void TypeLibExtract::DumpHeader()
+{
+    dprintf(("TYPELIB HEADER:"));
+    if (m_fValid)
+    {
+        dprintf(("  Magic1            - 0x%08lx", m_pHeader->magic1));
+        dprintf(("  Magic2            - 0x%08lx", m_pHeader->magic2));
+        dprintf(("  posguid           - 0x%08lx", m_pHeader->posguid));
+        dprintf(("  lcid              - 0x%08lx", m_pHeader->lcid));
+        dprintf(("  lcid2             - 0x%08lx", m_pHeader->lcid2));
+        dprintf(("  varflags          - 0x%08lx", m_pHeader->varflags));
+        dprintf(("  version           - 0x%08lx", m_pHeader->version));
+        dprintf(("  flags             - 0x%08lx", m_pHeader->flags));
+        dprintf(("  nrtypeinfos       - 0x%08lx", m_pHeader->nrtypeinfos));
+        dprintf(("  helpstring        - 0x%08lx", m_pHeader->helpstring));
+        dprintf(("  helpstringcontext - 0x%08lx", m_pHeader->helpstringcontext));
+        dprintf(("  helpcontext       - 0x%08lx", m_pHeader->helpcontext));
+        dprintf(("  nametablecount    - 0x%08lx", m_pHeader->nametablecount));
+        dprintf(("  nametablechars    - 0x%08lx", m_pHeader->nametablechars));
+        dprintf(("  nameoffset        - 0x%08lx", m_pHeader->nameOffset));
+        dprintf(("  helpfile          - 0x%08lx", m_pHeader->helpfile));
+        dprintf(("  custdataoffset    - 0x%08lx", m_pHeader->customDataOffset));
+        dprintf(("  res44             - 0x%08lx", m_pHeader->res44));
+        dprintf(("  res48             - 0x%08lx", m_pHeader->res48));
+        dprintf(("  dispatchpos       - 0x%08lx", m_pHeader->dispatchpos));
+        dprintf(("  res50             - 0x%08lx", m_pHeader->res50));
+    }
+    else
+    {
+        dprintf(("  INVALID"));
+    }
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::MakeITypeLib
+// ----------------------------------------------------------------------
+HRESULT TypeLibExtract::MakeITypeLib(ITypeLibImpl * * ppObject)
+{
+    dprintf(("OLEAUT32: TypeLibExtract::MakeITypeLib"));
+
+    HRESULT             rc;
+
+    // Create new typelib object...
+    if ((m_pITypeLib = ITypeLibImpl_Constructor()) == 0)
+        return E_OUTOFMEMORY;
+
+    // Parse the typelib into storeage independent format.
+    rc = Parse();
+    if (rc != S_OK)
+    {
+        ITypeLibImpl_Destructor(m_pITypeLib);
+        return rc;
+    }
+
+    // Return new object
+    *ppObject = m_pITypeLib;
+    return S_OK;
+}
+
+// ----------------------------------------------------------------------
+// TypeLibExtract::Parse
+// ----------------------------------------------------------------------
+HRESULT TypeLibExtract::Parse()
+{
+
+    dprintf(("OLEAUT32: TypeLibExtract::Parse"));
+
+    // Load header info...
+    ParseGuid(m_pHeader->posguid, &m_pITypeLib->LibAttr.guid);
+
+    m_pITypeLib->LibAttr.lcid = m_pHeader->lcid;
+    m_pITypeLib->LibAttr.syskind = (tagSYSKIND)(m_pHeader->varflags & 0x0f); /* check the mask */
+    m_pITypeLib->LibAttr.wMajorVerNum = LOWORD(m_pHeader->version);
+    m_pITypeLib->LibAttr.wMinorVerNum = HIWORD(m_pHeader->version);
+    m_pITypeLib->LibAttr.wLibFlags = (WORD) m_pHeader->flags & 0xffff;  /* check mask */
+
+    // name, eventually add to a hash table
+    ParseName(m_pHeader->nameOffset, &m_pITypeLib->szName);
+    dprintf((" reading library: \"%s\"", m_pITypeLib->szName));
+
+    // help info
+    m_pITypeLib->lHelpContext = m_pHeader->helpstringcontext;
+    ParseString(m_pHeader->helpstring, &m_pITypeLib->szDocString);
+    ParseString(m_pHeader->helpfile, &m_pITypeLib->szHelpFile);
+    if (m_pHelpStringOff)
+        ParseString(*m_pHelpStringOff, &m_pITypeLib->szHelpStringDll);
+
+    // Load Custom data
+    ParseCustomData(m_pHeader->customDataOffset, &m_pITypeLib->pCustData);
+
+    // Load typedescriptions
+    if (m_pSegDir->pTypedescTab.length > 0)
+    {
+        TLBTypedesc *   pTd;
+        TYPEDESC *      pNew;
+        TLBArray *      pArray;
+        ULONG           clTd;
+        ULONG           ii;
+        ULONG           jj;
+        
+        clTd = m_pSegDir->pTypedescTab.length / sizeof(TLBTypedesc);
+
+        // Preload (in case of forward references)
+        for (ii = 0; ii < clTd; ii++)
+        {
+            pNew = new TYPEDESC;
+            m_pITypeLib->pTypedesc.AddAtEnd(pNew);
+        }
+
+        // Populate
+        for (ii = 0, pTd = m_pTypedesc; ii < clTd; ii++, pTd++)
+        {
+            pNew = m_pITypeLib->pTypedesc[ii];
+
+            pNew->vt = pTd->rec0 & VT_TYPEMASK;
+            if ((pNew->vt == VT_PTR) || (pNew->vt == VT_SAFEARRAY))
+            {
+                if (pTd->rec3 < 0)
+                    V_UNION(pNew, lptdesc) = &stndTypeDesc[pTd->rec2];
+                else
+                    V_UNION(pNew, lptdesc) = m_pITypeLib->pTypedesc[pTd->rec3 / 8];
+            }
+            else if (pNew->vt == VT_CARRAY) 
+            {
+                pArray = (TLBArray *)((char *)m_pArray + pTd->rec2);
+
+                V_UNION(pNew, lpadesc) =
+                    (tagARRAYDESC*) HeapAlloc(m_hHeap, 0, (sizeof(ARRAYDESC)
+                        + sizeof(SAFEARRAYBOUND) * (pArray->rec3 - 1)));
+
+                if (pArray->rec1 < 0)
+                    V_UNION(pNew,lpadesc)->tdescElem.vt= pArray->rec0 & VT_TYPEMASK;
+                else
+                    V_UNION(pNew,lpadesc)->tdescElem = stndTypeDesc[pArray->rec0 / 8];
+
+                V_UNION(pNew,lpadesc)->cDims = pArray->rec2;
+
+                INT *   pInt = (INT *)(pArray + 1);
+
+                for (jj = 0; jj < pArray->rec2; jj++)
+                {
+                    V_UNION(pNew,lpadesc)->rgbounds[jj].cElements = *pInt++;
+                    V_UNION(pNew,lpadesc)->rgbounds[jj].lLbound = *pInt++;
+                }
+            }
+            else if (pNew->vt == VT_USERDEFINED)
+            {
+                V_UNION(pNew, hreftype) = MAKELONG(pTd->rec2, pTd->rec3);
+            }
+        }
+    }
+
+    // Load Imported typelibs
+    if (m_pSegDir->pImpFiles.length > 0)
+    {
+        TLBImpFile *    pImpFile = m_pImpFile;
+        TLBImpLib *     pNew;
+        ULONG           recLen = 0;
+        ULONG           totLen = 0;
+        ULONG           size;
+
+        while(totLen < m_pSegDir->pImpFiles.length)
+        {
+            pNew = new TLBImpLib;
+            pNew->offset = totLen;
+
+            ParseGuid(pImpFile->offGuid, &(pNew->guid));
+            
+            /* we are skipping some unknown info here */
+
+            size = pImpFile->size >> 2;
+
+            pNew->name = (char *)HeapAlloc(m_hHeap, 0, size + 1);
+            memcpy(pNew->name, pImpFile->name, size);
+
+            // Add to list
+            m_pITypeLib->pImpLibs.AddAtEnd(pNew);
+
+            // Align to next 4 byte boundary...
+            recLen = (sizeof(TLBImpFile) + size + 3) & 0xfffffffc;
+            totLen += recLen;
+            pImpFile = (TLBImpFile *)((char *)pImpFile + recLen);
         }
-    /* scode is not used: archaic win16 stuff FIXME: right? */
-        (*pptfd)->funcdesc.cScodes = 0 ;
-        (*pptfd)->funcdesc.lprgscode = NULL ;
-        pptfd=&((*pptfd)->next);
-        recoffset += reclength;
-    }
-}
-static void TLB_DoVars(TLBContext *pcx, int cFuncs, int cVars,
-                          int offset, TLBVarDesc ** pptvd)
-{
-    int infolen, nameoffset, reclength;
-    char recbuf[256];
-    TLBVarRecord * pVarRec=(TLBVarRecord *) recbuf;
-    int i;
-    int recoffset;
-    TLB_Read(&infolen,sizeof(INT), pcx, offset);
-    TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen +
-        ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
-    recoffset += offset+sizeof(INT);
-    for(i=0;i<cVars;i++){
-        *pptvd=(TLBVarDesc*)TLB_Alloc(sizeof(TLBVarDesc));
-    /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset, sizeof(INT), pcx,
-            offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
-        (*pptvd)->Name=TLB_ReadName(pcx, nameoffset);
-    /* read the variable information record */
-        TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
-        reclength &=0xff;
-        TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
-    /* Optional data */
-        if(reclength >(6*sizeof(INT)) )
-            (*pptvd)->HelpContext=pVarRec->HelpContext;
-        if(reclength >(7*sizeof(INT)) )
-            (*pptvd)->HelpString = TLB_ReadString(pcx, pVarRec->oHelpString) ;
-        if(reclength >(8*sizeof(INT)) )
-        if(reclength >(9*sizeof(INT)) )
-            (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
-    /* fill the VarDesc Structure */
-        TLB_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
-            offset + infolen + ( i + 1) * sizeof(INT));
-        (*pptvd)->vardesc.varkind = (tagVARKIND)pVarRec->VarKind;
-        (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
-        TLB_GetTdesc(pcx, pVarRec->DataType,
-            &(*pptvd)->vardesc.elemdescVar.tdesc) ;
-/*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
-        if(pVarRec->VarKind == VAR_CONST ){
-            V_UNION(&((*pptvd)->vardesc),lpvarValue)=(VARIANT*)TLB_Alloc(sizeof(VARIANT));
-            TLB_ReadValue(V_UNION(&((*pptvd)->vardesc),lpvarValue),
-                pVarRec->OffsValue, pcx);
-        }else
-            V_UNION(&((*pptvd)->vardesc),oInst)=pVarRec->OffsValue;
-        pptvd=&((*pptvd)->next);
-        recoffset += reclength;
-    }
-}
-/* fill in data for a hreftype (offset). When the refernced type is contained
- * in the typelib, its just an (file) offset in the type info base dir.
- * If comes fom import, its an offset+1 in the ImpInfo table
- * */
-static void TLB_DoRefType(TLBContext *pcx,
-                          int offset, TLBRefType ** pprtd)
-{
-    int j;
-    if(!HREFTYPE_INTHISFILE( offset)) {
-        /* external typelib */
-        TLBImpInfo impinfo;
-        TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
-        TLB_Read(&impinfo, sizeof(impinfo), pcx,
-            pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
-        for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
-            if(pImpLib->offset==impinfo.oImpFile) break;
-            pImpLib=pImpLib->next;
-        }
-        if(pImpLib){
-            (*pprtd)->reference=offset;
-            (*pprtd)->pImpTLInfo=pImpLib;
-            TLB_ReadGuid(&(*pprtd)->guid, impinfo.oGuid, pcx);
-        }else{
-            ERR_(typelib)("Cannot find a reference\n");
-            (*pprtd)->reference=-1;
-            (*pprtd)->pImpTLInfo=(tagTLBImpLib*)-1;
-        }
-    }else{
-        /* in this typelib */
-        (*pprtd)->reference=offset;
-        (*pprtd)->pImpTLInfo=(tagTLBImpLib*)-2;
-    }
-}
-
-/* process Implemented Interfaces of a com class */
-static void TLB_DoImplTypes(TLBContext *pcx, int count,
-                          int offset, TLBRefType ** pprtd)
-{
-    int i;
-    TLBRefRecord refrec;
-    for(i=0;i<count;i++){
-        if(offset<0) break; /* paranoia */
-        *pprtd=(TLBRefType*)TLB_Alloc(sizeof(TLBRefType));
-        TLB_Read(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
-        TLB_DoRefType(pcx, refrec.reftype, pprtd);
-        (*pprtd)->flags=refrec.flags;
-        (*pprtd)->ctCustData=
-            TLB_CustData(pcx, refrec.oCustData, &(*pprtd)->pCustData);
-        offset=refrec.onext;
-        pprtd=&((*pprtd)->next);
-    }
-}
-/*
- * process a typeinfo record
- */
-TLBTypeInfo * TLB_DoTypeInfo(TLBContext *pcx, int count, TLBLibInfo* pLibInfo)
-{
-    TLBTypeInfoBase tiBase;
-    TLBTypeInfo *ptiRet;
-    ptiRet=(TLBTypeInfo*)TLB_Alloc(sizeof(TLBTypeInfo));
-    ptiRet->lpvtbl = &tinfvt;
-    ptiRet->ref=1;
-    TLB_Read(&tiBase, sizeof(tiBase) ,pcx ,
-        pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
-/* this where we are coming from */
-    ptiRet->pTypeLib=pLibInfo;
-    ptiRet->index=count;
-/* fill in the typeattr fields */
-    TLB_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
-    ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid;   /* FIXME: correct? */
-    ptiRet->TypeAttr.memidConstructor=MEMBERID_NIL ;/* FIXME */
-    ptiRet->TypeAttr.memidDestructor=MEMBERID_NIL ; /* FIXME */
-    ptiRet->TypeAttr.lpstrSchema=NULL;              /* reserved */
-    ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
-    ptiRet->TypeAttr.typekind=(tagTYPEKIND)(tiBase.typekind & 0xF);
-    ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
-    ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
-    ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
-    ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
-    ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
-    ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
-    ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
-    ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
-    if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
-        TLB_GetTdesc(pcx, tiBase.datatype1,
-            &ptiRet->TypeAttr.tdescAlias) ;
-/*  FIXME: */
-/*    IDLDESC  idldescType; *//* never saw this one != zero  */
-
-/* name, eventually add to a hash table */
-    ptiRet->Name=TLB_ReadName(pcx, tiBase.NameOffset);
-    TRACE_(typelib)("reading %s\n", ptiRet->Name);
-    /* help info */
-    ptiRet->DocString=TLB_ReadString(pcx, tiBase.docstringoffs);
-    ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
-    ptiRet->dwHelpContext=tiBase.helpcontext;
-/* note: InfoType's Help file and HelpStringDll come from the containing
- * library. Further HelpString and Docstring appear to be the same thing :(
- */
-    /* functions */
-    if(ptiRet->TypeAttr.cFuncs >0 )
-        TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
-        tiBase.memoffset, & ptiRet->funclist);
-    /* variables */
-    if(ptiRet->TypeAttr.cVars >0 )
-        TLB_DoVars(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
-        tiBase.memoffset, & ptiRet->varlist);
-    if(ptiRet->TypeAttr.cImplTypes >0 ){
-        if(ptiRet->TypeAttr.typekind == TKIND_COCLASS)
-            TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes ,
-                tiBase.datatype1, & ptiRet->impltypelist);
-        else if(ptiRet->TypeAttr.typekind != TKIND_DISPATCH){
-            ptiRet->impltypelist=(TLBRefType*)TLB_Alloc(sizeof(TLBRefType));
-            TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
-        }
+    }
+
+    // Load Type info data
+    if (m_pHeader->nrtypeinfos >=0 )
+    {
+        ULONG                   ii;
+        ITypeInfoImpl *         pNew;
+        TLBTypeInfoBase *       pBase = m_pTypeInfo;
+
+        for (ii = 0; ii < m_pHeader->nrtypeinfos; ii++)
+        {
+            TLBTypeInfoBase *   pBase = (TLBTypeInfoBase *)
+                                        ((char *)m_pTypeInfo + m_pTypeInfoDir[ii]);
+            pNew = ITypeInfoImpl_Constructor();
+            pNew->pTypeLib = (ITypeLib *)m_pITypeLib;
+            pNew->index = ii;
+
+            ParseTypeInfo(pNew, pBase);
+
+            m_pITypeLib->pTypeInfo.AddAtEnd(pNew);
         }
-    ptiRet->ctCustData=
-        TLB_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
-    return ptiRet;
-}
-
-// ----------------------------------------------------------------------
-// TLB_FindMagic
-// ----------------------------------------------------------------------
-static  int     TLB_FindMagic(TLBContext *pcx, char * pMagic)
-{
-    long        lBlkSize = 1024;        // Block size
-    long        lCurrentPos = 0;        // Current search pos in file.
-    DWORD       lFileSize;              // Size of file to be searched.
-    long        lDataSize;              // Bytes last read.
-    long        lNoBlocks;              // Remaining blocks to scan.
-    long        ll;
-    int         fFound;                 // Found flag
-    char *      pBuf;                   // Allow room for a trailing '\0'
-    HANDLE      hHeap;                  // Heap Handle
-    int         iLen = strlen(pMagic);  // Length of search string
-
-    // Get a search buffer...
-    hHeap = GetProcessHeap();
-    pBuf = (char *)HeapAlloc(hHeap, 0, lBlkSize * 2);
-
-    // Calc search params...
-    lFileSize = GetFileSize(pcx->hFile, NULL);
-    lNoBlocks = lFileSize / lBlkSize;
-    fFound = FALSE;
-
-    // Read first block...
-    lDataSize = TLB_Read(pBuf, lBlkSize, pcx, 0);
-
-    // Loop through blocks searching for target string...
-    // Two blocks are stored to simplify boundary checking.
-    // NB lNoBlocks is zero where the file fits into one block,
-    //    so this is skipped
-    while((lNoBlocks > 0) && !fFound)
-    {
-        lNoBlocks -= 1;
-        lDataSize = TLB_Read(pBuf + lBlkSize, lBlkSize, pcx, DO_NOT_SEEK);
-
-        for (ll = 0; ll < lBlkSize; ll++)
-        {
-            if (strncmp(pBuf + ll, pMagic, iLen) == 0)
-            {
-                fFound = TRUE;
-                break;
-            }
-            lCurrentPos += 1;   // Keep track of posn.
-        }
-        // Copy block2 to block1
-        memcpy(pBuf, pBuf + lBlkSize, lDataSize);
-    }
-
-    // Now search last block...
-    if (!fFound)
-    {
-        for (ll = 0; ll < (lDataSize - iLen); ll++)
-        {
-            if (strncmp(pBuf + ll, pMagic, iLen) == 0)
-            {
-                fFound = TRUE;
-                break;
-            }
-            lCurrentPos += 1;   // Keep track of posn.
-        }
-    }
-
-    // Loose buffer.
-    HeapFree(hHeap, 0, pBuf);
-
-    if (fFound)
-        return lCurrentPos;
-
-   return 0;
-}
-
-// ----------------------------------------------------------------------
-// TLB_FindTlb
-// ----------------------------------------------------------------------
-long TLB_FindTlb(TLBContext *pcx)
-{
-    long        lPosn;
-
-    lPosn = TLB_FindMagic(pcx, TLBMAGIC2 );
-    if (lPosn != 0)
-    {
-        dprintf(("OLEAUT32: TLB_FindTlb - Located MAGIC2 @%lx", lPosn));
-        return lPosn;
-    }
-
-    lPosn = TLB_FindMagic(pcx, TLBMAGIC1 );
-    if (lPosn != 0)
-    {
-        dprintf(("OLEAUT32: TLB_FindTlb - Located MAGIC1 @%lx", lPosn));
-        dprintf(("OLEAUT32: ERROR UNSUPPORTED TYPELIB!"));
-        return -1;
-    }
-
-    dprintf(("OLEAUT32: TLB_FindTlb ERROR: NO TYPELIB FOUND"));
-    return -1;
-}
-
-// ----------------------------------------------------------------------
-// TLB_ReadTypeLib
-// ----------------------------------------------------------------------
-int TLB_ReadTypeLib(PCHAR file, ITypeLib **ppTypeLib)
-{
-    TLBContext          cx;
-    OFSTRUCT            ofStruct;
-    long                oStart , lPSegDir;
-    TLBLibInfo *        pLibInfo = NULL;
-    TLB2Header          tlbHeader;
-    TLBSegDir           tlbSegDir;
-
-    if((cx.hFile = OpenFile(file, &ofStruct, OF_READ))==HFILE_ERROR)
-    {
-        ERR_(typelib)("cannot open %s error0x%lx\n",file, GetLastError());
-        return E_FAIL;
-    }
-    /* get pointer to beginning of typelib data */
-    oStart = TLB_FindTlb( & cx);
-    if(oStart < 0)
-    {
-        ERR_(typelib)("cannot locate typelib in  %s\n",file);
-        return E_FAIL;
-    }
-    cx.oStart = oStart;
-    pLibInfo=(TLBLibInfo*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TLBLibInfo));
-    if (!pLibInfo){
-        CloseHandle(cx.hFile);
-        return E_OUTOFMEMORY;
-    }
-    pLibInfo->lpvtbl = &tlbvt;
-    pLibInfo->ref=1;
-    cx.pLibInfo=pLibInfo;
-    /* read header */
-    TLB_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, oStart);
-    /* there is a small number of information here until the next important
-     * part:
-     * the segment directory . Try to calculate the amount of data */
-    lPSegDir=sizeof(tlbHeader)+
-            (tlbHeader.nrtypeinfos)*4+
-            (tlbHeader.varflags & HELPDLLFLAG? 4 :0);
-    /* now read the segment directory */
-    TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, oStart + lPSegDir);
-    cx.pTblDir=&tlbSegDir;
-    /* just check two entries */
-    if (        tlbSegDir.pTypeInfoTab.res0c != 0x0F ||
-                tlbSegDir.pImpInfo.res0c != 0x0F
-    ) {
-        ERR_(typelib)("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
-        CloseHandle(cx.hFile);
-        return E_FAIL;
-    }
-    /* now fill our internal data */
-    /* TLIBATTR fields */
-    TLB_ReadGuid(&pLibInfo->LibAttr.guid, tlbHeader.posguid, &cx);
-    pLibInfo->LibAttr.lcid=tlbHeader.lcid;
-    pLibInfo->LibAttr.syskind=(tagSYSKIND)(tlbHeader.varflags & 0x0f); /* check the mask */
-    pLibInfo->LibAttr.wMajorVerNum=LOWORD(tlbHeader.version);
-    pLibInfo->LibAttr.wMinorVerNum=HIWORD(tlbHeader.version);
-    pLibInfo->LibAttr.wLibFlags=(WORD) tlbHeader.flags & 0xffff;/* check mask */
-    /* name, eventually add to a hash table */
-    pLibInfo->Name=TLB_ReadName(&cx, tlbHeader.NameOffset);
-    /* help info */
-    pLibInfo->DocString=TLB_ReadString(&cx, tlbHeader.helpstring);
-    pLibInfo->HelpFile=TLB_ReadString(&cx, tlbHeader.helpfile);
-    if( tlbHeader.varflags & HELPDLLFLAG){
-            int offset;
-            TLB_Read(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
-            pLibInfo->HelpStringDll=TLB_ReadString(&cx, offset);
-    }
-
-    pLibInfo->dwHelpContext=tlbHeader.helpstringcontext;
-    /* custom data */
-    if(tlbHeader.CustomDataOffset >= 0) {
-        pLibInfo->ctCustData=
-            TLB_CustData(&cx, tlbHeader.CustomDataOffset, &pLibInfo->pCustData);
-    }
-    /* fill in typedescriptions */
-    if(tlbSegDir.pTypdescTab.length >0){
-        int i, j, cTD=tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
-        INT16 td[4];
-        pLibInfo->pTypeDesc=(TYPEDESC*)
-            TLB_Alloc( cTD * sizeof(TYPEDESC));
-        TLB_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
-        for(i=0;i<cTD;){
-            /* FIXME: add several sanity checks here */
-            pLibInfo->pTypeDesc[i].vt=td[0] & VT_TYPEMASK;
-            if(td[0]==VT_PTR ||td[0]==VT_SAFEARRAY){/* FIXME: check safearray */
-                if(td[3]<0)
-                    V_UNION(&(pLibInfo->pTypeDesc[i]),lptdesc)=
-                        & stndTypeDesc[td[2]];
-                else
-                    V_UNION(&(pLibInfo->pTypeDesc[i]),lptdesc)=
-                        & pLibInfo->pTypeDesc[td[3]/8];
-            }else if(td[0]==VT_CARRAY)
-                V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)=
-                    (tagARRAYDESC*)((int) td[2]);  /* temp store offset in*/
-                                            /* array descr table here */
-            else if(td[0]==VT_USERDEFINED)
-                V_UNION(&(pLibInfo->pTypeDesc[i]),hreftype)=MAKELONG(td[2],td[3]);
-            if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
-        }
-        /* second time around to fill the array subscript info */
-        for(i=0;i<cTD;i++){
-            if(pLibInfo->pTypeDesc[i].vt != VT_CARRAY) continue;
-            if(tlbSegDir.pArrayDescriptions.offset>0){
-                TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset +
-                    (int) V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc));
-                V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)=(tagARRAYDESC*)
-                    TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
-                if(td[1]<0)
-                    V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)->tdescElem.vt=td[0] & VT_TYPEMASK;
-                else
-                    V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)->tdescElem=stndTypeDesc[td[0]/8];
-                V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)->cDims=td[2];
-                for(j=0;j<td[2];j++){
-                    TLB_Read(& V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)->rgbounds[j].cElements,
-                        sizeof(INT), &cx, DO_NOT_SEEK);
-                    TLB_Read(& V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)
-                        ->rgbounds[j].lLbound,
-                        sizeof(INT), &cx, DO_NOT_SEEK);
-                }
-            }else{
-                V_UNION(&(pLibInfo->pTypeDesc[i]),lpadesc)=NULL;
-                ERR_(ole)("didn't find array description data\n");
-            }
-        }
-    }
-    /* imported type libs */
-    if(tlbSegDir.pImpFiles.offset>0){
-        TLBImpLib **ppImpLib=&(pLibInfo->pImpLibs);
-        int offset=tlbSegDir.pImpFiles.offset;
-        int oGuid;
-        UINT16 size;
-        while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length){
-            *ppImpLib=(TLBImpLib*)TLB_Alloc(sizeof(TLBImpLib));
-            (*ppImpLib)->offset=offset - tlbSegDir.pImpFiles.offset;
-            TLB_Read(&oGuid, sizeof(INT), &cx, offset);
-            TLB_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
-            /* we are skipping some unknown info here */
-            TLB_Read(& size,sizeof(UINT16), &cx, offset+3*(sizeof(INT)));
-            size >>=2;
-            (*ppImpLib)->name=(CHAR*)TLB_Alloc(size+1);
-            TLB_Read((*ppImpLib)->name,size, &cx, DO_NOT_SEEK);
-            offset=(offset+3*(sizeof(INT))+sizeof(UINT16)+size+3) & 0xfffffffc;
-
-            ppImpLib=&(*ppImpLib)->next;
-        }
-    }
-    /* type info's */
-    if(tlbHeader.nrtypeinfos >=0 ){
-        /*pLibInfo->TypeInfoCount=tlbHeader.nrtypeinfos; */
-        TLBTypeInfo **ppTI=&(pLibInfo->pTypeInfo);
-        int i;
-        for(i=0;i<(int)tlbHeader.nrtypeinfos;i++){
-            *ppTI=TLB_DoTypeInfo(&cx, i, pLibInfo);
-            ppTI=&((*ppTI)->next);
-            (pLibInfo->TypeInfoCount)++;
-        }
-    }
-
-    CloseHandle(cx.hFile);
-    *ppTypeLib=(LPTYPELIB)pLibInfo;
+    }
+
     return S_OK;
 }
 
-/*================== ITypeLib(2) Methods ===================================*/
-
-/* ITypeLib::QueryInterface
- */
-static HRESULT WINAPI ITypeLib_fnQueryInterface( LPTYPELIB This, REFIID riid,
-    VOID **ppvObject)
-{
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)riid,xriid);
-        TRACE_(typelib)("(%p)->(IID: %s)\n",This,xriid);
-    }
-    *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) ||
-            IsEqualIID(riid,&IID_ITypeLib)||
-            IsEqualIID(riid,&IID_ITypeLib2))
-        *ppvObject = This;
-    if(*ppvObject){
-        (ICOM_VTBL(*(LPTYPELIB*)ppvObject))->fnAddRef(This);
-        TRACE_(typelib)("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
-        return S_OK;
-    }
-    TRACE_(typelib)("-- Interface: E_NOINTERFACE\n");
-    return E_NOINTERFACE;
-}
-
-/* ITypeLib::AddRef
- */
-static ULONG WINAPI ITypeLib_fnAddRef( LPTYPELIB iface)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TRACE_(typelib)("(%p)->ref is %u\n",This, This->ref);
-    return ++(This->ref);
-}
-
-/* ITypeLib::Release
- */
-static ULONG WINAPI ITypeLib_fnRelease( LPTYPELIB iface)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    FIXME_(typelib)("(%p)->ref is %u:   stub\n",This, This->ref);
-    (This->ref)--;
-    return S_OK;
-}
-
-/* ITypeLib::GetTypeInfoCount
- *
- * Returns the number of type descriptions in the type library
- */
-static UINT WINAPI ITypeLib_fnGetTypeInfoCount( LPTYPELIB iface)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TRACE_(typelib)("(%p)->count is %d\n",This, This->TypeInfoCount);
-    return This->TypeInfoCount;
-}
-
-/* ITypeLib::GetTypeInfo
- *
- *etrieves the specified type description in the library.
- */
-static HRESULT WINAPI ITypeLib_fnGetTypeInfo( LPTYPELIB iface, UINT index,
-    ITypeInfo **ppTInfo)
-{
-    int i;
-        ICOM_THIS( TLBLibInfo, iface);
-        TLBTypeInfo **ppTLBTInfo=(TLBTypeInfo **)ppTInfo;
-    TRACE_(typelib)("(%p) index %d \n",This, index);
-    for(i=0,*ppTLBTInfo=This->pTypeInfo;*ppTLBTInfo && i != index;i++)
-        *ppTLBTInfo=(*ppTLBTInfo)->next;
-    if(*ppTLBTInfo){
-        (*ppTLBTInfo)->lpvtbl->fnAddRef(*ppTInfo);
-        TRACE_(typelib)("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
-        return S_OK;
-    }
-    TRACE_(typelib)("-- element not found\n");
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeLibs::GetTypeInfoType
- *
- * Retrieves the type of a type description.
- */
-static HRESULT WINAPI ITypeLib_fnGetTypeInfoType( LPTYPELIB iface, UINT index,
-    TYPEKIND *pTKind)
-{
-    int i;
-    TLBTypeInfo *pTInfo;
-        ICOM_THIS( TLBLibInfo, iface);
-    TRACE_(typelib)("(%p) index %d \n",This, index);
-    for(i=0,pTInfo=This->pTypeInfo;pTInfo && i != index;i++)
-        pTInfo=(pTInfo)->next;
-    if(pTInfo){
-        *pTKind=pTInfo->TypeAttr.typekind;
-        TRACE_(typelib)("-- found Type (%p)->%d\n",pTKind,*pTKind);
-        return S_OK;
-    }
-    TRACE_(typelib)("-- element not found\n");
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeLib::GetTypeInfoOfGuid
- *
- * Retrieves the type description that corresponds to the specified GUID.
- *
- */
-static HRESULT WINAPI ITypeLib_fnGetTypeInfoOfGuid( LPTYPELIB iface,
-                                REFGUID guid, ITypeInfo **ppTInfo)
-{
-    int i;
-        ICOM_THIS( TLBLibInfo, iface);
-        TLBTypeInfo **ppTLBTInfo=(TLBTypeInfo **)ppTInfo;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %sx)\n",This,xriid);
-    }
-    for(i=0,*ppTLBTInfo=This->pTypeInfo;*ppTLBTInfo &&
-            !IsEqualIID(guid,&(*ppTLBTInfo)->TypeAttr.guid);i++)
-        *ppTLBTInfo=(*ppTLBTInfo)->next;
-    if(*ppTLBTInfo){
-        (*ppTLBTInfo)->lpvtbl->fnAddRef(*ppTInfo);
-        TRACE_(typelib)("-- found (%p)->(%p)\n",ppTLBTInfo,*ppTLBTInfo);
-        return S_OK;
-    }
-    TRACE_(typelib)("-- element not found\n");
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeLib::GetLibAttr
- *
- * Retrieves the structure that contains the library's attributes.
- *
- */
-static HRESULT WINAPI ITypeLib_fnGetLibAttr( LPTYPELIB iface,
-    LPTLIBATTR *ppTLibAttr)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TRACE_(typelib)("(%p)\n",This);
-    /* FIXME: must do a copy here */
-    *ppTLibAttr=&This->LibAttr;
-    return S_OK;
-}
-
-/* ITypeLib::GetTypeComp
- *
- * Enables a client compiler to bind to a library's types, variables,
- * constants, and global functions.
- *
- */
-static HRESULT WINAPI ITypeLib_fnGetTypeComp( LPTYPELIB iface,
-    ITypeComp **ppTComp)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    FIXME_(typelib)("(%p): stub!\n",This);
-    return E_NOTIMPL;
-}
-
-/* ITypeLib::GetDocumentation
- *
- * Retrieves the library's documentation string, the complete Help file name
- * and path, and the context identifier for the library Help topic in the Help
- * file.
- *
- */
-static HRESULT WINAPI ITypeLib_fnGetDocumentation( LPTYPELIB iface, INT index,
-    BSTR *pBstrName, BSTR *pBstrDocString, DWORD *pdwHelpContext,
-    BSTR *pBstrHelpFile)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    HRESULT result;
-    ITypeInfo *pTInfo;
-    TRACE_(typelib)("(%p) index %d Name(%p) DocString(%p)"
-           " HelpContext(%p) HelpFile(%p)\n",
-        This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
-    if(index<0){ /* documentation for the typelib */
-        if(pBstrName)
-            *pBstrName=TLB_DupAtoBstr(This->Name);
-        if(pBstrDocString)
-            *pBstrName=TLB_DupAtoBstr(This->DocString);
-        if(pdwHelpContext)
-            *pdwHelpContext=This->dwHelpContext;
-        if(pBstrHelpFile)
-            *pBstrName=TLB_DupAtoBstr(This->HelpFile);
-    }else {/* for a typeinfo */
-        result=ITypeLib_fnGetTypeInfo(iface, index, &pTInfo);
-        if(SUCCEEDED(result)){
-            result=ITypeInfo_GetDocumentation(pTInfo, MEMBERID_NIL,  pBstrName,
-                pBstrDocString, pdwHelpContext, pBstrHelpFile);
-            ITypeInfo_Release(pTInfo);
-        }
-        if(!SUCCEEDED(result))
-            return result;
-    }
-    return S_OK;
-}
-
-/* ITypeLib::IsName
- *
- * Indicates whether a passed-in string contains the name of a type or member
- * described in the library.
- *
- */
-static HRESULT WINAPI ITypeLib_fnIsName( LPTYPELIB iface, LPOLESTR szNameBuf,
-    ULONG lHashVal, BOOL *pfName)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TLBTypeInfo *pTInfo;
-    TLBFuncDesc *pFInfo;
-    TLBVarDesc *pVInfo;
-    int i;
-    PCHAR astr= HEAP_strdupWtoA( GetProcessHeap(), 0, szNameBuf );
-    *pfName=TRUE;
-    if(!strcmp(astr,This->Name)) goto ITypeLib_fnIsName_exit;
-    for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
-        if(!strcmp(astr,pTInfo->Name)) goto ITypeLib_fnIsName_exit;
-        for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
-            if(!strcmp(astr,pFInfo->Name)) goto ITypeLib_fnIsName_exit;
-            for(i=0;i<pFInfo->funcdesc.cParams;i++)
-                if(!strcmp(astr,pFInfo->pParamDesc[i].Name))
-                    goto ITypeLib_fnIsName_exit;
-        }
-        for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next) ;
-            if(!strcmp(astr,pVInfo->Name)) goto ITypeLib_fnIsName_exit;
-
-    }
-    *pfName=FALSE;
-
-ITypeLib_fnIsName_exit:
-    TRACE_(typelib)("(%p)slow! search for %s: %s found!\n", This,
-            debugstr_a(astr), *pfName?"NOT":"");
-
-    HeapFree( GetProcessHeap(), 0, astr );
-    return S_OK;
-}
-
-/* ITypeLib::FindName
- *
- * Finds occurrences of a type description in a type library. This may be used
- * to quickly verify that a name exists in a type library.
- *
- */
-static HRESULT WINAPI ITypeLib_fnFindName( LPTYPELIB iface, LPOLESTR szNameBuf,
-    ULONG lHashVal, ITypeInfo **ppTInfo, MEMBERID *rgMemId, UINT16 *pcFound)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TLBTypeInfo *pTInfo;
-    TLBFuncDesc *pFInfo;
-    TLBVarDesc *pVInfo;
-    int i,j = 0;
-    PCHAR astr= HEAP_strdupWtoA( GetProcessHeap(), 0, szNameBuf );
-    for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
-        if(!strcmp(astr,pTInfo->Name)) goto ITypeLib_fnFindName_exit;
-        for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
-            if(!strcmp(astr,pFInfo->Name)) goto ITypeLib_fnFindName_exit;
-            for(i=0;i<pFInfo->funcdesc.cParams;i++)
-                if(!strcmp(astr,pFInfo->pParamDesc[i].Name))
-                    goto ITypeLib_fnFindName_exit;
-        }
-        for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next) ;
-            if(!strcmp(astr,pVInfo->Name)) goto ITypeLib_fnFindName_exit;
-        continue;
-ITypeLib_fnFindName_exit:
-        pTInfo->lpvtbl->fnAddRef((LPTYPEINFO)pTInfo);
-        ppTInfo[j]=(LPTYPEINFO)pTInfo;
-        j++;
-    }
-    TRACE_(typelib)("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
-            This, *pcFound, debugstr_a(astr), j);
-
-    *pcFound=j;
-
-    HeapFree( GetProcessHeap(), 0, astr );
-    return S_OK;
-}
-
-/* ITypeLib::ReleaseTLibAttr
- *
- * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
- *
- */
-static VOID WINAPI ITypeLib_fnReleaseTLibAttr( LPTYPELIB iface, TLIBATTR *pTLibAttr)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TRACE_(typelib)("freeing (%p)\n",This);
-    /* nothing to do */
-}
-
-/* ITypeLib2::GetCustData
- *
- * gets the custom data
- */
-static HRESULT WINAPI ITypeLib2_fnGetCustData( ITypeLib * iface, REFGUID guid,
-        VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TLBCustData *pCData;
-    for(pCData=This->pCustData; pCData; pCData = pCData->next)
-        if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeLib2::GetLibStatistics
- *
- * Returns statistics about a type library that are required for efficient
- * sizing of hash tables.
- *
- */
-static HRESULT WINAPI ITypeLib2_fnGetLibStatistics( ITypeLib * iface,
-        UINT *pcUniqueNames, UINT *pcchUniqueNames)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    FIXME_(typelib)("(%p): stub!\n", This);
-    if(pcUniqueNames) *pcUniqueNames=1;
-    if(pcchUniqueNames) *pcchUniqueNames=1;
-    return S_OK;
-}
-
-/* ITypeLib2::GetDocumentation2
- *
- * Retrieves the library's documentation string, the complete Help file name
- * and path, the localization context to use, and the context ID for the
- * library Help topic in the Help file.
- *
- */
-static HRESULT WINAPI ITypeLib2_fnGetDocumentation2( ITypeLib * iface,
-        INT index, LCID lcid, BSTR *pbstrHelpString,
-        INT *pdwHelpStringContext, BSTR *pbstrHelpStringDll)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    HRESULT result;
-    ITypeInfo *pTInfo;
-    FIXME_(typelib)("(%p) index %d lcid %ld half implemented stub!\n", This,
-            index, lcid);
-    /* the help string should be obtained from the helpstringdll,
-     * using the _DLLGetDocumentation function, based on the supplied
-     * lcid. Nice to do sometime...
-     */
-    if(index<0){ /* documentation for the typelib */
-        if(pbstrHelpString)
-            *pbstrHelpString=TLB_DupAtoBstr(This->DocString);
-        if(pdwHelpStringContext)
-            *pdwHelpStringContext=This->dwHelpContext;
-        if(pbstrHelpStringDll)
-            *pbstrHelpStringDll=TLB_DupAtoBstr(This->HelpStringDll);
-    }else {/* for a typeinfo */
-        result=ITypeLib_fnGetTypeInfo(iface, index, &pTInfo);
-        if(SUCCEEDED(result)){
-            result=ITypeInfo2_fnGetDocumentation2(pTInfo, MEMBERID_NIL, lcid,
-                pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
-            ITypeInfo_Release(pTInfo);
-        }
-        if(!SUCCEEDED(result))
-            return result;
-    }
-    return S_OK;
-}
-
-/* ITypeLib2::GetAllCustData
- *
- * Gets all custom data items for the library.
- *
- */
-static HRESULT WINAPI ITypeLib2_fnGetAllCustData( ITypeLib * iface,
-        CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBLibInfo, iface);
-    TLBCustData *pCData;
-    int i;
-    TRACE_(typelib)("(%p) returning %d items\n", This, This->ctCustData);
-    pCustData->prgCustData = (tagCUSTDATAITEM*)TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
-    if(pCustData->prgCustData ){
-        pCustData->cCustData=This->ctCustData;
-        for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
-            pCustData->prgCustData[i].guid=pCData->guid;
-            VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
-        }
-    }else{
-        ERR_(typelib)(" OUT OF MEMORY! \n");
-        return E_OUTOFMEMORY;
-    }
-    return S_OK;
-}
-
-
-/*================== ITypeInfo(2) Methods ===================================*/
-
-/* ITypeInfo::QueryInterface
- */
-static HRESULT WINAPI ITypeInfo_fnQueryInterface( LPTYPEINFO iface, REFIID riid,
-    VOID **ppvObject)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)riid,xriid);
-        TRACE_(typelib)("(%p)->(IID: %s)\n",This,xriid);
-    }
-    *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) ||
-            IsEqualIID(riid,&IID_ITypeInfo)||
-            IsEqualIID(riid,&IID_ITypeInfo2))
-        *ppvObject = This;
-    if(*ppvObject){
-        (ICOM_VTBL(*(LPTYPEINFO*)ppvObject))->fnAddRef(iface);
-        TRACE_(typelib)("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
-        return S_OK;
-    }
-    TRACE_(typelib)("-- Interface: E_NOINTERFACE\n");
-    return E_NOINTERFACE;
-}
-
-/* ITypeInfo::AddRef
- */
-static ULONG WINAPI ITypeInfo_fnAddRef( LPTYPEINFO iface)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TRACE_(typelib)("(%p)->ref is %u\n",This, This->ref);
-    (This->pTypeLib->ref)++;
-    return ++(This->ref);
-}
-
-/* ITypeInfo::Release
- */
-static ULONG WINAPI ITypeInfo_fnRelease( LPTYPEINFO iface)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p)->ref is %u:   stub\n",This, This->ref);
-    (This->ref)--;
-    (This->pTypeLib->ref)--;
-    return S_OK;
-}
-
-/* ITypeInfo::GetTypeAttr
- *
- * Retrieves a TYPEATTR structure that contains the attributes of the type
- * description.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( LPTYPEINFO iface,
-        LPTYPEATTR  *ppTypeAttr)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-     TRACE_(typelib)("(%p)\n",This);
-    /* FIXME: must do a copy here */
-    *ppTypeAttr=&This->TypeAttr;
-    return S_OK;
-}
-
-/* ITypeInfo::GetTypeComp
- *
- * Retrieves the ITypeComp interface for the type description, which enables a
- * client compiler to bind to the type description's members.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnGetTypeComp( LPTYPEINFO iface,
-        ITypeComp  * *ppTComp)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!\n", This);
-    return S_OK;
-}
-
-/* ITypeInfo::GetFuncDesc
- *
- * Retrieves the FUNCDESC structure that contains information about a
- * specified function.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( LPTYPEINFO iface, UINT index,
-        LPFUNCDESC  *ppFuncDesc)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    int i;
-    TLBFuncDesc * pFDesc;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
-        ;
-    if(pFDesc){
-        /* FIXME: must do a copy here */
-        *ppFuncDesc=&pFDesc->funcdesc;
-        return S_OK;
-    }
-    return E_INVALIDARG;
-}
-
-/* ITypeInfo::GetVarDesc
- *
- * Retrieves a VARDESC structure that describes the specified variable.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnGetVarDesc( LPTYPEINFO iface, UINT index,
-        LPVARDESC  *ppVarDesc)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    int i;
-    TLBVarDesc * pVDesc;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
-        ;
-    if(pVDesc){
-        /* FIXME: must do a copy here */
-        *ppVarDesc=&pVDesc->vardesc;
-        return S_OK;
-    }
-    return E_INVALIDARG;
-}
-
-/* ITypeInfo_GetNames
- *
- * Retrieves the variable with the specified member ID (or the name of the
- * property or method and its parameters) that correspond to the specified
- * function ID.
- */
-static HRESULT WINAPI ITypeInfo_fnGetNames( LPTYPEINFO iface, MEMBERID memid,
-        BSTR  *rgBstrNames, UINT cMaxNames, UINT  *pcNames)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
-    int i;
-    TRACE_(typelib)("(%p) memid=0x%08lx Maxname=%d\n", This, memid,
-            cMaxNames);
-    for(pFDesc=This->funclist; pFDesc->funcdesc.memid != memid && pFDesc;
-            pFDesc=pFDesc->next)
-        ;
-    if(pFDesc){
-        /* function found, now return function and parameter names */
-        for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++){
-            if(!i) *rgBstrNames=TLB_DupAtoBstr(pFDesc->Name);
-            else
-                rgBstrNames[i]=TLB_DupAtoBstr(pFDesc->pParamDesc[i-1].Name);
-
-        }
-        *pcNames=i;
-    }else{
-        for(pVDesc=This->varlist; pVDesc->vardesc.memid != memid && pVDesc;
-                pVDesc=pVDesc->next)
-            ;
-        if(pVDesc){
-            *rgBstrNames=TLB_DupAtoBstr(pFDesc->Name);
-            *pcNames=1;
-        }else{
-            if(This->TypeAttr.typekind==TKIND_INTERFACE &&
-                    This->TypeAttr.cImplTypes ){
-                /* recursive search */
-                ITypeInfo *pTInfo;
-                HRESULT result;
-                result=This->lpvtbl->fnGetRefTypeInfo(iface,
-                        This->impltypelist->reference, &pTInfo);
-                if(SUCCEEDED(result)){
-                    result=ICOM_VTBL(pTInfo)->fnGetNames(pTInfo, memid, rgBstrNames,
-                            cMaxNames, pcNames);
-                    ICOM_VTBL(pTInfo)->fnRelease(pTInfo);
-                    return result;
-                }
-                WARN_(typelib)("Could not search inherited interface!\n");
-            } else
-                WARN_(typelib)("no names found\n");
-            *pcNames=0;
-            return TYPE_E_ELEMENTNOTFOUND;
-        }
-    }
-    return S_OK;
-}
-
-
-/* ITypeInfo::GetRefTypeOfImplType
- *
- * If a type description describes a COM class, it retrieves the type
- * description of the implemented interface types. For an interface,
- * GetRefTypeOfImplType returns the type information for inherited interfaces,
- * if any exist.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType( LPTYPEINFO iface,
-        UINT index, HREFTYPE  *pRefType)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    int(i);
-    TLBRefType *pIref;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pIref=This->impltypelist; i<index && pIref;
-            i++, pIref=pIref->next)
-        ;
-    if(i==index){
-        *pRefType=pIref->reference;
-        return S_OK;
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeInfo::GetImplTypeFlags
- *
- * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
- * or base interface in a type description.
- */
-static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( LPTYPEINFO iface,
-        UINT index, INT  *pImplTypeFlags)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    int(i);
-    TLBRefType *pIref;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pIref=This->impltypelist; i<index && pIref; i++, pIref=pIref->next)
-        ;
-    if(i==index && pIref){
-        *pImplTypeFlags=pIref->flags;
-        return S_OK;
-    }
-    *pImplTypeFlags=0;
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* GetIDsOfNames
- * Maps between member names and member IDs, and parameter names and
- * parameter IDs.
- */
-static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( LPTYPEINFO iface,
-        LPOLESTR  *rgszNames, UINT cNames, MEMBERID  *pMemId)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
-    HRESULT ret=S_OK;
-    PCHAR aszName= HEAP_strdupWtoA( GetProcessHeap(), 0, *rgszNames);
-    TRACE_(typelib)("(%p) Name %s cNames %d\n", This, debugstr_a(aszName),
-            cNames);
-    for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
-        int i, j;
-        if( !strcmp(aszName, pFDesc->Name)) {
-            if(cNames) *pMemId=pFDesc->funcdesc.memid;
-            for(i=1; i < cNames; i++){
-                PCHAR aszPar= HEAP_strdupWtoA( GetProcessHeap(), 0,
-                        rgszNames[i]);
-                for(j=0; j<pFDesc->funcdesc.cParams; j++)
-                    if(strcmp(aszPar,pFDesc->pParamDesc[j].Name))
-                            break;
-                if( j<pFDesc->funcdesc.cParams)
-                    pMemId[i]=j;
-                else
-                   ret=DISP_E_UNKNOWNNAME;
-                HeapFree( GetProcessHeap(), 0, aszPar);
-            };
-            HeapFree (GetProcessHeap(), 0, aszName);
-            return ret;
-        }
-    }
-    for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
-        if( !strcmp(aszName, pVDesc->Name)) {
-            if(cNames) *pMemId=pVDesc->vardesc.memid;
-            HeapFree (GetProcessHeap(), 0, aszName);
-            return ret;
-        }
-    }
-    /* not found, see if this is and interface with an inheritance */
-    if(This->TypeAttr.typekind==TKIND_INTERFACE &&
-            This->TypeAttr.cImplTypes ){
-        /* recursive search */
-        ITypeInfo *pTInfo;
-        ret=This->lpvtbl->fnGetRefTypeInfo(iface,
-                This->impltypelist->reference, &pTInfo);
-        if(SUCCEEDED(ret)){
-            ret=ICOM_VTBL(pTInfo)->fnGetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
-            ICOM_VTBL(pTInfo)->fnRelease(pTInfo);
-            return ret;
-        }
-        WARN_(typelib)("Could not search inherited interface!\n");
-    } else
-        WARN_(typelib)("no names found\n");
-    return DISP_E_UNKNOWNNAME;
-}
-
-/* ITypeInfo::Invoke
- *
- * Invokes a method, or accesses a property of an object, that implements the
- * interface described by the type description.
- */
-static HRESULT WINAPI ITypeInfo_fnInvoke( LPTYPEINFO iface, VOID  *pIUnk,
-        MEMBERID memid, UINT16 dwFlags, DISPPARAMS  *pDispParams,
-        VARIANT  *pVarResult, EXCEPINFO  *pExcepInfo, UINT  *pArgErr)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!", This);
-    return S_OK;
-}
-
-/* ITypeInfo::GetDocumentation
- *
- * Retrieves the documentation string, the complete Help file name and path,
- * and the context ID for the Help topic for a specified type description.
- */
-static HRESULT WINAPI ITypeInfo_fnGetDocumentation( LPTYPEINFO iface,
-        MEMBERID memid, BSTR  *pBstrName, BSTR  *pBstrDocString,
-        DWORD  *pdwHelpContext, BSTR  *pBstrHelpFile)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
-    TRACE_(typelib)("(%p) memid %ld Name(%p) DocString(%p)"
-           " HelpContext(%p) HelpFile(%p)\n",
-        This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
-    if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
-        if(pBstrName)
-            *pBstrName=TLB_DupAtoBstr(This->Name);
-        if(pBstrDocString)
-            *pBstrDocString=TLB_DupAtoBstr(This->DocString);
-        if(pdwHelpContext)
-            *pdwHelpContext=This->dwHelpContext;
-        if(pBstrHelpFile)
-            *pBstrHelpFile=TLB_DupAtoBstr(This->DocString);/* FIXME */
-        return S_OK;
-    }else {/* for a member */
-    for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
-        if(pFDesc->funcdesc.memid==memid){
-            return S_OK;
-        }
-    for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
-        if(pVDesc->vardesc.memid==memid){
-            return S_OK;
-        }
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/*  ITypeInfo::GetDllEntry
- *
- * Retrieves a description or specification of an entry point for a function
- * in a DLL.
- */
-static HRESULT WINAPI ITypeInfo_fnGetDllEntry( LPTYPEINFO iface, MEMBERID memid,
-        INVOKEKIND invKind, BSTR  *pBstrDllName, BSTR  *pBstrName,
-        WORD  *pwOrdinal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!\n", This);
-    return E_FAIL;
-}
-
-/* ITypeInfo::GetRefTypeInfo
- *
- * If a type description references other type descriptions, it retrieves
- * the referenced type descriptions.
- */
-static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo( LPTYPEINFO iface,
-        HREFTYPE hRefType, ITypeInfo  * *ppTInfo)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    HRESULT result;
-    if(HREFTYPE_INTHISFILE(hRefType)){
-        ITypeLib *pTLib;
-        int Index;
-        result=This->lpvtbl->fnGetContainingTypeLib(iface, &pTLib,
-                (UINT*)&Index);
-        if(SUCCEEDED(result)){
-            result=ICOM_VTBL(pTLib)->fnGetTypeInfo(pTLib,
-                    HREFTYPE_INDEX(hRefType),
-                    ppTInfo);
-            ICOM_VTBL(pTLib)->fnRelease(pTLib );
-        }
-    } else{
-        /* imported type lib */
-        TLBRefType * pRefType;
-        TLBLibInfo *pTypeLib;
-        for( pRefType=This->impltypelist; pRefType &&
-                pRefType->reference != hRefType; pRefType=pRefType->next)
-            ;
-        if(!pRefType)
-            return TYPE_E_ELEMENTNOTFOUND; /* FIXME : correct? */
-        pTypeLib=pRefType->pImpTLInfo->pImpTypeLib;
-        if(pTypeLib) /* typelib already loaded */
-            result=pTypeLib->lpvtbl->fnGetTypeInfoOfGuid(
-                    (LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
-        else{
-            result=LoadRegTypeLib( &pRefType->pImpTLInfo->guid,
-                    0,0,0, /* FIXME */
-                    (LPTYPELIB *)&pTypeLib);
-            if(!SUCCEEDED(result)){
-                BSTR libnam=TLB_DupAtoBstr(pRefType->pImpTLInfo->name);
-                result=LoadTypeLib(libnam, (LPTYPELIB *)&pTypeLib);
-                SysFreeString(libnam);
-            }
-            if(SUCCEEDED(result)){
-                result=pTypeLib->lpvtbl->fnGetTypeInfoOfGuid(
-                        (LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
-                pRefType->pImpTLInfo->pImpTypeLib=pTypeLib;
-           }
-        }
-    }
-    TRACE_(typelib)("(%p) hreftype 0x%04lx loaded %s (%p)\n", This, hRefType,
-            SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
-    return result;
-}
-
-/* ITypeInfo::AddressOfMember
- *
- * Retrieves the addresses of static functions or variables, such as those
- * defined in a DLL.
- */
-static HRESULT WINAPI ITypeInfo_fnAddressOfMember( LPTYPEINFO iface,
-        MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!\n", This);
-    return S_OK;
-}
-
-/* ITypeInfo::CreateInstance
- *
- * Creates a new instance of a type that describes a component object class
- * (coclass).
- */
-static HRESULT WINAPI ITypeInfo_fnCreateInstance( LPTYPEINFO iface,
-        IUnknown *pUnk, REFIID riid, VOID  **ppvObj)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!\n", This);
-    return S_OK;
-}
-
-/* ITypeInfo::GetMops
- *
- * Retrieves marshaling information.
- */
-static HRESULT WINAPI ITypeInfo_fnGetMops( LPTYPEINFO iface, MEMBERID memid,
-                                BSTR  *pBstrMops)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    FIXME_(typelib)("(%p) stub!\n", This);
-    return S_OK;
-}
-
-/* ITypeInfo::GetContainingTypeLib
- *
- * Retrieves the containing type library and the index of the type description
- * within that type library.
- */
-static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( LPTYPEINFO iface,
-        ITypeLib  * *ppTLib, UINT  *pIndex)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    *ppTLib=(LPTYPELIB )(This->pTypeLib);
-    *pIndex=This->index;
-    ICOM_VTBL(*ppTLib)->fnAddRef(*ppTLib);
-    TRACE_(typelib)("(%p) returns (%p) index %d!\n", This, *ppTLib, *pIndex);
-    return S_OK;
-}
-
-/* ITypeInfo::ReleaseTypeAttr
- *
- * Releases a TYPEATTR previously returned by GetTypeAttr.
- *
- */
-static HRESULT WINAPI ITypeInfo_fnReleaseTypeAttr( LPTYPEINFO iface,
-        TYPEATTR* pTypeAttr)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TRACE_(typelib)("(%p)->(%p)\n", This, pTypeAttr);
-    return S_OK;
-}
-
-/* ITypeInfo::ReleaseFuncDesc
- *
- * Releases a FUNCDESC previously returned by GetFuncDesc. *
- */
-static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc( LPTYPEINFO iface,
-        FUNCDESC *pFuncDesc)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TRACE_(typelib)("(%p)->(%p)\n", This, pFuncDesc);
-    return S_OK;
-}
-
-/* ITypeInfo::ReleaseVarDesc
- *
- * Releases a VARDESC previously returned by GetVarDesc.
- */
-static HRESULT WINAPI ITypeInfo_fnReleaseVarDesc( LPTYPEINFO iface,
-        VARDESC *pVarDesc)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TRACE_(typelib)("(%p)->(%p)\n", This, pVarDesc);
-    return S_OK;
-}
-
-/* ITypeInfo2::GetTypeKind
- *
- * Returns the TYPEKIND enumeration quickly, without doing any allocations.
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo * iface,
-    TYPEKIND *pTypeKind)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    *pTypeKind=This->TypeAttr.typekind;
-    TRACE_(typelib)("(%p) type 0x%0x\n", This,*pTypeKind);
-    return S_OK;
-}
-
-/* ITypeInfo2::GetTypeFlags
- *
- * Returns the type flags without any allocations. This returns a DWORD type
- * flag, which expands the type flags without growing the TYPEATTR (type
- * attribute).
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo * iface,
-    UINT *pTypeFlags)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    *pTypeFlags=This->TypeAttr.wTypeFlags;
-    TRACE_(typelib)("(%p) flags 0x%04x\n", This,*pTypeFlags);
-     return S_OK;
-}
-
-/* ITypeInfo2::GetFuncIndexOfMemId
- * Binds to a specific member based on a known DISPID, where the member name
- * is not known (for example, when binding to a default member).
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo * iface,
-    MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBFuncDesc *pFuncInfo;
-    int i;
-    HRESULT result;
-    /* FIXME: should check for invKind??? */
-    for(i=0, pFuncInfo=This->funclist;pFuncInfo &&
-            memid != pFuncInfo->funcdesc.memid; i++, pFuncInfo=pFuncInfo->next);
-    if(pFuncInfo){
-        *pFuncIndex=i;
-        result= S_OK;
-    }else{
-        *pFuncIndex=0;
-        result=E_INVALIDARG;
-    }
-    TRACE_(typelib)("(%p) memid 0x%08lx invKind 0x%04x -> %s\n", This,
-            memid, invKind, SUCCEEDED(result)? "SUCCES":"FAILED");
-    return result;
-}
-
-/* TypeInfo2::GetVarIndexOfMemId
- *
- * Binds to a specific member based on a known DISPID, where the member name
- * is not known (for example, when binding to a default member).
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo * iface,
-    MEMBERID memid, UINT *pVarIndex)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBVarDesc *pVarInfo;
-    int i;
-    HRESULT result;
-    for(i=0, pVarInfo=This->varlist; pVarInfo &&
-            memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
-        ;
-    if(pVarInfo){
-        *pVarIndex=i;
-        result= S_OK;
-    }else{
-        *pVarIndex=0;
-        result=E_INVALIDARG;
-    }
-    TRACE_(typelib)("(%p) memid 0x%08lx -> %s\n", This,
-            memid, SUCCEEDED(result)? "SUCCES":"FAILED");
-    return result;
-}
-
-/* ITypeInfo2::GetCustData
- *
- * Gets the custom data
- */
-static HRESULT WINAPI ITypeInfo2_fnGetCustData( ITypeInfo * iface,
-    REFGUID guid, VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData;
-    for(pCData=This->pCustData; pCData; pCData = pCData->next)
-        if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n", This, xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeInfo2::GetFuncCustData
- *
- * Gets the custom data
- */
-static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData( ITypeInfo * iface,
-    UINT index, REFGUID guid, VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
-    int i;
-    for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
-            pFDesc=pFDesc->next)
-        ;
-    if(pFDesc)
-        for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
-            if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeInfo2::GetParamCustData
- *
- * Gets the custom data
- */
-static HRESULT WINAPI ITypeInfo2_fnGetParamCustData( ITypeInfo * iface,
-    UINT indexFunc, UINT indexParam, REFGUID guid, VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
-    int i;
-    for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
-            pFDesc=pFDesc->next)
-        ;
-    if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
-        for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
-                pCData = pCData->next)
-            if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeInfo2::GetVarcCustData
- *
- * Gets the custom data
- */
-static HRESULT WINAPI ITypeInfo2_fnGetVarCustData( ITypeInfo * iface,
-    UINT index, REFGUID guid, VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData=NULL;
-    TLBVarDesc * pVDesc;
-    int i;
-    for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
-            pVDesc=pVDesc->next)
-        ;
-    if(pVDesc)
-        for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
-            if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeInfo2::GetImplcCustData
- *
- * Gets the custom data
- */
-static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData( ITypeInfo * iface,
-    UINT index, REFGUID guid, VARIANT *pVarVal)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData=NULL;
-    TLBRefType * pRDesc;
-    int i;
-    for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
-            pRDesc=pRDesc->next)
-        ;
-    if(pRDesc)
-        for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
-            if( IsEqualIID(guid, &pCData->guid)) break;
-    if(TRACE_ON(typelib)){
-        char xriid[50];
-        WINE_StringFromCLSID((LPCLSID)guid,xriid);
-        TRACE_(typelib)("(%p) guid %s %s found!x)\n",This,xriid,
-                pCData? "" : "NOT");
-    }
-    if(pCData){
-        VariantInit( pVarVal);
-        VariantCopy( pVarVal, &pCData->data);
-        return S_OK;
-    }
-    return E_INVALIDARG;  /* FIXME: correct? */
-}
-
-/* ITypeInfo2::GetDocumentation2
- *
- * Retrieves the documentation string, the complete Help file name and path,
- * the localization context to use, and the context ID for the library Help
- * topic in the Help file.
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2( ITypeInfo * iface,
-    MEMBERID memid, LCID lcid, BSTR *pbstrHelpString,
-    INT *pdwHelpStringContext, BSTR *pbstrHelpStringDll)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
-    TRACE_(typelib)("(%p) memid %ld lcid(0x%lx)  HelpString(%p) "
-           "HelpStringContext(%p) HelpStringDll(%p)\n",
-        This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
-        pbstrHelpStringDll );
-    /* the help string should be obtained from the helpstringdll,
-     * using the _DLLGetDocumentation function, based on the supplied
-     * lcid. Nice to do sometime...
-     */
-    if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
-        if(pbstrHelpString)
-            *pbstrHelpString=TLB_DupAtoBstr(This->Name);
-        if(pdwHelpStringContext)
-            *pdwHelpStringContext=This->dwHelpStringContext;
-        if(pbstrHelpStringDll)
-            *pbstrHelpStringDll=
-                TLB_DupAtoBstr(This->pTypeLib->HelpStringDll);/* FIXME */
-        return S_OK;
-    }else {/* for a member */
-    for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
-        if(pFDesc->funcdesc.memid==memid){
-             if(pbstrHelpString)
-                *pbstrHelpString=TLB_DupAtoBstr(pFDesc->HelpString);
-            if(pdwHelpStringContext)
-                *pdwHelpStringContext=pFDesc->HelpStringContext;
-            if(pbstrHelpStringDll)
-                *pbstrHelpStringDll=
-                    TLB_DupAtoBstr(This->pTypeLib->HelpStringDll);/* FIXME */
-        return S_OK;
-    }
-    for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
-        if(pVDesc->vardesc.memid==memid){
-             if(pbstrHelpString)
-                *pbstrHelpString=TLB_DupAtoBstr(pVDesc->HelpString);
-            if(pdwHelpStringContext)
-                *pdwHelpStringContext=pVDesc->HelpStringContext;
-            if(pbstrHelpStringDll)
-                *pbstrHelpStringDll=
-                    TLB_DupAtoBstr(This->pTypeLib->HelpStringDll);/* FIXME */
-            return S_OK;
-        }
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeInfo2::GetAllCustData
- *
- * Gets all custom data items for the Type info.
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetAllCustData( ITypeInfo * iface,
-    CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData;
-    int i;
-    TRACE_(typelib)("(%p) returning %d items\n", This, This->ctCustData);
-    pCustData->prgCustData = (tagCUSTDATAITEM*)TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
-    if(pCustData->prgCustData ){
-        pCustData->cCustData=This->ctCustData;
-        for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
-            pCustData->prgCustData[i].guid=pCData->guid;
-            VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
-        }
-    }else{
-        ERR_(typelib)(" OUT OF MEMORY! \n");
-        return E_OUTOFMEMORY;
-    }
-    return S_OK;
-}
-
-/* ITypeInfo2::GetAllFuncCustData
- *
- * Gets all custom data items for the specified Function
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData( ITypeInfo * iface,
-    UINT index, CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData;
-    TLBFuncDesc * pFDesc;
-    int i;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
-            pFDesc=pFDesc->next)
-        ;
-    if(pFDesc){
-        pCustData->prgCustData =(tagCUSTDATAITEM*)
-            TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
-        if(pCustData->prgCustData ){
-            pCustData->cCustData=pFDesc->ctCustData;
-            for(i=0, pCData=pFDesc->pCustData; pCData; i++,
-                    pCData = pCData->next){
-                pCustData->prgCustData[i].guid=pCData->guid;
-                VariantCopy(& pCustData->prgCustData[i].varValue,
-                        & pCData->data);
-            }
-        }else{
-            ERR_(typelib)(" OUT OF MEMORY! \n");
-            return E_OUTOFMEMORY;
-        }
-        return S_OK;
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeInfo2::GetAllParamCustData
- *
- * Gets all custom data items for the Functions
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo * iface,
-    UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
-    int i;
-    TRACE_(typelib)("(%p) index %d\n", This, indexFunc);
-    for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
-            pFDesc=pFDesc->next)
-        ;
-    if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams){
-        pCustData->prgCustData =(tagCUSTDATAITEM*)
-            TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
-                    sizeof(CUSTDATAITEM));
-        if(pCustData->prgCustData ){
-            pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
-            for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
-                    pCData; i++, pCData = pCData->next){
-                pCustData->prgCustData[i].guid=pCData->guid;
-                VariantCopy(& pCustData->prgCustData[i].varValue,
-                        & pCData->data);
-            }
-        }else{
-            ERR_(typelib)(" OUT OF MEMORY! \n");
-            return E_OUTOFMEMORY;
-        }
-        return S_OK;
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeInfo2::GetAllVarCustData
- *
- * Gets all custom data items for the specified Variable
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo * iface,
-    UINT index, CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData;
-    TLBVarDesc * pVDesc;
-    int i;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
-            pVDesc=pVDesc->next)
-        ;
-    if(pVDesc){
-        pCustData->prgCustData =(tagCUSTDATAITEM*)
-            TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
-        if(pCustData->prgCustData ){
-            pCustData->cCustData=pVDesc->ctCustData;
-            for(i=0, pCData=pVDesc->pCustData; pCData; i++,
-                    pCData = pCData->next){
-                pCustData->prgCustData[i].guid=pCData->guid;
-                VariantCopy(& pCustData->prgCustData[i].varValue,
-                        & pCData->data);
-            }
-        }else{
-            ERR_(typelib)(" OUT OF MEMORY! \n");
-            return E_OUTOFMEMORY;
-        }
-        return S_OK;
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
-/* ITypeInfo2::GetAllImplCustData
- *
- * Gets all custom data items for the specified implementation type
- *
- */
-static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData( ITypeInfo * iface,
-    UINT index, CUSTDATA *pCustData)
-{
-        ICOM_THIS( TLBTypeInfo, iface);
-    TLBCustData *pCData;
-    TLBRefType * pRDesc;
-    int i;
-    TRACE_(typelib)("(%p) index %d\n", This, index);
-    for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
-            pRDesc=pRDesc->next)
-        ;
-    if(pRDesc){
-        pCustData->prgCustData =(tagCUSTDATAITEM*)
-            TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
-        if(pCustData->prgCustData ){
-            pCustData->cCustData=pRDesc->ctCustData;
-            for(i=0, pCData=pRDesc->pCustData; pCData; i++,
-                    pCData = pCData->next){
-                pCustData->prgCustData[i].guid=pCData->guid;
-                VariantCopy(& pCustData->prgCustData[i].varValue,
-                        & pCData->data);
-            }
-        }else{
-            ERR_(typelib)(" OUT OF MEMORY! \n");
-            return E_OUTOFMEMORY;
-        }
-        return S_OK;
-    }
-    return TYPE_E_ELEMENTNOTFOUND;
-}
-
+// ----------------------------------------------------------------------
+// DupAtoBstr
+// ----------------------------------------------------------------------
+extern BSTR DupAtoBstr(char * pAscii)
+{
+    int         len;
+    BSTR        bstr;
+    DWORD *     pl;
+
+    if (!pAscii)
+        return NULL;
+
+    len = strlen(pAscii);
+    pl  =  (DWORD *)HeapAlloc(GetProcessHeap(), 0, (len+3)*sizeof(OLECHAR));
+    pl[0] = (len)*sizeof(OLECHAR);
+    bstr = (BSTR)&( pl[1]);
+    lstrcpyAtoW( bstr, pAscii);
+    return bstr;
+}
+