Changeset 7934 for trunk/src


Ignore:
Timestamp:
Feb 16, 2002, 5:55:23 PM (24 years ago)
Author:
sandervl
Message:

typelib resync (wine 20021602)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/oleaut32/typelib.c

    r7508 r7934  
    5454#include "winnls.h"         /* for PRIMARYLANGID */
    5555#include "winreg.h"         /* for HKEY_LOCAL_MACHINE */
     56#include "winuser.h"
    5657
    5758#include "wine/unicode.h"
    … …  
    6869#ifdef __WIN32OS2__
    6970#include <neexe.h>
    70 #endif
    71 
    72 #ifndef __WIN32OS2__
     71#else
    7372/****************************************************************************
    7473 *              QueryPathOfRegTypeLib   [TYPELIB.14]
    … …  
    114113        return S_OK;
    115114}
    116 #endif
     115#endif
     116
    117117/****************************************************************************
    118118 *              QueryPathOfRegTypeLib   [OLEAUT32.164]
    … …  
    143143    char    szPath[dwPathLen];
    144144#endif
    145 
    146145    if ( !HIWORD(guid) )
    147146    {
    … …  
    219218    return E_FAIL;
    220219}
    221 #ifndef __WIN32OS2__
    222220/******************************************************************************
    223221 * LoadTypeLib [TYPELIB.3]  Loads and registers a type library
    … …  
    241239    return E_FAIL;
    242240}
    243 #endif
     241
    244242/******************************************************************************
    245243 *              LoadTypeLib     [OLEAUT32.161]
    … …  
    277275{
    278276    WCHAR szPath[MAX_PATH+1], szFileCopy[MAX_PATH+1];
    279     const WCHAR *pFile, *pIndexStr;
     277    WCHAR *pIndexStr;
    280278    HRESULT res;
    281279    INT index = 1;
    282280    TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
    283281   
    284     pFile = szFile;
    285282    if(!SearchPathW(NULL,szFile,NULL,sizeof(szPath)/sizeof(WCHAR),szPath,
    286283                    NULL)) {
    … …  
    293290                   (pIndexStr - szFile - 1) * sizeof(WCHAR));
    294291            szFileCopy[pIndexStr - szFile - 1] = '\0';
    295             pFile = szFileCopy;
    296292            if(!SearchPathW(NULL,szFileCopy,NULL,sizeof(szPath)/sizeof(WCHAR),
    297293                            szPath,NULL))
    298294                return TYPE_E_CANTLOADLIBRARY;
     295            if (GetFileAttributesW(szFileCopy) & FILE_ATTRIBUTE_DIRECTORY)
     296                return TYPE_E_CANTLOADLIBRARY;
    299297        } else
    300298            return TYPE_E_CANTLOADLIBRARY;
    301299    }
    302300
    303     TRACE("File %s index %d\n", debugstr_w(pFile), index);
    304 
    305     res = TLB_ReadTypeLib(pFile, index, (ITypeLib2**)pptLib);
     301    TRACE("File %s index %d\n", debugstr_w(szPath), index);
     302
     303    res = TLB_ReadTypeLib(szPath, index, (ITypeLib2**)pptLib);
    306304
    307305    if (SUCCEEDED(res))
    … …  
    704702    BSTR Name;             /* the name of this variable */
    705703    int HelpContext;
    706     int HelpStringContext;  /* fixme: where? */
     704    int HelpStringContext;  /* FIXME: where? */
    707705    BSTR HelpString;
    708706    int ctCustData;
    … …  
    769767static void MSFT_DoRefType(TLBContext *pcx, ITypeInfoImpl *pTI, int offset);
    770768
    771 //#define TYPELIBDEBUG
    772 #if defined(__WIN32OS2__) && defined(TYPELIBDEBUG)
    773 
     769#if defined(__WIN32OS2__) && defined(DEBUG)
    774770/*
    775771 debug
    … …  
    779775     * of the variant
    780776     */
    781     switch(vt) {
     777    if (vt & VT_RESERVED)
     778        szVarType += strlen(strcpy(szVarType, "reserved | "));
     779    if (vt & VT_BYREF)
     780        szVarType += strlen(strcpy(szVarType, "ref to "));
     781    if (vt & VT_ARRAY)
     782        szVarType += strlen(strcpy(szVarType, "array of "));
     783    if (vt & VT_VECTOR)
     784        szVarType += strlen(strcpy(szVarType, "vector of "));
     785    switch(vt & VT_TYPEMASK) {
    782786    case VT_UI1: sprintf(szVarType, "VT_UI"); break;
    783787    case VT_I2: sprintf(szVarType, "VT_I2"); break;
    … …  
    790794    case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
    791795    case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
    792     case VT_BYREF: case VT_UNKNOWN: sprintf(szVarType, "VT_BYREF"); break;
     796    case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
    793797    case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
    794     case VT_ARRAY: sprintf(szVarType, "VT_ARRAY"); break;
    795798    case VT_I1: sprintf(szVarType, "VT_I1"); break;
    796799    case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
    … …  
    798801    case VT_INT: sprintf(szVarType, "VT_INT"); break;
    799802    case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
     803    case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
     804    case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
    800805    case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED\n"); break;
    801     default: sprintf(szVarType, "unknown");break;
     806    default: sprintf(szVarType, "unknown(%d)", vt & VT_TYPEMASK); break;
    802807    }
    803808}
    804809
    805810static void dump_TypeDesc(TYPEDESC *pTD,char *szVarType) {
    806     switch(pTD->vt) {
     811    if (pTD->vt & VT_RESERVED)
     812        szVarType += strlen(strcpy(szVarType, "reserved | "));
     813    if (pTD->vt & VT_BYREF)
     814        szVarType += strlen(strcpy(szVarType, "ref to "));
     815    if (pTD->vt & VT_ARRAY)
     816        szVarType += strlen(strcpy(szVarType, "array of "));
     817    if (pTD->vt & VT_VECTOR)
     818        szVarType += strlen(strcpy(szVarType, "vector of "));
     819    switch(pTD->vt & VT_TYPEMASK) {
    807820    case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
    808821    case VT_I2: sprintf(szVarType, "VT_I2"); break;
    … …  
    815828    case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
    816829    case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
    817     case VT_BYREF: case VT_UNKNOWN: sprintf(szVarType, "VT_BYREF"); break;
     830    case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
    818831    case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
    819     case VT_ARRAY: sprintf(szVarType, "VT_ARRAY"); break;
    820832    case VT_I1: sprintf(szVarType, "VT_I1"); break;
    821833    case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
    … …  
    838850      break;
    839851
    840     default: sprintf(szVarType, "unknown");break;
     852    default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
    841853    }
    842854}
    … …  
    955967static void dump_Variant(VARIANT * pvar)
    956968{
    957     char szVarType[15];
     969    char szVarType[32];
     970    LPVOID ref;
    958971   
    959972    TRACE("(%p)\n", pvar);
    … …  
    969982
    970983    TRACE("VARTYPE: %s\n", szVarType);
    971    
     984
     985    if (V_VT(pvar) & VT_BYREF) {
     986      ref = V_UNION(pvar, byref);
     987      TRACE("%p\n", ref);
     988    }
     989    else ref = &V_UNION(pvar, cVal);
     990
     991    if (V_VT(pvar) & VT_ARRAY) {
     992      /* FIXME */
     993      return;
     994    }
     995    if (V_VT(pvar) & VT_VECTOR) {
     996      /* FIXME */
     997      return;
     998    }
     999
    9721000    switch (V_VT(pvar))
    9731001    {
     1002        case VT_I2:
     1003            TRACE("%d\n", *(short*)ref);
     1004            break;
     1005
     1006        case VT_I4:
     1007            TRACE("%d\n", *(INT*)ref);
     1008            break;
     1009
    9741010        case VT_R4:
    975             TRACE("%3.3e\n", V_UNION(pvar, fltVal));
     1011            TRACE("%3.3e\n", *(float*)ref);
    9761012            break;
    977            
     1013
    9781014        case VT_R8:
    979             TRACE("%3.3e\n", V_UNION(pvar, dblVal));
     1015            TRACE("%3.3e\n", *(double*)ref);
    9801016            break;
    981            
     1017
     1018        case VT_BOOL:
     1019            TRACE("%s\n", *(VARIANT_BOOL*)ref ? "TRUE" : "FALSE");
     1020            break;
     1021
     1022        case VT_BSTR:
     1023            TRACE("%s\n", debugstr_w(*(BSTR*)ref));
     1024            break;
     1025
     1026        case VT_UNKNOWN:
     1027        case VT_DISPATCH:
     1028            TRACE("%p\n", *(LPVOID*)ref);
     1029            break;
     1030
     1031        case VT_VARIANT:
     1032            if (V_VT(pvar) & VT_BYREF) dump_Variant(ref);
     1033            break;
     1034
    9821035        default:
    983             TRACE("%ld\n", V_UNION(pvar, lVal));
     1036            TRACE("(?)%ld\n", *(long*)ref);
    9841037            break;
    9851038    }       
    986 
    987     if (V_VT(pvar) & VT_BYREF)
    988       return dump_Variant(V_UNION(pvar,pvarVal));
    9891039}
    9901040
    … …  
    10481098#define  dump_TLBFuncDesc(a)
    10491099#define  dump_TypeDesc(a,b)
     1100#define  dump_Variant(a)
     1101#define  debugstr_an(a,b) NULL
    10501102#endif
    10511103
    … …  
    16221674        MSFT_GetTdesc(pcx, pVarRec->DataType,   
    16231675            &(*pptvd)->vardesc.elemdescVar.tdesc, pTI);
    1624 /*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
     1676/*   (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
    16251677        if(pVarRec->VarKind == VAR_CONST ){
    16261678            (*pptvd)->vardesc.u.lpvarValue=TLB_Alloc(sizeof(VARIANT));
    … …  
    17261778/* this is where we are coming from */
    17271779    ptiRet->pTypeLib = pLibInfo;
     1780    ITypeLib2_AddRef((ITypeLib2 *)pLibInfo);
    17281781    ptiRet->index=count;
    17291782/* fill in the typeattr fields */
    … …  
    19311984      ret = S_OK;
    19321985    else
    1933       ERR("Loading of typelib %s failed with error 0x%08lx\n",
     1986      ERR("Loading of typelib %s failed with error %ld\n",
    19341987          debugstr_w(pszFileName), GetLastError());
    19351988
    … …  
    19962049    /* TLIBATTR fields */
    19972050    MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
    1998     pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;
     2051
     2052    /*    pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;*/
     2053    /* Windows seems to have zero here, is this correct? */
     2054    if(SUBLANGID(tlbHeader.lcid) == SUBLANG_NEUTRAL)
     2055      pTypeLibImpl->LibAttr.lcid = PRIMARYLANGID(tlbHeader.lcid);
     2056    else
     2057      pTypeLibImpl->LibAttr.lcid = 0;
     2058
    19992059    pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
    20002060    pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
    … …  
    27592819          order = pBlkEntry[order].next - 1, i++) {
    27602820#ifdef __WIN32OS2__
    2761         pBlk = (LPBYTE)pBlk + pBlkEntry[order].len;
     2821        pBlk = (LPBYTE)pBlk + pBlkEntry[order].len;
    27622822#else
    2763         pBlk += pBlkEntry[order].len;
     2823        pBlk += pBlkEntry[order].len;
    27642824#endif
    27652825    }
    … …  
    28672927      *ppTypeInfoImpl = (ITypeInfoImpl*)ITypeInfo_Constructor();
    28682928      (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
     2929          ITypeLib2_AddRef((ITypeLib2 *)pTypeLibImpl);
    28692930      (*ppTypeInfoImpl)->index = i;
    28702931      (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
    … …  
    29903051    if (!This->ref)
    29913052    {
    2992       /* fixme destroy child objects */
     3053      /* FIXME destroy child objects */
    29933054
    29943055      TRACE(" destroying ITypeLib(%p)\n",This);
    … …  
    31833244 * file.
    31843245 *
     3246 * On a successful return all non-null BSTR pointers will have been set,
     3247 * possibly to NULL.
    31853248 */
    31863249static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
    … …  
    32063269    if(index<0)
    32073270    {
    3208        /* documentation for the typelib */
    3209        if(pBstrName && This->Name)
    3210        {
    3211            *pBstrName = SysAllocString(This->Name);
    3212 
    3213            if (!(*pBstrName)) return STG_E_INSUFFICIENTMEMORY;
    3214        }
    3215        if(pBstrDocString && This->DocString)
    3216        {
    3217            *pBstrDocString = SysAllocString(This->DocString);
    3218 
    3219            if (!(*pBstrDocString)) return STG_E_INSUFFICIENTMEMORY;
    3220        }
    3221    
    3222        if(pdwHelpContext)
    3223        {
     3271        /* documentation for the typelib */
     3272        if(pBstrName)
     3273        {
     3274            if (This->Name)
     3275                if(!(*pBstrName = SysAllocString(This->Name))) goto memerr1;else;
     3276            else
     3277                *pBstrName = NULL;
     3278        }
     3279        if(pBstrDocString)
     3280        {
     3281            if (This->DocString)
     3282                if(!(*pBstrDocString = SysAllocString(This->DocString))) goto memerr2;else;
     3283            else if (This->Name)
     3284                if(!(*pBstrDocString = SysAllocString(This->Name))) goto memerr2;else;
     3285            else
     3286                *pBstrDocString = NULL;
     3287        }
     3288        if(pdwHelpContext)
     3289        {
    32243290            *pdwHelpContext = This->dwHelpContext;
    3225        }
    3226        if(pBstrHelpFile && This->HelpFile)
    3227        {
    3228             *pBstrHelpFile = SysAllocString(This->HelpFile);
    3229 
    3230             if (!(*pBstrHelpFile)) return STG_E_INSUFFICIENTMEMORY;
    3231        }
    3232 
    3233        result = S_OK;
     3291        }
     3292        if(pBstrHelpFile)
     3293        {
     3294            if (This->HelpFile)
     3295                if(!(*pBstrHelpFile = SysAllocString(This->HelpFile))) goto memerr3;else;
     3296            else
     3297                *pBstrHelpFile = NULL;
     3298        }
     3299
     3300        result = S_OK;
    32343301    }
    32353302    else
    … …  
    32503317    }
    32513318    return result;
     3319memerr3:
     3320    if (pBstrDocString) SysFreeString (*pBstrDocString);
     3321memerr2:
     3322    if (pBstrName) SysFreeString (*pBstrName);
     3323memerr1:
     3324    return STG_E_INSUFFICIENTMEMORY;
    32523325}
    32533326
    … …  
    38913964 * interface described by the type description.
    38923965 */
    3893 static DWORD _invoke(LPVOID func,CALLCONV callconv, int nrargs, DWORD *args) {
     3966DWORD
     3967_invoke(LPVOID func,CALLCONV callconv, int nrargs, DWORD *args) {
    38943968    DWORD res;
    38953969
    … …  
    39053979
    39063980        switch (nrargs) {
     3981#ifdef __WIN32OS2__
    39073982        case 0: {
    3908 #ifdef __WIN32OS2__
    39093983                DWORD (* WINAPI xfunc)() = func;
    3910 #else
    3911                 DWORD (WINAPI *xfunc)() = func;
    3912 #endif
    39133984                res = xfunc();
    39143985                break;
    39153986        }
    39163987        case 1: {
    3917 #ifdef __WIN32OS2__
    39183988                DWORD (* WINAPI xfunc)(DWORD) = func;
    3919 #else
    3920                 DWORD (WINAPI *xfunc)(DWORD) = func;
    3921 #endif
    39223989                res = xfunc(args[0]);
    39233990                break;
    39243991        }
    39253992        case 2: {
    3926 #ifdef __WIN32OS2__
    39273993                DWORD (* WINAPI xfunc)(DWORD,DWORD) = func;
    3928 #else
    3929                 DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
    3930 #endif
    39313994                res = xfunc(args[0],args[1]);
    39323995                break;
    39333996        }
    39343997        case 3: {
    3935 #ifdef __WIN32OS2__
    39363998                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD) = func;
    3937 #else
    3938                 DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
    3939 #endif
    39403999                res = xfunc(args[0],args[1],args[2]);
    39414000                break;
    39424001        }
     4002        case 4: {
     4003                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD,DWORD) = func;
     4004                res = xfunc(args[0],args[1],args[2],args[3]);
     4005                break;
     4006        }
     4007        case 5: {
     4008                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4009                res = xfunc(args[0],args[1],args[2],args[3],args[4]);
     4010                break;
     4011        }
     4012        case 6: {
     4013                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4014                res = xfunc(args[0],args[1],args[2],args[3],args[4],args[5]);
     4015                break;
     4016        }
     4017        case 7: {
     4018                DWORD (* WINAPI xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4019                res = xfunc(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
     4020                break;
     4021        }
     4022#else
     4023        case 0: {
     4024                DWORD (WINAPI *xfunc)() = func;
     4025                res = xfunc();
     4026                break;
     4027        }
     4028        case 1: {
     4029                DWORD (WINAPI *xfunc)(DWORD) = func;
     4030                res = xfunc(args[0]);
     4031                break;
     4032        }
     4033        case 2: {
     4034                DWORD (WINAPI *xfunc)(DWORD,DWORD) = func;
     4035                res = xfunc(args[0],args[1]);
     4036                break;
     4037        }
     4038        case 3: {
     4039                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD) = func;
     4040                res = xfunc(args[0],args[1],args[2]);
     4041                break;
     4042        }
     4043        case 4: {
     4044                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD,DWORD) = func;
     4045                res = xfunc(args[0],args[1],args[2],args[3]);
     4046                break;
     4047        }
     4048        case 5: {
     4049                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4050                res = xfunc(args[0],args[1],args[2],args[3],args[4]);
     4051                break;
     4052        }
     4053        case 6: {
     4054                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4055                res = xfunc(args[0],args[1],args[2],args[3],args[4],args[5]);
     4056                break;
     4057        }
     4058        case 7: {
     4059                DWORD (WINAPI *xfunc)(DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,DWORD) = func;
     4060                res = xfunc(args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
     4061                break;
     4062        }
     4063#endif
    39434064        default:
    39444065                FIXME("unsupported number of arguments %d in stdcall\n",nrargs);
    … …  
    40264147            if (pVarResult && (dwFlags & (DISPATCH_PROPERTYGET))) {
    40274148                for (i=0;i<pFDesc->funcdesc.cParams-pDispParams->cArgs;i++) {
    4028                     TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i].tdesc);
     4149                    TYPEDESC *tdesc = &(pFDesc->funcdesc.lprgelemdescParam[i+pDispParams->cArgs].tdesc);
    40294150                    /* If we are a pointer to a variant, we are done already */
    40304151                    if ((tdesc->vt==VT_PTR)&&(tdesc->u.lptdesc->vt==VT_VARIANT))
    … …  
    40324153
    40334154                    VariantInit(&pVarResult[i]);
    4034                     V_UNION(pVarResult+i,intVal) = args2[i];
     4155                    V_UNION(pVarResult+i,intVal) = args2[i+pDispParams->cArgs];
    40354156
    40364157                    if (tdesc->vt == VT_PTR)
    … …  
    40454166                    if ((tdesc->vt == VT_PTR) && (dwFlags & DISPATCH_METHOD))
    40464167                        V_VT(pVarResult+i) = VT_DISPATCH;
    4047                     TRACE("storing into variant: [%d] type %d, val %08x\n",
    4048                             i,V_VT(pVarResult+i),V_UNION(pVarResult+i,intVal)
    4049                     );
     4168                    TRACE("storing into variant: [%d]\n", i);
     4169                    dump_Variant(pVarResult+i);
    40504170                }
    40514171            }
    … …  
    42104330          FIXME("Can't find pRefType for ref %lx\n", hRefType);
    42114331        if(pRefType && hRefType != -1) {
    4212             ITypeLib *pTLib;
     4332            ITypeLib *pTLib = NULL;
    42134333
    42144334            if(pRefType->pImpTLInfo == TLB_REF_INTERNAL) {
    … …  
    42494369                                                   ppTInfo);
    42504370            }
     4371            if (pTLib != NULL)
     4372                ITypeLib2_Release(pTLib);
    42514373        }
    42524374    }
Note: See TracChangeset for help on using the changeset viewer.