Changeset 2296 for trunk/src


Ignore:
Timestamp:
Jan 2, 2000, 10:29:58 PM (26 years ago)
Author:
davidr
Message:

Custom Data, Default values, Private logging, embedded tlib ids, misc fixes

Location:
trunk/src/oleaut32
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/oleaut32/initterm.cpp

    r951 r2296  
    1 /* $Id: initterm.cpp,v 1.2 1999-09-15 23:26:08 sandervl Exp $ */
     1/* $Id: initterm.cpp,v 1.3 2000-01-02 21:29:57 davidr Exp $ */
    22
    33/*
    … …  
    4141}
    4242
     43//Global DLL Data
     44#pragma data_seg(_GLOBALDATA)
     45int globLoadNr = 0;
     46#pragma data_seg()
     47
     48char  oleaut32Path[CCHMAXPATH] = "";
     49int   loadNr = 0;
     50
    4351/*-------------------------------------------------------------------*/
    4452/* A clean up routine registered with DosExitList must be used if    */
    … …  
    7280   switch (ulFlag) {
    7381      case 0 :
     82      {
     83         loadNr = globLoadNr++;
     84
     85#if 0
     86         strcpy(oleaut32Path, OSLibGetDllName(hModule));
     87         char *endofpath = strrchr(oleaut32Path, '\\');
     88         *(endofpath+1) = 0;
     89#endif
     90
    7491         _ctordtorInit();
    7592
    … …  
    88105                return 0UL;
    89106
     107         OpenPrivateLogFiles();
     108
     109
    90110         break;
     111      }
    91112      case 1 :
    92113         UnregisterLxDll(hModule);
    … …  
    106127{
    107128   _ctordtorTerm();
     129   ClosePrivateLogFiles();
    108130   DosExitList(EXLST_EXIT, cleanup);
    109131   return ;

  • trunk/src/oleaut32/itypelib.h

    r2021 r2296  
    1 /* $Id: itypelib.h,v 1.1 1999-12-08 19:59:25 davidr Exp $ */
     1/* $Id: itypelib.h,v 1.2 2000-01-02 21:29:58 davidr Exp $ */
    22/*
    33 * OLE Typelib functions private header
    … …  
    179179/*6*/pSeg                       pGuidTab;       /* all guids are stored here together with  */
    180180                                                /* offset in some table???? */
    181 /*7*/pSeg                       res07;          /* always created, alway same size (0x200) */
     181/*7*/pSeg                       pRes7;          /* always created, alway same size (0x200) */
    182182                                                /* purpose largely unknown */
    183183/*8*/pSeg                       pNameTab;       /* name tables */
    … …  
    188188                                                /* parameter values */
    189189/*D*/pSeg                       pCDGuids;       /* table with offsets for the guids and into the customer data table */
    190 /*E*/pSeg                       res0e;          /* unknown */
    191 /*F*/pSeg                       res0f;          /* unknown  */
     190/*E*/pSeg                       pResE;          /* unknown */
     191/*F*/pSeg                       pResF;          /* unknown  */
    192192} TLBSegDir;
    193193
    … …  
    243243{
    244244    INT16                       recsize;        // record size including some xtra stuff
    245     INT16                       unk02;          //
     245    INT16                       index;          // 99.12.19 This must be the function index :-)
    246246    INT                         DataType;       /* data type of memeber, eg return of function */
    247247    INT                         Flags;          /* something to do with attribute flags (LOWORD) */
    … …  
    296296    INT16                       res3;         /* some offset into dunno what */
    297297    INT                         OffsValue;    /* value of the variable or the offset  */
    298                         /* in the data structure */
    299     /* optional attribute fields, the number of them is variable */
    300     /* controlled by record length */
    301     INT                         HelpContext;
    302     INT                         oHelpString;
    303     INT                         res9;         /* unknown (-1) */
    304     INT                         oCustData;        /* custom data for variable */
    305     INT                         HelpStringContext;
     298
     299    INT                         OptAttr[1];
     300
     301//                        /* in the data structure */
     302//    /* optional attribute fields, the number of them is variable */
     303//  /* controlled by record length */
     304//    INT                       HelpContext;
     305//    INT                       oHelpString;
     306//    INT                       res9;         /* unknown (-1) */
     307//    INT                       oCustData;        /* custom data for variable */
     308//    INT                       HelpStringContext;
    306309} TLBVarRecord;
    307310
    … …  
    407410
    408411    ITypeLibImpl *      m_pITypeLib;            // Pointer to typelib resource...
     412    BOOL                m_fFree;                // Set if we need to free m_pITypeLib
    409413    BOOL                m_fValid;
    410414    HANDLE              m_hHeap;                // Heap Handle
    … …  
    426430    void *              m_pCustData;
    427431    TLBCDGuid *         m_pCDGuid;
     432    void *              m_pRes7;
     433    void *              m_pResE;
     434    void *              m_pResF;
    428435
    429436    BOOL        Read(HANDLE hFile, void * buffer, DWORD count, DWORD * pBytesRead, long where);
    … …  
    446453    void        GetTypedesc(int type, TYPEDESC * pTypedesc);
    447454
    448     // Debug only...
    449     void        DumpHeader();
    450455};
    451456

  • trunk/src/oleaut32/oleaut32.cpp

    r1034 r2296  
    1 /* $Id: oleaut32.cpp,v 1.4 1999-09-24 21:55:24 davidr Exp $ */
     1/* $Id: oleaut32.cpp,v 1.5 2000-01-02 21:29:58 davidr Exp $ */
    22/*
    33 * OLEAUT32
    … …  
    2323
    2424#include <debugdefs.h>
     25
     26//******************************************************************************
     27//Used to open any private logfiles used in oleaut32
     28//******************************************************************************
     29void OpenPrivateLogFiles()
     30{
     31    OpenPrivateLogFileTypelib();
     32}
     33//******************************************************************************
     34//Used to close all private logfiles used in oleaut32
     35//******************************************************************************
     36void ClosePrivateLogFiles()
     37{
     38    ClosePrivateLogFileTypelib();
     39}
    2540
    2641/***********************************************************************

  • trunk/src/oleaut32/oleaut32.h

    r1729 r2296  
    1 /* $Id: oleaut32.h,v 1.6 1999-11-14 01:26:36 davidr Exp $ */
     1/* $Id: oleaut32.h,v 1.7 2000-01-02 21:29:58 davidr Exp $ */
    22/*
    33 * Win32 OLE stubs for OS/2
    … …  
    5252#include <heapstring.h>
    5353
     54extern int      loadNr;
     55extern char *   oleaut32Path;
     56
     57void ClosePrivateLogFileTypelib();
     58void OpenPrivateLogFileTypelib();
     59
    5460#endif

  • trunk/src/oleaut32/typelib.cpp

    r2022 r2296  
    1 /* $Id: typelib.cpp,v 1.6 1999-12-08 19:59:58 davidr Exp $ */
     1/* $Id: typelib.cpp,v 1.7 2000-01-02 21:29:58 davidr Exp $ */
     2/*
     3 * ITypelib interface
     4 *
     5 * 1/12/99
     6 *
     7 * Copyright 1999 David J. Raison
     8 * Some portions based on original work on Wine
     9 *   Copyright 1997 Marcus Meissner
     10               1999 Rein Klazes
     11 *
     12 * Project Odin Software License can be found in LICENSE.TXT
     13 *
     14 * NB: Logging from this module is piped into TLIB_n.LOG via
     15 * the private logging interface.
     16 */
    217
    318typedef enum tagREGKIND
    … …  
    823} REGKIND;
    924
     25#define PRIVATE_LOGGING // Private logfile
     26
    1027#include "oleaut32.h"
    1128#include "olectl.h"
    1229#include "oList.h"      // linked list template
    1330#include "itypelib.h"
     31
     32static FILE *_privateLogFile = NULL;
     33
     34// ----------------------------------------------------------------------
     35// OpenPrivateLogFileTypelib
     36// ----------------------------------------------------------------------
     37void OpenPrivateLogFileTypelib()
     38{
     39    char logname[1024];
     40
     41    sprintf(logname, "tlib_%d.log", loadNr);
     42    _privateLogFile = fopen(logname, "w");
     43#if 0
     44    if(_privateLogFile == NULL)
     45    {
     46        sprintf(logname, "%stlib_%d.log", oleaut32Path, loadNr);
     47        _privateLogFile = fopen(logname, "w");
     48    }
     49#endif
     50    dprintfGlobal(("TLIB LOGFILE : %s", logname));
     51}
     52
     53// ----------------------------------------------------------------------
     54// ClosePrivateLogFileTypelib
     55// ----------------------------------------------------------------------
     56void ClosePrivateLogFileTypelib()
     57{
     58    if(_privateLogFile)
     59    {
     60        fclose(_privateLogFile);
     61        _privateLogFile = NULL;
     62    }
     63}
    1464
    1565// ======================================================================
    … …  
    4999    DWORD       plen;
    50100
    51     dprintf(("OLEAUT32: QueryPathOfRegTypeLib()"));
     101    dprintfGlobal(("OLEAUT32: QueryPathOfRegTypeLib()"));
    52102
    53103    if (HIWORD(guid))
    … …  
    61111    {
    62112        sprintf(xguid, "<guid 0x%08lx>", (DWORD)guid);
    63         dprintf(("OLEAUT32: QueryPathOfRegTypeLib(%s,%d,%d,0x%04lx,%p) - stub!",
     113        dprintfGlobal(("OLEAUT32: QueryPathOfRegTypeLib(%s,%d,%d,0x%04lx,%p) - stub!",
    64114            xguid, wMaj, wMin, (DWORD)lcid, path));
    65115        return E_FAIL;
    … …  
    72122            return QueryPathOfRegTypeLib(guid, wMaj, wMin, PRIMARYLANGID(lcid), path);
    73123
    74         dprintf(("OLEAUT32: QueryPathOfRegTypeLib() - key \"%s\" not found", typelibkey));
     124        dprintfGlobal(("OLEAUT32: QueryPathOfRegTypeLib() - key \"%s\" not found", typelibkey));
    75125        return E_FAIL;
    76126    }
    … …  
    103153
    104154    szFileA = HEAP_strdupWtoA(hHeap, 0, szFile);
    105     dprintf(("OLEAUT32: LoadTypeLibEx(%s)", szFileA));
     155    dprintfGlobal(("OLEAUT32: LoadTypeLibEx(%s)", szFileA));
    106156
    107157    // Sanity check...
    … …  
    119169    {
    120170        HeapFree(hHeap, 0, szFileA);
    121         dprintf(("  Invalid typelib file"));
     171        dprintfGlobal(("  Invalid typelib file"));
    122172        return E_FAIL;
    123173    }
    … …  
    141191    HRESULT             res;
    142192
    143     dprintf(("OLEAUT32: LoadTypeLib()"));
     193    dprintfGlobal(("OLEAUT32: LoadTypeLib()"));
    144194
    145195    return LoadTypeLibEx(szFile, REGKIND_DEFAULT, ppTLib);
    … …  
    162212    HRESULT             res;
    163213
    164     dprintf(("OLEAUT32: LoadRegTypeLib()"));
     214    dprintfGlobal(("OLEAUT32: LoadRegTypeLib()"));
    165215
    166216    res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
    … …  
    186236                                                         may be NULL*/
    187237{
    188     dprintf(("OLEAUT32: RegisterTypeLib() - stub\n"));
     238    dprintfGlobal(("OLEAUT32: RegisterTypeLib() - stub\n"));
    189239
    190240    return S_OK;        /* FIXME: pretend everything is OK */
    … …  
    203253    SYSKIND             syskind)
    204254{
    205     dprintf(("OLEAUT32: UnRegisterTypeLib() - stub"));
     255    dprintfGlobal(("OLEAUT32: UnRegisterTypeLib() - stub"));
    206256
    207257    return S_OK;        /* FIXME: pretend everything is OK */
    208258}
     259
     260// ======================================================================
     261// Local functions.
     262// ======================================================================
     263
     264#if defined(DEBUG)
     265
     266// ----------------------------------------------------------------------
     267// dprintfLine2
     268// ----------------------------------------------------------------------
     269static void dprintfLine2(void)
     270{
     271    dprintf((LOG, "========================================"));
     272}
     273
     274// ----------------------------------------------------------------------
     275// dprintfLine
     276// ----------------------------------------------------------------------
     277static void dprintfLine(void)
     278{
     279    dprintf((LOG, "----------------------------------------"));
     280}
     281
     282// ----------------------------------------------------------------------
     283// TypeKindAsString
     284// ----------------------------------------------------------------------
     285char * TypeKindAsString(int typekind)
     286{
     287    char *      p;
     288    switch (typekind)
     289    {
     290        case TKIND_ENUM: p = "TKIND_ENUM"; break;
     291        case TKIND_RECORD: p = "TKIND_RECORD"; break;
     292        case TKIND_MODULE: p = "TKIND_MODULE"; break;
     293        case TKIND_INTERFACE: p = "TKIND_INTERFACE"; break;
     294        case TKIND_DISPATCH: p = "TKIND_DISPATCH"; break;
     295        case TKIND_COCLASS: p = "TKIND_COCLASS"; break;
     296        case TKIND_ALIAS: p = "TKIND_ALIAS"; break;
     297        case TKIND_UNION: p = "TKIND_UNION"; break;
     298        case TKIND_MAX: p = "TKIND_MAX"; break;
     299        default: p = "*UNKNOWN*"; break;
     300    }
     301    return p;
     302}
     303
     304// ----------------------------------------------------------------------
     305// FuncKindAsString
     306// ----------------------------------------------------------------------
     307char * FuncKindAsString(int funckind)
     308{
     309    char *      p;
     310    switch (funckind)
     311    {
     312        case FUNC_VIRTUAL: p = "FUNC_VIRTUAL"; break;
     313        case FUNC_PUREVIRTUAL: p = "FUNC_PUREVIRTUAL"; break;
     314        case FUNC_NONVIRTUAL: p = "FUNC_NONVIRTUAL"; break;
     315        case FUNC_STATIC: p = "FUNC_STATIC"; break;
     316        case FUNC_DISPATCH: p = "FUNC_DISPATCH"; break;
     317        default: p = "*UNKNOWN*"; break;
     318    }
     319    return p;
     320}
     321
     322// ----------------------------------------------------------------------
     323// InvKindAsString
     324// ----------------------------------------------------------------------
     325char * InvKindAsString(int invkind)
     326{
     327    char *      p;
     328    switch (invkind)
     329    {
     330        case INVOKE_FUNC: p = "INVOKE_FUNC"; break;
     331        case INVOKE_PROPERTYGET: p = "INVOKE_PROPERTYGET"; break;
     332        case INVOKE_PROPERTYPUT: p = "INVOKE_PROPERTYPUT"; break;
     333        case INVOKE_PROPERTYPUTREF: p = "INVOKE_PROPERTYPUTREF"; break;
     334        default: p = "*UNKNOWN*"; break;
     335    }
     336    return p;
     337}
     338
     339// ----------------------------------------------------------------------
     340// VarKindAsString
     341// ----------------------------------------------------------------------
     342char * VarKindAsString(int varkind)
     343{
     344    char *      p;
     345    switch (varkind)
     346    {
     347        case VAR_PERINSTANCE: p = "VAR_PERINSTANCE"; break;
     348        case VAR_STATIC: p = "VAR_STATIC"; break;
     349        case VAR_CONST: p = "VAR_CONST"; break;
     350        case VAR_DISPATCH: p = "VAR_DISPATCH"; break;
     351        default: p = "*UNKNOWN*"; break;
     352    }
     353    return p;
     354}
     355
     356// ----------------------------------------------------------------------
     357// CallConvAsString
     358// ----------------------------------------------------------------------
     359char * CallConvAsString(int callconv)
     360{
     361    char *      p;
     362    switch (callconv)
     363    {
     364        case CC_CDECL: p = "CC_CDECL"; break;
     365//      case CC_MSCPASCAL: p = "CC_MSCPASCAL"; break;
     366        case CC_PASCAL: p = "CC_PASCAL"; break;
     367        case CC_MACPASCAL: p = "CC_MACPASCAL"; break;
     368        case CC_STDCALL: p = "CC_STDCALL"; break;
     369        case CC_RESERVED: p = "CC_RESERVED"; break;
     370        case CC_SYSCALL: p = "CC_SYSCALL"; break;
     371        case CC_MPWCDECL: p = "CC_MPWCDECL"; break;
     372        case CC_MPWPASCAL: p = "CC_MPWPASCAL"; break;
     373        case CC_MAX: p = "CC_MAX"; break;
     374
     375        default: p = "*UNKNOWN*"; break;
     376    }
     377    return p;
     378}
     379
     380// ----------------------------------------------------------------------
     381// VariantAsString
     382// ----------------------------------------------------------------------
     383char * VariantTypeAsString(int vt)
     384{
     385    char *      p;
     386
     387    switch(vt & VT_TYPEMASK)
     388    {
     389        case VT_EMPTY: p = "VT_EMPTY"; break;
     390        case VT_NULL: p = "VT_NULL"; break;
     391        case VT_I2: p = "VT_I2"; break;
     392        case VT_I4: p = "VT_I4"; break;
     393        case VT_R4: p = "VT_R4"; break;
     394        case VT_ERROR: p = "VT_ERROR"; break;
     395        case VT_BOOL: p = "VT_BOOL"; break;
     396        case VT_I1: p = "VT_I1"; break;
     397        case VT_UI1: p = "VT_UI1"; break;
     398        case VT_UI2: p = "VT_UI2"; break;
     399        case VT_UI4: p = "VT_UI4"; break;
     400        case VT_INT: p = "VT_INT"; break;
     401        case VT_UINT: p = "VT_UINT"; break;
     402        case VT_VOID: p = "VT_VOID"; break;
     403        case VT_HRESULT: p = "VT_HRESULT"; break;
     404        case VT_R8: p = "VT_R8"; break;
     405        case VT_CY: p = "VT_CY"; break;
     406        case VT_DATE: p = "VT_DATE"; break;
     407        case VT_I8: p = "VT_I8"; break;
     408        case VT_UI8: p = "VT_UI8"; break;
     409        case VT_DECIMAL: p = "VT_DECIMAL"; break;
     410        case VT_FILETIME: p = "VT_FILETIME"; break;
     411        case VT_BSTR: p = "VT_BSTR"; break;
     412        case VT_DISPATCH: p = "VT_DISPATCH"; break;
     413        case VT_VARIANT: p = "VT_VARIANT"; break;
     414        case VT_UNKNOWN: p = "VT_UNKNOWN"; break;
     415        case VT_PTR: p = "VT_PTR"; break;
     416        case VT_SAFEARRAY: p = "VT_SAFEARRAY"; break;
     417        case VT_CARRAY: p = "VT_CARRAY"; break;
     418        case VT_USERDEFINED: p = "VT_USERDEFINED"; break;
     419        case VT_LPSTR: p = "VT_LPSTR"; break;
     420        case VT_LPWSTR: p = "VT_LPWSTR"; break;
     421        case VT_BLOB: p = "VT_BLOB"; break;
     422        case VT_STREAM: p = "VT_STREAM"; break;
     423        case VT_STORAGE: p = "VT_STORAGE"; break;
     424        case VT_STREAMED_OBJECT: p = "VT_STREAMED_OBJECT"; break;
     425        case VT_STORED_OBJECT: p = "VT_STORED_OBJECT"; break;
     426        case VT_BLOB_OBJECT: p = "VT_BLOB_OBJECT"; break;
     427        case VT_CF: p = "VT_CF"; break;
     428        case VT_CLSID: p = "VT_CLSID"; break;
     429        default: p = "*UNKNOWN*"; break;
     430    }
     431
     432    return p;
     433}
     434
     435// ----------------------------------------------------------------------
     436// VariantTypeAsString2
     437// ----------------------------------------------------------------------
     438char * VariantTypeAsString2(int vt)
     439{
     440    char *      p;
     441
     442    switch(vt & VT_TYPEMASK)
     443    {
     444        case VT_EMPTY: p = "(empty)"; break;
     445        case VT_NULL: p = "(null)"; break;
     446        case VT_I2: p = "short"; break;
     447        case VT_I4: p = "long"; break;
     448        case VT_R4: p = "float"; break;
     449        case VT_ERROR: p = "(error)"; break;
     450        case VT_BOOL: p = "boolean"; break;
     451        case VT_I1: p = "char"; break;
     452        case VT_UI1: p = "unsigned char"; break;
     453        case VT_UI2: p = "unsigned short"; break;
     454        case VT_UI4: p = "unsigned long"; break;
     455        case VT_INT: p = "int"; break;
     456        case VT_UINT: p = "unsigned int"; break;
     457        case VT_VOID: p = "void"; break;
     458        case VT_HRESULT: p = "HRESULT"; break;
     459        case VT_R8: p = "double"; break;
     460        case VT_CY: p = "currency"; break;
     461        case VT_DATE: p = "date"; break;
     462        case VT_I8: p = "long long"; break;
     463        case VT_UI8: p = "unsigned long long"; break;
     464        case VT_DECIMAL: p = "decimal"; break;
     465        case VT_FILETIME: p = "FILETIME"; break;
     466        case VT_BSTR: p = "BSTR"; break;
     467        case VT_DISPATCH: p = "IDISPATCH"; break;
     468        case VT_VARIANT: p = "VARIANT"; break;
     469        case VT_UNKNOWN: p = "IUNKNOWN"; break;
     470        case VT_PTR: p = "*"; break;
     471        case VT_SAFEARRAY: p = "SAFEARRAY"; break;
     472        case VT_CARRAY: p = "CARRAY"; break;
     473        case VT_USERDEFINED: p = "USERDEFINED"; break;
     474        case VT_LPSTR: p = "LPSTR"; break;
     475        case VT_LPWSTR: p = "LPWSTR"; break;
     476        case VT_BLOB: p = "BLOB"; break;
     477        case VT_STREAM: p = "STREAM"; break;
     478        case VT_STORAGE: p = "STORAGE"; break;
     479        case VT_STREAMED_OBJECT: p = "STREAMED_OBJECT"; break;
     480        case VT_STORED_OBJECT: p = "STORED_OBJECT"; break;
     481        case VT_BLOB_OBJECT: p = "BLOB_OBJECT"; break;
     482        case VT_CF: p = "CF"; break;
     483        case VT_CLSID: p = "CLSID"; break;
     484        default: p = "*UNKNOWN*"; break;
     485    }
     486
     487    return p;
     488}
     489// ----------------------------------------------------------------------
     490// dprintTypeDesc
     491// ----------------------------------------------------------------------
     492size_t sprintfTypeDesc(char * buf, TYPEDESC * pDesc)
     493{
     494    LONG        ii;
     495    size_t      len = 0;
     496
     497    if (pDesc->vt & VT_ARRAY)
     498    {
     499        ARRAYDESC *     pArray = V_UNION(pDesc, lpadesc);
     500       
     501        len += sprintfTypeDesc(buf + len, &pArray->tdescElem);
     502        for (ii = 0; ii < pArray->cDims; ii++)
     503        {
     504            if (ii)
     505                len += sprintf(buf + len, ", ");
     506
     507            len += sprintf(buf + len, "[%ld..%ld]", pArray->rgbounds[ii].lLbound,
     508                                pArray->rgbounds[ii].lLbound + pArray->rgbounds[ii].cElements);
     509        }
     510
     511    }
     512    else if (pDesc->vt == VT_PTR)
     513    {
     514        len += sprintfTypeDesc(buf + len, V_UNION(pDesc, lptdesc)) ;    // 'ware recursion...!
     515        len += sprintf(buf + len,  "%s ", VariantTypeAsString2(pDesc->vt));
     516    }
     517    else if (pDesc->vt == VT_USERDEFINED)
     518    {
     519        len += sprintf(buf + len, "(%ld) ", V_UNION(pDesc, hreftype)  );
     520    }
     521    else
     522    {
     523        len += sprintf(buf + len, "%s ",  VariantTypeAsString2(pDesc->vt));
     524    }
     525    return len;
     526}
     527
     528typedef struct FlagSt
     529{
     530    char *              name;
     531    ULONG               value;
     532} FLAGST;
     533
     534static FLAGST FKCCICFlagData[] =
     535{
     536    {"custom data",         0x80},
     537    {"default values",      0x1000},
     538    {"numeric entry",       0x2000},
     539    {"has retval",          0x4000},    // Set for methods with a retval parameter
     540    {"0x8000",              0x8000},
     541    {0, 0}
     542};
     543
     544static FLAGST VarFlagData[] =
     545{
     546    {"readonly",            0x1},
     547    {"source",              0x2},
     548    {"bindable",            0x4},
     549    {"requestedit ",        0x8},
     550    {"displaybind ",        0x10},
     551    {"defaultbinD ",        0x20},
     552    {"hidden",              0x40},
     553    {"restricted",          0x80},
     554    {"defaultcollElem",     0x100},
     555    {"uidefault ",          0x200},
     556    {"nonbrowsable",        0x400},
     557    {"replaceable ",        0x800},
     558    {"immediatebind ",      0x1000},
     559    {0, 0}
     560};
     561
     562static FLAGST ParamFlagData[] =
     563{
     564    {"in",                  0x01},
     565    {"out",                 0x02},
     566    {"lcid",                0x04},
     567    {"retval",              0x08},
     568    {"opt",                 0x10},
     569    {"hasdefault",          0x20},
     570    {0, 0}
     571};
     572
     573static FLAGST FuncFlagData[] =
     574{
     575    {"restricted",          0x1},
     576    {"source",              0x2},
     577    {"bindable",            0x4},
     578    {"requestedit",         0x8},
     579    {"displaybind",         0x10},
     580    {"defaultbind",         0x20},
     581    {"hidden",              0x40},
     582    {"usesgetlasterror",    0x80},
     583    {"defaultcollelem",     0x100},
     584    {"uidefault",           0x200},
     585    {"nonbrowsable",        0x400},
     586    {"replaceable",         0x800},
     587    {"immediatebind",       0x1000},
     588    {0, 0}
     589};
     590
     591// ----------------------------------------------------------------------
     592// sprintfFlags
     593// ----------------------------------------------------------------------
     594size_t sprintfFlags(char * buf, FLAGST const * pData, ULONG flags)
     595{
     596    size_t      len = 0;
     597
     598    len += sprintf(buf + len, "[");
     599
     600    while (pData->name != 0)
     601    {
     602        if (flags & pData->value)
     603        {
     604            if (len > 1)
     605                len += sprintf(buf + len, ", ");
     606
     607            len += sprintf(buf + len, pData->name);
     608        }
     609        pData++;
     610    }
     611    len += sprintf(buf + len, "]");
     612
     613    return len;
     614}
     615
     616
     617#endif
    209618
    210619// ======================================================================
    … …  
    215624// TypeLibExtract::TypeLibExtract
    216625// ----------------------------------------------------------------------
    217 TypeLibExtract::TypeLibExtract(char * szName) : m_fValid(0), m_hHeap(GetProcessHeap())
     626TypeLibExtract::TypeLibExtract(char * szName)
     627    : m_fValid(0), m_hHeap(GetProcessHeap()), m_fFree(FALSE)
    218628{
    219629    if ((Load(szName) == S_OK)
    220         && (EstablishPointers() == S_OK))
     630    && (EstablishPointers() == S_OK))
    221631    {
    222632        m_fValid = TRUE;
    … …  
    231641    m_fValid = 0;
    232642
    233     if (m_pTypeLib)
     643    if (m_fFree)
    234644        HeapFree(m_hHeap, 0, m_pTypeLib);
    235645
    … …  
    244654    // Locate segment directory...
    245655    m_pHeader = (TLB2Header *)m_pTypeLib;
     656
    246657    if (m_pHeader->varflags & HELPDLLFLAG)
    247658    {
    … …  
    259670    if (m_pSegDir->pTypeInfoTab.res0c != 0x0F || m_pSegDir->pImpInfo.res0c != 0x0F)
    260671    {
    261         dprintf(("  Segment directory sanity check failed!"));
     672        dprintf((LOG, "  Segment directory sanity check failed!"));
    262673        return E_FAIL;
    263674    }
    264675
    265 //    m_pLib
    266     if (m_pSegDir->pImpInfo.offset > 0)
     676    // Decode the segment offsets...
     677    dprintf((LOG, "Segment Offsets:"));
     678
     679    if (m_pSegDir->pImpInfo.offset != 0xffffffff)
     680    {
    267681        m_pImpInfo = (TLBImpInfo *)((char *)m_pTypeLib + m_pSegDir->pImpInfo.offset);
    268     else
     682        dprintf((LOG, "  ImpInfo       0x%08lx", m_pSegDir->pImpInfo.offset));
     683    }
     684    else
     685    {
    269686        m_pImpInfo = 0;
    270 
    271     if (m_pSegDir->pRefTab.offset > 0)
     687    }
     688
     689    if (m_pSegDir->pRefTab.offset != 0xffffffff)
     690    {
    272691        m_pRef = (TLBRefRecord *)((char *)m_pTypeLib + m_pSegDir->pRefTab.offset);
    273     else
     692        dprintf((LOG, "  RefTab        0x%08lx", m_pSegDir->pRefTab.offset));
     693    }
     694    else
     695    {
    274696        m_pRef = 0;
    275 
    276     if (m_pSegDir->pGuidTab.offset > 0)
     697    }
     698
     699    if (m_pSegDir->pGuidTab.offset != 0xffffffff)
     700    {
    277701        m_pGUID = (GUID *)((char *)m_pTypeLib + m_pSegDir->pGuidTab.offset);
    278     else
     702        dprintf((LOG, "  GuidTab       0x%08lx", m_pSegDir->pGuidTab.offset));
     703    }
     704    else
     705    {
    279706        m_pGUID = 0;
    280 
    281     if (m_pSegDir->pNameTab.offset > 0)
     707    }
     708
     709    if (m_pSegDir->pNameTab.offset != 0xffffffff)
     710    {
    282711        m_pName = (TLBName *)((char *)m_pTypeLib + m_pSegDir->pNameTab.offset);
    283     else
     712        dprintf((LOG, "  NameTab       0x%08lx", m_pSegDir->pNameTab.offset));
     713    }
     714    else
     715    {
    284716        m_pName = 0;
    285 
    286     if (m_pSegDir->pStringTab.offset > 0)
     717    }
     718
     719    if (m_pSegDir->pStringTab.offset != 0xffffffff)
     720    {
    287721        m_pString = (TLBString *)((char *)m_pTypeLib + m_pSegDir->pStringTab.offset);
    288     else
     722        dprintf((LOG, "  StringTab     0x%08lx", m_pSegDir->pStringTab.offset));
     723    }
     724    else
     725    {
    289726        m_pString = 0;
    290 
    291     if (m_pSegDir->pTypedescTab.offset > 0)
     727    }
     728
     729    if (m_pSegDir->pTypedescTab.offset != 0xffffffff)
     730    {
    292731        m_pTypedesc = (TLBTypedesc *)((char *)m_pTypeLib + m_pSegDir->pTypedescTab.offset);
    293     else
     732        dprintf((LOG, "  TypedescTab   0x%08lx", m_pSegDir->pTypedescTab.offset));
     733    }
     734    else
     735    {
    294736        m_pTypedesc = 0;
    295 
    296     if (m_pSegDir->pTypedescTab.offset > 0)
    297         m_pArray = (TLBArray *)((char *)m_pTypeLib + m_pSegDir->pTypedescTab.offset);
    298     else
     737    }
     738
     739    if (m_pSegDir->pCustData.offset != 0xffffffff)
     740    {
     741        m_pCustData = (void *)((char *)m_pTypeLib + m_pSegDir->pCustData.offset);
     742        dprintf((LOG, "  CustData      0x%08lx", m_pSegDir->pCustData.offset));
     743    }
     744    else
     745    {
     746        m_pCustData = 0;
     747    }
     748
     749    if (m_pSegDir->pCDGuids.offset != 0xffffffff)
     750    {
     751        m_pCDGuid = (TLBCDGuid *)((char *)m_pTypeLib + m_pSegDir->pCDGuids.offset);
     752        dprintf((LOG, "  CDGuids       0x%08lx", m_pSegDir->pCDGuids.offset));
     753    }
     754    else
     755    {
     756        m_pCDGuid = 0;
     757    }
     758
     759    if (m_pSegDir->pImpFiles.offset != 0xffffffff)
     760    {
     761        m_pImpFile = (TLBImpFile *)((char *)m_pTypeLib + m_pSegDir->pImpFiles.offset);
     762        dprintf((LOG, "  ImpFiles      0x%08lx", m_pSegDir->pImpFiles.offset));
     763    }
     764    else
     765    {
     766        m_pImpFile = 0;
     767    }
     768
     769    if (m_pSegDir->pTypeInfoTab.offset != 0xffffffff)
     770    {
     771        m_pTypeInfo = (TLBTypeInfoBase *)((char *)m_pTypeLib + m_pSegDir->pTypeInfoTab.offset);
     772        dprintf((LOG, "  TypeInfoTab   0x%08lx", m_pSegDir->pTypeInfoTab.offset));
     773    }
     774    else
     775    {
     776        m_pTypeInfo = 0;
     777    }
     778
     779    if (m_pSegDir->pArrayDescriptions.offset != 0xffffffff)
     780    {
     781        m_pArray = (TLBArray *)((char *)m_pTypeLib + m_pSegDir->pArrayDescriptions.offset);
     782        dprintf((LOG, "  ArrayDesc     0x%08lx", m_pSegDir->pArrayDescriptions.offset));
     783    }
     784    else
     785    {
    299786        m_pArray = 0;
    300 
    301     if (m_pSegDir->pCustData.offset > 0)
    302         m_pCustData = (void *)((char *)m_pTypeLib + m_pSegDir->pCustData.offset);
    303     else
    304         m_pCustData = 0;
    305 
    306     if (m_pSegDir->pCDGuids.offset > 0)
    307         m_pCDGuid = (TLBCDGuid *)((char *)m_pTypeLib + m_pSegDir->pCDGuids.offset);
    308     else
    309         m_pCDGuid = 0;
    310 
    311     if (m_pSegDir->pImpFiles.offset > 0)
    312         m_pImpFile = (TLBImpFile *)((char *)m_pTypeLib + m_pSegDir->pImpFiles.offset);
    313     else
    314         m_pImpFile = 0;
    315 
    316     if (m_pSegDir->pTypeInfoTab.offset > 0)
    317         m_pTypeInfo = (TLBTypeInfoBase *)((char *)m_pTypeLib + m_pSegDir->pTypeInfoTab.offset);
    318     else
    319         m_pTypeInfo = 0;
     787    }
     788
     789    if (m_pSegDir->pRes7.offset != 0xffffffff)
     790    {
     791        m_pRes7 = (void *)((char *)m_pTypeLib + m_pSegDir->pRes7.offset);
     792        dprintf((LOG, "  Res7          0x%08lx", m_pSegDir->pRes7.offset));
     793    }
     794    else
     795    {
     796        m_pRes7 = 0;
     797    }
     798
     799    if (m_pSegDir->pResE.offset != 0xffffffff)
     800    {
     801        m_pResE = (void *)((char *)m_pTypeLib + m_pSegDir->pResE.offset);
     802        dprintf((LOG, "  ResE          0x%08lx", m_pSegDir->pResE.offset));
     803    }
     804    else
     805    {
     806        m_pResE = 0;
     807    }
     808
     809    if (m_pSegDir->pResF.offset != 0xffffffff)
     810    {
     811        m_pResF = (void *)((char *)m_pTypeLib + m_pSegDir->pResF.offset);
     812        dprintf((LOG, "  ResF          0x%08lx", m_pSegDir->pResF.offset));
     813    }
     814    else
     815    {
     816        m_pResF = 0;
     817    }
    320818
    321819    return S_OK;
    … …  
    5091007        default:
    5101008            size = 0;
    511             dprintf(("OLEAUT32: VARTYPE %d is not supported, setting pointer to NULL\n", pVar->vt));
     1009            dprintf((LOG, " VARTYPE %d is not supported, setting pointer to NULL\n", pVar->vt));
    5121010    }
    5131011
    … …  
    5251023    TLBCustData *       pNew;
    5261024
    527     while (offset >=0)
     1025    while (offset != 0xffffffff)
    5281026    {
    5291027        pCDGuid = (TLBCDGuid *)((char *)m_pCDGuid + offset);
    5301028        pNew = new TLBCustData;
     1029        memset(pNew, 0, sizeof(*pNew)); // Ensure that unset fields get nulled out.
    5311030
    5321031        ParseGuid(pCDGuid->GuidOffset, &(pNew->guid));
    … …  
    5681067    ParseName(pBase->NameOffset, &pTypeInfo->szName);
    5691068
    570     dprintf(("  -> typeinfo \"%s\"\n", pTypeInfo->szName));
    571 
    5721069    /* help info */
    5731070    ParseString(pBase->docstringoffs, &pTypeInfo->szDocString);
    … …  
    5781075     */
    5791076
     1077#if defined(DEBUG)         
     1078    dprintfLine2();
     1079    dprintf((LOG, "TypeInfo        %s", pTypeInfo->szName));
     1080    dprintf((LOG, "  .typeKind:    %08x (%s)", pTypeInfo->TypeAttr.typekind,
     1081                                                TypeKindAsString(pTypeInfo->TypeAttr.typekind)));
     1082    char        guid[128];
     1083    WINE_StringFromCLSID(&pTypeInfo->TypeAttr.guid, guid);
     1084    dprintf((LOG, "  .GUID:        %s", guid));
     1085    dprintf((LOG, "  .lcid:        %08x", pTypeInfo->TypeAttr.lcid));
     1086    dprintf((LOG, "  .memidCon:    %08x", pTypeInfo->TypeAttr.memidConstructor));
     1087    dprintf((LOG, "  .memidDest:   %08x", pTypeInfo->TypeAttr.memidDestructor));
     1088    dprintf((LOG, "  .SizeInst:    %08x", pTypeInfo->TypeAttr.cbSizeInstance));
     1089    dprintf((LOG, "  .cFuncs:      %08x", pTypeInfo->TypeAttr.cFuncs));
     1090    dprintf((LOG, "  .cVars:       %08x", pTypeInfo->TypeAttr.cVars));
     1091    dprintf((LOG, "  .cbAlignment: %08x", pTypeInfo->TypeAttr.cbAlignment));
     1092    dprintf((LOG, "  .TypeFlags:   %08x", pTypeInfo->TypeAttr.wTypeFlags));
     1093    dprintf((LOG, "  .MajorVerNum: %08x", pTypeInfo->TypeAttr.wMajorVerNum));
     1094    dprintf((LOG, "  .MinorVerNum: %08x", pTypeInfo->TypeAttr.wMinorVerNum));
     1095    dprintf((LOG, "  .cImplTypes:  %08x", pTypeInfo->TypeAttr.cImplTypes));
     1096    dprintf((LOG, "  .cbSizeVft:   %08x", pTypeInfo->TypeAttr.cbSizeVft));
     1097#endif
     1098
    5801099    // Functions/
    5811100    ParseMembers(pTypeInfo, pBase);
    … …  
    5881107    else if (pTypeInfo->TypeAttr.typekind != TKIND_DISPATCH)
    5891108    {
    590         TLBRefType *    pNew = new TLBRefType;
    591         ParseReference(pBase->datatype1, pNew);
    592         pTypeInfo->pImplements.AddAtEnd(pNew);
    593 
     1109        if (pBase->datatype1 != 0xffffffff)
     1110        {
     1111            TLBRefType *        pNew = new TLBRefType;
     1112            memset(pNew, 0, sizeof(*pNew));     // Ensure that unset fields get nulled out.
     1113
     1114            dprintf((LOG, "Datatype1:      %08x", pBase->datatype1));
     1115            ParseReference(pBase->datatype1, pNew);
     1116            pTypeInfo->pImplements.AddAtEnd(pNew);
     1117        }
    5941118    }
    5951119
    5961120    // Load Custom data
    5971121    ParseCustomData(pBase->oCustData, &pTypeInfo->pCustData);
     1122
     1123#if defined(DEBUG)         
     1124    dprintfLine();
     1125#endif
     1126
    5981127}
    5991128
    … …  
    6241153            }
    6251154        }
    626         dprintf((" WARNING: Cannot find a reference\n"));
     1155        dprintf((LOG, " WARNING: Cannot find a reference\n"));
    6271156        pNew->reference = -1;
    6281157        pNew->pImpTLInfo = (TLBImpLib *)-1;
    … …  
    6561185        pRefRec = (TLBRefRecord *)((char *)m_pRef + offset);
    6571186        pNew = new TLBRefType;
     1187        memset(pNew, 0, sizeof(*pNew)); // Ensure that unset fields get nulled out.
    6581188
    6591189        ParseReference(pRefRec->reftype, pNew);
    … …  
    6981228void    TypeLibExtract::ParseMembers(ITypeInfoImpl * pTypeInfo, TLBTypeInfoBase * pBase)
    6991229{
     1230    char *              pMemberRec;
    7001231    TLBFuncRecord *     pFuncRec;
    7011232    TLBVarRecord *      pVarRec;
    … …  
    7071238    INT *               pMemberID;
    7081239    INT *               pMemberOff;
     1240    INT *               pDefaultOff;
     1241    INT *               pCustomOff;
     1242    LONG                lMembers = pTypeInfo->TypeAttr.cFuncs + pTypeInfo->TypeAttr.cVars;
    7091243
    7101244    // Map ptrs to sections of the typeinfo record...
    7111245    pInfoLen = (INT *)((char *)m_pTypeLib + pBase->memoffset);
    712     pFuncRec = (TLBFuncRecord *)(pInfoLen + 1);
    713     pMemberID = (INT *)((char *)pFuncRec + *pInfoLen);
    714     pNameOff = pMemberID + pTypeInfo->TypeAttr.cFuncs + pTypeInfo->TypeAttr.cVars;
    715     pMemberOff = pNameOff + pTypeInfo->TypeAttr.cFuncs + pTypeInfo->TypeAttr.cVars;
     1246    pMemberRec = (char *)(pInfoLen + 1);
     1247    pMemberID = (INT *)(pMemberRec + *pInfoLen);
     1248    pNameOff = pMemberID + lMembers;
     1249    pMemberOff = pNameOff + lMembers;
    7161250
    7171251    // loop through each function...
    7181252    for (ii = 0; ii < pTypeInfo->TypeAttr.cFuncs; ii++)
    7191253    {
     1254        // Get record...
     1255        pFuncRec = (TLBFuncRecord *)(pMemberRec + pMemberOff[ii]);
     1256
    7201257        TLBFuncDesc *   pNew;
    7211258
    7221259        pNew = new TLBFuncDesc;
     1260        memset(pNew, 0, sizeof(*pNew)); // Ensure that unset fields get nulled out.
     1261
    7231262        ParseName(pNameOff[ii], &pNew->szName);
    724 
    725         dprintf(("    -> function \"%s\"\n", pNew->szName));
    726 
    727         // decode optional attributes
    728         iAttrCount = (pFuncRec->recsize
    729                         - pFuncRec->nrargs * 3 * sizeof(int) - 0x18) / sizeof(int);
    730 
    731         if (iAttrCount > 0)
    732             pNew->helpcontext = pFuncRec->OptAttr[0] ;
    733 
    734         if (iAttrCount > 1)
    735             ParseString(pFuncRec->OptAttr[1], &pNew->szHelpString);
    736 
    737         if (iAttrCount > 2)
    738         {
    739             if (pFuncRec->FKCCIC & 0x2000)
    740                 pNew->szEntry = (char *) pFuncRec->OptAttr[2] ;
    741             else
    742                 ParseString(pFuncRec->OptAttr[2], &pNew->szEntry);
    743         }
    744 
    745         if (iAttrCount > 5 )
    746             pNew->lHelpStringContext = pFuncRec->OptAttr[5] ;
    747 
    748         if (iAttrCount > 6 && pFuncRec->FKCCIC & 0x80)
    749             ParseCustomData(pFuncRec->OptAttr[6], &pNew->pCustData);
    750 
    7511263        // fill the FuncDesc Structure
    7521264        pNew->funcdesc.memid = pMemberID[ii];
    … …  
    7601272        GetTypedesc(pFuncRec->DataType, &pNew->funcdesc.elemdescFunc.tdesc) ;
    7611273
     1274        // Calc remaining attributes to be decoded.
     1275        iAttrCount = pFuncRec->recsize
     1276                        - 24            // OFFSETOF(OptAttr[0])
     1277                        - (pFuncRec->nrargs * sizeof(TLBParameterInfo));
     1278
     1279        iAttrCount /= sizeof(INT);
     1280
     1281        // If the 'default values' flag is set
     1282        // allow for a default value for each argument
     1283        // (include the return value)
     1284        if (pFuncRec->FKCCIC & 0x1000)
     1285            iAttrCount -= pFuncRec->nrargs;
     1286
     1287        // If the 'custom data' flag is set
     1288        // allow for one dataoffset for the method
     1289        // plus one for each argument
     1290        // (include the return value)
     1291        if (pFuncRec->FKCCIC & 0x0080)
     1292            iAttrCount -= pFuncRec->nrargs + 1;
     1293
     1294        // Loop through 'size specified' block to rip info...
     1295        for (jj = 0; jj < iAttrCount; jj++)
     1296        {
     1297            switch(jj)
     1298            {
     1299                case 0:
     1300                    pNew->helpcontext = pFuncRec->OptAttr[jj];
     1301                    break;
     1302
     1303                case 1:
     1304                    ParseString(pFuncRec->OptAttr[jj], &pNew->szHelpString);
     1305                    break;
     1306
     1307                case 2:
     1308                    if (pFuncRec->FKCCIC & 0x2000)
     1309                        pNew->szEntry = (char *)(pFuncRec->OptAttr[jj]);
     1310                    else
     1311                        ParseString(pFuncRec->OptAttr[jj], &pNew->szEntry);
     1312                    break;
     1313
     1314                case 5:
     1315                    pNew->lHelpStringContext = pFuncRec->OptAttr[jj];
     1316                    break;
     1317
     1318                default:
     1319                    if (pFuncRec->OptAttr[jj] != 0xffffffff)
     1320                        dprintf((LOG, "- skipping pFuncRec->OptAttr[%lx] (%08x)...",
     1321                                jj, pFuncRec->OptAttr[jj]));
     1322            }
     1323        }
     1324
     1325        // Default & custom data come after size specified' block...
     1326        pCustomOff = pDefaultOff = pFuncRec->OptAttr + iAttrCount;
     1327
     1328        // Only advance custom data if there are defaults...
     1329        if (pFuncRec->FKCCIC & 0x1000)
     1330            pCustomOff += pFuncRec->nrargs;
     1331
     1332        // Rip the method custom data...
     1333        if (pFuncRec->FKCCIC & 0x80)
     1334            ParseCustomData(pCustomOff[0], &pNew->pCustData);
     1335
     1336#if defined(DEBUG)
     1337        {
     1338        dprintfLine();
     1339        char     buf[1024];
     1340        dprintf((LOG, "Method          \"%s\"\n", pNew->szName));
     1341        dprintf((LOG, "  .memid        %08x", pNew->funcdesc.memid));
     1342        dprintf((LOG, "  .funckind     %08x (%s)",
     1343                                    pNew->funcdesc.funckind,
     1344                                    FuncKindAsString(pNew->funcdesc.funckind)));
     1345        dprintf((LOG, "  .invkind      %08x (%s)",
     1346                                    pNew->funcdesc.invkind,
     1347                                    InvKindAsString(pNew->funcdesc.invkind)));
     1348        dprintf((LOG, "  .callconv     %08x (%s)",
     1349                                    pNew->funcdesc.callconv,
     1350                                    CallConvAsString(pNew->funcdesc.callconv)));
     1351        dprintf((LOG, "  .cParams      %08x", pNew->funcdesc.cParams));
     1352        dprintf((LOG, "  .cParamsOpt   %08x", pNew->funcdesc.cParamsOpt));
     1353        dprintf((LOG, "  .oVft         %08x", pNew->funcdesc.oVft));
     1354        sprintfFlags(buf, FuncFlagData, pNew->funcdesc.wFuncFlags);
     1355        dprintf((LOG, "  .wFuncFlags   %s", buf));
     1356        sprintfTypeDesc(buf, &pNew->funcdesc.elemdescFunc.tdesc);
     1357        dprintf((LOG, "  .tdesc        %s", buf));
     1358        dprintf((LOG, "  .helpcontext  %08x", pNew->helpcontext));
     1359        dprintf((LOG, "  .helpstring   %s", pNew->szHelpString));
     1360        if (pFuncRec->FKCCIC & 0x2000)
     1361            dprintf((LOG, "  .entry        %08x", pNew->szHelpString));
     1362        else
     1363            dprintf((LOG, "  .entry        %s", pNew->szHelpString));
     1364#if 0
     1365        dprintf((LOG, "pFuncRec"));
     1366        dprintf((LOG, "  .recsize      %08lx", pFuncRec->recsize));
     1367        dprintf((LOG, "  .index        %08lx", pFuncRec->index));
     1368        dprintf((LOG, "  .Datatype     %08lx", pFuncRec->DataType));
     1369        dprintf((LOG, "  .Flags        %08lx", pFuncRec->Flags));
     1370        dprintf((LOG, "  .res3         %08lx", pFuncRec->res3));
     1371
     1372        sprintfFlags(buf, FKCCICFlagData, pFuncRec->FKCCIC);
     1373        dprintf((LOG, "  .FKCCIC       %08lx (%s)", pFuncRec->FKCCIC, buf));
     1374        dprintf((LOG, "  .nrargs       %04lx", pFuncRec->nrargs));
     1375        dprintf((LOG, "  .nroargs      %04lx", pFuncRec->nroargs));
     1376        for (jj = 0;
     1377                (pFuncRec->recsize
     1378                    - (jj * sizeof(INT))
     1379                    - 24
     1380                    - (pFuncRec->nrargs * sizeof(TLBParameterInfo))) > 0 ;
     1381                jj++)
     1382            dprintf((LOG, "  .optattr[%d]   %08lx", jj, pFuncRec->OptAttr[jj]));
     1383
     1384#endif // 0
     1385        }
     1386#endif // defined(DEBUG)
     1387
    7621388        // do the parameters/arguments
    7631389        if (pFuncRec->nrargs)
    … …  
    7791405                // Name
    7801406                ParseName(pParam->oName, &pNew->pParamDesc[jj].szName);
    781                 dprintf(("      -> param \"%s\"\n", pNew->pParamDesc[jj].szName));
    7821407
    7831408                // default value
    7841409                if ((PARAMFLAG_FHASDEFAULT & V_UNION(&(pNew->funcdesc.
    785                     lprgelemdescParam[jj]),paramdesc.wParamFlags)) &&
    786                     ((pFuncRec->FKCCIC) & 0x1000))
     1410                        lprgelemdescParam[jj]),paramdesc.wParamFlags)) )
    7871411                {
    788                     INT *pInt = (INT *)((char *)pFuncRec + pFuncRec->recsize -
    789                         (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
    790                     PARAMDESC * pParamDesc =  &V_UNION(&(pNew->funcdesc.
    791                         lprgelemdescParam[jj]),paramdesc);
    792                     pParamDesc->pparamdescex  = new PARAMDESCEX;
    793                     pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
    794                     ParseValue(pInt[jj], &(pParamDesc->pparamdescex->varDefaultValue));
     1412                    if (pDefaultOff[jj] != 0xffffffff)  // jic
     1413                    {
     1414                        PARAMDESC * pParamDesc =  &V_UNION(&(pNew->funcdesc.
     1415                                lprgelemdescParam[jj]), paramdesc);
     1416                        pParamDesc->pparamdescex  = new PARAMDESCEX;
     1417                        pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
     1418                        ParseValue(pDefaultOff[jj], &(pParamDesc->pparamdescex->varDefaultValue));
     1419                    }
    7951420                }
    7961421
    7971422                // custom info
    798                 if (iAttrCount > 7 + jj && pFuncRec->FKCCIC & 0x80)
    799                     ParseCustomData(pFuncRec->OptAttr[7 + jj], &pNew->pParamDesc[jj].pCustData);
     1423                if (pFuncRec->FKCCIC & 0x80)
     1424                    ParseCustomData(pCustomOff[1 + jj], &pNew->pParamDesc[jj].pCustData);
     1425
     1426#if defined(DEBUG)
     1427        dprintfLine();
     1428        dprintf((LOG, "Parameter       \"%s\"\n", pNew->pParamDesc[jj].szName));
     1429        char    buf[1024];
     1430        sprintfTypeDesc(buf, &pNew->funcdesc.lprgelemdescParam[jj].tdesc);
     1431        dprintf((LOG, "  .tdesc        %s", buf));
     1432        sprintfFlags(buf, ParamFlagData,
     1433                V_UNION(&pNew->funcdesc.lprgelemdescParam[jj], paramdesc.wParamFlags));
     1434        dprintf((LOG, "  .wParamFlags  %s", buf));
     1435#endif
     1436
    8001437
    8011438                pParam++;       // Next record.
    … …  
    8101447        pTypeInfo->pFunctions.AddAtEnd(pNew);
    8111448
    812         // Next record...
    813         pFuncRec = (TLBFuncRecord *)((char *)pFuncRec + pFuncRec->recsize);
    814     }
    815 
    816     // Wine calc's for this ptr were b**ll***s
    817     pVarRec = (TLBVarRecord *)pFuncRec;
     1449    }
    8181450
    8191451    for (ii = 0; ii < pTypeInfo->TypeAttr.cVars; ii++)
    8201452    {
     1453        // Get record...
     1454        pVarRec = (TLBVarRecord *)(pMemberRec + pMemberOff[pTypeInfo->TypeAttr.cFuncs + ii]);
     1455
    8211456        TLBVarDesc *    pNew;
    8221457
    8231458        pNew = new TLBVarDesc;
     1459        memset(pNew, 0, sizeof(*pNew)); // Ensure that unset fields get nulled out.
    8241460
    8251461        // name, eventually add to a hash table
    8261462        ParseName(pNameOff[ii], &pNew->szName);
    827         dprintf(("    -> variable \"%s\"\n", pNew->szName));
     1463
     1464        // Calc remaining attributes to be decoded.
     1465        iAttrCount = pVarRec->recsize - 20;
     1466
     1467        iAttrCount /= sizeof(INT);
    8281468
    8291469        // Optional data
    830         if (pVarRec->recsize > (6 * sizeof(INT)) )
    831             pNew->lHelpContext = pVarRec->HelpContext;
    832 
    833         if (pVarRec->recsize > (7 * sizeof(INT)) )
    834             ParseString(pVarRec->oHelpString, &pNew->szHelpString);
    835 
    836         if (pVarRec->recsize > (8 * sizeof(INT)) )
    837             ;
    838 
    839         if (pVarRec->recsize > (9 * sizeof(INT)) )
    840             pNew->lHelpStringContext = pVarRec->HelpStringContext;
     1470        for (jj = 0; jj < iAttrCount; jj++)
     1471        {
     1472            switch(jj)
     1473            {
     1474                case 0:
     1475                    pNew->lHelpContext = pVarRec->OptAttr[jj];
     1476                    break;
     1477
     1478                case 1:
     1479                    ParseString(pVarRec->OptAttr[jj], &pNew->szHelpString);
     1480                    break;
     1481
     1482                case 4:
     1483                    pNew->lHelpStringContext = pVarRec->OptAttr[jj];
     1484                    break;
     1485
     1486                default:
     1487                    if (pVarRec->OptAttr[jj] != 0xffffffff)
     1488                        dprintf((LOG, "- skipping pVarRec->OptAttr[%lx] (%08x)...",
     1489                                jj, pVarRec->OptAttr[jj]));
     1490
     1491            }
     1492        }
    8411493
    8421494        // fill the VarDesc Structure
    … …  
    8541506            V_UNION(&(pNew->vardesc), oInst) = pVarRec->OffsValue;
    8551507
     1508#if defined(DEBUG)
     1509        {
     1510        dprintfLine();
     1511        char     buf[1024];
     1512        dprintf((LOG, "Variable        \"%s\"\n", pNew->szName));
     1513        dprintf((LOG, "  .MemberID     %08x", pNew->vardesc.memid));
     1514        dprintf((LOG, "  .VarKind      %08x (%s)",
     1515                                        pNew->vardesc.varkind,
     1516                                        VarKindAsString(pNew->vardesc.varkind)));
     1517        sprintfFlags(buf, FuncFlagData, pNew->vardesc.wVarFlags);
     1518        dprintf((LOG, "  .VarFlags     %08x %s", pNew->vardesc.wVarFlags, buf));
     1519        sprintfTypeDesc(buf, &pNew->vardesc.elemdescVar.tdesc);
     1520        dprintf((LOG, "  .TDesc        %s", buf));
     1521        dprintf((LOG, "  .HelpContext  %08x", pNew->lHelpContext));
     1522        dprintf((LOG, "  .HelpStrCtx   %08x", pNew->lHelpStringContext));
     1523        dprintf((LOG, "  .HelpStr      %s", pNew->szHelpString));
     1524
     1525        dprintf((LOG, "pVarRec"));
     1526        for (jj = 0; jj < iAttrCount; jj++)
     1527            dprintf((LOG, "  .optattr[%d]   %08lx", jj, pVarRec->OptAttr[jj]));
     1528        }
     1529
     1530#endif // defined(DEBUG)
     1531
    8561532        // Store
    8571533        pTypeInfo->pVariables.AddAtEnd(pNew);
    858 
    859         // Next record...
    860         pVarRec = (TLBVarRecord *)((char *)pVarRec + pVarRec->recsize);
    861     }
    862 }
     1534    }
     1535}
     1536
     1537typedef struct LoadSt
     1538{
     1539    ULONG       cLibs;
     1540    VOID * *    ppLib;
     1541} LoadSt;
    8631542
    8641543// ----------------------------------------------------------------------
    … …  
    8691548static BOOL     WIN32API LoadSub(HANDLE hMod, LPCTSTR pResType, LPTSTR pResName, LONG lParm)
    8701549{
    871     dprintf((" LoadSub called"));
    872     HRSRC       hRsrc;
    873     HGLOBAL     hData;
    874 
    875     hRsrc = FindResourceA(hMod, pResName, pResType);
    876     hData =  LoadResource(hMod, hRsrc);
    877     *((void **)lParm) = LockResource(hData);
    878     return FALSE;
     1550    LoadSt *    pLoad = (LoadSt *)lParm;
     1551
     1552    if (--pLoad->cLibs == 0)
     1553    {
     1554
     1555        HRSRC   hRsrc;
     1556        HGLOBAL hData;
     1557
     1558        hRsrc = FindResourceA(hMod, pResName, pResType);
     1559        hData =  LoadResource(hMod, hRsrc);
     1560        *(pLoad->ppLib) = LockResource(hData);
     1561        return FALSE;
     1562    }
     1563    return TRUE;
    8791564}
    8801565
    … …  
    8931578    HANDLE              hFile;
    8941579    HRESULT             rc;
    895 
    896     dprintf(("OLEAUT32: TypeLibExtract::Load()"));
     1580    HINSTANCE           hInst;
     1581    LoadSt              loadData;
     1582
     1583    dprintf((LOG, "TypeLibExtract::Load()"));
    8971584
    8981585    // Open file
    899     if ((hFile = OpenFile(szFile, &ofStruct, OF_READ)) == HFILE_ERROR)
    900     {
    901         dprintf(("  Error opening file - 0x%08x", GetLastError()));
    902         return E_ACCESSDENIED;
    903     }
    904 
    905     lStart = 0;
    906 
    907     // Read first four byts of file to identify it...
    908     if (!Read(hFile, (void *)buf, 4, &lReadLen, lStart))
    909     {
    910         CloseHandle(hFile);
    911         dprintf(("  Failed to read file start bytes"));
    912         return E_FAIL;
    913     }
    914 
    915     // Check to see if this is a type 1 typelib...
    916     if ((buf[0] == 'S') && (buf[1] == 'L') && (buf[2] == 'T') && (buf[3] == 'G'))
    917     {
    918         dprintf(("  File identified as TYPE1 TYPELIB - not supported yet :-("));
    919         CloseHandle(hFile);
    920         return E_FAIL;
    921     }
    922 
    923     // Check to see if this is a type 2 typelib...
    924     if ((buf[0] == 'M') && (buf[1] == 'S') && (buf[2] == 'F') && (buf[3] == 'T'))
    925     {
    926         // Get typelib file size...
    927         lFileSize = GetFileSize(hFile, NULL);
    928         dprintf(("  File identified as TYPE2 TYPELIB - Loading image (%lu bytes)...", lFileSize));
    929 
    930         m_pTypeLib = HeapAlloc(m_hHeap, 0, lFileSize);
    931         if (!m_pTypeLib)
     1586    if ((hFile = OpenFile(szFile, &ofStruct, OF_READ)) != HFILE_ERROR)
     1587    {
     1588        lStart = 0;
     1589
     1590        // Read first four byts of file to identify it...
     1591        if (!Read(hFile, (void *)buf, 4, &lReadLen, lStart))
    9321592        {
    9331593            CloseHandle(hFile);
    934             dprintf(("  Failed to allocate a memory pool for typelib image"));
    935             return E_OUTOFMEMORY;
     1594            dprintf((LOG, "  Failed to read file start bytes"));
     1595            return E_FAIL;
    9361596        }
    9371597
    938         // Read whole file into memory...
    939         if (!Read(hFile, m_pTypeLib, lFileSize, &lReadLen, lStart))
     1598        // Check to see if this is a type 1 typelib...
     1599        if ((buf[0] == 'S') && (buf[1] == 'L') && (buf[2] == 'T') && (buf[3] == 'G'))
    9401600        {
    9411601            CloseHandle(hFile);
    942             dprintf(("  Failed to read typelib"));
    943             HeapFree(m_hHeap, 0, m_pTypeLib);
     1602            dprintf((LOG, "  File identified as TYPE1 TYPELIB - not supported yet :-("));
    9441603            return E_FAIL;
    9451604        }
    9461605
    947         // Return buffer...
     1606        // Check to see if this is a type 2 typelib...
     1607        if ((buf[0] == 'M') && (buf[1] == 'S') && (buf[2] == 'F') && (buf[3] == 'T'))
     1608        {
     1609            // Get typelib file size...
     1610            lFileSize = GetFileSize(hFile, NULL);
     1611            dprintf((LOG, "  File identified as TYPE2 TYPELIB - Loading image (%lu bytes)", lFileSize));
     1612
     1613            m_pTypeLib = HeapAlloc(m_hHeap, 0, lFileSize);
     1614            if (!m_pTypeLib)
     1615            {
     1616                CloseHandle(hFile);
     1617                dprintf((LOG, "  Failed to allocate a memory pool for typelib image"));
     1618                return E_OUTOFMEMORY;
     1619            }
     1620
     1621            // Read whole file into memory...
     1622            if (!Read(hFile, m_pTypeLib, lFileSize, &lReadLen, lStart))
     1623            {
     1624                CloseHandle(hFile);
     1625                dprintf((LOG, "  Failed to read typelib"));
     1626                HeapFree(m_hHeap, 0, m_pTypeLib);
     1627                return E_FAIL;
     1628            }
     1629
     1630            // Return buffer...
     1631            CloseHandle(hFile);
     1632            m_fFree = TRUE;
     1633            return S_OK;
     1634        }
     1635
     1636        // Done with file handle...
    9481637        CloseHandle(hFile);
    949         return S_OK;
    950     }
    951 
    952     // Done with file handle...
    953     CloseHandle(hFile);
    954 
    955     HINSTANCE           hInst;
     1638    }
     1639    else
     1640    {
     1641        // Failed to open file - Check to see if this is a request for a given resource
     1642        HRSRC                   hRsrc;
     1643        HGLOBAL                 hData;
     1644        char *                  szLibName = HEAP_strdupA(m_hHeap, 0, szFile);
     1645        char *                  p = strrchr(szLibName, '\\');
     1646        ULONG                   lResId;
     1647
     1648        if (p)
     1649        {
     1650            // Filename of form {drive:}{\\path\\}file\\resid
     1651            *p = 0;
     1652            lResId = atoi(p + 1);
     1653            hInst = CoLoadLibrary(szLibName, TRUE);
     1654            HeapFree(m_hHeap, 0, szLibName);
     1655            if (hInst != 0)
     1656            {
     1657                HRSRC   hRsrc;
     1658                HGLOBAL hData;
     1659
     1660                if ((hRsrc = FindResourceA(hInst, (LPTSTR)lResId, "TYPELIB")) != 0)
     1661                {
     1662                    hData =  LoadResource(hInst, hRsrc);
     1663                    m_pTypeLib = LockResource(hData);
     1664                    return S_OK;
     1665                }
     1666                return E_FAIL;
     1667            }
     1668        }
     1669        HeapFree(m_hHeap, 0, szLibName);
     1670    }
    9561671
    9571672    // Check to see if this is a module...
    … …  
    9591674    if (hInst)
    9601675    {
    961         // Yup - use EnumResourceNames to locate & load resource.
    962         EnumResourceNamesA(hInst, "TYPELIB", LoadSub, (LONG)&m_pTypeLib);
    963     }
    964 
    965     if (!m_pTypeLib)
    966     {
    967         dprintf(("  No TYPELIB resources found..."));
    968         return E_FAIL;
    969     }
    970 
    971     return S_OK;
    972 }
    973 
    974 // ----------------------------------------------------------------------
    975 // TypeLibExtract::DumpHeader
    976 //
    977 // Drop a debug print of the header content to the ODIN log.
    978 // ----------------------------------------------------------------------
    979 void TypeLibExtract::DumpHeader()
    980 {
    981     dprintf(("TYPELIB HEADER:"));
    982     if (m_fValid)
    983     {
    984         dprintf(("  Magic1            - 0x%08lx", m_pHeader->magic1));
    985         dprintf(("  Magic2            - 0x%08lx", m_pHeader->magic2));
    986         dprintf(("  posguid           - 0x%08lx", m_pHeader->posguid));
    987         dprintf(("  lcid              - 0x%08lx", m_pHeader->lcid));
    988         dprintf(("  lcid2             - 0x%08lx", m_pHeader->lcid2));
    989         dprintf(("  varflags          - 0x%08lx", m_pHeader->varflags));
    990         dprintf(("  version           - 0x%08lx", m_pHeader->version));
    991         dprintf(("  flags             - 0x%08lx", m_pHeader->flags));
    992         dprintf(("  nrtypeinfos       - 0x%08lx", m_pHeader->nrtypeinfos));
    993         dprintf(("  helpstring        - 0x%08lx", m_pHeader->helpstring));
    994         dprintf(("  helpstringcontext - 0x%08lx", m_pHeader->helpstringcontext));
    995         dprintf(("  helpcontext       - 0x%08lx", m_pHeader->helpcontext));
    996         dprintf(("  nametablecount    - 0x%08lx", m_pHeader->nametablecount));
    997         dprintf(("  nametablechars    - 0x%08lx", m_pHeader->nametablechars));
    998         dprintf(("  nameoffset        - 0x%08lx", m_pHeader->nameOffset));
    999         dprintf(("  helpfile          - 0x%08lx", m_pHeader->helpfile));
    1000         dprintf(("  custdataoffset    - 0x%08lx", m_pHeader->customDataOffset));
    1001         dprintf(("  res44             - 0x%08lx", m_pHeader->res44));
    1002         dprintf(("  res48             - 0x%08lx", m_pHeader->res48));
    1003         dprintf(("  dispatchpos       - 0x%08lx", m_pHeader->dispatchpos));
    1004         dprintf(("  res50             - 0x%08lx", m_pHeader->res50));
    1005     }
    1006     else
    1007     {
    1008         dprintf(("  INVALID"));
    1009     }
     1676        loadData.cLibs = 1;
     1677        loadData.ppLib = &m_pTypeLib;
     1678        // Yup - use EnumResourceNames to locate & load 1st resource.
     1679        EnumResourceNamesA(hInst, "TYPELIB", LoadSub, (LONG)&loadData);
     1680        return m_pTypeLib ? S_OK : E_FAIL;
     1681    }
     1682
     1683    return E_FAIL;
    10101684}
    10111685
    … …  
    10151689HRESULT TypeLibExtract::MakeITypeLib(ITypeLibImpl * * ppObject)
    10161690{
    1017     dprintf(("OLEAUT32: TypeLibExtract::MakeITypeLib"));
     1691    dprintf((LOG, "TypeLibExtract::MakeITypeLib"));
    10181692
    10191693    HRESULT             rc;
    … …  
    10421716{
    10431717
    1044     dprintf(("OLEAUT32: TypeLibExtract::Parse"));
     1718    dprintf((LOG, "TypeLibExtract::Parse"));
     1719
     1720    // name, eventually add to a hash table
     1721    ParseName(m_pHeader->nameOffset, &m_pITypeLib->szName);
    10451722
    10461723    // Load header info...
    … …  
    10521729    m_pITypeLib->LibAttr.wMinorVerNum = HIWORD(m_pHeader->version);
    10531730    m_pITypeLib->LibAttr.wLibFlags = (WORD) m_pHeader->flags & 0xffff;  /* check mask */
    1054 
    1055     // name, eventually add to a hash table
    1056     ParseName(m_pHeader->nameOffset, &m_pITypeLib->szName);
    1057     dprintf((" reading library: \"%s\"", m_pITypeLib->szName));
    10581731
    10591732    // help info
    … …  
    10631736    if (m_pHelpStringOff)
    10641737        ParseString(*m_pHelpStringOff, &m_pITypeLib->szHelpStringDll);
     1738
     1739#if defined(DEBUG)
     1740
     1741    dprintfLine2();
     1742    dprintf((LOG, "Library:        \"%s\"", m_pITypeLib->szName));
     1743    char        guid[128];
     1744    WINE_StringFromCLSID(&m_pITypeLib->LibAttr.guid, guid);
     1745    dprintf((LOG, "  .GUID:        %s", guid));
     1746    dprintf((LOG, "  .lcid:        %08x", m_pITypeLib->LibAttr.lcid));
     1747    dprintf((LOG, "  .syskind:     %08x", m_pITypeLib->LibAttr.syskind));
     1748    dprintf((LOG, "  .MajorVer:    %08x", m_pITypeLib->LibAttr.wMajorVerNum));
     1749    dprintf((LOG, "  .MinorVer:    %08x", m_pITypeLib->LibAttr.wMinorVerNum));
     1750    dprintf((LOG, "  .LibFlags:    %08x", m_pITypeLib->LibAttr.wLibFlags));
     1751
     1752#endif
    10651753
    10661754    // Load Custom data
    … …  
    10831771        {
    10841772            pNew = new TYPEDESC;
     1773            memset(pNew, 0, sizeof(*pNew));     // Ensure that unset fields get nulled out.
    10851774            m_pITypeLib->pTypedesc.AddAtEnd(pNew);
    10861775        }
    … …  
    10921781
    10931782            pNew->vt = pTd->rec0 & VT_TYPEMASK;
    1094             if ((pNew->vt == VT_PTR) || (pNew->vt == VT_SAFEARRAY))
     1783            if (pNew->vt == VT_PTR)
    10951784            {
    1096                 if (pTd->rec3 < 0)
     1785                // >< 99.12.18 DJR Changed test
     1786                if ((pTd->rec3 & 0x8000))
    10971787                    V_UNION(pNew, lptdesc) = &stndTypeDesc[pTd->rec2];
    10981788                else
    1099                     V_UNION(pNew, lptdesc) = m_pITypeLib->pTypedesc[pTd->rec3 / 8];
     1789                    V_UNION(pNew, lptdesc) = m_pITypeLib->pTypedesc[pTd->rec2 / 8];
     1790            }
     1791            if (pNew->vt == VT_SAFEARRAY)
     1792            {
     1793                dprintf((LOG, "VT_SAFEARRAY - NIY"));
    11001794            }
    11011795            else if (pNew->vt == VT_CARRAY)
    … …  
    11261820                V_UNION(pNew, hreftype) = MAKELONG(pTd->rec2, pTd->rec3);
    11271821            }
     1822
     1823#if defined(DEBUG)         
     1824            dprintfLine2();
     1825            dprintf((LOG, "TypeDesc:       %i", ii));
     1826            char        buf[1024];
     1827            sprintfTypeDesc(buf, pNew);
     1828            dprintf((LOG, "  desc          %s", buf));
     1829            dprintf((LOG, "  pTd->rec0:    %04x", pTd->rec0));
     1830            dprintf((LOG, "  pTd->rec1:    %04x", pTd->rec1));
     1831            dprintf((LOG, "  pTd->rec2:    %04x", pTd->rec2));
     1832            dprintf((LOG, "  pTd->rec3:    %04x", pTd->rec3));
     1833            if (pNew->vt == VT_CARRAY)
     1834            {
     1835                dprintf((LOG, "  pArray->rec0: %04x", pArray->rec0));
     1836                dprintf((LOG, "  pArray->rec1: %04x", pArray->rec1));
     1837                dprintf((LOG, "  pArray->rec2: %04x", pArray->rec2));
     1838                dprintf((LOG, "  pArray->rec3: %04x", pArray->rec3));
     1839            }
     1840#endif
    11281841        }
    11291842    }
    … …  
    11411854        {
    11421855            pNew = new TLBImpLib;
     1856            memset(pNew, 0, sizeof(*pNew));     // Ensure that unset fields get nulled out.
    11431857            pNew->offset = totLen;
    11441858
    … …  
    11591873            totLen += recLen;
    11601874            pImpFile = (TLBImpFile *)((char *)pImpFile + recLen);
     1875#if defined(DEBUG)         
     1876            dprintfLine2();
     1877            dprintf((LOG, "ImpLib %i", pNew->offset));
     1878            char        guid[128];
     1879            WINE_StringFromCLSID(&(pNew->guid), guid);
     1880            dprintf((LOG, "  .GUID:        %s", guid));
     1881            dprintf((LOG, "  .Name:        %s", pNew->name));
     1882#endif
    11611883        }
    11621884    }
Note: See TracChangeset for help on using the changeset viewer.