Changeset 6689 for trunk/src

Timestamp:

Sep 9, 2001, 10:45:20 PM (24 years ago)

Author:

sandervl

Message:

wine typelib update

Location:

trunk/src/oleaut32

Files:

• connpt.c (modified) (1 diff)
• dispatch.c (modified) (1 diff)
• initterm.cpp (modified) (1 diff)
• ole2disp.c (modified) (1 diff)
• oleaut.c (modified) (1 diff)
• olefont.c (modified) (1 diff)
• olepicture.c (modified) (1 diff)
• parsedt.c (modified) (1 diff)
• safearray.c (modified) (1 diff)
• typelib.c (modified) (192 diffs)
• typelib.h (modified) (12 diffs)
• variant.c (modified) (1 diff)

trunk/src/oleaut32/connpt.c

@@ -1 @@
-/* $Id: connpt.c,v 1.2 2001-09-05 13:18:59 bird Exp $ */
 /*
  * Implementation of a generic ConnectionPoint object.

trunk/src/oleaut32/dispatch.c

@@ -1 @@
-/* $Id: dispatch.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /**
  * Dispatch API functions

trunk/src/oleaut32/initterm.cpp

@@ -1 @@
-/* $Id: initterm.cpp,v 1.10 2001-09-05 13:19:00 bird Exp $ */
 /*
  * DLL entry point

trunk/src/oleaut32/ole2disp.c

@@ -1 @@
-/* $Id: ole2disp.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /*
  *  OLE2DISP library

trunk/src/oleaut32/oleaut.c

@@ -1 @@
-/* $Id: oleaut.c,v 1.2 2001-09-05 13:19:00 bird Exp $ */
 /*
  *  OLEAUT32

trunk/src/oleaut32/olefont.c

@@ -1 @@
-/* $Id: olefont.c,v 1.3 2001-09-05 13:19:00 bird Exp $ */
 /*
  * OLE Font encapsulation implementation

trunk/src/oleaut32/olepicture.c

@@ -1 @@
-/* $Id: olepicture.c,v 1.5 2001-09-05 13:19:01 bird Exp $ */
 /*
  * OLE Picture object

trunk/src/oleaut32/parsedt.c

@@ -1 @@
-/* $Id: parsedt.c,v 1.2 2001-09-05 13:19:01 bird Exp $ */
 /*
 PostgreSQL Data Base Management System (formerly known as Postgres, then

trunk/src/oleaut32/safearray.c

@@ -1 @@
-/* $Id: safearray.c,v 1.3 2001-09-05 13:19:01 bird Exp $ */
 /*************************************************************************
  * OLE Automation

trunk/src/oleaut32/typelib.c

@@ -1 @@
-/* $Id: typelib.c,v 1.6 2001-09-05 13:19:01 bird Exp $ */
 /*
- *  TYPELIB
- *
- *  Copyright 1997  Marcus Meissner
- *            1999  Rein Klazes
- *            2000  Francois Jacques
+ *      TYPELIB
+ *
+ *      Copyright 1997  Marcus Meissner
+ *                    1999  Rein Klazes
+ *                    2000  Francois Jacques
+ *                    2001  Huw D M Davies for CodeWeavers
+ *                    
  * --------------------------------------------------------------------------------------
  * Known problems (2000, Francois Jacques)
  *
  * - Tested using OLEVIEW (Platform SDK tool) only.
- *
- * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
- *   creating by doing a straight copy of the dispinterface instance and just changing
+ *   
+ * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are 
+ *   creating by doing a straight copy of the dispinterface instance and just changing 
  *   its typekind. Pointed structures aren't copied - only the address of the pointers.
  *   So when you release the dispinterface, you delete the vtable-interface structures
  *   as well... fortunately, clean up of structures is not implemented.
- *
+ * 
  * - locale stuff is partially implemented but hasn't been tested.
  *
- * - imported typelib should be stored together in a linked list instead of having
- *   independant TLBImpLib structures in each ITypeInfo. This way, imported libraries
- *   are just imported once (major optimization)
- *
- * - typelib file is still read it's in entirety, but it is released now.
- * - some garbage is read from function names on some very rare occasion
+ * - typelib file is still read in its entirety, but it is released now.
+ * - some garbage is read from function names on some very rare occasions.
  *
  * --------------------------------------------------------------------------------------
  *  Known problems left from previous implementation (1999, Rein Klazes) :
  *
- * -. Only one format of typelibs is supported
  * -. Data structures are straightforward, but slow for look-ups.
  * -. (related) nothing is hashed
@@ -40 +36 @@
  * -. some methods just return pointers to internal data structures, this is
  *      partly laziness, partly I want to check how windows does it.
- *
+ * 
  */
 #ifdef __WIN32OS2__
@@ -46 +42 @@
 #define WINE_LARGE_INTEGER
 #include "oleaut32.h"
-
 #endif
 
@@ -85 +80 @@
 #ifndef __WIN32OS2__
 /****************************************************************************
- *      QueryPathOfRegTypeLib   [TYPELIB.14]
+ *              QueryPathOfRegTypeLib   [TYPELIB.14]
  *
  * the path is "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\"
  * RETURNS
- *  path of typelib
+ *      path of typelib
  */
 HRESULT WINAPI
-QueryPathOfRegTypeLib16(
-    REFGUID guid,   /* [in] referenced guid */
-    WORD wMaj,  /* [in] major version */
-    WORD wMin,  /* [in] minor version */
-    LCID lcid,  /* [in] locale id */
-    LPBSTR16 path   /* [out] path of typelib */
+QueryPathOfRegTypeLib16(        
+        REFGUID guid,   /* [in] referenced guid */
+        WORD wMaj,      /* [in] major version */
+        WORD wMin,      /* [in] minor version */
+        LCID lcid,      /* [in] locale id */
+        LPBSTR16 path   /* [out] path of typelib */
 ) {
-    char    xguid[80];
-    char    typelibkey[100],pathname[260];
-    DWORD   plen;
-
-        TRACE("\n");
-
-    if (HIWORD(guid)) {
+        char    xguid[80];
+        char    typelibkey[100],pathname[260];
+        DWORD   plen;
+
+        TRACE("\n");
+
+        if (HIWORD(guid)) {
             sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win16",
                      guid->Data1, guid->Data2, guid->Data3,
@@ -111 +106 @@
                      guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
                      wMaj,wMin,lcid);
-    } else {
-        sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
-        FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
-        return E_FAIL;
-    }
-    plen = sizeof(pathname);
-    if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
-        /* try again without lang specific id */
-        if (SUBLANGID(lcid))
-            return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
-        FIXME("key %s not found\n",typelibkey);
-        return E_FAIL;
-    }
-    *path = SysAllocString16(pathname);
-    return S_OK;
+        } else {
+                sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
+                FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
+                return E_FAIL;
+        }
+        plen = sizeof(pathname);
+        if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
+                /* try again without lang specific id */
+                if (SUBLANGID(lcid))
+                        return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
+                FIXME("key %s not found\n",typelibkey);
+                return E_FAIL;
+        }
+        *path = SysAllocString16(pathname);
+        return S_OK;
 }
 #endif
-
+ 
 /****************************************************************************
- *      QueryPathOfRegTypeLib   [OLEAUT32.164]
+ *              QueryPathOfRegTypeLib   [OLEAUT32.164]
  * RETURNS
- *  path of typelib
+ *      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 */
+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 */
 {
     /* don't need to ZeroMemory those arrays since sprintf and RegQueryValue add
@@ -157 +152 @@
     char    szPath[dwPathLen];
 #endif
+
     if ( !HIWORD(guid) )
     {
@@ -172 +168 @@
             "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win32",
             guid->Data1,    guid->Data2,    guid->Data3,
-            guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
+            guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], 
             guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
             wMaj,
@@ -212 +208 @@
         }
     }
-
+        
     if (hr != S_OK)
-        TRACE_(typelib)("%s not found\n", szTypeLibKey);
-
+                TRACE_(typelib)("%s not found\n", szTypeLibKey);
+        
     return hr;
 }
@@ -227 +223 @@
  */
 HRESULT WINAPI CreateTypeLib(
-    SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
+        SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
 ) {
     FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
@@ -257 +253 @@
 
 /******************************************************************************
- *      LoadTypeLib [OLEAUT32.161]
+ *              LoadTypeLib     [OLEAUT32.161]
  * Loads and registers a type library
  * NOTES
@@ -278 +274 @@
 
 /******************************************************************************
- *      LoadTypeLibEx   [OLEAUT32.183]
+ *              LoadTypeLibEx   [OLEAUT32.183]
  * Loads and optionally registers a type library
  *
@@ -290 +286 @@
     ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
 {
-    LPSTR p;
+    LPSTR p=NULL;
+    WCHAR szPath[MAX_PATH+1];
     HRESULT res;
     TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
-
-    p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
-
-    res= TLB_ReadTypeLib(p, (ITypeLib2**)pptLib);
-
+    
+    if(!SearchPathW(NULL,szFile,NULL,sizeof(szPath)/sizeof(WCHAR),szPath,NULL))
+      res = TYPE_E_CANTLOADLIBRARY;
+    else {
+      p=HEAP_strdupWtoA(GetProcessHeap(),0,szPath);
+      res= TLB_ReadTypeLib(p, (ITypeLib2**)pptLib);
+    }
     if (SUCCEEDED(res))
         switch(regkind)
@@ -303 +302 @@
             case REGKIND_DEFAULT:
                 /* FIXME: is this correct? */
-                if (!p || !p[0] || (p[0] != '\\' && p[0] != '/' && p[1] != ':'))
+                if (!szFile || !szFile[0] ||
+                   (szFile[0] != '\\' && szFile[0] != '/' && szFile[1] != ':'))
                     break;
                 /* else fall-through */
@@ -318 +318 @@
         }
 
-    HeapFree(GetProcessHeap(),0,p);
+    if(p) HeapFree(GetProcessHeap(),0,p);
     TRACE(" returns %08lx\n",res);
     return res;
@@ -324 +324 @@
 
 /******************************************************************************
- *      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 */
+ *              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;
@@ -345 +345 @@
 
     return res;
-}
+}       
 
 
 /******************************************************************************
- *      RegisterTypeLib [OLEAUT32.163]
- * Adds information about a type library to the System Registry
+ *              RegisterTypeLib [OLEAUT32.163]
+ * Adds information about a type library to the System Registry           
  * NOTES
  *    Docs: ITypeLib FAR * ptlib
@@ -364 +364 @@
      OLECHAR * szFullPath, /* [in] full Path of the library*/
      OLECHAR * szHelpDir)  /* [in] dir to the helpfile for the library,
-                             may be NULL*/
+                                                         may be NULL*/
 {
     HRESULT res;
@@ -445 +445 @@
 
 /******************************************************************************
- *  UnRegisterTypeLib   [OLEAUT32.186]
- * Removes information about a type library from the System Registry
+ *      UnRegisterTypeLib       [OLEAUT32.186]
+ * Removes information about a type library from the System Registry           
  * NOTES
  *
@@ -454 +454 @@
  */
 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)
-{
+    REFGUID libid,      /* [in] Guid of the library */
+        WORD wVerMajor, /* [in] major version */
+        WORD wVerMinor, /* [in] minor version */
+        LCID lcid,      /* [in] locale id */
+        SYSKIND syskind)
+{   
     TRACE("(IID: %s): stub\n",debugstr_guid(libid));
-    return S_OK;    /* FIXME: pretend everything is OK */
+    return S_OK;        /* FIXME: pretend everything is OK */
 }
 
 #ifndef __WIN32OS2__
 /****************************************************************************
- *  OaBuildVersion              (TYPELIB.15)
+ *      OaBuildVersion                          (TYPELIB.15)
  *
  * known TYPELIB.DLL versions:
  *
- * OLE 2.01 no OaBuildVersion() avail   1993    --  ---
- * OLE 2.02             1993-94 02     3002
- * OLE 2.03                 23  730
- * OLE 2.03                 03     3025
- * OLE 2.03 W98 SE orig. file !!    1993-95 10     3024
- * OLE 2.1   NT             1993-95 ??  ???
- * OLE 2.3.1 W95                23  700
- * OLE2 4.0  NT4SP6         1993-98 40     4277
+ * OLE 2.01 no OaBuildVersion() avail   1993    --      ---
+ * OLE 2.02                             1993-94 02     3002
+ * OLE 2.03                                     23      730
+ * OLE 2.03                                     03     3025
+ * OLE 2.03 W98 SE orig. file !!        1993-95 10     3024
+ * OLE 2.1   NT                         1993-95 ??      ???
+ * OLE 2.3.1 W95                                23      700
+ * OLE2 4.0  NT4SP6                     1993-98 40     4277
  */
 DWORD WINAPI OaBuildVersion16(void)
@@ -489 +489 @@
     {
     case 0x80000a03:  /* WIN31 */
-        return MAKELONG(3027, 3); /* WfW 3.11 */
+                return MAKELONG(3027, 3); /* WfW 3.11 */
     case 0x80000004:  /* WIN95 */
-        return MAKELONG(700, 23); /* Win95A */
+                return MAKELONG(700, 23); /* Win95A */
     case 0x80000a04:  /* WIN98 */
-        return MAKELONG(3024, 10); /* W98 SE */
+                return MAKELONG(3024, 10); /* W98 SE */
     case 0x00000004:  /* NT4 */
-        return MAKELONG(4277, 40); /* NT4 SP6 */
+                return MAKELONG(4277, 40); /* NT4 SP6 */
     default:
-    FIXME("Version value not known yet. Please investigate it!\n");
-        return 0;
+        FIXME("Version value not known yet. Please investigate it!\n");
+                return 0;
     }
 }
 #endif
-
 /* for better debugging info leave the static out for the time being */
 #define static
@@ -508 +507 @@
 /*======================= ITypeLib implementation =======================*/
 
-typedef struct tagTLBCustData
+typedef struct tagTLBCustData 
 {
     GUID guid;
@@ -518 +517 @@
 typedef struct tagTLBImpLib
 {
-    int offset;                 /* offset in the file */
+    int offset;                 /* offset in the file (MSFT)
+                                   offset in nametable (SLTG)
+                                   just used to identify library while reading
+                                   data from file */
     GUID guid;                  /* libid */
-    BSTR name;                  /* name; */
+    BSTR name;                  /* name */
 
     LCID lcid;                  /* lcid of imported typelib */
@@ -527 +529 @@
     WORD wVersionMinor;         /* minor version number */
 
-    struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib */
+    struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib, or
+                                            NULL if not yet loaded */
     struct tagTLBImpLib * next;
 } TLBImpLib;
@@ -537 +540 @@
     UINT ref;
     TLIBATTR LibAttr;            /* guid,lcid,syskind,version,flags */
-
+    
     /* strings can be stored in tlb as multibyte strings BUT they are *always*
      * exported to the application as a UNICODE string.
@@ -549 +552 @@
     struct tagITypeInfoImpl *pTypeInfo;   /* linked list of type info data */
     int ctCustData;             /* number of items in cust data list */
-    TLBCustData * pCustData;    /* linked list to cust data; */
+    TLBCustData * pCustData;    /* linked list to cust data */
     TLBImpLib   * pImpLibs;     /* linked list to all imported typelibs */
-    TYPEDESC * pTypeDesc;       /* array of TypeDescriptions found in the libary */
+    TYPEDESC * pTypeDesc;       /* array of TypeDescriptions found in the
+                                   libary. Only used while read MSFT
+                                   typelibs */
 } ITypeLibImpl;
 
@@ -557 +562 @@
 
 /* ITypeLib methods */
-static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength);
+static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength);
+static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength);
 
 /*======================= ITypeInfo implementation =======================*/
 
-/* data for refernced types in a coclass, or an inherited interface */
+/* data for refernced types */
 typedef struct tagTLBRefType
 {
+    INT index;              /* Type index for internal ref or for external ref
+                               it the format is SLTG.  -2 indicates to
+                               use guid */
+
     GUID guid;              /* guid of the referenced type */
-                            /* (important if its a imported type) */
-    HREFTYPE reference;
-    int flags;
-    int ctCustData;
-    TLBCustData * pCustData;/* linked list to custom data; */
-    TLBImpLib *pImpTLInfo;
+                            /* if index == TLB_REF_USE_GUID */
+
+    HREFTYPE reference;     /* The href of this ref */
+    TLBImpLib *pImpTLInfo;  /* If ref is external ptr to library data
+                               TLB_REF_INTERNAL for internal refs
+                               TLB_REF_NOT_FOUND for broken refs */
+  
     struct tagTLBRefType * next;
 } TLBRefType;
 
+#define TLB_REF_USE_GUID -2
+
+#define TLB_REF_INTERNAL (void*)-2
+#define TLB_REF_NOT_FOUND (void*)-1
+
 /* internal Parameter data */
 typedef struct tagTLBParDesc
@@ -579 +595 @@
     BSTR Name;
     int ctCustData;
-    TLBCustData * pCustData;        /* linked list to cust data; */
-    TLBRefType * pRefType;          /* linked list to referenced types */
+    TLBCustData * pCustData;        /* linked list to cust data */
 } TLBParDesc;
 
@@ -588 +603 @@
     FUNCDESC funcdesc;      /* lots of info on the function and its attributes. */
     BSTR Name;             /* the name of this function */
-    TLBParDesc *pParamDesc; /* array with name and custom data */
+    TLBParDesc *pParamDesc; /* array with param names and custom data */
     int helpcontext;
     int HelpStringContext;
@@ -595 +610 @@
     int ctCustData;
     TLBCustData * pCustData;        /* linked list to cust data; */
-    struct tagTLBFuncDesc * next;
+    struct tagTLBFuncDesc * next; 
 } TLBFuncDesc;
 
@@ -608 +623 @@
     int ctCustData;
     TLBCustData * pCustData;/* linked list to cust data; */
-    struct tagTLBVarDesc * next;
+    struct tagTLBVarDesc * next; 
 } TLBVarDesc;
+
+/* internal implemented interface data */
+typedef struct tagTLBImplType
+{
+    HREFTYPE hRef;          /* hRef of interface */
+    int implflags;          /* IMPLFLAG_*s */
+    int ctCustData;
+    TLBCustData * pCustData;/* linked list to custom data; */
+    struct tagTLBImplType *next;
+} TLBImplType;
 
 /* internal TypeInfo data */
@@ -619 +644 @@
     ITypeLibImpl * pTypeLib;        /* back pointer to typelib */
     int index;                  /* index in this typelib; */
-    /* type libs seem to store the doc strings in ascii
+    /* type libs seem to store the doc strings in ascii 
      * so why should we do it in unicode?
      */
@@ -634 +659 @@
 
     /* Implemented Interfaces  */
-    TLBRefType * impltypelist;
+    TLBImplType * impltypelist;
+
+    TLBRefType * reflist;
     int ctCustData;
     TLBCustData * pCustData;        /* linked list to cust data; */
@@ -646 +673 @@
 typedef struct tagTLBContext
 {
-    unsigned int oStart;  /* start of TLB in file */
-    unsigned int pos;     /* current pos */
-    unsigned int length;  /* total length */
-    void *mapping;        /* memory mapping */
-    TLBSegDir * pTblDir;
-    ITypeLibImpl* pLibInfo;
+        unsigned int oStart;  /* start of TLB in file */
+        unsigned int pos;     /* current pos */
+        unsigned int length;  /* total length */
+        void *mapping;        /* memory mapping */
+        MSFT_SegDir * pTblDir;
+        ITypeLibImpl* pLibInfo;
 } TLBContext;
 
 
-static void TLB_DoRefType(TLBContext *pcx, int offset, TLBRefType ** pprtd);
+static void MSFT_DoRefType(TLBContext *pcx, ITypeInfoImpl *pTI, int offset);
 
 //#define TYPELIBDEBUG
@@ -680 +707 @@
     case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
     case VT_ARRAY: sprintf(szVarType, "VT_ARRAY"); break;
-    case VT_I1: sprintf(szVarType, "VT_I2"); break;
+    case VT_I1: sprintf(szVarType, "VT_I1"); break;
     case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
     case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
     case VT_INT: sprintf(szVarType, "VT_INT"); break;
     case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
+    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED\n"); break;
     default: sprintf(szVarType, "unknown");break;
     }
 }
+
+static void dump_TypeDesc(TYPEDESC *pTD,char *szVarType) {
+    switch(pTD->vt) {
+    case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
+    case VT_I2: sprintf(szVarType, "VT_I2"); break;
+    case VT_I4: sprintf(szVarType, "VT_I4"); break;
+    case VT_R4: sprintf(szVarType, "VT_R4"); break;
+    case VT_R8: sprintf(szVarType, "VT_R8"); break;
+    case VT_BOOL: sprintf(szVarType, "VT_BOOL"); break;
+    case VT_ERROR: sprintf(szVarType, "VT_ERROR"); break;
+    case VT_CY: sprintf(szVarType, "VT_CY"); break;
+    case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
+    case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
+    case VT_BYREF: case VT_UNKNOWN: sprintf(szVarType, "VT_BYREF"); break;
+    case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
+    case VT_ARRAY: sprintf(szVarType, "VT_ARRAY"); break;
+    case VT_I1: sprintf(szVarType, "VT_I1"); break;
+    case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
+    case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
+    case VT_INT: sprintf(szVarType, "VT_INT"); break;
+    case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
+    case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
+    case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
+    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %lx",
+                                 pTD->u.hreftype); break;
+    case VT_PTR: sprintf(szVarType, "ptr to ");
+      dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
+      break;
+    case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
+      dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
+      break;
+    case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
+                            pTD->u.lpadesc->cDims); /* FIXME print out sizes */
+      dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
+      break;
+
+    default: sprintf(szVarType, "unknown");break;
+    }
+}
+
 static void dump_ELEMDESC(ELEMDESC *edesc) {
   char buf[200];
-  dump_VarType(edesc->tdesc.vt,buf);
+  dump_TypeDesc(&edesc->tdesc,buf);
   MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
   MESSAGE("\t\tu.parmadesc.flags %x\n",edesc->u.paramdesc.wParamFlags);
@@ -697 +765 @@
 static void dump_FUNCDESC(FUNCDESC *funcdesc) {
   int i;
-  MESSAGE("memid is %d\n",(int)funcdesc->memid);
-  for (i=0;i<funcdesc->cParams;i++)
-      MESSAGE("Param %d:\n",i);dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
+  MESSAGE("memid is %08lx\n",funcdesc->memid);
+  for (i=0;i<funcdesc->cParams;i++) {
+      MESSAGE("Param %d:\n",i);
+      dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
+  }
   MESSAGE("\tfunckind: %d (",funcdesc->funckind);
   switch (funcdesc->funckind) {
@@ -745 +815 @@
 static void dump_TLBFuncDesc(TLBFuncDesc * pfd)
 {
-    while (pfd)
-    {
-      dump_TLBFuncDescOne(pfd);
-      pfd = pfd->next;
-    };
+        while (pfd)
+        {
+          dump_TLBFuncDescOne(pfd);
+          pfd = pfd->next;
+        };
 }
 static void dump_TLBVarDesc(TLBVarDesc * pvd)
 {
-    while (pvd)
-    {
-      TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
-      pvd = pvd->next;
-    };
-}
+        while (pvd)
+        {
+          TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
+          pvd = pvd->next;
+        };
+}
+
+static void dump_TLBImpLib(TLBImpLib *import)
+{
+    TRACE_(typelib)("%s %s\n", debugstr_guid(&(import->guid)),
+                    debugstr_w(import->name));
+    TRACE_(typelib)("v%d.%d lcid=%lx offset=%x\n", import->wVersionMajor,
+                    import->wVersionMinor, import->lcid, import->offset);
+}
+
 static void dump_TLBRefType(TLBRefType * prt)
 {
-    while (prt)
-    {
-      TRACE_(typelib)("%s\n", debugstr_guid(&(prt->guid)));
-      TRACE_(typelib)("  href:0x%08lx\n", prt->reference);
-      prt = prt->next;
-    };
-}
-
+        while (prt)
+        {
+          TRACE_(typelib)("href:0x%08lx\n", prt->reference);
+          if(prt->index == -1)
+            TRACE_(typelib)("%s\n", debugstr_guid(&(prt->guid)));
+          else
+            TRACE_(typelib)("type no: %d\n", prt->index);
+
+          if(prt->pImpTLInfo != TLB_REF_INTERNAL &&
+             prt->pImpTLInfo != TLB_REF_NOT_FOUND) {
+              TRACE_(typelib)("in lib\n");
+              dump_TLBImpLib(prt->pImpTLInfo);
+          }
+          prt = prt->next;
+        };
+}
+
+static void dump_TLBImplType(TLBImplType * impl)
+{
+    while (impl) {
+        TRACE_(typelib)(
+                "implementing/inheriting interface hRef = %lx implflags %x\n",
+                impl->hRef, impl->implflags);
+        impl = impl->next;
+    }
+}
+      
 static void dump_Variant(VARIANT * pvar)
 {
     char szVarType[15];
-
+    
     TRACE("(%p)\n", pvar);
-
+ 
     if (!pvar)  return;
-
+ 
     ZeroMemory(szVarType, sizeof(szVarType));
-
+               
     /* FIXME : we could have better trace here, depending on the VARTYPE
      * of the variant
@@ -785 +883 @@
 
     TRACE("VARTYPE: %s\n", szVarType);
-
+    
     switch (V_VT(pvar))
     {
@@ -791 +889 @@
             TRACE("%3.3e\n", V_UNION(pvar, fltVal));
             break;
-
+            
         case VT_R8:
             TRACE("%3.3e\n", V_UNION(pvar, dblVal));
             break;
-
+            
         default:
             TRACE("%ld\n", V_UNION(pvar, lVal));
             break;
-    }
+    }       
 
     if (V_VT(pvar) & VT_BYREF)
@@ -808 +906 @@
 {
     int index = 0;
-
+    
     TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
 
@@ -820 +918 @@
 static char * typekind_desc[] =
 {
-    "TKIND_ENUM",
-    "TKIND_RECORD",
-    "TKIND_MODULE",
-    "TKIND_INTERFACE",
-    "TKIND_DISPATCH",
-    "TKIND_COCLASS",
-    "TKIND_ALIAS",
-    "TKIND_UNION",
-    "TKIND_MAX"
+        "TKIND_ENUM",
+        "TKIND_RECORD",
+        "TKIND_MODULE",
+        "TKIND_INTERFACE",
+        "TKIND_DISPATCH",
+        "TKIND_COCLASS",
+        "TKIND_ALIAS",
+        "TKIND_UNION",
+        "TKIND_MAX"
 };
 
@@ -842 +940 @@
     dump_TLBFuncDesc(pty->funclist);
     dump_TLBVarDesc(pty->varlist);
-    dump_TLBRefType(pty->impltypelist);
+    dump_TLBImplType(pty->impltypelist);
 }
 #else
 static char * typekind_desc[] =
 {
-    "TKIND_ENUM",
-    "TKIND_RECORD",
-    "TKIND_MODULE",
-    "TKIND_INTERFACE",
-    "TKIND_DISPATCH",
-    "TKIND_COCLASS",
-    "TKIND_ALIAS",
-    "TKIND_UNION",
-    "TKIND_MAX"
+        "TKIND_ENUM",
+        "TKIND_RECORD",
+        "TKIND_MODULE",
+        "TKIND_INTERFACE",
+        "TKIND_DISPATCH",
+        "TKIND_COCLASS",
+        "TKIND_ALIAS",
+        "TKIND_UNION",
+        "TKIND_MAX"
 };
 #define  dump_TypeInfo(a)
@@ -861 +959 @@
 #define  dump_TLBFuncDescOne(a)
 #define  dump_TLBVarDesc(a)
+#define  dump_TLBRefType(a)
+#define  dump_TLBFuncDesc(a)
+#define  dump_TypeDesc(a,b)
 #endif
 
@@ -894 +995 @@
     HeapFree(GetProcessHeap(), 0, ptr);
 }
+
+
+/**********************************************************************
+ *
+ *  Functions for reading MSFT typelibs (those created by CreateTypeLib2)
+ */
 /* read function */
-DWORD TLB_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
+DWORD MSFT_Read(void *buffer,  DWORD count, TLBContext *pcx, long where )
 {
     TRACE_(typelib)("pos=0x%08x len=0x%08lx 0x%08x 0x%08x 0x%08lx\n",
@@ -917 +1024 @@
 }
 
-static void TLB_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
+static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
 {
     TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
@@ -925 +1032 @@
         return;
     }
-    TLB_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
-}
-
-BSTR TLB_ReadName( TLBContext *pcx, int offset)
+    MSFT_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
+}
+
+BSTR MSFT_ReadName( TLBContext *pcx, int offset)
 {
     char * name;
-    TLBNameIntro niName;
+    MSFT_NameIntro niName;
     int lengthInChars;
     WCHAR* pwstring = NULL;
     BSTR bstrName = NULL;
 
-    TLB_Read(&niName, sizeof(niName), pcx,
-                pcx->pTblDir->pNametab.offset+offset);
+    MSFT_Read(&niName, sizeof(niName), pcx,
+                                pcx->pTblDir->pNametab.offset+offset);
     niName.namelen &= 0xFF; /* FIXME: correct ? */
     name=TLB_Alloc((niName.namelen & 0xff) +1);
-    TLB_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
+    MSFT_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
     name[niName.namelen & 0xff]='\0';
 
@@ -963 +1070 @@
 }
 
-BSTR TLB_ReadString( TLBContext *pcx, int offset)
+BSTR MSFT_ReadString( TLBContext *pcx, int offset)
 {
     char * string;
@@ -971 +1078 @@
 
     if(offset<0) return NULL;
-    TLB_Read(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
+    MSFT_Read(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
     if(length <= 0) return 0;
     string=TLB_Alloc(length +1);
-    TLB_Read(string, length, pcx, DO_NOT_SEEK);
+    MSFT_Read(string, length, pcx, DO_NOT_SEEK);
     string[length]='\0';
 
@@ -997 +1104 @@
 }
 /*
- * read a value and fill a VARIANT structure
- */
-static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
+ * read a value and fill a VARIANT structure 
+ */
+static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
 {
     int size;
@@ -1005 +1112 @@
     TRACE_(typelib)("\n");
 
-    if(offset <0) { /* data is packed in here */
+    if(offset <0) { /* data are packed in here */
         V_VT(pVar) = (offset & 0x7c000000 )>> 26;
         V_UNION(pVar, iVal) = offset & 0xffff;
         return;
     }
-    TLB_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
+    MSFT_Read(&(V_VT(pVar)), sizeof(VARTYPE), pcx, 
         pcx->pTblDir->pCustData.offset + offset );
     TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
@@ -1019 +1126 @@
         case VT_I4  :
         case VT_R4  :
-        case VT_ERROR   :
-        case VT_BOOL    :
-        case VT_I1  :
-        case VT_UI1 :
-        case VT_UI2 :
-        case VT_UI4 :
-        case VT_INT :
-        case VT_UINT    :
+        case VT_ERROR   : 
+        case VT_BOOL    : 
+        case VT_I1  : 
+        case VT_UI1 : 
+        case VT_UI2 : 
+        case VT_UI4 : 
+        case VT_INT : 
+        case VT_UINT    : 
         case VT_VOID    : /* FIXME: is this right? */
-        case VT_HRESULT :
+        case VT_HRESULT : 
             size=4; break;
         case VT_R8  :
         case VT_CY  :
-        case VT_DATE    :
-        case VT_I8  :
-        case VT_UI8 :
+        case VT_DATE    : 
+        case VT_I8  : 
+        case VT_UI8 : 
         case VT_DECIMAL :  /* FIXME: is this right? */
         case VT_FILETIME :
@@ -1041 +1148 @@
         case VT_BSTR    :{
             char * ptr;
-            TLB_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
-        if(size <= 0) {
-            FIXME("BSTR length = %d?\n", size);
-        } else {
+            MSFT_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
+            if(size <= 0) {
+                FIXME("BSTR length = %d?\n", size);
+            } else {
                 ptr=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;
+                MSFT_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;
     /* FIXME: this will not work AT ALL when the variant contains a pointer */
         case VT_DISPATCH :
-        case VT_VARIANT :
-        case VT_UNKNOWN :
-        case VT_PTR :
+        case VT_VARIANT : 
+        case VT_UNKNOWN : 
+        case VT_PTR : 
         case VT_SAFEARRAY :
-        case VT_CARRAY  :
-        case VT_USERDEFINED :
-        case VT_LPSTR   :
-        case VT_LPWSTR  :
-        case VT_BLOB    :
-        case VT_STREAM  :
-        case VT_STORAGE :
-        case VT_STREAMED_OBJECT :
-        case VT_STORED_OBJECT   :
-        case VT_BLOB_OBJECT :
-        case VT_CF  :
-        case VT_CLSID   :
-        default:
-            size=0;
+        case VT_CARRAY  : 
+        case VT_USERDEFINED : 
+        case VT_LPSTR   : 
+        case VT_LPWSTR  : 
+        case VT_BLOB    : 
+        case VT_STREAM  : 
+        case VT_STORAGE : 
+        case VT_STREAMED_OBJECT : 
+        case VT_STORED_OBJECT   : 
+        case VT_BLOB_OBJECT : 
+        case VT_CF  : 
+        case VT_CLSID   : 
+        default: 
+            size=0; 
             FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
                 V_VT(pVar));
@@ -1080 +1187 @@
 
     if(size>0) /* (big|small) endian correct? */
-        TLB_Read(&(V_UNION(pVar, iVal)), size, pcx, DO_NOT_SEEK );
+        MSFT_Read(&(V_UNION(pVar, iVal)), size, pcx, DO_NOT_SEEK );
     return;
 }
@@ -1086 +1193 @@
  * create a linked list with custom data
  */
-static int TLB_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
-{
-    TLBCDGuid entry;
+static int MSFT_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
+{
+    MSFT_CDGuid entry;
     TLBCustData* pNew;
     int count=0;
@@ -1097 +1204 @@
         count++;
         pNew=TLB_Alloc(sizeof(TLBCustData));
-        TLB_Read(&entry, sizeof(entry), pcx,
+        MSFT_Read(&entry, sizeof(entry), pcx, 
             pcx->pTblDir->pCDGuids.offset+offset);
-        TLB_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
-        TLB_ReadValue(&(pNew->data), entry.DataOffset, pcx);
+        MSFT_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
+        MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
         /* add new custom data at head of the list */
         pNew->next=*ppCustData;
@@ -1109 +1216 @@
 }
 
-static void TLB_GetTdesc(TLBContext *pcx, INT type,TYPEDESC * pTd )
+static void MSFT_GetTdesc(TLBContext *pcx, INT type, TYPEDESC *pTd,
+                          ITypeInfoImpl *pTI)
 {
     if(type <0)
@@ -1116 +1224 @@
         *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
 
+    if(pTd->vt == VT_USERDEFINED)
+      MSFT_DoRefType(pcx, pTI, pTd->u.hreftype);
+
     TRACE_(typelib)("vt type = %X\n", pTd->vt);
 }
 
-static void
-TLB_DoFuncs(TLBContext*     pcx,
-            int             cFuncs,
+static void 
+MSFT_DoFuncs(TLBContext*     pcx,
+            ITypeInfoImpl*  pTI,
+            int             cFuncs, 
             int             cVars,
-            int             offset,
+            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
+     * 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
+     * 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
@@ -1143 +1255 @@
      * 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
+     * 
+     * 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.
@@ -1155 +1267 @@
 
     char recbuf[512];
-    TLBFuncRecord * pFuncRec=(TLBFuncRecord *) recbuf;
+    MSFT_FuncRecord * pFuncRec=(MSFT_FuncRecord *) recbuf;
 
     TRACE_(typelib)("\n");
 
-    TLB_Read(&infolen, sizeof(INT), pcx, offset);
+    MSFT_Read(&infolen, sizeof(INT), pcx, offset);
 
     for ( i = 0; i < cFuncs ; i++ )
@@ -1166 +1278 @@
 
         /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset,
-                 sizeof(INT),
-                 pcx,
+        MSFT_Read(&nameoffset, 
+                 sizeof(INT), 
+                 pcx, 
                  offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
 
-        (*pptfd)->Name = TLB_ReadName(pcx, nameoffset);
+        (*pptfd)->Name = MSFT_ReadName(pcx, nameoffset);
 
         /* read the function information record */
-        TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
-
+        MSFT_Read(&reclength, sizeof(INT), pcx, recoffset);
+        
         reclength &= 0x1ff;
 
-        TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
+        MSFT_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ; 
 
         /* do the attributes */
@@ -1187 +1299 @@
         {
             (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
-
+            
             if ( nrattributes > 1 )
             {
-                (*pptfd)->HelpString = TLB_ReadString(pcx,
+                (*pptfd)->HelpString = MSFT_ReadString(pcx,
                                                       pFuncRec->OptAttr[1]) ;
 
@@ -1201 +1313 @@
                     else
                     {
-                        (*pptfd)->Entry = TLB_ReadString(pcx,
+                        (*pptfd)->Entry = MSFT_ReadString(pcx,
                                                          pFuncRec->OptAttr[2]);
                     }
@@ -1210 +1322 @@
                         if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
                         {
-                            TLB_CustData(pcx,
-                                         pFuncRec->OptAttr[6],
-                                         &(*pptfd)->pCustData);
+                            MSFT_CustData(pcx, 
+                                          pFuncRec->OptAttr[6],
+                                          &(*pptfd)->pCustData);
                         }
                     }
@@ -1220 +1332 @@
 
         /* fill the FuncDesc Structure */
-        TLB_Read( & (*pptfd)->funcdesc.memid,
-                  sizeof(INT), pcx,
+        MSFT_Read( & (*pptfd)->funcdesc.memid, 
+                  sizeof(INT), pcx, 
                   offset + infolen + ( i + 1) * sizeof(INT));
 
@@ -1232 +1344 @@
         (*pptfd)->funcdesc.wFuncFlags =   LOWORD(pFuncRec->Flags) ;
 
-        TLB_GetTdesc(pcx,
-                     pFuncRec->DataType,
-                     &(*pptfd)->funcdesc.elemdescFunc.tdesc) ;
+        MSFT_GetTdesc(pcx, 
+                      pFuncRec->DataType,   
+                      &(*pptfd)->funcdesc.elemdescFunc.tdesc,
+                      pTI);
 
         /* do the parameters/arguments */
@@ -1240 +1353 @@
         {
             int j = 0;
-            TLBParameterInfo paraminfo;
-
-            (*pptfd)->funcdesc.lprgelemdescParam =
+            MSFT_ParameterInfo paraminfo;
+
+            (*pptfd)->funcdesc.lprgelemdescParam = 
                 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
 
-            (*pptfd)->pParamDesc =
+            (*pptfd)->pParamDesc = 
                 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
 
-            TLB_Read(&paraminfo,
-                     sizeof(paraminfo),
-                     pcx,
-                     recoffset + reclength -
-                        pFuncRec->nrargs * sizeof(TLBParameterInfo));
+            MSFT_Read(&paraminfo,
+                      sizeof(paraminfo), 
+                      pcx, 
+                      recoffset + reclength -
+                      pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
 
             for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
@@ -1258 +1371 @@
                 TYPEDESC* lpArgTypeDesc = 0;
 
-                TLB_GetTdesc(pcx,
-                             paraminfo.DataType,
-                             &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
+                MSFT_GetTdesc(pcx, 
+                              paraminfo.DataType,   
+                              &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc,
+                              pTI);
 
                 (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags = paraminfo.Flags;
@@ -1266 +1380 @@
                 (*pptfd)->pParamDesc[j].Name = (void *) paraminfo.oName;
 
-                /* SEEK value = jump to offset,
+                /* SEEK value = jump to offset, 
                  * from there jump to the end of record,
                  * go back by (j-1) arguments
                  */
-                TLB_Read( &paraminfo ,
-                          sizeof(TLBParameterInfo), pcx,
-                          recoffset + reclength - ((pFuncRec->nrargs - j - 1)
-                                                   * sizeof(TLBParameterInfo)));
-                lpArgTypeDesc =
+                MSFT_Read( &paraminfo ,
+                           sizeof(MSFT_ParameterInfo), pcx,
+                           recoffset + reclength - ((pFuncRec->nrargs - j - 1) 
+                                               * sizeof(MSFT_ParameterInfo)));
+                lpArgTypeDesc = 
                     & ((*pptfd)->funcdesc.lprgelemdescParam[j].tdesc);
 
@@ -1290 +1404 @@
 
                     case VT_USERDEFINED:
-                        (*pptfd)->pParamDesc[j].pRefType =
-                        TLB_Alloc(sizeof(TLBRefType));
-
-                        TLB_DoRefType(pcx,
-                                      lpArgTypeDesc->u.hreftype,
-                                      & ( (*pptfd)->pParamDesc[j].pRefType ));
+                        MSFT_DoRefType(pcx, pTI, 
+                                       lpArgTypeDesc->u.hreftype);
 
                         lpArgTypeDesc = NULL;
@@ -1312 +1422 @@
                 TYPEDESC* lpArgTypeDesc;
 
-                (*pptfd)->funcdesc.elemdescFunc =
+                (*pptfd)->funcdesc.elemdescFunc = 
                 (*pptfd)->funcdesc.lprgelemdescParam[j];
 
@@ -1325 +1435 @@
                         break;
                     case VT_CARRAY:
-                        lpArgTypeDesc =
+                        lpArgTypeDesc = 
                         & (lpArgTypeDesc->u.lpadesc->tdescElem);
 
@@ -1331 +1441 @@
 
                     case VT_USERDEFINED:
-                        (*pptfd)->pParamDesc[j].pRefType
-                        = TLB_Alloc(sizeof(TLBRefType));
-
-                        TLB_DoRefType(pcx,
-                                      lpArgTypeDesc->u.hreftype,
-                                      &((*pptfd)->pParamDesc[j].pRefType));
+                        MSFT_DoRefType(pcx, 
+                                       pTI,
+                                       lpArgTypeDesc->u.hreftype);
 
                         lpArgTypeDesc = NULL;
@@ -1352 +1459 @@
                 /* name */
                 (*pptfd)->pParamDesc[j].Name =
-                    TLB_ReadName( pcx, (int)(*pptfd)->pParamDesc[j].Name );
+                    MSFT_ReadName( pcx, (int)(*pptfd)->pParamDesc[j].Name );
 
                 /* default value */
-                if ( (PARAMFLAG_FHASDEFAULT &
+                if ( (PARAMFLAG_FHASDEFAULT & 
                       (*pptfd)->funcdesc.lprgelemdescParam[j].u.paramdesc.wParamFlags) &&
                      ((pFuncRec->FKCCIC) & 0x1000) )
                 {
-                    INT* pInt = (INT *)((char *)pFuncRec +
-                                   reclength -
+                    INT* pInt = (INT *)((char *)pFuncRec + 
+                                   reclength - 
                                    (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
 
@@ -1368 +1475 @@
                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
 
-                    TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
+                    MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue), 
                         pInt[j], pcx);
                 }
@@ -1374 +1481 @@
                 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
                 {
-                    TLB_CustData(pcx,
-                                 pFuncRec->OptAttr[7+j],
-                                 &(*pptfd)->pParamDesc[j].pCustData);
+                    MSFT_CustData(pcx, 
+                                  pFuncRec->OptAttr[7+j],
+                                  &(*pptfd)->pParamDesc[j].pCustData);
                 }
            }
@@ -1389 +1496 @@
     }
 }
-static void TLB_DoVars(TLBContext *pcx, int cFuncs, int cVars,
-                          int offset, TLBVarDesc ** pptvd)
+static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
+                       int cVars, int offset, TLBVarDesc ** pptvd)
 {
     int infolen, nameoffset, reclength;
     char recbuf[256];
-    TLBVarRecord * pVarRec=(TLBVarRecord *) recbuf;
+    MSFT_VarRecord * pVarRec=(MSFT_VarRecord *) recbuf;
     int i;
     int recoffset;
@@ -1400 +1507 @@
     TRACE_(typelib)("\n");
 
-    TLB_Read(&infolen,sizeof(INT), pcx, offset);
-    TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen +
+    MSFT_Read(&infolen,sizeof(INT), pcx, offset);
+    MSFT_Read(&recoffset,sizeof(INT), pcx, offset + infolen + 
         ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
     recoffset += offset+sizeof(INT);
@@ -1407 +1514 @@
         *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
     /* name, eventually add to a hash table */
-        TLB_Read(&nameoffset, sizeof(INT), pcx,
+        MSFT_Read(&nameoffset, sizeof(INT), pcx, 
             offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
-        (*pptvd)->Name=TLB_ReadName(pcx, nameoffset);
+        (*pptvd)->Name=MSFT_ReadName(pcx, nameoffset);
     /* read the variable information record */
-        TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
+        MSFT_Read(&reclength, sizeof(INT), pcx, recoffset);
         reclength &=0xff;
-        TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
+        MSFT_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) ;
+            (*pptvd)->HelpString = MSFT_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,
+        MSFT_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx, 
             offset + infolen + ( i + 1) * sizeof(INT));
         (*pptvd)->vardesc.varkind = pVarRec->VarKind;
         (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
-        TLB_GetTdesc(pcx, pVarRec->DataType,
-            &(*pptvd)->vardesc.elemdescVar.tdesc) ;
+        MSFT_GetTdesc(pcx, pVarRec->DataType,    
+            &(*pptvd)->vardesc.elemdescVar.tdesc, pTI);
 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
         if(pVarRec->VarKind == VAR_CONST ){
             (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
-            TLB_ReadValue((*pptvd)->vardesc.u.lpvarValue,
+            MSFT_ReadValue((*pptvd)->vardesc.u.lpvarValue,
                 pVarRec->OffsValue, pcx);
         } else
@@ -1441 +1548 @@
 }
 /* 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 from import, its an offset+1 in the ImpInfo table
+ * in the typelib, it's just an (file) offset in the type info base dir.
+ * If comes from import, it's an offset+1 in the ImpInfo table
  * */
-static void TLB_DoRefType(TLBContext *pcx,
-                          int offset, TLBRefType ** pprtd)
+static void MSFT_DoRefType(TLBContext *pcx, ITypeInfoImpl *pTI,
+                          int offset)
 {
     int j;
+    TLBRefType **ppRefType = &pTI->reflist;
 
     TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
 
-    if(!HREFTYPE_INTHISFILE( offset)) {
+    while(*ppRefType) {
+        if((*ppRefType)->reference == offset)
+            return;
+        ppRefType = &(*ppRefType)->next;
+    }
+
+    *ppRefType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                           sizeof(**ppRefType));
+
+    if(!MSFT_HREFTYPE_INTHISFILE( offset)) {
         /* external typelib */
-        TLBImpInfo impinfo;
+        MSFT_ImpInfo impinfo;
         TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
 
         TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
 
-        TLB_Read(&impinfo, sizeof(impinfo), pcx,
+        MSFT_Read(&impinfo, sizeof(impinfo), pcx, 
             pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
         for(j=0;pImpLib;j++){   /* search the known offsets of all import libraries */
@@ -1465 +1582 @@
         }
         if(pImpLib){
-            (*pprtd)->reference=offset;
-            (*pprtd)->pImpTLInfo = pImpLib;
-            TLB_ReadGuid(&(*pprtd)->guid, impinfo.oGuid, pcx);
+            (*ppRefType)->reference=offset;
+            (*ppRefType)->pImpTLInfo = pImpLib;
+            MSFT_ReadGuid(&(*ppRefType)->guid, impinfo.oGuid, pcx);
+            (*ppRefType)->index = TLB_REF_USE_GUID;
         }else{
             ERR("Cannot find a reference\n");
-            (*pprtd)->reference=-1;
-            (*pprtd)->pImpTLInfo=(void *)-1;
+            (*ppRefType)->reference=-1;
+            (*ppRefType)->pImpTLInfo=TLB_REF_NOT_FOUND;
         }
     }else{
         /* in this typelib */
-        (*pprtd)->reference=offset;
-        (*pprtd)->pImpTLInfo=(void *)-2;
+        (*ppRefType)->index = MSFT_HREFTYPE_INDEX(offset);
+        (*ppRefType)->reference=offset;
+        (*ppRefType)->pImpTLInfo=TLB_REF_INTERNAL;
     }
 }
 
 /* process Implemented Interfaces of a com class */
-static void TLB_DoImplTypes(TLBContext *pcx, int count,
-                          int offset, TLBRefType ** pprtd)
+static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
+                            int offset)
 {
     int i;
-    TLBRefRecord refrec;
+    MSFT_RefRecord refrec;
+    TLBImplType **ppImpl = &pTI->impltypelist;
 
     TRACE_(typelib)("\n");
@@ -1491 +1611 @@
     for(i=0;i<count;i++){
         if(offset<0) break; /* paranoia */
-        *pprtd=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);
+        *ppImpl=TLB_Alloc(sizeof(**ppImpl));
+        MSFT_Read(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
+        MSFT_DoRefType(pcx, pTI, refrec.reftype); 
+        (*ppImpl)->hRef = refrec.reftype;
+        (*ppImpl)->implflags=refrec.flags;
+        (*ppImpl)->ctCustData=
+            MSFT_CustData(pcx, refrec.oCustData, &(*ppImpl)->pCustData);
         offset=refrec.onext;
-        pprtd=&((*pprtd)->next);
+        ppImpl=&((*ppImpl)->next);
     }
 }
@@ -1504 +1625 @@
  * process a typeinfo record
  */
-ITypeInfoImpl * TLB_DoTypeInfo(
+ITypeInfoImpl * MSFT_DoTypeInfo(
     TLBContext *pcx,
     int count,
     ITypeLibImpl * pLibInfo)
 {
-    TLBTypeInfoBase tiBase;
+    MSFT_TypeInfoBase tiBase;
     ITypeInfoImpl *ptiRet;
 
@@ -1515 +1636 @@
 
     ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
-    TLB_Read(&tiBase, sizeof(tiBase) ,pcx ,
+    MSFT_Read(&tiBase, sizeof(tiBase) ,pcx ,
         pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
 /* this is where we are coming from */
@@ -1523 +1644 @@
     FIXME("Assign constructor/destructor memid\n");
 
-    TLB_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
+    MSFT_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
     ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid;   /* FIXME: correct? */
     ptiRet->TypeAttr.memidConstructor=MEMBERID_NIL ;/* FIXME */
@@ -1539 +1660 @@
     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) ;
+        MSFT_GetTdesc(pcx, tiBase.datatype1, 
+            &ptiRet->TypeAttr.tdescAlias, ptiRet);
 
 /*  FIXME: */
@@ -1546 +1667 @@
 
 /* name, eventually add to a hash table */
-    ptiRet->Name=TLB_ReadName(pcx, tiBase.NameOffset);
+    ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
     TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
     /* help info */
-    ptiRet->DocString=TLB_ReadString(pcx, tiBase.docstringoffs);
+    ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
     ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
     ptiRet->dwHelpContext=tiBase.helpcontext;
@@ -1557 +1678 @@
     /* functions */
     if(ptiRet->TypeAttr.cFuncs >0 )
-        TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
-        tiBase.memoffset, & ptiRet->funclist);
+        MSFT_DoFuncs(pcx, ptiRet, 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 ){
+        MSFT_DoVars(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
+                   ptiRet->TypeAttr.cVars, 
+                   tiBase.memoffset, & ptiRet->varlist);
+    if(ptiRet->TypeAttr.cImplTypes >0 ) {
         switch(ptiRet->TypeAttr.typekind)
         {
         case TKIND_COCLASS:
-            TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes ,
-                tiBase.datatype1, & ptiRet->impltypelist);
+            MSFT_DoImplTypes(pcx, ptiRet, ptiRet->TypeAttr.cImplTypes , 
+                tiBase.datatype1);
             break;
         case TKIND_DISPATCH:
-            ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
-
+            ptiRet->impltypelist=TLB_Alloc(sizeof(TLBImplType));
+            
             if (tiBase.datatype1 != -1)
             {
-              TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
+              MSFT_DoRefType(pcx, ptiRet, tiBase.datatype1);
+              ptiRet->impltypelist->hRef = tiBase.datatype1;
             }
             else
-            {
+            { /* FIXME: This is a really bad hack to add IDispatch */
               char* szStdOle     = "stdole2.tlb\0";
               int   nStdOleLen = strlen(szStdOle);
-
-              ptiRet->impltypelist->guid             = IID_IDispatch;
-              ptiRet->impltypelist->reference        = -1;
-              ptiRet->impltypelist->pImpTLInfo       = TLB_Alloc(sizeof(TLBImpLib));
-              ptiRet->impltypelist->pImpTLInfo->guid = IID_StdOle;
-              ptiRet->impltypelist->pImpTLInfo->name = SysAllocStringLen(NULL, nStdOleLen  + 1);
-
-              MultiByteToWideChar(CP_ACP,
-                                  MB_PRECOMPOSED,
-                                  szStdOle,
-                                  -1,
-                                  ptiRet->impltypelist->pImpTLInfo->name,
-                                  SysStringLen(ptiRet->impltypelist->pImpTLInfo->name));
-
-              ptiRet->impltypelist->pImpTLInfo->lcid          = 0;
-              ptiRet->impltypelist->pImpTLInfo->wVersionMajor = 2;
-              ptiRet->impltypelist->pImpTLInfo->wVersionMinor = 0;
-            }
+              TLBRefType **ppRef = &ptiRet->reflist;
+
+              while(*ppRef) {
+                if((*ppRef)->reference == -1)
+                  break;
+                ppRef = &(*ppRef)->next;
+              }
+              if(!*ppRef) {
+                *ppRef = TLB_Alloc(sizeof(**ppRef));
+                (*ppRef)->guid             = IID_IDispatch;
+                (*ppRef)->reference        = -1;
+                (*ppRef)->index            = TLB_REF_USE_GUID;
+                (*ppRef)->pImpTLInfo       = TLB_Alloc(sizeof(TLBImpLib));
+                (*ppRef)->pImpTLInfo->guid = IID_StdOle;             
+                (*ppRef)->pImpTLInfo->name = SysAllocStringLen(NULL,
+                                                              nStdOleLen  + 1);
+              
+                MultiByteToWideChar(CP_ACP,
+                                    MB_PRECOMPOSED,
+                                    szStdOle,
+                                    -1,
+                                    (*ppRef)->pImpTLInfo->name,
+                                    SysStringLen((*ppRef)->pImpTLInfo->name));
+                                  
+                (*ppRef)->pImpTLInfo->lcid          = 0;
+                (*ppRef)->pImpTLInfo->wVersionMajor = 2;
+                (*ppRef)->pImpTLInfo->wVersionMinor = 0;
+              }
+            }
             break;
         default:
-            ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
-            TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
+            ptiRet->impltypelist=TLB_Alloc(sizeof(TLBImplType));
+            MSFT_DoRefType(pcx, ptiRet, tiBase.datatype1);
+            ptiRet->impltypelist->hRef = tiBase.datatype1;
             break;
-        }
+       }
     }
     ptiRet->ctCustData=
-        TLB_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
+        MSFT_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
 
     TRACE_(typelib)("%s guid: %s kind:%s\n",
@@ -1618 +1754 @@
 
 /****************************************************************************
- *  TLB_ReadTypeLib
+ *      TLB_ReadTypeLib
  *
  * find the type of the typelib file and map the typelib resource into
@@ -1624 +1760 @@
  */
 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
+#define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
 int TLB_ReadTypeLib(LPSTR pszFileName, ITypeLib2 **ppTypeLib)
 {
@@ -1640 +1777 @@
 
     /* is it a DLL? */
-    for (i=0 ; i < nStrLen ; ++i)
-    {
-        pszFileName[i] = tolower(pszFileName[i]);
-    }
+        for (i=0 ; i < nStrLen ; ++i)
+        {
+            pszFileName[i] = tolower(pszFileName[i]);
+        }
     pszTypeLibIndex = strstr(pszFileName, ".dll");
 
@@ -1655 +1792 @@
     if (pszTypeLibIndex && pszTypeLibIndex < pszFileName + nStrLen)
     {
-      /* yes -> it's a index! store DLL name, without the trailing back-slash */
+      /* yes -> it's an index! store DLL name, without the trailing back-slash */
       size_t nMemToAlloc = pszTypeLibIndex - pszFileName;
-
+      
       pszDllName = HeapAlloc(GetProcessHeap(),
-                          HEAP_ZERO_MEMORY,
+                          HEAP_ZERO_MEMORY, 
                           nMemToAlloc + 1);
-
+                          
       strncpy(pszDllName, pszFileName, nMemToAlloc);
-
+      
       /* move index string pointer pass the backslash */
       while (*pszTypeLibIndex == '\\')
@@ -1672 +1809 @@
       /* No index, reset variable to 1 */
       pszDllName = HeapAlloc(GetProcessHeap(),
-                          HEAP_ZERO_MEMORY,
+                          HEAP_ZERO_MEMORY, 
                           nStrLen + 1);
-
+                          
       strncpy(pszDllName, pszFileName, nStrLen);
-
+      
       pszTypeLibIndex = "1\0";
     }
@@ -1694 +1831 @@
         if(pBase)
         {
+          /* retrieve file size */
+          DWORD dwTLBLength = GetFileSize(hFile, NULL);
+
           /* first try to load as *.tlb */
           dwSignature = *((DWORD*) pBase);
           if ( dwSignature == MSFT_SIGNATURE)
           {
-                /* retrieve file size */
-                DWORD dwTLBLength = GetFileSize(hFile, NULL);
-
-            *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
+            *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
             ITypeLib2_AddRef(*ppTypeLib);
           }
+          else if ( dwSignature == SLTG_SIGNATURE)
+          {
+            *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
+            ITypeLib2_AddRef(*ppTypeLib);
+          }
           UnmapViewOfFile(pBase);
         }
@@ -1726 +1868 @@
             LPVOID pBase = LockResource(hGlobal);
             DWORD  dwTLBLength = SizeofResource(hinstDLL, hrsrc);
-
+            
             if (pBase)
             {
@@ -1733 +1875 @@
               if ( dwSignature == MSFT_SIGNATURE)
               {
-                  *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
+                  *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
                   ITypeLib2_AddRef(*ppTypeLib);
-              }
+              }
+              else if ( dwSignature == SLTG_SIGNATURE)
+              {
+                  *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
+                  ITypeLib2_AddRef(*ppTypeLib);
+              }
               else
               {
@@ -1761 +1908 @@
 
 /****************************************************************************
- *  ITypeLib2_Constructor
- *
- * loading a typelib from a in-memory image
- */
-static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength)
+ *      ITypeLib2_Constructor_MSFT
+ *
+ * loading an MSFT typelib from an in-memory image
+ */
+static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
 {
     TLBContext cx;
     long lPSegDir;
-    TLB2Header tlbHeader;
-    TLBSegDir tlbSegDir;
+    MSFT_Header tlbHeader;
+    MSFT_SegDir tlbSegDir;
     ITypeLibImpl * pTypeLibImpl;
 
@@ -1787 +1934 @@
     cx.pLibInfo = pTypeLibImpl;
     cx.length = dwTLBLength;
-
+    
     /* read header */
-    TLB_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
+    MSFT_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
     TRACE("header:\n");
     TRACE("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
     if (memcmp(&tlbHeader.magic1,TLBMAGIC2,4)) {
-    FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
-    return NULL;
-    }
-    /* there is a small number of information here until the next important
+        FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
+        return NULL;
+    }
+    /* there is a small amount of information here until the next important
      * part:
      * the segment directory . Try to calculate the amount of data */
@@ -1803 +1950 @@
     /* now read the segment directory */
     TRACE("read segment directory (at %ld)\n",lPSegDir);
-    TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
+    MSFT_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);  
     cx.pTblDir = &tlbSegDir;
 
@@ -1810 +1957 @@
     {
         ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
-    HeapFree(GetProcessHeap(),0,pTypeLibImpl);
-    return NULL;
+        HeapFree(GetProcessHeap(),0,pTypeLibImpl);
+        return NULL;
     }
 
     /* now fill our internal data */
     /* TLIBATTR fields */
-    TLB_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
+    MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
     pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;
     pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
@@ -1824 +1971 @@
 
     /* name, eventually add to a hash table */
-    pTypeLibImpl->Name = TLB_ReadName(&cx, tlbHeader.NameOffset);
+    pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
 
     /* help info */
-    pTypeLibImpl->DocString = TLB_ReadString(&cx, tlbHeader.helpstring);
-    pTypeLibImpl->HelpFile = TLB_ReadString(&cx, tlbHeader.helpfile);
+    pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
+    pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
 
     if( tlbHeader.varflags & HELPDLLFLAG)
     {
             int offset;
-            TLB_Read(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
-            pTypeLibImpl->HelpStringDll = TLB_ReadString(&cx, offset);
+            MSFT_Read(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
+            pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
     }
 
@@ -1842 +1989 @@
     if(tlbHeader.CustomDataOffset >= 0)
     {
-        pTypeLibImpl->ctCustData = TLB_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
+        pTypeLibImpl->ctCustData = MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
     }
 
@@ -1851 +1998 @@
         INT16 td[4];
         pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
-        TLB_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
+        MSFT_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
         for(i=0; i<cTD; )
-    {
+        {
             /* FIXME: add several sanity checks here */
             pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
             if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
-        {
-            /* FIXME: check safearray */
+            {
+                /* FIXME: check safearray */
                 if(td[3] < 0)
                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & stndTypeDesc[td[2]];
@@ -1864 +2011 @@
                     pTypeLibImpl->pTypeDesc[i].u.lptdesc= & pTypeLibImpl->pTypeDesc[td[2]/8];
             }
-        else if(td[0] == VT_CARRAY)
+            else if(td[0] == VT_CARRAY)
             {
-            /* array descr table here */
-            pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
+                /* array descr table here */
+                pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)((int) td[2]);  /* temp store offset in*/
             }
             else if(td[0] == VT_USERDEFINED)
-        {
+            {
                 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
             }
-        if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
+            if(++i<cTD) MSFT_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
         }
 
         /* second time around to fill the array subscript info */
         for(i=0;i<cTD;i++)
-    {
+        {
             if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
             if(tlbSegDir.pArrayDescriptions.offset>0)
-        {
-                TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
+            {
+                MSFT_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) pTypeLibImpl->pTypeDesc[i].u.lpadesc);
                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
 
@@ -1893 +2040 @@
 
                 for(j = 0; j<td[2]; j++)
-        {
-                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
+                {
+                    MSFT_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements, 
                         sizeof(INT), &cx, DO_NOT_SEEK);
-                    TLB_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
+                    MSFT_Read(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound, 
                         sizeof(INT), &cx, DO_NOT_SEEK);
                 }
             }
-        else
-        {
+            else
+            {
                 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
                 ERR("didn't find array description data\n");
@@ -1916 +2063 @@
 
         while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
-    {
+        {
             *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
             (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
-            TLB_Read(&oGuid, sizeof(INT), &cx, offset);
-
-            TLB_Read(&(*ppImpLib)->lcid,          sizeof(LCID),   &cx, DO_NOT_SEEK);
-            TLB_Read(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
-            TLB_Read(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
-            TLB_Read(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
+            MSFT_Read(&oGuid, sizeof(INT), &cx, offset);
+
+            MSFT_Read(&(*ppImpLib)->lcid,          sizeof(LCID),   &cx, DO_NOT_SEEK);
+            MSFT_Read(&(*ppImpLib)->wVersionMajor, sizeof(WORD),   &cx, DO_NOT_SEEK);
+            MSFT_Read(&(*ppImpLib)->wVersionMinor, sizeof(WORD),   &cx, DO_NOT_SEEK);
+            MSFT_Read(& size,                      sizeof(UINT16), &cx, DO_NOT_SEEK);
 
             size >>= 2;
             (*ppImpLib)->name = TLB_Alloc(size+1);
-            TLB_Read((*ppImpLib)->name, size, &cx, DO_NOT_SEEK);
-            TLB_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
+            MSFT_Read((*ppImpLib)->name, size, &cx, DO_NOT_SEEK);
+            MSFT_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
             offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & 0xfffffffc;
 
@@ -1945 +2092 @@
         for(i = 0; i<(int)tlbHeader.nrtypeinfos; i++)
         {
-            *ppTI = TLB_DoTypeInfo(&cx, i, pTypeLibImpl);
+            *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
 
             ITypeInfo_AddRef((ITypeInfo*) *ppTI);
@@ -1957 +2104 @@
 }
 
+
+static BSTR TLB_MultiByteToBSTR(char *ptr)
+{
+    DWORD len;
+    WCHAR *nameW;
+    BSTR ret;
+
+    len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
+    nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    MultiByteToWideChar(CP_ACP, 0, ptr, -1, nameW, len);
+    ret = SysAllocString(nameW);
+    HeapFree(GetProcessHeap(), 0, nameW);
+    return ret;
+}
+
+static BOOL TLB_GUIDFromString(char *str, GUID *guid)
+{
+  char b[3];
+  int i;
+  short s;
+
+  if(sscanf(str, "%lx-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
+    FIXME("Can't parse guid %s\n", debugstr_guid(guid));
+    return FALSE;
+  }
+
+  guid->Data4[0] = s >> 8;
+  guid->Data4[1] = s & 0xff;
+
+  b[2] = '\0';
+  for(i = 0; i < 6; i++) {
+    memcpy(b, str + 24 + 2 * i, 2);
+    guid->Data4[i + 2] = strtol(b, NULL, 16);
+  }
+  return TRUE;
+}
+
+static WORD SLTG_ReadString(char *ptr, BSTR *pBstr)
+{
+    WORD bytelen;
+    DWORD len;
+    WCHAR *nameW;
+
+    *pBstr = NULL;
+    bytelen = *(WORD*)ptr;
+    if(bytelen == 0xffff) return 2;
+    len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
+    nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+    len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, nameW, len);
+    *pBstr = SysAllocStringLen(nameW, len);
+    HeapFree(GetProcessHeap(), 0, nameW);
+    return bytelen + 2;
+}
+
+static WORD SLTG_ReadStringA(char *ptr, char **str)
+{
+    WORD bytelen;
+
+    *str = NULL;
+    bytelen = *(WORD*)ptr;
+    if(bytelen == 0xffff) return 2;
+    *str = HeapAlloc(GetProcessHeap(), 0, bytelen + 1);
+    memcpy(*str, ptr + 2, bytelen);
+    (*str)[bytelen] = '\0';
+    return bytelen + 2;
+}
+
+static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
+{
+    char *ptr = pLibBlk;
+    WORD w;
+
+    if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
+        FIXME("libblk magic = %04x\n", w);
+        return 0;
+    }
+
+    ptr += 6;
+    if((w = *(WORD*)ptr) != 0xffff) {
+        FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
+        ptr += w;
+    }
+    ptr += 2;
+
+    ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
+
+    ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
+
+    pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
+    ptr += 4;
+
+    pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
+    ptr += 2;
+
+    pTypeLibImpl->LibAttr.lcid = *(WORD*)ptr;
+    ptr += 2;
+
+    ptr += 4; /* skip res12 */
+
+    pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
+    ptr += 2;
+
+    pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
+    ptr += 2;
+
+    pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
+    ptr += 2;
+
+    memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
+    ptr += sizeof(GUID);
+
+    return ptr - (char*)pLibBlk;
+}
+
+static WORD *SLTG_DoType(WORD *pType, char *pBlk, ELEMDESC *pElem)
+{
+    BOOL done = FALSE;
+    TYPEDESC *pTD = &pElem->tdesc;
+
+    /* Handle [in/out] first */
+    if((*pType & 0xc000) == 0xc000)
+        pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
+    else if(*pType & 0x8000)
+        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
+    else if(*pType & 0x4000)
+        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
+    else
+        pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
+
+    if(*pType & 0x2000)
+        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
+
+    if(*pType & 0x80)
+        pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
+
+    while(!done) {
+        if((*pType & 0xe00) == 0xe00) {
+            pTD->vt = VT_PTR;
+            pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                       sizeof(TYPEDESC));
+            pTD = pTD->u.lptdesc;
+        }
+        switch(*pType & 0x7f) {
+        case VT_PTR:
+            pTD->vt = VT_PTR;
+            pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                       sizeof(TYPEDESC));
+            pTD = pTD->u.lptdesc;
+            break;
+
+        case VT_USERDEFINED:
+            pTD->vt = VT_USERDEFINED;
+            pTD->u.hreftype = *(++pType) / 4;
+            done = TRUE;
+            break;
+
+        case VT_CARRAY:
+          {
+            /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
+               array */
+
+            SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
+
+            pTD->vt = VT_CARRAY;
+            pTD->u.lpadesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                sizeof(ARRAYDESC) +
+                                (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
+            pTD->u.lpadesc->cDims = pSA->cDims;
+            memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
+                   pSA->cDims * sizeof(SAFEARRAYBOUND));
+
+            pTD = &pTD->u.lpadesc->tdescElem;
+            break;
+          }
+
+        case VT_SAFEARRAY:
+          {
+            /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
+               useful? */
+
+            pType++;
+            pTD->vt = VT_SAFEARRAY;
+            pTD->u.lptdesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                       sizeof(TYPEDESC));
+            pTD = pTD->u.lptdesc;
+            break;
+          }
+        default:
+            pTD->vt = *pType & 0x7f;
+            done = TRUE;
+            break;
+        }
+        pType++;
+    }
+    return pType;
+}
+
+
+static void SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeInfoImpl *pTI,
+                        char *pNameTable)
+{
+    int ref;
+    char *name;
+    TLBRefType **ppRefType;
+
+    if(pRef->magic != SLTG_REF_MAGIC) {
+        FIXME("Ref magic = %x\n", pRef->magic);
+        return;
+    }
+    name = ( (char*)(&pRef->names) + pRef->number);
+
+    ppRefType = &pTI->reflist;
+    for(ref = 0; ref < pRef->number >> 3; ref++) {
+        char *refname;
+        unsigned int lib_offs, type_num;
+
+        *ppRefType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                               sizeof(**ppRefType));
+
+        name += SLTG_ReadStringA(name, &refname);
+        if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
+            FIXME("Can't sscanf ref\n");
+        if(lib_offs != 0xffff) {
+            TLBImpLib **import = &pTI->pTypeLib->pImpLibs;
+
+            while(*import) {
+                if((*import)->offset == lib_offs)
+                    break;
+                import = &(*import)->next;
+            }
+            if(!*import) {
+                char fname[MAX_PATH+1];
+                int len;
+
+                *import = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                    sizeof(**import));
+                (*import)->offset = lib_offs;
+                TLB_GUIDFromString( pNameTable + lib_offs + 4,
+                                    &(*import)->guid);
+                if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%lx#%s",
+                          &(*import)->wVersionMajor,
+                          &(*import)->wVersionMinor,
+                          &(*import)->lcid, fname) != 4) {
+                  FIXME("can't sscanf ref %s\n",
+                        pNameTable + lib_offs + 40);
+                }
+                len = strlen(fname);
+                if(fname[len-1] != '#')
+                    FIXME("fname = %s\n", fname);
+                fname[len-1] = '\0';
+                (*import)->name = TLB_MultiByteToBSTR(fname);
+            }
+            (*ppRefType)->pImpTLInfo = *import;
+        } else { /* internal ref */
+          (*ppRefType)->pImpTLInfo = TLB_REF_INTERNAL;
+        }
+        (*ppRefType)->reference = ref;
+        (*ppRefType)->index = type_num;
+
+        HeapFree(GetProcessHeap(), 0, refname);
+        ppRefType = &(*ppRefType)->next;
+    }
+    if((BYTE)*name != SLTG_REF_MAGIC)
+      FIXME("End of ref block magic = %x\n", *name);
+    dump_TLBRefType(pTI->reflist);
+}
+
+static char *SLTG_DoImpls(SLTG_ImplInfo *info, ITypeInfoImpl *pTI,
+                          BOOL OneOnly)
+{
+    TLBImplType **ppImplType = &pTI->impltypelist;
+
+    while(1) {
+        *ppImplType = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                sizeof(**ppImplType));
+        (*ppImplType)->hRef = info->ref;
+        (*ppImplType)->implflags = info->impltypeflags;
+        pTI->TypeAttr.cImplTypes++;
+        ppImplType = &(*ppImplType)->next;
+
+        if(info->next == 0xffff)
+            break;
+        if(OneOnly)
+            FIXME("Interface inheriting more than one interface\n");
+        info++;
+    }
+    info++;
+    return (char*)info;
+}
+
+static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
+                                char *pNameTable)
+{
+    SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
+    SLTG_MemberHeader *pMemHeader;
+    char *pFirstItem, *pNextItem;
+
+    if(pTIHeader->href_table != 0xffffffff) {
+        SLTG_DoRefs((SLTG_RefInfo*)(pBlk + pTIHeader->href_table), pTI,
+                    pNameTable);
+    }
+
+
+    pMemHeader = (SLTG_MemberHeader*)(pBlk + pTIHeader->elem_table);
+
+    pFirstItem = pNextItem = (char*)(pMemHeader + 1);
+
+    if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
+        pNextItem = SLTG_DoImpls((SLTG_ImplInfo*)pFirstItem, pTI, FALSE);
+    }
+
+    return;
+}
+
+
+static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
+                                  char *pNameTable)
+{
+    SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
+    SLTG_MemberHeader *pMemHeader;
+    SLTG_Function *pFunc;
+    char *pFirstItem, *pNextItem;
+    TLBFuncDesc **ppFuncDesc = &pTI->funclist;
+    int num = 0;
+
+    if(pTIHeader->href_table != 0xffffffff) {
+        SLTG_DoRefs((SLTG_RefInfo*)(pBlk + pTIHeader->href_table), pTI,
+                    pNameTable);
+    }
+
+    pMemHeader = (SLTG_MemberHeader*)(pBlk + pTIHeader->elem_table);
+
+    pFirstItem = pNextItem = (char*)(pMemHeader + 1);
+
+    if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
+        pNextItem = SLTG_DoImpls((SLTG_ImplInfo*)pFirstItem, pTI, TRUE);
+    }
+
+    for(pFunc = (SLTG_Function*)pNextItem, num = 1; 1;
+        pFunc = (SLTG_Function*)(pFirstItem + pFunc->next), num++) {
+
+        int param;
+        WORD *pType, *pArg;
+
+        if(pFunc->magic != SLTG_FUNCTION_MAGIC &&
+           pFunc->magic != SLTG_FUNCTION_WITH_FLAGS_MAGIC) {
+            FIXME("func magic = %02x\n", pFunc->magic);
+            return;
+        }
+        *ppFuncDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                sizeof(**ppFuncDesc));
+        (*ppFuncDesc)->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
+
+        (*ppFuncDesc)->funcdesc.memid = pFunc->dispid;
+        (*ppFuncDesc)->funcdesc.invkind = pFunc->inv >> 4;
+        (*ppFuncDesc)->funcdesc.callconv = pFunc->nacc & 0x7;
+        (*ppFuncDesc)->funcdesc.cParams = pFunc->nacc >> 3;
+        (*ppFuncDesc)->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
+        (*ppFuncDesc)->funcdesc.oVft = pFunc->vtblpos;
+
+        if(pFunc->magic == SLTG_FUNCTION_WITH_FLAGS_MAGIC)
+            (*ppFuncDesc)->funcdesc.wFuncFlags = pFunc->funcflags;
+
+        if(pFunc->retnextopt & 0x80)
+            pType = &pFunc->rettype;
+        else
+            pType = (WORD*)(pFirstItem + pFunc->rettype);
+
+
+        SLTG_DoType(pType, pFirstItem, &(*ppFuncDesc)->funcdesc.elemdescFunc);
+
+        (*ppFuncDesc)->funcdesc.lprgelemdescParam =
+          HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                    (*ppFuncDesc)->funcdesc.cParams * sizeof(ELEMDESC));
+        (*ppFuncDesc)->pParamDesc =
+          HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                    (*ppFuncDesc)->funcdesc.cParams * sizeof(TLBParDesc));
+
+        pArg = (WORD*)(pFirstItem + pFunc->arg_off);
+
+        for(param = 0; param < (*ppFuncDesc)->funcdesc.cParams; param++) {
+            char *paramName = pNameTable + *pArg;
+            /* right, if the arg type follows then paramName points to the 2nd
+               letter of the name (or there is no name), else if the next
+               WORD is an offset to the arg type then paramName points to the
+               first letter. Before the name there always seems to be the byte
+               0xff or 0x00, so let's take one char off paramName and see what
+               we're pointing at.  Got that? */
+
+            if(*pArg == 0xffff) /* If we don't have a name the type seems to
+                                   always follow.  FIXME is this correct? */
+              paramName = NULL;
+
+            pArg++;
+
+            if(paramName &&
+               (*(paramName-1) == '\xff' ||
+                *(paramName-1) == '\x00')) { /* the next word is an offset to
+                                              the type */
+                pType = (WORD*)(pFirstItem + *pArg);
+                SLTG_DoType(pType, pFirstItem,
+                            &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param]);
+                pArg++;
+            } else {
+                if(paramName)
+                  paramName--;
+                pArg = SLTG_DoType(pArg, pFirstItem,
+                           &(*ppFuncDesc)->funcdesc.lprgelemdescParam[param]);
+            }
+
+            /* Are we an optional param ? */
+            if((*ppFuncDesc)->funcdesc.cParams - param <=
+               (*ppFuncDesc)->funcdesc.cParamsOpt)
+              (*ppFuncDesc)->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
+
+            if(paramName) {
+                (*ppFuncDesc)->pParamDesc[param].Name =
+                  TLB_MultiByteToBSTR(paramName);
+            }
+        }
+        
+        ppFuncDesc = &((*ppFuncDesc)->next);
+        if(pFunc->next == 0xffff) break;
+    }
+    pTI->TypeAttr.cFuncs = num;
+    dump_TLBFuncDesc(pTI->funclist);
+}
+
+static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable)
+{
+  SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
+  SLTG_MemberHeader *pMemHeader;
+  SLTG_RecordItem *pItem;
+  char *pFirstItem;
+  TLBVarDesc **ppVarDesc = &pTI->varlist;
+  int num = 0;
+  WORD *pType;
+  char buf[300];
+
+  pMemHeader = (SLTG_MemberHeader*)(pBlk + pTIHeader->elem_table);
+
+  pFirstItem = (char*)(pMemHeader + 1);
+  for(pItem = (SLTG_RecordItem *)pFirstItem, num = 1; 1;
+      pItem = (SLTG_RecordItem *)(pFirstItem + pItem->next), num++) {
+      if(pItem->magic != SLTG_RECORD_MAGIC) {
+          FIXME("record magic = %02x\n", pItem->magic);
+          return;
+      }
+      *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                             sizeof(**ppVarDesc));
+      (*ppVarDesc)->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
+      (*ppVarDesc)->vardesc.memid = pItem->memid;
+      (*ppVarDesc)->vardesc.u.oInst = pItem->byte_offs;
+      (*ppVarDesc)->vardesc.varkind = VAR_PERINSTANCE;
+
+      if(pItem->typepos == 0x02)
+          pType = &pItem->type;
+      else if(pItem->typepos == 0x00)
+          pType = (WORD*)(pFirstItem + pItem->type);
+      else {
+          FIXME("typepos = %02x\n", pItem->typepos);
+          break;
+      }
+
+      SLTG_DoType(pType, pFirstItem,
+                  &(*ppVarDesc)->vardesc.elemdescVar);
+
+      /* FIXME("helpcontext, helpstring\n"); */
+
+      dump_TypeDesc(&(*ppVarDesc)->vardesc.elemdescVar.tdesc, buf);
+
+      ppVarDesc = &((*ppVarDesc)->next);
+      if(pItem->next == 0xffff) break;
+  }
+  pTI->TypeAttr.cVars = num;
+}
+
+static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable)
+{
+  SLTG_TypeInfoHeader *pTIHeader = (SLTG_TypeInfoHeader*)pBlk;
+  SLTG_MemberHeader *pMemHeader;
+  SLTG_EnumItem *pItem;
+  char *pFirstItem;
+  TLBVarDesc **ppVarDesc = &pTI->varlist;
+  int num = 0;
+
+  pMemHeader = (SLTG_MemberHeader*)(pBlk + pTIHeader->elem_table);
+
+  pFirstItem = (char*)(pMemHeader + 1);
+  for(pItem = (SLTG_EnumItem *)pFirstItem, num = 1; 1;
+      pItem = (SLTG_EnumItem *)(pFirstItem + pItem->next), num++) {
+      if(pItem->magic != SLTG_ENUMITEM_MAGIC) {
+          FIXME("enumitem magic = %04x\n", pItem->magic);
+          return;
+      }
+      *ppVarDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                             sizeof(**ppVarDesc));
+      (*ppVarDesc)->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
+      (*ppVarDesc)->vardesc.memid = pItem->memid;
+      (*ppVarDesc)->vardesc.u.lpvarValue = HeapAlloc(GetProcessHeap(), 0,
+                                                     sizeof(VARIANT));
+      V_VT((*ppVarDesc)->vardesc.u.lpvarValue) = VT_INT;
+      V_UNION((*ppVarDesc)->vardesc.u.lpvarValue, intVal) =
+        *(INT*)(pItem->value + pFirstItem);
+      (*ppVarDesc)->vardesc.elemdescVar.tdesc.vt = VT_I4;
+      (*ppVarDesc)->vardesc.varkind = VAR_CONST;
+      /* FIXME("helpcontext, helpstring\n"); */
+
+      ppVarDesc = &((*ppVarDesc)->next);
+      if(pItem->next == 0xffff) break;
+  }
+  pTI->TypeAttr.cVars = num;
+}
+
+/* Because SLTG_OtherTypeInfo is such a painfull struct, we make a more
+   managable copy of it into this */
+typedef struct {
+  WORD small_no;
+  char *index_name;
+  char *other_name;
+  WORD res1a;
+  WORD name_offs;
+  WORD more_bytes;
+  char *extra;
+  WORD res20;
+  DWORD helpcontext;
+  WORD res26;
+  GUID uuid;
+} SLTG_InternalOtherTypeInfo;
+
+/****************************************************************************
+ *      ITypeLib2_Constructor_SLTG
+ *
+ * loading a SLTG typelib from an in-memory image
+ */
+static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
+{
+    ITypeLibImpl *pTypeLibImpl;
+    SLTG_Header *pHeader;
+    SLTG_BlkEntry *pBlkEntry;
+    SLTG_Magic *pMagic;
+    SLTG_Index *pIndex;
+    SLTG_Pad9 *pPad9;
+    LPVOID pBlk, pFirstBlk;
+    SLTG_LibBlk *pLibBlk;
+    SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
+    char *pAfterOTIBlks = NULL;
+    char *pNameTable, *ptr;
+    int i;
+    DWORD len, order;
+    ITypeInfoImpl **ppTypeInfoImpl;
+
+    TRACE("%p, TLB length = %ld\n", pLib, dwTLBLength);
+
+    pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
+    if (!pTypeLibImpl) return NULL;
+
+    ICOM_VTBL(pTypeLibImpl) = &tlbvt;
+    pTypeLibImpl->ref = 1;
+
+    pHeader = pLib;
+    
+    TRACE("header:\n");
+    TRACE("\tmagic=0x%08lx, file blocks = %d\n", pHeader->SLTG_magic,
+          pHeader->nrOfFileBlks );
+    if (memcmp(&pHeader->SLTG_magic, TLBMAGIC1, 4)) {
+        FIXME("Header type magic 0x%08lx not supported.\n",
+              pHeader->SLTG_magic);
+        return NULL;
+    }
+    
+    /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
+    pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
+
+    /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
+    pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
+
+    /* Next we have a magic block */
+    pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
+
+    /* Let's see if we're still in sync */
+    if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
+              sizeof(SLTG_COMPOBJ_MAGIC))) {
+        FIXME("CompObj magic = %s\n", pMagic->CompObj_magic);
+        return NULL;
+    }
+    if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
+              sizeof(SLTG_DIR_MAGIC))) {
+        FIXME("dir magic = %s\n", pMagic->dir_magic);
+        return NULL;
+    }
+
+    pIndex = (SLTG_Index*)(pMagic+1);
+
+    pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
+
+    pFirstBlk = (LPVOID)(pPad9 + 1);
+
+    /* We'll set up a ptr to the main library block, which is the last one. */
+
+    for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
+          pBlkEntry[order].next != 0;
+          order = pBlkEntry[order].next - 1, i++) {
+#ifdef __WIN32OS2__
+        pBlk = (LPBYTE)pBlk + pBlkEntry[order].len;
+#else
+        pBlk += pBlkEntry[order].len;
+#endif
+    }
+    pLibBlk = pBlk;
+
+    len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
+
+    /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
+       interspersed */
+
+    len += 0x40;
+
+    /* And now TypeInfoCount of SLTG_OtherTypeInfo */
+
+    pOtherTypeInfoBlks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+                                   sizeof(*pOtherTypeInfoBlks) *
+                                   pTypeLibImpl->TypeInfoCount);
+
+
+    ptr = (char*)pLibBlk + len;
+    
+    for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
+        WORD w, extra;
+        len = 0;
+
+        pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
+
+        w = *(WORD*)(ptr + 2);
+        if(w != 0xffff) {
+            len += w;
+            pOtherTypeInfoBlks[i].index_name = HeapAlloc(GetProcessHeap(),0,
+                                                         w+1);
+            memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
+            pOtherTypeInfoBlks[i].index_name[w] = '\0';
+        }
+        w = *(WORD*)(ptr + 4 + len);
+        if(w != 0xffff) {
+            TRACE("\twith %s\n", debugstr_an(ptr + 6 + len, w));
+            len += w;
+            pOtherTypeInfoBlks[i].other_name = HeapAlloc(GetProcessHeap(),0,
+                                                         w+1);
+            memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
+            pOtherTypeInfoBlks[i].other_name[w] = '\0';
+        }
+        pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
+        pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
+        extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
+        if(extra) {
+            pOtherTypeInfoBlks[i].extra = HeapAlloc(GetProcessHeap(),0,
+                                                    extra);
+            memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
+            len += extra;
+        }
+        pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
+        pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
+        pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
+        memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
+        len += sizeof(SLTG_OtherTypeInfo);
+        ptr += len;
+    }
+
+    pAfterOTIBlks = ptr;
+
+    /* Skip this WORD and get the next DWORD */
+    len = *(DWORD*)(pAfterOTIBlks + 2);
+
+    /* Now add this to pLibBLk and then add 0x216, sprinkle a bit a
+       magic dust and we should be pointing at the beginning of the name
+       table */
+
+    pNameTable = (char*)pLibBlk + len + 0x216;
+    
+    pNameTable += 2;
+
+    TRACE("Library name is %s\n", pNameTable + pLibBlk->name);
+
+    pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
+
+
+    /* Hopefully we now have enough ptrs set up to actually read in
+       some TypeInfos.  It's not clear which order to do them in, so
+       I'll just follow the links along the BlkEntry chain and read
+       them in in the order in which they're in the file */
+
+    ppTypeInfoImpl = &(pTypeLibImpl->pTypeInfo);
+
+    for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
+        pBlkEntry[order].next != 0;
+        order = pBlkEntry[order].next - 1, i++) {
+
+      SLTG_TypeInfoHeader *pTIHeader;
+
+      if(strcmp(pBlkEntry[order].index_string + (char*)pMagic,
+                pOtherTypeInfoBlks[i].index_name)) {
+        FIXME("Index strings don't match\n");
+        return NULL;
+      }
+
+      pTIHeader = pBlk;
+      if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
+        FIXME("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
+        return NULL;
+      }
+      *ppTypeInfoImpl = (ITypeInfoImpl*)ITypeInfo_Constructor();
+      (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
+      (*ppTypeInfoImpl)->index = i;
+      (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
+                                             pOtherTypeInfoBlks[i].name_offs +
+                                             pNameTable);
+      (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
+      memcpy(&((*ppTypeInfoImpl)->TypeAttr.guid), &pOtherTypeInfoBlks[i].uuid,
+             sizeof(GUID));
+      (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
+      (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
+      (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
+      (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
+        (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
+      
+      if((pTIHeader->typeflags1 & 7) != 2)
+        FIXME("typeflags1 = %02x\n", pTIHeader->typeflags1);
+      if(pTIHeader->typeflags3 != 2)
+        FIXME("typeflags3 = %02x\n", pTIHeader->typeflags3);
+
+      TRACE("TypeInfo %s of kind %s guid %s typeflags %04x\n",
+            debugstr_w((*ppTypeInfoImpl)->Name),
+            typekind_desc[pTIHeader->typekind],
+            debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
+            (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
+
+      switch(pTIHeader->typekind) {
+      case TKIND_ENUM:
+        SLTG_ProcessEnum(pBlk, *ppTypeInfoImpl, pNameTable); 
+        break;
+
+      case TKIND_RECORD:
+        SLTG_ProcessRecord(pBlk, *ppTypeInfoImpl, pNameTable); 
+        break;
+
+      case TKIND_INTERFACE:
+        SLTG_ProcessInterface(pBlk, *ppTypeInfoImpl, pNameTable);
+        break;
+
+      case TKIND_COCLASS:
+        SLTG_ProcessCoClass(pBlk, *ppTypeInfoImpl, pNameTable);
+        break;
+
+      default:
+        FIXME("Not processing typekind %d\n", pTIHeader->typekind);
+        break;
+
+      }
+
+      ppTypeInfoImpl = &((*ppTypeInfoImpl)->next);
+#ifdef __WIN32OS2__
+      pBlk = (LPBYTE)pBlk + pBlkEntry[order].len;
+#else
+      pBlk += pBlkEntry[order].len;
+#endif
+    }
+
+    if(i != pTypeLibImpl->TypeInfoCount) {
+      FIXME("Somehow processed %d TypeInfos\n", i);
+      return NULL;
+    }
+
+    HeapFree(GetProcessHeap(), 0, pOtherTypeInfoBlks);
+    return (ITypeLib2*)pTypeLibImpl;
+}
+
 /* ITypeLib::QueryInterface
  */
 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
-    ITypeLib2 * iface,
-    REFIID riid,
-    VOID **ppvObject)
+        ITypeLib2 * iface,
+        REFIID riid,
+        VOID **ppvObject)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -1969 +2891 @@
 
     *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) ||
+    if(IsEqualIID(riid, &IID_IUnknown) || 
        IsEqualIID(riid,&IID_ITypeLib)||
        IsEqualIID(riid,&IID_ITypeLib2))
@@ -2004 +2926 @@
 
     --(This->ref);
-
+    
     TRACE("(%p)->(%u)\n",This, This->ref);
 
@@ -2036 +2958 @@
           This->HelpStringDll = NULL;
       }
-
+    
       ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
       HeapFree(GetProcessHeap(),0,This);
@@ -2046 +2968 @@
 
 /* ITypeLib::GetTypeInfoCount
- *
+ * 
  * Returns the number of type descriptions in the type library
  */
@@ -2062 +2984 @@
 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
     ITypeLib2 *iface,
-    UINT index,
+    UINT index, 
     ITypeInfo **ppTInfo)
 {
     int i;
-
+    
     ICOM_THIS( ITypeLibImpl, iface);
     ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
@@ -2073 +2995 @@
 
     if (!ppTInfo) return E_INVALIDARG;
-
+    
     /* search element n in list */
     for(i=0; i < index; i++)
@@ -2083 +3005 @@
         return TYPE_E_ELEMENTNOTFOUND;
       }
-    }
+    }   
 
     *ppTInfo = (ITypeInfo *) pTypeInfo;
-
+    
     ITypeInfo_AddRef(*ppTInfo);
     TRACE("-- found (%p)\n",*ppTInfo);
@@ -2109 +3031 @@
 
     if(!pTKind) return E_INVALIDARG;
-
+    
     /* search element n in list */
     for(i=0; i < index; i++)
@@ -2156 +3078 @@
     }
 
-    TRACE("-- found (%p, %s)\n",
-          pTypeInfo,
+    TRACE("-- found (%p, %s)\n", 
+          pTypeInfo, 
           debugstr_w(pTypeInfo->Name));
 
@@ -2171 +3093 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
-    ITypeLib2 *iface,
-    LPTLIBATTR *ppTLibAttr)
+        ITypeLib2 *iface, 
+        LPTLIBATTR *ppTLibAttr)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2188 +3110 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
-    ITypeLib2 *iface,
-    ITypeComp **ppTComp)
+        ITypeLib2 *iface,
+        ITypeComp **ppTComp)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2208 +3130 @@
     BSTR *pBstrName,
     BSTR *pBstrDocString,
-    DWORD *pdwHelpContext,
+    DWORD *pdwHelpContext, 
     BSTR *pBstrHelpFile)
 {
     ICOM_THIS( ITypeLibImpl, iface);
-
+    
     HRESULT result = E_INVALIDARG;
-
+    
     ITypeInfo *pTInfo;
 
-
+   
     TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
         This, index,
-        pBstrName, pBstrDocString,
+        pBstrName, pBstrDocString, 
         pdwHelpContext, pBstrHelpFile);
-
+   
     if(index<0)
-    {
+    { 
        /* documentation for the typelib */
        if(pBstrName && This->Name)
@@ -2238 +3160 @@
            if (!(*pBstrDocString)) return STG_E_INSUFFICIENTMEMORY;
        }
-
+    
        if(pdwHelpContext)
        {
@@ -2252 +3174 @@
        result = S_OK;
     }
-    else
+    else 
     {
         /* for a typeinfo */
@@ -2259 +3181 @@
         if(SUCCEEDED(result))
         {
-            result = ITypeInfo_GetDocumentation(pTInfo,
-                                          MEMBERID_NIL,
+            result = ITypeInfo_GetDocumentation(pTInfo, 
+                                          MEMBERID_NIL,  
                                           pBstrName,
-                                          pBstrDocString,
+                                          pBstrDocString, 
                                           pdwHelpContext, pBstrHelpFile);
-
+            
             ITypeInfo_Release(pTInfo);
         }
@@ -2278 +3200 @@
  */
 static HRESULT WINAPI ITypeLib2_fnIsName(
-    ITypeLib2 *iface,
-    LPOLESTR szNameBuf,
-    ULONG lHashVal,
-    BOOL *pfName)
+        ITypeLib2 *iface,
+        LPOLESTR szNameBuf,
+        ULONG lHashVal,
+        BOOL *pfName)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2291 +3213 @@
 
     TRACE("(%p)->(%s,%08lx,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
-      pfName);
+          pfName);
 
     *pfName=TRUE;
@@ -2304 +3226 @@
         for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
             if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
-
+       
     }
     *pfName=FALSE;
@@ -2311 +3233 @@
     TRACE("(%p)slow! search for %s: %s found!\n", This,
           debugstr_w(szNameBuf), *pfName?"NOT":"");
-
+    
     return S_OK;
 }
@@ -2322 +3244 @@
  */
 static HRESULT WINAPI ITypeLib2_fnFindName(
-    ITypeLib2 *iface,
-    LPOLESTR szNameBuf,
-    ULONG lHashVal,
-    ITypeInfo **ppTInfo,
-    MEMBERID *rgMemId,
-    UINT16 *pcFound)
+        ITypeLib2 *iface,
+        LPOLESTR szNameBuf,
+        ULONG lHashVal,
+        ITypeInfo **ppTInfo,
+        MEMBERID *rgMemId,
+        UINT16 *pcFound)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2334 +3256 @@
     TLBVarDesc *pVInfo;
     int i,j = 0;
-
+   
     UINT nNameBufLen = SysStringLen(szNameBuf);
 
@@ -2357 +3279 @@
 
     *pcFound=j;
-
+    
     return S_OK;
 }
@@ -2367 +3289 @@
  */
 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
-    ITypeLib2 *iface,
-    TLIBATTR *pTLibAttr)
+        ITypeLib2 *iface,
+        TLIBATTR *pTLibAttr)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2380 +3302 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetCustData(
-    ITypeLib2 * iface,
-    REFGUID guid,
+        ITypeLib2 * iface,
+        REFGUID guid, 
         VARIANT *pVarVal)
 {
@@ -2391 +3313 @@
       if( IsEqualIID(guid, &pCData->guid)) break;
     }
-
+    
     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
 
@@ -2410 +3332 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
-    ITypeLib2 * iface,
+        ITypeLib2 * iface, 
         ULONG *pcUniqueNames,
-    ULONG *pcchUniqueNames)
+        ULONG *pcchUniqueNames)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2431 +3353 @@
  */
 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
-    ITypeLib2 * iface,
+        ITypeLib2 * iface, 
         INT index,
-    LCID lcid,
-    BSTR *pbstrHelpString,
+        LCID lcid,
+        BSTR *pbstrHelpString,
         DWORD *pdwHelpStringContext,
-    BSTR *pbstrHelpStringDll)
+        BSTR *pbstrHelpStringDll)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2464 +3386 @@
       /* for a typeinfo */
       result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
-
+      
       if(SUCCEEDED(result))
-      {
+      { 
         ITypeInfo2 * pTInfo2;
-        result = ITypeInfo_QueryInterface(pTInfo,
-                                          &IID_ITypeInfo2,
+        result = ITypeInfo_QueryInterface(pTInfo, 
+                                          &IID_ITypeInfo2, 
                                           (LPVOID*) &pTInfo2);
 
         if(SUCCEEDED(result))
         {
-          result = ITypeInfo2_GetDocumentation2(pTInfo2,
-                                           MEMBERID_NIL,
+          result = ITypeInfo2_GetDocumentation2(pTInfo2, 
+                                           MEMBERID_NIL, 
                                            lcid,
-                                           pbstrHelpString,
-                                           pdwHelpStringContext,
+                                           pbstrHelpString, 
+                                           pdwHelpStringContext, 
                                            pbstrHelpStringDll);
-
+  
           ITypeInfo2_Release(pTInfo2);
         }
-
+            
         ITypeInfo_Release(pTInfo);
       }
@@ -2492 +3414 @@
 /* ITypeLib2::GetAllCustData
  *
- * Gets all custom data items for the library.
+ * Gets all custom data items for the library. 
  *
  */
 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
-    ITypeLib2 * iface,
+        ITypeLib2 * iface,
         CUSTDATA *pCustData)
 {
@@ -2502 +3424 @@
     TLBCustData *pCData;
     int i;
-    TRACE("(%p) returning %d items\n", This, This->ctCustData);
+    TRACE("(%p) returning %d items\n", This, This->ctCustData); 
     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
     if(pCustData->prgCustData ){
@@ -2557 +3479 @@
  */
 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
-    ITypeInfo2 *iface,
-    REFIID riid,
-    VOID **ppvObject)
+        ITypeInfo2 *iface,
+        REFIID riid,
+        VOID **ppvObject)
 {
     ICOM_THIS( ITypeLibImpl, iface);
@@ -2566 +3488 @@
 
     *ppvObject=NULL;
-    if(IsEqualIID(riid, &IID_IUnknown) ||
+    if(IsEqualIID(riid, &IID_IUnknown) || 
             IsEqualIID(riid,&IID_ITypeInfo)||
             IsEqualIID(riid,&IID_ITypeInfo2))
@@ -2599 +3521 @@
 
     --(This->ref);
-
+    
     TRACE("(%p)->(%u)\n",This, This->ref);
 
@@ -2606 +3528 @@
       FIXME("destroy child objects\n");
 
-      TRACE("destroying ITypeInfo(%p)\n",This);
+      TRACE("destroying ITypeInfo(%p)\n",This); 
       if (This->Name)
       {
@@ -2612 +3534 @@
           This->Name = 0;
       }
-
+      
       if (This->DocString)
       {
@@ -2671 +3593 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     int i;
-    TLBFuncDesc * pFDesc;
+    TLBFuncDesc * pFDesc; 
     TRACE("(%p) index %d\n", This, index);
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
@@ -2685 +3607 @@
 /* ITypeInfo::GetVarDesc
  *
- * Retrieves a VARDESC structure that describes the specified variable.
+ * Retrieves a VARDESC structure that describes the specified variable. 
  *
  */
@@ -2693 +3615 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     int i;
-    TLBVarDesc * pVDesc;
+    TLBVarDesc * pVDesc; 
     TRACE("(%p) index %d\n", This, index);
     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
@@ -2715 +3637 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
+    TLBFuncDesc * pFDesc; 
+    TLBVarDesc * pVDesc; 
     int i;
     TRACE("(%p) memid=0x%08lx Maxname=%d\n", This, memid, cMaxNames);
@@ -2726 +3648 @@
       {
         if(!i)
-          *rgBstrNames=SysAllocString(pFDesc->Name);
+          *rgBstrNames=SysAllocString(pFDesc->Name);
         else
           rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
@@ -2747 +3669 @@
           ITypeInfo *pTInfo;
           HRESULT result;
-          result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->reference, &pTInfo);
+          result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->hRef,
+                                          &pTInfo);
           if(SUCCEEDED(result))
-      {
+          {
             result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
             ITypeInfo_Release(pTInfo);
@@ -2757 +3680 @@
         }
         else
-    {
+        {
           WARN("no names found\n");
-    }
+        }
         *pcNames=0;
         return TYPE_E_ELEMENTNOTFOUND;
@@ -2777 +3700 @@
  */
 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
-    ITypeInfo2 *iface,
+        ITypeInfo2 *iface,
         UINT index,
-    HREFTYPE  *pRefType)
+        HREFTYPE  *pRefType)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     int(i);
-    TLBRefType *pIref = This->impltypelist;
+    TLBImplType *pImpl = This->impltypelist;
 
     TRACE("(%p) index %d\n", This, index);
@@ -2794 +3717 @@
       */
       if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
-
+      
       if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
           This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
@@ -2802 +3725 @@
       else
       {
-        if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
-        *pRefType = pIref->reference;
+        if (!pImpl) return TYPE_E_ELEMENTNOTFOUND;
+        *pRefType = pImpl->hRef;
       }
     }
@@ -2809 +3732 @@
     {
       /* get element n from linked list */
-      for(i=0; pIref && i<index; i++)
+      for(i=0; pImpl && i<index; i++)
       {
-        pIref = pIref->next;
+        pImpl = pImpl->next;
       }
-
-      if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
-
-      *pRefType = pIref->reference;
-
-      TRACE("-- 0x%08lx %s\n",pIref->reference, debugstr_guid(&pIref->guid) );
-    }
-
+      
+      if (!pImpl) return TYPE_E_ELEMENTNOTFOUND;
+      
+      *pRefType = pImpl->hRef;
+      
+      TRACE("-- 0x%08lx\n", pImpl->hRef );
+    }
+    
     return S_OK;
-
+   
 }
 
 /* ITypeInfo::GetImplTypeFlags
- *
- * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
+ * 
+ * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface 
  * or base interface in a type description.
  */
@@ -2834 +3757 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    int(i);
-    TLBRefType *pIref;
+    int i;
+    TLBImplType *pImpl;
+
     TRACE("(%p) index %d\n", This, index);
-    for(i=0, pIref=This->impltypelist; i<index && pIref; i++, pIref=pIref->next)
+    for(i=0, pImpl=This->impltypelist; i<index && pImpl;
+        i++, pImpl=pImpl->next)
         ;
-    if(i==index && pIref){
-        *pImplTypeFlags=pIref->flags;
+    if(i==index && pImpl){
+        *pImplTypeFlags=pImpl->implflags;
         return S_OK;
     }
@@ -2855 +3780 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
+    TLBFuncDesc * pFDesc; 
+    TLBVarDesc * pVDesc; 
     HRESULT ret=S_OK;
-    UINT nNameLen = SysStringLen(*rgszNames);
-
+        UINT nNameLen = SysStringLen(*rgszNames);
+        
     TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
             cNames);
@@ -2867 +3792 @@
             if(cNames) *pMemId=pFDesc->funcdesc.memid;
             for(i=1; i < cNames; i++){
-                UINT nParamLen = SysStringLen(rgszNames[i]);
+                                UINT nParamLen = SysStringLen(rgszNames[i]);
                 for(j=0; j<pFDesc->funcdesc.cParams; j++)
                     if(memcmp(rgszNames[i],pFDesc->pParamDesc[j].Name, nParamLen))
@@ -2878 +3803 @@
             return ret;
         }
-    }
+    }   
     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
         if( !memcmp(*rgszNames, pVDesc->Name, nNameLen)) {
@@ -2885 +3810 @@
         }
     }
-    /* not found, see if this is and interface with an inheritance */
-    if(This->TypeAttr.typekind==TKIND_INTERFACE &&
+    /* 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=ITypeInfo_GetRefTypeInfo(iface,
-                This->impltypelist->reference, &pTInfo);
+        ret=ITypeInfo_GetRefTypeInfo(iface, 
+                This->impltypelist->hRef, &pTInfo);
         if(SUCCEEDED(ret)){
             ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
@@ -2904 +3829 @@
 
 /* ITypeInfo::Invoke
- *
+ * 
  * Invokes a method, or accesses a property of an object, that implements the
  * interface described by the type description.
@@ -2912 +3837 @@
 
     if (TRACE_ON(ole)) {
-    int i;
-    MESSAGE("Calling %p(",func);
-    for (i=0;i<nrargs;i++) MESSAGE("%08lx,",args[i]);
-    MESSAGE(")\n");
+        int i;
+        MESSAGE("Calling %p(",func);
+        for (i=0;i<nrargs;i++) MESSAGE("%08lx,",args[i]);
+        MESSAGE(")\n");
     }
 
@@ -2921 +3846 @@
     case CC_STDCALL:
 
-    switch (nrargs) {
-    case 0: {
+        switch (nrargs) {
+        case 0: {
 #ifdef __WIN32OS2__
-        DWORD (* WINAPI xfunc)() = func;
+                DWORD (* WINAPI xfunc)() = func;
 #else
-        DWORD (WINAPI *xfunc)() = func;
+                DWORD (WINAPI *xfunc)() = func;
 #endif
-        res = xfunc();
-        break;
-    }
-    case 1: {
+                res = xfunc();
+                break;
+        }
+        case 1: {
 #ifdef __WIN32OS2__
-        DWORD (* WINAPI xfunc)(DWORD) = func;
+                DWORD (* WINAPI xfunc)(DWORD) = func;
 #else
-        DWORD (WINAPI *xfunc)(DWORD) = func;
+                DWORD (WINAPI *xfunc)(DWORD) = func;
 #endif
-        res = xfunc(args[0]);
-        break;
-    }
-    case 2: {
+                res = xfunc(args[0]);
+                break;
+        }
+        case 2: {
 #ifdef __WIN32OS2__
-        DWORD (* WINAPI xfunc)(DWORD,DWORD) = func;
+                DWORD (* WINAPI xfunc)(DWORD,DWORD) = func;
 #else
-        DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
+                DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
 #endif
-        res = xfunc(args[0],args[1]);
-        break;
-    }
-    case 3: {
+                res = xfunc(args[0],args[1]);
+                break;
+        }
+        case 3: {
 #ifdef __WIN32OS2__
-        DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD) = func;
+                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD) = func;
 #else
-        DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
+                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
 #endif
-        res = xfunc(args[0],args[1],args[2]);
-        break;
-    }
+                res = xfunc(args[0],args[1],args[2]);
+                break;
+        }
+        default:
+                FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
+                res = -1;
+                break;
+        }
+        break;
     default:
-        FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
-        res = -1;
-        break;
-    }
-    break;
-    default:
-    FIXME("unsupported calling convention %d\n",callconv);
-    res = -1;
-    break;
+        FIXME("unsupported calling convention %d\n",callconv);
+        res = -1;
+        break;
     }
     TRACE("returns %08lx\n",res);
@@ -2984 +3909 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
+    TLBFuncDesc * pFDesc; 
+    TLBVarDesc * pVDesc; 
     int i;
 
@@ -2994 +3919 @@
 
     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
-    if (pFDesc->funcdesc.memid == memid) {
-        if (pFDesc->funcdesc.invkind & (dwFlags & ~DISPATCH_METHOD))
-        break;
-    }
+        if (pFDesc->funcdesc.memid == memid) {
+            if (pFDesc->funcdesc.invkind & (dwFlags & ~DISPATCH_METHOD))
+                break;
+        }
     if (pFDesc) {
-    dump_TLBFuncDescOne(pFDesc);
-    switch (pFDesc->funcdesc.funckind) {
-    case FUNC_PUREVIRTUAL:
-    case FUNC_VIRTUAL: {
-        DWORD res;
-        DWORD *args = (DWORD*)HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*(pFDesc->funcdesc.cParams+1));
-        DWORD *args2 = (DWORD*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD)*(pFDesc->funcdesc.cParams));
-        args[0] = (DWORD)pIUnk;
-
-        for (i=0;i<pFDesc->funcdesc.cParams;i++) {
-        if (i<pDispParams->cArgs) {
-            TRACE("set %d to disparg type %d vs %d\n",i,
-                V_VT(pDispParams->rgvarg+i),
-                pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt
-            );
-            args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal);
-        } else {
-            TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
-            TRACE("set %d to pointer for get (type is %d)\n",i,tdesc->vt);
-            /*FIXME: give pointers for the rest, so propertyget works*/
-            args[i+1] = (DWORD)&args2[i];
-
-            /* If pointer to variant, pass reference to variant
-             * in result variant array.
-             */
-            if ((tdesc->vt == VT_PTR) &&
-            (tdesc->u.lptdesc->vt == VT_VARIANT) &&
-            pVarResult
-            )
-            args[i+1] = (DWORD)(pVarResult+(i-pDispParams->cArgs));
-        }
-        }
-        if (pFDesc->funcdesc.cParamsOpt)
-        FIXME("Does not support optional parameters (%d)\n",
-            pFDesc->funcdesc.cParamsOpt
-        );
-
-        res = _invoke((*(DWORD***)pIUnk)[pFDesc->funcdesc.oVft/4],
-            pFDesc->funcdesc.callconv,
-            pFDesc->funcdesc.cParams+1,
-            args
-        );
-        if (pVarResult && (dwFlags & (DISPATCH_PROPERTYGET))) {
-        for (i=0;i<pFDesc->funcdesc.cParams-pDispParams->cArgs;i++) {
-            TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
-            /* If we are a pointer to a variant, we are done already */
-            if ((tdesc->vt==VT_PTR)&&(tdesc->u.lptdesc->vt==VT_VARIANT))
-            continue;
-
-            VariantInit(&pVarResult[i]);
-            V_UNION(pVarResult+i,intVal) = args2[i];
-
-            if (tdesc->vt == VT_PTR)
-            tdesc = tdesc->u.lptdesc;
-            V_VT(pVarResult+i) = tdesc->vt;
-
-            /* HACK: VB5 likes this.
-             * I do not know why. There is 1 example in MSDN which uses
-             * this which appears broken (mixes int vals and
-             * IDispatch*.).
-             */
-            if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
-            V_VT(pVarResult+i) = VT_DISPATCH;
-            TRACE("storing into variant: [%d] type %d, val %08x\n",
-                i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
-            );
-        }
-        }
-        HeapFree(GetProcessHeap(),0,args2);
-        HeapFree(GetProcessHeap(),0,args);
-        return S_OK;
-    }
-    case FUNC_DISPATCH:  {
-       IDispatch *disp;
-       HRESULT hr;
-
-       hr = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
-       if (hr) {
-           FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
-           return hr;
-       }
-       FIXME("Calling Invoke in IDispatch iface. untested!\n");
-       hr = IDispatch_Invoke(
-           disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,dwFlags,pDispParams,
-           pVarResult,pExcepInfo,pArgErr
-       );
-       if (hr)
-           FIXME("IDispatch::Invoke failed with %08lx. (Could be not a real error?)\n",hr);
-       IDispatch_Release(disp);
-       return hr;
-    }
-    default:
-       FIXME("Unknown function invocation type %d\n",pFDesc->funcdesc.funckind);
-       return E_FAIL;
-    }
+        dump_TLBFuncDescOne(pFDesc);
+        switch (pFDesc->funcdesc.funckind) {
+        case FUNC_PUREVIRTUAL:
+        case FUNC_VIRTUAL: {
+            DWORD res;
+            DWORD *args = (DWORD*)HeapAlloc(GetProcessHeap(),0,sizeof(DWORD)*(pFDesc->funcdesc.cParams+1));
+            DWORD *args2 = (DWORD*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DWORD)*(pFDesc->funcdesc.cParams));
+            args[0] = (DWORD)pIUnk;
+
+            for (i=0;i<pFDesc->funcdesc.cParams;i++) {
+                if (i<pDispParams->cArgs) {
+                    TRACE("set %d to disparg type %d vs %d\n",i,
+                            V_VT(pDispParams->rgvarg+i),
+                            pFDesc->funcdesc.lprgelemdescParam[i].tdesc.vt
+                    );
+                    args[i+1] = V_UNION(pDispParams->rgvarg+i,lVal);
+                } else {
+                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
+                    TRACE("set %d to pointer for get (type is %d)\n",i,tdesc->vt);
+                    /*FIXME: give pointers for the rest, so propertyget works*/
+                    args[i+1] = (DWORD)&args2[i];
+
+                    /* If pointer to variant, pass reference to variant
+                     * in result variant array.
+                     */
+                    if ((tdesc->vt == VT_PTR) &&
+                        (tdesc->u.lptdesc->vt == VT_VARIANT) &&
+                        pVarResult
+                    )
+                        args[i+1] = (DWORD)(pVarResult+(i-pDispParams->cArgs));
+                }
+            }
+            if (pFDesc->funcdesc.cParamsOpt)
+                FIXME("Does not support optional parameters (%d)\n",
+                        pFDesc->funcdesc.cParamsOpt
+                );
+
+            res = _invoke((*(DWORD***)pIUnk)[pFDesc->funcdesc.oVft/4],
+                    pFDesc->funcdesc.callconv,
+                    pFDesc->funcdesc.cParams+1,
+                    args
+            );
+            if (pVarResult && (dwFlags & (DISPATCH_PROPERTYGET))) {
+                for (i=0;i<pFDesc->funcdesc.cParams-pDispParams->cArgs;i++) {
+                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
+                    /* If we are a pointer to a variant, we are done already */
+                    if ((tdesc->vt==VT_PTR)&&(tdesc->u.lptdesc->vt==VT_VARIANT))
+                        continue;
+
+                    VariantInit(&pVarResult[i]);
+                    V_UNION(pVarResult+i,intVal) = args2[i];
+
+                    if (tdesc->vt == VT_PTR)
+                        tdesc = tdesc->u.lptdesc;
+                    V_VT(pVarResult+i) = tdesc->vt;
+
+                    /* HACK: VB5 likes this.
+                     * I do not know why. There is 1 example in MSDN which uses
+                     * this which appears broken (mixes int vals and
+                     * IDispatch*.).
+                     */
+                    if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
+                        V_VT(pVarResult+i) = VT_DISPATCH;
+                    TRACE("storing into variant: [%d] type %d, val %08x\n",
+                            i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
+                    );
+                }
+            }
+            HeapFree(GetProcessHeap(),0,args2);
+            HeapFree(GetProcessHeap(),0,args);
+            return S_OK;
+        }
+        case FUNC_DISPATCH:  {
+           IDispatch *disp;
+           HRESULT hr;
+
+           hr = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
+           if (hr) {
+               FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
+               return hr;
+           }
+           FIXME("Calling Invoke in IDispatch iface. untested!\n");
+           hr = IDispatch_Invoke(
+               disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,dwFlags,pDispParams,
+               pVarResult,pExcepInfo,pArgErr
+           );
+           if (hr)
+               FIXME("IDispatch::Invoke failed with %08lx. (Could be not a real error?)\n",hr);
+           IDispatch_Release(disp);
+           return hr;
+        }
+        default:
+           FIXME("Unknown function invocation type %d\n",pFDesc->funcdesc.funckind);
+           return E_FAIL;
+        }
     } else {
-    FIXME("variable based invoking not supported yet.\n");
-    for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
-        if (pVDesc->vardesc.memid == memid) {
-        FIXME("varseek: Found memid name %s\n",debugstr_w(((LPWSTR)pVDesc->Name)));
-        dump_TLBVarDesc(pVDesc);
-        break;
-        }
-    }
+        FIXME("variable based invoking not supported yet.\n");
+        for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
+            if (pVDesc->vardesc.memid == memid) {
+                FIXME("varseek: Found memid name %s\n",debugstr_w(((LPWSTR)pVDesc->Name)));
+                dump_TLBVarDesc(pVDesc);
+                break;
+            }
+        }
     }
     FIXME("Did not find member id %d!\n",(int)memid);
@@ -3109 +4034 @@
 
 /* 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.
@@ -3118 +4043 @@
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
+    TLBFuncDesc * pFDesc; 
+    TLBVarDesc * pVDesc; 
     TRACE("(%p) memid %ld Name(%p) DocString(%p)"
           " HelpContext(%p) HelpFile(%p)\n",
@@ -3136 +4061 @@
     for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
         if(pFDesc->funcdesc.memid==memid){
-            return S_OK;
+          if(pBstrName)
+            *pBstrName = SysAllocString(pFDesc->Name);
+          if(pBstrDocString)
+            *pBstrDocString=SysAllocString(pFDesc->HelpString);
+          if(pdwHelpContext)
+            *pdwHelpContext=pFDesc->helpcontext;
+          return S_OK;
         }
     for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
         if(pVDesc->vardesc.memid==memid){
+            FIXME("Not implemented\n");
             return S_OK;
         }
@@ -3147 +4079 @@
 
 /*  ITypeInfo::GetDllEntry
- *
+ * 
  * Retrieves a description or specification of an entry point for a function
  * in a DLL.
@@ -3161 +4093 @@
 
 /* ITypeInfo::GetRefTypeInfo
- *
+ * 
  * If a type description references other type descriptions, it retrieves
  * the referenced type descriptions.
  */
 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
-    ITypeInfo2 *iface,
+        ITypeInfo2 *iface,
         HREFTYPE hRefType,
-    ITypeInfo  **ppTInfo)
+        ITypeInfo  **ppTInfo)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     HRESULT result = E_FAIL;
 
-    if(HREFTYPE_INTHISFILE(hRefType))
+
+    if (hRefType == -1 && 
+        (((ITypeInfoImpl*) This)->TypeAttr.typekind   == TKIND_DISPATCH) &&
+        (((ITypeInfoImpl*) This)->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
     {
-      ITypeLib *pTLib;
-      int Index;
-      result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
-      if(SUCCEEDED( result ))
-      {
-        result=ITypeLib2_GetTypeInfo(pTLib, HREFTYPE_INDEX(hRefType), ppTInfo);
-        ITypeLib2_Release(pTLib );
-      }
-    }
-    else if (hRefType == -1 &&
-             (((ITypeInfoImpl*) This)->TypeAttr.typekind   == TKIND_DISPATCH) &&
-             (((ITypeInfoImpl*) This)->TypeAttr.wTypeFlags &  TYPEFLAG_FDUAL))
-    {
-      /* when we meet a DUAL dispinterface, we must create the interface
-      * version of it.
-      */
-      ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
-
-
-      /* the interface version contains the same information as the dispinterface
-       * copy the contents of the structs.
-       */
-      *pTypeInfoImpl = *This;
-      pTypeInfoImpl->ref = 1;
-
-      /* change the type to interface */
-      pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
-
-      *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
-
-      ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
-
-      result = S_OK;
-    }
-    else
-    {
-      /* imported type lib */
-      TLBRefType   *pRefType     = NULL;
-
-      /* search in implemented types */
-      for( pRefType = This->impltypelist;
-           pRefType && (pRefType->reference != hRefType);
-           pRefType = pRefType->next);
-
-      if(!pRefType)
-      {
-        TYPEATTR*       pMyTypeAttr  = &This->TypeAttr;
-        unsigned short  cFuncs       = pMyTypeAttr->cFuncs;
-        unsigned short  cVars        = pMyTypeAttr->cVars;
-
-        /* search in arguments */
-        if (cFuncs > 0)
-        {
-          unsigned short  cFuncIndex   = 0;
-
-          TLBFuncDesc*    pCurrFunc    = This->funclist;
-
-          for (cFuncIndex = 0; !pRefType && cFuncIndex < cFuncs ; ++cFuncIndex)
-          {
-            FUNCDESC*  pCurrFuncDesc = &pCurrFunc->funcdesc;
-
-            short      cParams       = pCurrFuncDesc->cParams;
-            short      cParamIndex   = 0;
-
-            for (cParamIndex = 0 ;
-                 !pRefType && cParamIndex < cParams ;
-                 ++cParamIndex)
-            {
-              TLBParDesc* pCurrParamDesc = &(pCurrFunc->pParamDesc[cParamIndex]);
-
-              if ( pCurrParamDesc->pRefType && pCurrParamDesc->pRefType->reference == hRefType)
-              {
-                pRefType = pCurrParamDesc->pRefType;
-                break; /* also break from outer loop since pRefType != 0 */
-              }
-            }
-
-            pCurrFunc = pCurrFunc->next;
-          }
-        }
-        /* search in variables */
-        else if (cVars > 0)
-        {
-          FIXME("search hreftype in variables, if any\n");
-          result = E_INVALIDARG; // FIXME : correct?
-        }
-      }
-
-      /* href-referenced typeinfo found! */
-      if (pRefType || hRefType == -1)
-      {
-        ITypeLibImpl *pTypeLib = pRefType->pImpTLInfo->pImpTypeLib;
-
-        if(pTypeLib)
-        {
-          TRACE("typeinfo in imported typelib that is already loaded\n");
-
-          result = ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib,
-                                           &pRefType->guid,
-                                           ppTInfo);
-        }
-        else
-        {
-          result = LoadRegTypeLib( &pRefType->pImpTLInfo->guid,
-                      pRefType->pImpTLInfo->wVersionMajor,
-                      pRefType->pImpTLInfo->wVersionMinor,
-                      pRefType->pImpTLInfo->lcid,
-                      (LPTYPELIB *)&pTypeLib);
-
-          if(!SUCCEEDED(result))
-          {
-            BSTR libnam=SysAllocString(pRefType->pImpTLInfo->name);
-            TRACE("typeinfo in imported typelib that isn't already loaded\n");
-            result=LoadTypeLib(libnam, (LPTYPELIB *)&pTypeLib);
-            SysFreeString(libnam);
-          }
-          if(SUCCEEDED(result))
-          {
-            result=ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
-            pRefType->pImpTLInfo->pImpTypeLib = pTypeLib;
-            ITypeLib2_AddRef((ITypeLib*) pTypeLib);
-          }
-        }
-      }
+          /* when we meet a DUAL dispinterface, we must create the interface 
+          * version of it.
+          */
+          ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
+
+                
+          /* the interface version contains the same information as the dispinterface
+           * copy the contents of the structs.
+           */
+          *pTypeInfoImpl = *This;
+          pTypeInfoImpl->ref = 1;
+                
+          /* change the type to interface */
+          pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
+          
+          *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
+
+          ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
+
+          result = S_OK;
+
+    } else {
+        TLBRefType *pRefType;
+        for(pRefType = This->reflist; pRefType; pRefType = pRefType->next) {
+            if(pRefType->reference == hRefType)
+                break;
+        }
+        if(!pRefType)
+          FIXME("Can't find pRefType for ref %lx\n", hRefType);
+        if(pRefType && hRefType != -1) {
+            ITypeLib *pTLib;
+
+            if(pRefType->pImpTLInfo == TLB_REF_INTERNAL) {
+                int Index;
+                result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
+            } else {
+                if(pRefType->pImpTLInfo->pImpTypeLib) {
+                    TRACE("typeinfo in imported typelib that is already loaded\n");
+                    pTLib = (ITypeLib*)pRefType->pImpTLInfo->pImpTypeLib;
+                    ITypeLib2_AddRef((ITypeLib*) pTLib);
+                    result = S_OK;
+                } else {
+                    TRACE("typeinfo in imported typelib that isn't already loaded\n");
+                    result = LoadRegTypeLib( &pRefType->pImpTLInfo->guid,
+                                             pRefType->pImpTLInfo->wVersionMajor,
+                                             pRefType->pImpTLInfo->wVersionMinor,
+                                             pRefType->pImpTLInfo->lcid,
+                                             &pTLib);
+
+                    if(!SUCCEEDED(result)) {
+                        BSTR libnam=SysAllocString(pRefType->pImpTLInfo->name);
+                        result=LoadTypeLib(libnam, &pTLib);
+                        SysFreeString(libnam);
+                    }
+                    if(SUCCEEDED(result)) {
+                        pRefType->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
+                        ITypeLib2_AddRef(pTLib);
+                    }
+                }
+            }
+            if(SUCCEEDED(result)) {
+                if(pRefType->index == TLB_REF_USE_GUID)
+                    result = ITypeLib2_GetTypeInfoOfGuid(pTLib, 
+                                                         &pRefType->guid, 
+                                                         ppTInfo);
+                else
+                    result = ITypeLib2_GetTypeInfo(pTLib, pRefType->index,
+                                                   ppTInfo);
+            }
+        }
     }
 
@@ -3307 +4188 @@
 
 /* ITypeInfo::AddressOfMember
- *
+ * 
  * Retrieves the addresses of static functions or variables, such as those
  * defined in a DLL.
@@ -3320 +4201 @@
 
 /* ITypeInfo::CreateInstance
- *
- * Creates a new instance of a type that describes a component object class
+ * 
+ * Creates a new instance of a type that describes a component object class 
  * (coclass).
  */
-static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
-        IUnknown *pUnk, REFIID riid, VOID  **ppvObj)
+static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface, 
+        IUnknown *pUnk, REFIID riid, VOID  **ppvObj) 
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3337 +4218 @@
  */
 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
-                BSTR  *pBstrMops)
+                                BSTR  *pBstrMops)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3345 +4226 @@
 
 /* ITypeInfo::GetContainingTypeLib
- *
+ * 
  * Retrieves the containing type library and the index of the type description
  * within that type library.
@@ -3380 +4261 @@
  */
 static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc(
-    ITypeInfo2 *iface,
+        ITypeInfo2 *iface,
         FUNCDESC *pFuncDesc)
 {
@@ -3418 +4299 @@
  * Returns the type flags without any allocations. This returns a DWORD type
  * flag, which expands the type flags without growing the TYPEATTR (type
- * attribute).
+ * attribute). 
  *
  */
@@ -3443 +4324 @@
     HRESULT result;
     /* FIXME: should check for invKind??? */
-    for(i=0, pFuncInfo=This->funclist;pFuncInfo &&
+    for(i=0, pFuncInfo=This->funclist;pFuncInfo && 
             memid != pFuncInfo->funcdesc.memid; i++, pFuncInfo=pFuncInfo->next);
     if(pFuncInfo){
@@ -3460 +4341 @@
  *
  * 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).
+ * is not known (for example, when binding to a default member). 
  *
  */
@@ -3470 +4351 @@
     int i;
     HRESULT result;
-    for(i=0, pVarInfo=This->varlist; pVarInfo &&
+    for(i=0, pVarInfo=This->varlist; pVarInfo && 
             memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
         ;
@@ -3490 +4371 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
-    ITypeInfo2 * iface,
-    REFGUID guid,
-    VARIANT *pVarVal)
+        ITypeInfo2 * iface,
+        REFGUID guid,
+        VARIANT *pVarVal)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3516 +4397 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
-    ITypeInfo2 * iface,
-    UINT index,
-    REFGUID guid,
-    VARIANT *pVarVal)
+        ITypeInfo2 * iface,
+        UINT index,
+        REFGUID guid,
+        VARIANT *pVarVal)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
+    TLBFuncDesc * pFDesc; 
     int i;
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
@@ -3547 +4428 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
-    ITypeInfo2 * iface,
-    UINT indexFunc,
-    UINT indexParam,
-    REFGUID guid,
-    VARIANT *pVarVal)
-{
+        ITypeInfo2 * iface,
+        UINT indexFunc,
+        UINT indexParam,
+        REFGUID guid,
+        VARIANT *pVarVal)
+{   
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
+    TLBFuncDesc * pFDesc; 
     int i;
 
@@ -3561 +4442 @@
 
     if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
-        for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
+        for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData; 
                 pCData = pCData->next)
             if( IsEqualIID(guid, &pCData->guid)) break;
@@ -3576 +4457 @@
 }
 
-/* ITypeInfo2::GetVarcCustData
+/* ITypeInfo2::GetVarCustData
  *
  * Gets the custom data
  */
 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
-    ITypeInfo2 * iface,
-    UINT index,
-    REFGUID guid,
-    VARIANT *pVarVal)
-{
+        ITypeInfo2 * iface,
+        UINT index,
+        REFGUID guid,
+        VARIANT *pVarVal)
+{   
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBVarDesc * pVDesc;
+    TLBVarDesc * pVDesc; 
     int i;
 
@@ -3612 +4493 @@
 }
 
-/* ITypeInfo2::GetImplcCustData
+/* ITypeInfo2::GetImplCustData
  *
  * Gets the custom data
  */
 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
-    ITypeInfo2 * iface,
-    UINT index,
-    REFGUID guid,
-    VARIANT *pVarVal)
-{
+        ITypeInfo2 * iface,
+        UINT index,
+        REFGUID guid,
+        VARIANT *pVarVal)
+{   
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBRefType * pRDesc;
+    TLBImplType * pRDesc; 
     int i;
 
@@ -3636 +4517 @@
       }
     }
-
+    
     TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
 
@@ -3649 +4530 @@
 
 /* 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
@@ -3656 +4537 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
-    ITypeInfo2 * iface,
-    MEMBERID memid,
-    LCID lcid,
-    BSTR *pbstrHelpString,
-    DWORD *pdwHelpStringContext,
-    BSTR *pbstrHelpStringDll)
+        ITypeInfo2 * iface,
+        MEMBERID memid,
+        LCID lcid,
+        BSTR *pbstrHelpString,
+        DWORD *pdwHelpStringContext,
+        BSTR *pbstrHelpStringDll)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
-    TLBFuncDesc * pFDesc;
-    TLBVarDesc * pVDesc;
+    TLBFuncDesc * pFDesc; 
+    TLBVarDesc * pVDesc; 
     TRACE("(%p) memid %ld lcid(0x%lx)  HelpString(%p) "
           "HelpStringContext(%p) HelpStringDll(%p)\n",
@@ -3712 +4593 @@
 /* ITypeInfo2::GetAllCustData
  *
- * Gets all custom data items for the Type info.
+ * Gets all custom data items for the Type info. 
  *
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
-    ITypeInfo2 * iface,
-    CUSTDATA *pCustData)
+        ITypeInfo2 * iface,
+        CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
@@ -3723 +4604 @@
     int i;
 
-    TRACE("(%p) returning %d items\n", This, This->ctCustData);
+    TRACE("(%p) returning %d items\n", This, This->ctCustData); 
 
     pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
@@ -3745 +4626 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
-    ITypeInfo2 * iface,
-    UINT index,
-    CUSTDATA *pCustData)
+        ITypeInfo2 * iface,
+        UINT index,
+        CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBFuncDesc * pFDesc;
+    TLBFuncDesc * pFDesc; 
     int i;
-    TRACE("(%p) index %d\n", This, index);
+    TRACE("(%p) index %d\n", This, index); 
     for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
             pFDesc=pFDesc->next)
@@ -3787 +4668 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData=NULL;
-    TLBFuncDesc * pFDesc;
+    TLBFuncDesc * pFDesc; 
     int i;
-    TRACE("(%p) index %d\n", This, indexFunc);
+    TRACE("(%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 =
+        pCustData->prgCustData = 
             TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
                     sizeof(CUSTDATAITEM));
@@ -3824 +4705 @@
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBVarDesc * pVDesc;
+    TLBVarDesc * pVDesc; 
     int i;
-    TRACE("(%p) index %d\n", This, index);
+    TRACE("(%p) index %d\n", This, index); 
     for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
             pVDesc=pVDesc->next)
@@ -3856 +4737 @@
  */
 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
-    ITypeInfo2 * iface,
-    UINT index,
-    CUSTDATA *pCustData)
+        ITypeInfo2 * iface,
+        UINT index,
+        CUSTDATA *pCustData)
 {
     ICOM_THIS( ITypeInfoImpl, iface);
     TLBCustData *pCData;
-    TLBRefType * pRDesc;
+    TLBImplType * pRDesc; 
     int i;
-    TRACE("(%p) index %d\n", This, index);
+    TRACE("(%p) index %d\n", This, index); 
     for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
             pRDesc=pRDesc->next)
@@ -3888 +4769 @@
 }
 
-static ICOM_VTABLE(ITypeInfo2) tinfvt =
+static ICOM_VTABLE(ITypeInfo2) tinfvt = 
 {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE

trunk/src/oleaut32/typelib.h

@@ -17 +17 @@
 #define DO_NOT_SEEK (-1)
 
-#define HREFTYPE_INTHISFILE(href) (!((href) & 3))
-#define HREFTYPE_INDEX(href) ((href) /sizeof(TLBTypeInfoBase))
+#define MSFT_HREFTYPE_INTHISFILE(href) (!((href) & 3))
+#define MSFT_HREFTYPE_INDEX(href) ((href) /sizeof(MSFT_TypeInfoBase))
 
 /*-------------------------FILE STRUCTURES-----------------------------------*/
 
+/* There are two known file formats, those created with ICreateTypeLib
+ * have the signature "SLGT" as their first four bytes, while those created
+ * with ICreateTypeLib2 have "MSFT".
+ */
+
+/*****************************************************
+ *                MSFT typelibs
+ *
+ * These are TypeLibs created with ICreateTypeLib2
+ *
+ */
 
 /*
@@ -28 +39 @@
  *  
  */
-typedef struct tagTLB2Header {
+typedef struct tagMSFT_Header {
 /*0x00*/INT magic1;       /* 0x5446534D "MSFT" */
         INT   magic2;       /* 0x00010002 version nr? */
@@ -37 +48 @@
         INT   varflags;     /* (largely) unknown flags ,seems to be always 41 */
                             /* becomes 0x51 with a helpfile defined */
-                            /* if help dll defined its 0x151 */
+                            /* if help dll defined it's 0x151 */
                             /* update : the lower nibble is syskind */
         INT   version;      /* set with SetVersion() */
@@ -55 +66 @@
         INT   dispatchpos;      /* gets a value (1+n*0x0c) with Idispatch interfaces */
 /*0x50*/INT   res50;            /* is zero becomes one when an interface is derived */
-} TLB2Header;
+} MSFT_Header;
 
 /* segments in the type lib file have a structure like this: */
-typedef struct _tptag {
+typedef struct tagMSFT_pSeg {
         INT   offset;       /* absolute offset in file */
         INT   length;       /* length of segment */
@@ -64 +75 @@
         INT   res0c;        /* unknown always 0x0f in the header */
                             /* 0x03 in the typeinfo_data */
-} pSeg;
+} MSFT_pSeg;
 
 /* layout of the main segment directory */
-typedef struct tagTLBSegDir {
-/*1*/pSeg pTypeInfoTab; /* each type info get an entry of 0x64 bytes */
-                        /* (25 ints) */
-/*2*/pSeg pImpInfo;     /* table with info for imported types */
-/*3*/pSeg pImpFiles;    /* import libaries */
-/*4*/pSeg pRefTab;      /* References table */
-/*5*/pSeg pLibtab;      /* always exists, alway same size (0x80) */
-                        /* hash table w offsets to guid????? */
-/*6*/pSeg pGuidTab;     /* all guids are stored here together with  */
-                        /* offset in some table???? */
-/*7*/pSeg res07;        /* always created, alway same size (0x200) */
-                        /* purpose largely unknown */
-/*8*/pSeg pNametab;     /* name tables */
-/*9*/pSeg pStringtab;   /*string table */
-/*A*/pSeg pTypdescTab;  /* table with type descriptors */
-/*B*/pSeg pArrayDescriptions;
-/*C*/pSeg pCustData;    /*  data table, used for custom data and default */
-                        /* parameter values */
-/*D*/pSeg pCDGuids;     /* table with offsets for the guids and into the customer data table */
-/*E*/pSeg res0e;            /* unknown */
-/*F*/pSeg res0f;            /* unknown  */
-} TLBSegDir;
+typedef struct tagMSFT_SegDir {
+/*1*/MSFT_pSeg pTypeInfoTab; /* each type info get an entry of 0x64 bytes */
+                             /* (25 ints) */
+/*2*/MSFT_pSeg pImpInfo;     /* table with info for imported types */
+/*3*/MSFT_pSeg pImpFiles;    /* import libaries */
+/*4*/MSFT_pSeg pRefTab;      /* References table */
+/*5*/MSFT_pSeg pLibtab;      /* always exists, alway same size (0x80) */
+                             /* hash table w offsets to guid????? */
+/*6*/MSFT_pSeg pGuidTab;     /* all guids are stored here together with  */
+                             /* offset in some table???? */
+/*7*/MSFT_pSeg res07;        /* always created, alway same size (0x200) */
+                             /* purpose largely unknown */
+/*8*/MSFT_pSeg pNametab;     /* name tables */
+/*9*/MSFT_pSeg pStringtab;   /* string table */
+/*A*/MSFT_pSeg pTypdescTab;  /* table with type descriptors */
+/*B*/MSFT_pSeg pArrayDescriptions;
+/*C*/MSFT_pSeg pCustData;    /* data table, used for custom data and default */
+                             /* parameter values */
+/*D*/MSFT_pSeg pCDGuids;     /* table with offsets for the guids and into */
+                             /* the customer data table */
+/*E*/MSFT_pSeg res0e;        /* unknown */
+/*F*/MSFT_pSeg res0f;        /* unknown  */
+} MSFT_SegDir;
 
 
 /* base type info data */
-typedef struct tagTLBTypeInfoBase {
+typedef struct tagMSFT_TypeInfoBase {
 /*000*/ INT   typekind;             /*  it is the TKIND_xxx */
                                     /* some byte alignment stuf */
@@ -126 +138 @@
         INT     res18;          /* always? 0 */
 /*060*/ INT     res19;          /* always? -1 */
-    } TLBTypeInfoBase;
+    } MSFT_TypeInfoBase;
 
 /* layout of an entry with information on imported types */
-typedef struct tagTLBImpInfo {
+typedef struct tagMSFT_ImpInfo {
     INT     res0;           /* unknown */
     INT     oImpFile;       /* offset inthe Import File table */
     INT     oGuid;          /* offset in Guid table */
-    } TLBImpInfo;
+    } MSFT_ImpInfo;
 
 /* function description data */
@@ -165 +177 @@
 7*  INT   oArgCustData[1];  // custom data per argument //
 */
-} TLBFuncRecord;
+} MSFT_FuncRecord;
 
 /* after this may follow an array with default value pointers if the 
@@ -177 +189 @@
         INT   oName;
         INT   Flags;
-    } TLBParameterInfo;
+    } MSFT_ParameterInfo;
 
 /* Variable description data */
@@ -196 +208 @@
     INT   HelpStringContext;
 
-} TLBVarRecord;
+} MSFT_VarRecord;
 
 /* Structure of the reference data  */
 typedef struct {
-    INT   reftype;  /* either offset in type info table, then its */
+    INT   reftype;  /* either offset in type info table, then it's */
                     /* a multiple of 64 */
                     /* or offset in the external reference table */
@@ -207 +219 @@
     INT   oCustData;    /* custom data */
     INT   onext;    /* next offset, -1 if last */
-} TLBRefRecord;
+} MSFT_RefRecord;
 
 /* this is how a guid is stored */
@@ -213 +225 @@
     GUID guid;
     INT   unk10;        /* differntiate with libid, classid etc? */
-                        /* its -2 for a libary */
+                        /* it's -2 for a libary */
                         /* it's 0 for an interface */
     INT   unk14;        /* always? -1 */
-} TLBGuidEntry;
+} MSFT_GuidEntry;
 /* some data preceding entries in the name table */
 typedef struct {
@@ -222 +234 @@
                            sometimes 0 (interface, func) */
     INT   unk10;        /* sometimes -1 (lib) , sometimes 0 (interface, func),
-                           sometime 0x10 (par) */
+                           sometimes 0x10 (par) */
     INT   namelen;      /* only lower 8 bits are valid */
-} TLBNameIntro;
+} MSFT_NameIntro;
 /* the custom data table directory has enties like this */
 typedef struct {
     INT   GuidOffset;
     INT   DataOffset;
-    INT   next;     /* next offset in the table, -1 if its the last */
-} TLBCDGuid;
-
-
+    INT   next;     /* next offset in the table, -1 if it's the last */
+} MSFT_CDGuid;
+
+
+/***********************************************************
+ *
+ *                SLTG typelibs.
+ *
+ * These are created with ICreateTypeLib
+ *
+ */
+
+#include "pshpack1.h"
+
+typedef struct {
+/*00*/  DWORD SLTG_magic;       /* 0x47544c53  == "SLTG" */
+/*04*/  WORD nrOfFileBlks;      /* no of SLTG_BlkEntry's + 1 */
+/*06*/  WORD res06;             /* ?? always 9 */
+/*08*/  WORD res08;             /* some kind of len/offset ?? */
+/*0a*/  WORD first_blk;         /* 1 based index into blk entries that
+                                   corresponds to first block in file */
+/*0c*/  DWORD res0c;            /* always 0x000204ff */
+/*10*/  DWORD res10;            /* always 0x00000000 */
+/*14*/  DWORD res14;            /* always 0x000000c0 */
+/*18*/  DWORD res18;            /* always 0x46000000 */
+/*1c*/  DWORD res1c;            /* always 0x00000044 */
+/*20*/  DWORD res20;            /* always 0xffff0000 */
+} SLTG_Header;
+
+/* This gets followed by a list of block entries */
+typedef struct {
+/*00*/  DWORD len;
+/*04*/  WORD index_string; /* offs from start of SLTG_Magic to index string */
+/*06*/  WORD next;
+} SLTG_BlkEntry;
+
+/* The order of the blocks in the file is given by starting at Block
+   entry firt_blk and stepping through using the next pointer */
+
+/* These then get followed by this magic */
+typedef struct {
+/*00*/ BYTE res00;              /* always 0x01 */
+/*01*/ CHAR CompObj_magic[8];   /* always "CompObj" */
+/*09*/ CHAR dir_magic[4];       /* always "dir" */
+} SLTG_Magic;
+
+#define SLTG_COMPOBJ_MAGIC "CompObj"
+#define SLTG_DIR_MAGIC "dir"
+
+/* Next we have SLTG_Header.nrOfFileBlks - 2 of Index strings.  These
+are persumbably unique to within the file and look something like
+"AAAAAAAAAA" with the first character incremented from 'A' to ensure
+uniqueness.  I guess successive chars increment when we need to wrap
+the first one. */
+
+typedef struct {
+/*00*/ CHAR string[11];
+} SLTG_Index;
+
+
+/* This is followed by SLTG_pad9 */
+typedef struct {
+/*00*/ CHAR pad[9];     /* 9 '\0's */
+} SLTG_Pad9;
+
+
+/* Now we have the noOfFileBlks - 1 worth of blocks. The length of
+each block is given by its entry in SLTG_BlkEntry. */
+
+/* type SLTG_NAME in rather like a BSTR except that the length in
+bytes is given by the first WORD and the string contains 8bit chars */
+
+typedef WORD SLTG_Name;
+
+/* The main library block looks like this.  This one seems to come last */
+
+typedef struct {
+/*00*/  WORD magic;             /* 0x51cc */
+/*02*/  WORD res02;             /* 0x0003, 0x0004 */
+/*04*/  WORD name;              /* offset to name in name table */
+/*06*/  SLTG_Name res06;        /* maybe this is just WORD == 0xffff */
+        SLTG_Name helpstring;
+        SLTG_Name helpfile;
+        DWORD helpcontext;
+        WORD syskind;           /* == 1 for win32, 0 for win16 */
+        WORD lcid;              /* == 0x409, 0x809 etc */
+        DWORD res12;            /* == 0 */
+        WORD libflags;          /* LIBFLAG_* */
+        WORD maj_vers;
+        WORD min_vers;
+        GUID uuid;
+} SLTG_LibBlk;
+
+#define SLTG_LIBBLK_MAGIC 0x51cc
+
+/* we then get 0x40 bytes worth of 0xffff or small numbers followed by
+   nrOfFileBlks - 2 of these */
+typedef struct {
+        WORD small_no;
+        SLTG_Name index_name; /* This refers to a name in the directory */
+        SLTG_Name other_name; /* Another one of these weird names */
+        WORD res1a;           /* 0xffff */
+        WORD name_offs;       /* offset to name in name table */
+        WORD more_bytes;      /* if this is non-zero we get this many
+                                 bytes before the next element, which seem 
+                                 to reference the docstring of the type ? */
+        WORD res20;           /* 0xffff */
+        DWORD helpcontext;
+        WORD res26;           /* 0xffff */
+        GUID uuid;
+} SLTG_OtherTypeInfo;
+
+/* Next we get WORD 0x0003 followed by a DWORD which if we add to
+0x216 gives the offset to the name table from the start of the LibBlk
+struct */
+
+typedef struct {
+/*00*/  WORD magic;             /* 0x0501 */
+/*02*/  DWORD href_table;       /* if not 0xffffffff, then byte offset from
+                                   beginning of struct to href table */
+/*06*/  DWORD res06;            /* 0xffffffff */
+/*0a*/  DWORD elem_table;       /* offset to members */
+/*0e*/  DWORD res0e;            /* 0xffffffff */
+/*12*/  WORD major_version;     /* major version number */
+/*14*/  WORD minor_version;     /* minor version number */
+/*16*/  DWORD res16;    /* 0xfffe0000 */
+/*1a*/  BYTE typeflags1;/* 0x02 | top 5 bits hold l5sbs of TYPEFLAGS */
+/*1b*/  BYTE typeflags2;/* TYPEFLAGS >> 5 */
+/*1c*/  BYTE typeflags3;/* 0x02*/
+/*1d*/  BYTE typekind;  /* 0x03 == TKIND_INTERFACE etc. */
+/*1e*/  DWORD res1e;    /* 0x00000000 or 0xffffffff */
+} SLTG_TypeInfoHeader;
+
+#define SLTG_TIHEADER_MAGIC 0x0501
+
+typedef struct {
+/*00*/ WORD res00; /* 0x0001 sometimes 0x0003 ?? */
+/*02*/ WORD res02; /* 0xffff */
+/*04*/ BYTE res04; /* 0x01 */
+/*05*/ DWORD cbExtra; /* No of bytes that follow */
+} SLTG_MemberHeader;
+
+typedef struct {
+/*00*/  WORD magic;     /* 0x120a */
+/*02*/  WORD next;      /* offset in bytes to next block from start of block
+                           group, 0xffff if last item */
+/*04*/  WORD name;      /* offset to name within name table */
+/*06*/  WORD value;     /* offset to value from start of block group */
+/*08*/  WORD res08;     /* 0x56 */
+/*0a*/  DWORD memid;    /* memid */
+/*0e*/  WORD helpcontext;/* 0xfffe == no context, 0x0001 == stored in EnumInfo struct, else offset
+                            to value from start of block group */
+/*10*/  WORD helpstring;/* offset from start of block group to string offset */
+} SLTG_EnumItem;
+
+#define SLTG_ENUMITEM_MAGIC 0x120a
+
+
+typedef struct {
+        BYTE magic;     /* 0x4c or 0x6c */
+        BYTE inv;       /* high nibble is INVOKE_KIND, low nibble = 2 */
+        WORD next;      /* byte offset from beginning of group to next fn */
+        WORD name;      /* Offset within name table to name */
+        DWORD dispid;   /* dispid */
+        WORD helpcontext; /* helpcontext (again 1 is special) */
+        WORD helpstring;/* helpstring offset to offset */
+        WORD arg_off;   /* offset to args from start of block */
+        BYTE nacc;      /* lowest 3bits are CALLCONV, rest are no of args */
+        BYTE retnextopt;/* if 0x80 bit set ret type follows else next WORD
+                           is offset to ret type. No of optional args is
+                           middle 6 bits */
+        WORD rettype;   /* return type VT_?? or offset to ret type */
+        WORD vtblpos;   /* position in vtbl? */
+        WORD funcflags; /* present if magic == 0x6c */ 
+/* Param list starts, repeat next two as required */
+#if 0
+        WORD  name;     /* offset to 2nd letter of name */
+        WORD+ type;     /* VT_ of param */
+#endif
+} SLTG_Function;
+
+#define SLTG_FUNCTION_MAGIC 0x4c
+#define SLTG_FUNCTION_WITH_FLAGS_MAGIC 0x6c
+
+typedef struct {
+/*00*/  BYTE magic;             /* 0xdf */
+/*01*/  BYTE res01;             /* 0x00 */
+/*02*/  DWORD res02;            /* 0xffffffff */
+/*06*/  DWORD res06;            /* 0xffffffff */
+/*0a*/  DWORD res0a;            /* 0xffffffff */
+/*0e*/  DWORD res0e;            /* 0xffffffff */
+/*12*/  DWORD res12;            /* 0xffffffff */
+/*16*/  DWORD res16;            /* 0xffffffff */
+/*1a*/  DWORD res1a;            /* 0xffffffff */
+/*1e*/  DWORD res1e;            /* 0xffffffff */
+/*22*/  DWORD res22;            /* 0xffffffff */
+/*26*/  DWORD res26;            /* 0xffffffff */
+/*2a*/  DWORD res2a;            /* 0xffffffff */
+/*2e*/  DWORD res2e;            /* 0xffffffff */
+/*32*/  DWORD res32;            /* 0xffffffff */
+/*36*/  DWORD res36;            /* 0xffffffff */
+/*3a*/  DWORD res3a;            /* 0xffffffff */
+/*3e*/  DWORD res3e;            /* 0xffffffff */
+/*42*/  WORD  res42;            /* 0xffff */
+/*44*/  DWORD number;           /* this is 8 times the number of refs */
+/*48*/  /* Now we have number bytes (8 for each ref) of SLTG_UnknownRefInfo */
+
+/*50*/  WORD res50;             /* 0xffff */
+/*52*/  BYTE res52;             /* 0x01 */
+/*53*/  DWORD res53;            /* 0x00000000 */
+/*57*/  SLTG_Name names[1];
+  /*    Now we have number/8 SLTG_Names (first WORD is no of bytes in the ascii
+   *    string).  Strings look like "*\Rxxxx*#n".  If xxxx == ffff then the
+   *    ref refers to the nth type listed in this library (0 based).  Else
+   *    the xxxx (which maybe fewer than 4 digits) is the offset into the name
+   *    table to a string "*\G{<guid>}#1.0#0#C:\WINNT\System32\stdole32.tlb#"
+   *    The guid is the typelib guid; the ref again refers to the nth type of
+   *    the imported typelib.
+   */
+
+/*xx*/ BYTE resxx;              /* 0xdf */
+
+} SLTG_RefInfo;
+
+#define SLTG_REF_MAGIC 0xdf
+
+typedef struct {
+        WORD res00;     /* 0x0001 */
+        BYTE res02;     /* 0x02 */
+        BYTE res03;     /* 0x40 if internal ref, 0x00 if external ? */
+        WORD res04;     /* 0xffff */
+        WORD res06;     /* 0x0000, 0x0013 or 0xffff ?? */
+} SLTG_UnknownRefInfo;
+
+typedef struct {
+  WORD res00; /* 0x004a */
+  WORD next;  /* byte offs to next interface */
+  WORD res04; /* 0xffff */
+  BYTE impltypeflags; /* IMPLTYPEFLAG_* */
+  BYTE res07; /* 0x80 */
+  WORD res08; /* 0x0012, 0x0028 ?? */
+  WORD ref;   /* number in ref table ? */
+  WORD res0c; /* 0x4000 */
+  WORD res0e; /* 0xfffe */
+  WORD res10; /* 0xffff */
+  WORD res12; /* 0x001d */
+  WORD pos_in_table; /* 0x0, 0x4, ? */
+} SLTG_ImplInfo;
+
+#define SLTG_IMPL_MAGIC 0x004a
+
+typedef struct {
+  BYTE magic; /* 0x0a */
+  BYTE typepos;
+  WORD next;
+  WORD name;
+  WORD byte_offs; /* pos in struct */
+  WORD type; /* if typepos == 0x02 this is the type, else offset to type */
+  DWORD memid;
+  WORD helpcontext; /* ?? */
+  WORD helpstring; /* ?? */
+} SLTG_RecordItem;
+
+#define SLTG_RECORD_MAGIC 0x0a
+
+
+/* CARRAYs look like this
+WORD type == VT_CARRAY
+WORD offset from start of block to SAFEARRAY
+WORD typeofarray
+*/
+
+#include "poppack.h"
 
 /*---------------------------END--------------------------------------------*/
 #endif
+
+

trunk/src/oleaut32/variant.c

@@ -1 @@
-/* $Id: variant.c,v 1.5 2001-09-05 13:19:02 bird Exp $ */
 /*
  * VARIANT