Changeset 3765 for trunk/src


Ignore:
Timestamp:
Jun 28, 2000, 8:08:36 PM (25 years ago)
Author:
sandervl
Message:

findresource cleanup

Location:
trunk/src/kernel32
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmdevice.h

    r3642 r3765  
    1 /* $Id: hmdevice.h,v 1.19 2000-06-01 11:28:46 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.20 2000-06-28 18:08:34 sandervl Exp $ */
    22
    33/*
    … …  
    176176
    177177                         /* this is a handler method for calls to LockFile() */
    178   virtual DWORD LockFile(PHMHANDLEDATA pHMHandleData,
     178  virtual BOOL LockFile(PHMHANDLEDATA pHMHandleData,
    179179                         DWORD         arg2,
    180180                         DWORD         arg3,
    … …  
    183183
    184184                       /* this is a handler method for calls to LockFileEx() */
    185   virtual DWORD LockFileEx(PHMHANDLEDATA pHMHandleData,
     185  virtual BOOL LockFileEx(PHMHANDLEDATA pHMHandleData,
    186186                           DWORD         dwFlags,
    187187                           DWORD         dwReserved,
    … …  
    191191
    192192                       /* this is a handler method for calls to UnlockFile() */
    193   virtual DWORD UnlockFile(PHMHANDLEDATA pHMHandleData,
     193  virtual BOOL UnlockFile(PHMHANDLEDATA pHMHandleData,
    194194                           DWORD         arg2,
    195195                           DWORD         arg3,
    … …  
    198198
    199199                     /* this is a handler method for calls to UnlockFileEx() */
    200   virtual DWORD UnlockFileEx(PHMHANDLEDATA pHMHandleData,
     200  virtual BOOL UnlockFileEx(PHMHANDLEDATA pHMHandleData,
    201201                             DWORD         dwReserved,
    202202                             DWORD         nNumberOfBytesToLockLow,

  • trunk/src/kernel32/hmfile.cpp

    r3751 r3765  
    1 /* $Id: hmfile.cpp,v 1.6 2000-06-25 12:33:16 sandervl Exp $ */
     1/* $Id: hmfile.cpp,v 1.7 2000-06-28 18:08:34 sandervl Exp $ */
    22
    33/*
    … …  
    858858 *****************************************************************************/
    859859
    860 DWORD HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
     860BOOL HMDeviceFileClass::LockFile(PHMHANDLEDATA pHMHandleData,
    861861                                  DWORD         dwFileOffsetLow,
    862862                                  DWORD         dwFileOffsetHigh,
    … …  
    898898 *****************************************************************************/
    899899
    900 DWORD HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
     900BOOL HMDeviceFileClass::LockFileEx(PHMHANDLEDATA pHMHandleData,
    901901                                    DWORD         dwFlags,
    902902                                    DWORD         dwReserved,
    … …  
    942942 *****************************************************************************/
    943943
    944 DWORD HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
     944BOOL HMDeviceFileClass::UnlockFile(PHMHANDLEDATA pHMHandleData,
    945945                                    DWORD         dwFileOffsetLow,
    946946                                    DWORD         dwFileOffsetHigh,
    … …  
    983983 *****************************************************************************/
    984984
    985 DWORD HMDeviceFileClass::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
    986                                       DWORD         dwReserved,
    987                                       DWORD         nNumberOfBytesToLockLow,
    988                                       DWORD         nNumberOfBytesToLockHigh,
    989                                       LPOVERLAPPED  lpOverlapped)
     985BOOL HMDeviceFileClass::UnlockFileEx(PHMHANDLEDATA pHMHandleData,
     986                                     DWORD         dwReserved,
     987                                     DWORD         nNumberOfBytesToLockLow,
     988                                     DWORD         nNumberOfBytesToLockHigh,
     989                                     LPOVERLAPPED  lpOverlapped)
    990990{
    991991

  • trunk/src/kernel32/hmfile.h

    r3642 r3765  
    1 /* $Id: hmfile.h,v 1.1 2000-06-01 11:28:47 sandervl Exp $ */
     1/* $Id: hmfile.h,v 1.2 2000-06-28 18:08:34 sandervl Exp $ */
    22
    33/*
    … …  
    128128
    129129                         /* this is a handler method for calls to LockFile() */
    130   virtual DWORD LockFile(PHMHANDLEDATA pHMHandleData,
     130  virtual BOOL LockFile(PHMHANDLEDATA pHMHandleData,
    131131                         DWORD         arg2,
    132132                         DWORD         arg3,
    … …  
    135135
    136136                       /* this is a handler method for calls to LockFileEx() */
    137   virtual DWORD LockFileEx(PHMHANDLEDATA pHMHandleData,
     137  virtual BOOL LockFileEx(PHMHANDLEDATA pHMHandleData,
    138138                           DWORD         dwFlags,
    139139                           DWORD         dwReserved,
    … …  
    143143
    144144                       /* this is a handler method for calls to UnlockFile() */
    145   virtual DWORD UnlockFile(PHMHANDLEDATA pHMHandleData,
     145  virtual BOOL UnlockFile(PHMHANDLEDATA pHMHandleData,
    146146                           DWORD         arg2,
    147147                           DWORD         arg3,
    … …  
    150150
    151151                     /* this is a handler method for calls to UnlockFileEx() */
    152   virtual DWORD UnlockFileEx(PHMHANDLEDATA pHMHandleData,
     152  virtual BOOL UnlockFileEx(PHMHANDLEDATA pHMHandleData,
    153153                             DWORD         dwReserved,
    154154                             DWORD         nNumberOfBytesToLockLow,

  • trunk/src/kernel32/winimagebase.cpp

    r3678 r3765  
    1 /* $Id: winimagebase.cpp,v 1.22 2000-06-08 18:08:56 sandervl Exp $ */
     1/* $Id: winimagebase.cpp,v 1.23 2000-06-28 18:08:35 sandervl Exp $ */
    22
    33/*
    … …  
    4747    errorState(NO_ERROR), entryPoint(0), fullpath(NULL),
    4848    tlsAddress(0), tlsIndexAddr(0), tlsInitSize(0), tlsTotalSize(0),
    49     tlsCallBackAddr(0), tlsIndex(-1), pResDir(NULL),
     49    tlsCallBackAddr(0), tlsIndex(-1), pResRootDir(NULL),
    5050    ulRVAResourceSection(0)
    5151{

  • trunk/src/kernel32/winimagebase.h

    r3720 r3765  
    1 /* $Id: winimagebase.h,v 1.12 2000-06-17 09:03:36 sandervl Exp $ */
     1/* $Id: winimagebase.h,v 1.13 2000-06-28 18:08:35 sandervl Exp $ */
    22
    33/*
    … …  
    2222#endif
    2323
    24 #define LANG_GETFIRST           0x80000000
    25 #define IDLANG_GETFIRST         LANG_GETFIRST
     24#define LANG_GETFIRST           0xF0000000
     25#define ID_GETFIRST             0xF0000000
    2626
    2727#ifndef ENUMRESNAMEPROC
    … …  
    5959
    6060//Returns required OS version for this image
    61 virtual ULONG     getVersion();
     61virtual ULONG getVersion();
    6262
    63 virtual void setFullPath(char *name);
     63virtual void  setFullPath(char *name);
    6464        char *getFullPath()           { return fullpath; };
    6565
    … …  
    6767
    6868        //findResource returns the pointer of the resource's IMAGE_RESOURCE_DATA_ENTRY structure
    69 virtual HRSRC findResourceA(LPCSTR lpszName, LPSTR lpszType, ULONG lang = LANG_GETFIRST);
    70         HRSRC findResourceW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang = LANG_GETFIRST);
     69        HRSRC findResourceA(LPCSTR lpszName, LPSTR lpszType, ULONG lang = LANG_GETFIRST);
     70        HRSRC findResourceW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang = LANG_GETFIRST);
    7171
    72 virtual ULONG getResourceSizeA(LPCSTR lpszName, LPSTR lpszType, ULONG lang = LANG_GETFIRST);
    73         ULONG getResourceSizeW(LPCWSTR lpszName, LPWSTR lpszType, ULONG lang = LANG_GETFIRST);
    74 virtual BOOL  enumResourceNamesA(HMODULE hmod, LPCTSTR  lpszType, ENUMRESNAMEPROCA lpEnumFunc, LONG lParam);
    75 virtual BOOL  enumResourceNamesW(HMODULE hmod, LPCWSTR  lpszType, ENUMRESNAMEPROCW lpEnumFunc, LONG lParam);
    76 virtual BOOL  enumResourceTypesA(HMODULE hmod, ENUMRESTYPEPROCA lpEnumFunc,
     72        ULONG getResourceSizeA(LPSTR lpszName, LPSTR lpszType, ULONG lang = LANG_GETFIRST);
     73        ULONG getResourceSizeW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang = LANG_GETFIRST);
     74        BOOL  enumResourceNamesA(HMODULE hmod, LPCTSTR  lpszType, ENUMRESNAMEPROCA lpEnumFunc, LONG lParam);
     75        BOOL  enumResourceNamesW(HMODULE hmod, LPCWSTR  lpszType, ENUMRESNAMEPROCW lpEnumFunc, LONG lParam);
     76        BOOL  enumResourceTypesA(HMODULE hmod, ENUMRESTYPEPROCA lpEnumFunc,
    7777                                 LONG lParam);
    78 virtual BOOL  enumResourceTypesW(HMODULE hmod, ENUMRESTYPEPROCW lpEnumFunc,
     78        BOOL  enumResourceTypesW(HMODULE hmod, ENUMRESTYPEPROCW lpEnumFunc,
    7979                                 LONG lParam);
    8080
    81 virtual ULONG getVersionSize();
    82 virtual BOOL  getVersionStruct(char *verstruct, ULONG bufLength);
     81        ULONG getVersionSize();
     82        BOOL  getVersionStruct(char *verstruct, ULONG bufLength);
    8383
    8484        //Returns pointer to data of resource handle
    … …  
    140140        ULONG                 tlsIndex;         //module TLS index
    141141
    142         ULONG getPEResourceSize(ULONG id, ULONG type, ULONG lang = LANG_GETFIRST);
    143 
    144         PIMAGE_RESOURCE_DATA_ENTRY getPEResourceEntry(ULONG id, ULONG type, ULONG lang, int *error);
    145         PIMAGE_RESOURCE_DATA_ENTRY ProcessResSubDir(PIMAGE_RESOURCE_DIRECTORY prdType,
    146                                                     ULONG *nodeData, int level, int *error);
    147142        PIMAGE_RESOURCE_DIRECTORY  getResSubDirW(PIMAGE_RESOURCE_DIRECTORY pResDir, LPCWSTR lpszName);
    148143        PIMAGE_RESOURCE_DIRECTORY  getResSubDirA(PIMAGE_RESOURCE_DIRECTORY pResDir, LPCTSTR lpszName);
    149144
    150         PIMAGE_RESOURCE_DIRECTORY pResDir;
     145        PIMAGE_RESOURCE_DATA_ENTRY getResDataLang(PIMAGE_RESOURCE_DIRECTORY pResDir, ULONG language, BOOL fGetDefault = FALSE);
     146
     147        PIMAGE_RESOURCE_DIRECTORY pResRootDir;
    151148
    152149        //substracted from RVA data offsets

  • trunk/src/kernel32/winimagelx.cpp

    r3625 r3765  
    1 /* $Id: winimagelx.cpp,v 1.7 2000-05-28 16:45:13 sandervl Exp $ */
     1/* $Id: winimagelx.cpp,v 1.8 2000-06-28 18:08:35 sandervl Exp $ */
    22
    33/*
    … …  
    5656
    5757  //Pointer to PE resource tree generates by wrc (or NULL for system dlls)
    58   pResDir = (PIMAGE_RESOURCE_DIRECTORY)pResData;
     58  pResRootDir = (PIMAGE_RESOURCE_DIRECTORY)pResData;
    5959
    6060  //ulRVAResourceSection contains the virtual address of the imagebase in the PE header

  • trunk/src/kernel32/winimagepe2lx.cpp

    r3433 r3765  
    1 /* $Id: winimagepe2lx.cpp,v 1.10 2000-04-19 22:16:49 bird Exp $ */
     1/* $Id: winimagepe2lx.cpp,v 1.11 2000-06-28 18:08:35 sandervl Exp $ */
    22
    33/*
    … …  
    174174 *            Read the PE section table the set the RVAs in paSections.
    175175 *            Locate and set the entrypoint.
    176  *            Locate the resource directory (if any). (pResDir, ulRVAResourceSection)
     176 *            Locate the resource directory (if any). (pResRootDir, ulRVAResourceSection)
    177177 *            TLS - FIXME!
    178178 * @status    completely implemented.
    … …  
    259259    {
    260260        ulRVAResourceSection = pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;
    261         pResDir = (PIMAGE_RESOURCE_DIRECTORY)getPointerFromRVA(ulRVAResourceSection);
     261        pResRootDir = (PIMAGE_RESOURCE_DIRECTORY)getPointerFromRVA(ulRVAResourceSection);
    262262    }
    263263

  • trunk/src/kernel32/winimagepeldr.cpp

    r3757 r3765  
    1 /* $Id: winimagepeldr.cpp,v 1.48 2000-06-26 12:23:54 sandervl Exp $ */
     1/* $Id: winimagepeldr.cpp,v 1.49 2000-06-28 18:08:36 sandervl Exp $ */
    22
    33/*
    … …  
    501501  SetPDBInstance(hinstance);
    502502
    503   //PH: get pResDir pointer correct first, since processImports may
     503  //PH: get pResRootDir pointer correct first, since processImports may
    504504  //    implicitly call functions depending on it.
    505505  if(GetSectionHdrByName (win32file, &sh, ".rsrc")) {
    506506        //get offset in resource object of directory entry
    507         pResDir = (PIMAGE_RESOURCE_DIRECTORY)(sh.VirtualAddress + realBaseAddress);
     507        pResRootDir = (PIMAGE_RESOURCE_DIRECTORY)(sh.VirtualAddress + realBaseAddress);
    508508        ulRVAResourceSection = sh.VirtualAddress;
    509509  }

  • trunk/src/kernel32/winimgres.cpp

    r3753 r3765  
    1 /* $Id: winimgres.cpp,v 1.41 2000-06-26 07:35:56 sandervl Exp $ */
     1/* $Id: winimgres.cpp,v 1.42 2000-06-28 18:08:36 sandervl Exp $ */
    22
    33/*
    44 * Win32 PE Image class (resource methods)
    55 *
    6  * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
     6 * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
    77 *
    88 *
    … …  
    1010 *
    1111 * TODO: Check created resource objects before loading the resource!
    12  * TODO: Once the resource handling in PE2LX/win32k is changed,
    13  *       getVersionStruct/Size can be moved into the Win32ImageBase class
    1412 * TODO: Support for 'DIB' resource type (VPBuddy)
    1513 *
    … …  
    3230
    3331#define MAX_RES 17
    34 char *ResTypes[MAX_RES] =
    35       {"niks", "CURSOR", "BITMAP", "ICON", "MENU", "DIALOG", "STRING",
    36        "FONTDIR", "FONT", "ACCELERATOR", "RCDATA",  "MESSAGETABLE",
    37        "GROUP_CURSOR", "niks", "GROUP_ICON", "niks", "VERSION"};
     32typedef struct {
     33  char *typename;
     34  int   namelen;
     35} STD_RESTYPE;
     36
     37STD_RESTYPE ResType[MAX_RES] =
     38      { {NULL,          0},
     39        {"CURSOR",      6},
     40        {"BITMAP",      6},
     41        {"ICON",        4},
     42        {"MENU",        4},
     43        {"DIALOG",      6},
     44        {"STRING",      6},
     45        {"FONTDIR",     7},
     46        {"FONT",        4},
     47        {"ACCELERATOR", 11},
     48        {"RCDATA",      6},
     49        {"MESSAGETABLE",12},
     50        {"GROUP_CURSOR",12},
     51        {NULL,          0},
     52        {"GROUP_ICON",  10},
     53        {NULL,          0},
     54        {"VERSION",     7}
     55      };
    3856
    3957//SvL: VPBuddy bugfix, seems to load bitmaps with type name 'DIB'
    4058#define BITMAP_TYPENAME2    "DIB"
    4159
    42 #define RESERR_SUCCESS          0
    43 #define RESERR_IDNOTFOUND       1
    44 #define RESERR_TYPENOTFOUND     2
    45 #define RESERR_LANGNOTFOUND     3
    46 
    47 //******************************************************************************
    48 //Assuming names are case insensitive
    49 //PE spec says names & ids are sorted; keep on searching just to be sure
    50 //******************************************************************************
    51 PIMAGE_RESOURCE_DATA_ENTRY
    52  Win32ImageBase::getPEResourceEntry(ULONG id, ULONG type, ULONG lang, int *error)
    53 {
    54  PIMAGE_RESOURCE_DIRECTORY       prdType;
    55  PIMAGE_RESOURCE_DIRECTORY_ENTRY prde;
    56  PIMAGE_RESOURCE_DIR_STRING_U    pstring;
    57  PIMAGE_RESOURCE_DATA_ENTRY      pData = NULL;
    58  ULONG  nodeData[3], i, j, nameOffset;
    59  BOOL  fFound = FALSE, fNumType;
    60 
    61   *error = RESERR_TYPENOTFOUND;
    62 
    63   //PH: our system LX DLLs might not have a resource segment
    64   if (pResDir == NULL)
    65     return NULL;
    66 
    67   if(HIWORD(type)) {
    68         char *lpszName = (char *)type;
    69         //"#102" really means numeric id 102
    70         if(lpszName[0] == '#') {
    71                 type = atoi(&lpszName[1]);
    72         }
    73   }
    74 
    75   if(HIWORD(id) && id != IDLANG_GETFIRST) {
    76         char *lpszName = (char *)id;
    77         //"#102" really means numeric id 102
    78         if(lpszName[0] == '#') {
    79                 id = atoi(&lpszName[1]);
    80         }
    81   }
    82 
    83   /* set pointer to first resource type entry */
    84   prde = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
    85 
    86   /* loop through all resource directory entry types */
    87   //1st level -> types
    88   //2nd level -> names
    89   //3rd level -> language
    90   nodeData[0] = id;
    91   nodeData[1] = lang;
    92   nodeData[2] = 0xFFFFFFFF;
    93 
    94   fNumType = TRUE;    //assume numeric
    95   if(HIWORD(type) != 0) {//string id?
    96     for(i=0;i<MAX_RES;i++) {
    97         if(stricmp((char *)type, ResTypes[i]) == 0)
    98                 break;
    99     }
    100 //TODO:
    101 #if 0
    102     if(stricmp((char *)type, BITMAP_TYPENAME2) == 0) {
    103         i = (int)RT_BITMAPA;
    104     }
    105 #endif
    106 
    107     if(i == MAX_RES) {//custom resource type
    108          fNumType = FALSE;
    109     }
    110     else type   = i;
    111   }
    112 
    113   for (i=0; i<pResDir->NumberOfNamedEntries+pResDir->NumberOfIdEntries; i++) {
    114     /* locate directory or each resource type */
    115     prdType = (PIMAGE_RESOURCE_DIRECTORY)((int)pResDir + (int)prde->u2.OffsetToData);
    116 
    117     if(i < pResDir->NumberOfNamedEntries)
    118     {//name or id entry?
    119         //SvL: 30-10-'97, high bit is set, so clear to get real offset
    120         nameOffset = prde->u1.Name & ~0x80000000;
    121 
    122         pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResDir + nameOffset);
    123         char *typename = (char *)malloc(pstring->Length+1);
    124         lstrcpynWtoA(typename, pstring->NameString, pstring->Length+1);
    125         typename[pstring->Length] = 0;
    126 
    127         if(!fNumType) {
    128             if(stricmp(typename, (char *)type) == 0) {
    129                 fFound = TRUE;
    130             }
    131         }
    132         else {
    133             for(j=0;j<MAX_RES;j++) {
    134                 if(stricmp(typename, ResTypes[j]) == 0)
    135                     break;
    136             }
    137             if(j == type) {
    138                 fFound = TRUE;
    139             }
    140         }
    141         free(typename);
    142     }
    143     else {
    144         if(prde->u1.Id == type) {
    145             fFound = TRUE;
    146         }
    147     }
    148     if(fFound) {
    149         if((ULONG)prdType & 0x80000000) {//subdirectory?
    150             pData = ProcessResSubDir(prdType, &nodeData[0], 2, error);
    151         }
    152         else {
    153             pData = (PIMAGE_RESOURCE_DATA_ENTRY)prdType;
    154             dprintf(("getResource: not a subdir!!\n"));
    155         }
    156         break;
    157     }
    158     /* increment to next entry */
    159     prde++;
    160   }
    161   if(pData) {
    162         *error = RESERR_SUCCESS; //found it
    163   }
    164   return pData;
    165 }
    166 //******************************************************************************
    167 //level: 2 ids
    168 //       3 languages
    169 //******************************************************************************
    170 PIMAGE_RESOURCE_DATA_ENTRY
    171     Win32ImageBase::ProcessResSubDir(PIMAGE_RESOURCE_DIRECTORY prdType,
    172                                      ULONG *nodeData, int level, int *error)
    173 {
    174  PIMAGE_RESOURCE_DIRECTORY       prdType2;
    175  PIMAGE_RESOURCE_DIRECTORY_ENTRY prde;
    176  PIMAGE_RESOURCE_DIR_STRING_U    pstring;
    177  PIMAGE_RESOURCE_DATA_ENTRY      pData;
    178  BOOL  fFound = FALSE, fNumId;
    179  ULONG nrres, nameOffset;
    180  char *resname;
    181  int   i;
    182 
    183   if(*nodeData == 0xFFFFFFFF) {//shouldn't happen!
    184         dprintf(("ProcessResSubDir: *nodeData == 0xFFFFFFFF!\n"));
    185         DebugInt3();
    186         return(NULL);
    187   }
    188   prdType = (PIMAGE_RESOURCE_DIRECTORY)((ULONG)prdType & ~0x80000000);
    189   prde    = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((DWORD)prdType + sizeof(IMAGE_RESOURCE_DIRECTORY));
    190 
    191   if(level == 2) {
    192         *error = RESERR_IDNOTFOUND;
    193   }
    194   else {
    195         *error = RESERR_LANGNOTFOUND;
    196   }
    197   //level 2 (id)   -> get first id?
    198   //level 3 (lang) -> get first language?
    199   if(*nodeData == IDLANG_GETFIRST) {
    200         nrres  = prdType->NumberOfNamedEntries + prdType->NumberOfIdEntries;
    201         fNumId = (prdType->NumberOfNamedEntries == 0);
    202   }
    203   else {
    204         fNumId = HIWORD(*nodeData) == 0;
    205 
    206         if(fNumId) {//numeric or string id?
    207                 nrres = prdType->NumberOfIdEntries;
    208                 prde += prdType->NumberOfNamedEntries;  //skip name entries
    209         }
    210         else    nrres = prdType->NumberOfNamedEntries;
    211   }
    212 
    213   for(i=0;i<nrres;i++) {
    214         /* locate directory or each resource type */
    215         prdType2 = (PIMAGE_RESOURCE_DIRECTORY)((ULONG)pResDir + (ULONG)prde->u2.OffsetToData);
    216 
    217         if(*nodeData == IDLANG_GETFIRST) {
    218                 fFound = TRUE; //always take the first one
    219         }
    220         else
    221         if(!fNumId) {//name or id entry?
    222             nameOffset = prde->u1.Name;
    223             if(prde->u1.s.NameIsString) //unicode directory string /*PLF Sat  97-06-21 22:30:35*/
    224                     nameOffset &= ~0x80000000;
    225 
    226             pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResDir + nameOffset);
    227 
    228             resname = (char *)malloc(pstring->Length+1);
    229             lstrcpynWtoA(resname, pstring->NameString, pstring->Length+1);
    230             resname[pstring->Length] = 0;
    231             if(stricmp(resname, (char *)*nodeData) == 0) {
    232                     fFound = TRUE;
    233             }
    234             free(resname);
    235         }
    236         else {
    237             if(*nodeData == prde->u1.Id)
    238                     fFound = TRUE;
    239         }
    240 
    241         if(fFound) {
    242             if((ULONG)prdType2 & 0x80000000) {//subdirectory?
    243                     return ProcessResSubDir(prdType2, nodeData+1, 3, error);
    244             }
    245             else {
    246                     pData = (PIMAGE_RESOURCE_DATA_ENTRY)prdType2;
    247                     if(pData->Size) {//winamp17 winzip archive has resource with size 0
    248                             return(pData);
    249                     }
    250                     else    return(NULL);
    251             }
    252         }
    253         prde++;
    254   }
    255   return(NULL);
    256 }
    257 //******************************************************************************
    258 //******************************************************************************
    259 ULONG Win32ImageBase::getPEResourceSize(ULONG id, ULONG type, ULONG lang)
     60//******************************************************************************
     61//******************************************************************************
     62ULONG Win32ImageBase::getResourceSizeA(LPSTR lpszName, LPSTR lpszType, ULONG lang)
    26063{
    26164 PIMAGE_RESOURCE_DATA_ENTRY pData = NULL;
    262  int                        error;
    263 
    264     switch(lang) {
    265     case LOCALE_SYSTEM_DEFAULT:
    266         lang = GetSystemDefaultLangID();
    267         break;   
    268     case LOCALE_USER_DEFAULT:
    269         lang = GetUserDefaultLangID();
    270         break;   
    271     case LOCALE_NEUTRAL:
    272         //TODO: Not correct; should take language associated with current thread
    273         lang = IDLANG_GETFIRST;
    274         break;   
    275     }
    276 
    277     pData = getPEResourceEntry(id, type, lang, &error);
     65   
     66    pData = (PIMAGE_RESOURCE_DATA_ENTRY)findResourceA(lpszName, lpszType, lang);
    27867    if(pData == NULL) {
    279         dprintf(("Win32ImageBase::getPEResourceSize: couldn't find resource %d (type %d, lang %x)", id, type, lang));
     68        dprintf(("Win32ImageBase::getPEResourceSizeA: couldn't find resource %x (type %x, lang %x)", lpszName, lpszType, lang));
     69        return 0;
     70    }
     71    return pData->Size;
     72}
     73//******************************************************************************
     74//******************************************************************************
     75ULONG Win32ImageBase::getResourceSizeW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang)
     76{
     77 PIMAGE_RESOURCE_DATA_ENTRY pData = NULL;
     78   
     79    pData = (PIMAGE_RESOURCE_DATA_ENTRY)findResourceW(lpszName, lpszType, lang);
     80    if(pData == NULL) {
     81        dprintf(("Win32ImageBase::getResourceSizeW: couldn't find resource %x (type %x, lang %x)", lpszName, lpszType, lang));
    28082        return 0;
    28183    }
    … …  
    29698  //for the resource section (images loaded by the pe.exe and pe2lx/win32k)
    29799  //For LX images, this is 0 as OffsetToData contains a relative offset
    298   return (char *)((char *)pResDir + (pData->OffsetToData - ulRVAResourceSection));
     100  return (char *)((char *)pResRootDir + (pData->OffsetToData - ulRVAResourceSection));
    299101}
    300102//******************************************************************************
    … …  
    313115//findResource returns the pointer of the resource's IMAGE_RESOURCE_DATA_ENTRY structure
    314116//******************************************************************************
    315 HRSRC Win32ImageBase::findResourceA(LPCSTR lpszName, LPSTR lpszType, ULONG langid)
    316 {
    317  PIMAGE_RESOURCE_DATA_ENTRY      pData = NULL;
    318  char  *winres = NULL;
    319  ULONG  id, type, lang;
    320  int    i, j, error;
    321 
    322 #ifdef DEBUG
    323     if(HIWORD(lpszType) != 0) {//string id?
    324         for(i=0;i<MAX_RES;i++) {
    325             if(stricmp(lpszType, ResTypes[i]) == 0)
     117HRSRC Win32ImageBase::findResourceA(LPCSTR lpszName, LPSTR lpszType, ULONG lang)
     118{
     119 PIMAGE_RESOURCE_DIRECTORY pResDirRet;
     120 int                       typelen;
     121 HRSRC                     hRes;
     122
     123    if(HIWORD(lpszType) != 0)
     124    {
     125        typelen = strlen(lpszType);
     126
     127        for(int i=0;i<MAX_RES;i++) {
     128            if(ResType[i].namelen &&
     129               ResType[i].namelen == typelen &&
     130               stricmp(lpszType, ResType[i].typename) == 0)
    326131                    break;
    327132        }
    328         if(i == MAX_RES) {//custom resource type
    329             type = (ULONG)lpszType;
     133        if(i != MAX_RES) {//standard res type
     134             lpszType = (LPSTR)i;
    330135        }
    331         else type = i;
    332     }
    333     else  type = (ULONG)lpszType;
    334 #else
    335     type = (ULONG)lpszType;
    336 #endif
    337 
    338     switch(langid) {
    339     case LOCALE_SYSTEM_DEFAULT:
     136    }
     137    pResDirRet = getResSubDirA(pResRootDir, lpszType);
     138    if(!pResDirRet) {
     139        SetLastError(ERROR_RESOURCE_TYPE_NOT_FOUND);
     140        return NULL;
     141    }
     142    pResDirRet = getResSubDirA(pResDirRet, lpszName);
     143    if(!pResDirRet) {
     144        SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
     145        return NULL;
     146    }
     147
     148    switch(lang) {
     149    case LANG_SYSTEM_DEFAULT:
    340150        lang = GetSystemDefaultLangID();
    341         break;   
    342     case LOCALE_USER_DEFAULT:
     151        break;
     152    case LANG_USER_DEFAULT:
    343153        lang = GetUserDefaultLangID();
    344154        break;   
    345     case LOCALE_NEUTRAL:
     155    case LANG_NEUTRAL:
    346156        //TODO: Not correct; should take language associated with current thread
    347         lang = IDLANG_GETFIRST;
     157        lang = LANG_NEUTRAL;
    348158        break;
    349     case IDLANG_GETFIRST:
     159    case LANG_GETFIRST:
    350160        lang = GetUserDefaultLangID();
    351161        break;   
    352162    }
    353     id = (ULONG)lpszName;
    354     pData = getPEResourceEntry(id, type, lang, &error);
    355     if(pData == NULL) {
    356         //TODO: Optimize this; check if language wasn't found
    357         //try system default language
    358         if(error == RESERR_LANGNOTFOUND) {
    359                 pData = getPEResourceEntry(id, type, GetSystemDefaultLangID(), &error);
     163
     164    hRes = (HRSRC)getResDataLang(pResDirRet, lang);
     165    if(!hRes) {
     166        //try primary language with default sublang
     167        lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_DEFAULT);
     168        hRes = (HRSRC)getResDataLang(pResDirRet, lang);
     169        if(!hRes) {
     170                //try neutral language or get first entry if nothing found
     171                hRes = (HRSRC)getResDataLang(pResDirRet, LANG_NEUTRAL, TRUE);
    360172        }
    361         if(pData == NULL) {
    362                 //finally try first available language
    363                 if(error == RESERR_LANGNOTFOUND) {
    364                         pData = getPEResourceEntry(id, type, IDLANG_GETFIRST, &error);
    365                 }
    366                 if(pData == NULL) {
    367                         if(HIWORD(id)) {
    368                                 dprintf(("Win32ImageBase::getPEResource %s: couldn't find resource %s (type %d, lang %x)", szModule, id, type, lang));
    369                         }
    370                         else    dprintf(("Win32ImageBase::getPEResource %s: couldn't find resource %d (type %d, lang %x)", szModule, id, type, lang));
    371                         return 0;
    372                 }
     173    }
     174
     175    if((ULONG)lpszName != ID_GETFIRST && HIWORD(lpszName)) {
     176            dprintf(("FindResource %s: resource %s (type %x, lang %x)", szModule, lpszName, lpszType, lang));
     177    }
     178    else    dprintf(("FindResource %s: resource %x (type %x, lang %x)", szModule, lpszName, lpszType, lang));
     179
     180    return hRes;
     181}
     182//******************************************************************************
     183//******************************************************************************
     184HRSRC Win32ImageBase::findResourceW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang)
     185{
     186 PIMAGE_RESOURCE_DIRECTORY pResDirRet;
     187 char                     *astring1 = NULL;
     188 int                       typelen;
     189 HRSRC                     hRes;
     190
     191    if(HIWORD(lpszType) != 0 && lpszType[0] != (WCHAR)'#')
     192    {
     193        astring1 = UnicodeToAsciiString(lpszType);
     194        typelen = strlen(astring1);
     195
     196        for(int i=0;i<MAX_RES;i++) {
     197            if(ResType[i].namelen &&
     198               ResType[i].namelen == typelen &&
     199               stricmp(astring1, ResType[i].typename) == 0)
     200                    break;
     201        }
     202        if(i != MAX_RES) {//standard res type
     203             lpszType = (LPWSTR)i;
     204        }
     205        FreeAsciiString(astring1);
     206    }
     207    pResDirRet = getResSubDirW(pResRootDir, lpszType);
     208    if(!pResDirRet) {
     209        SetLastError(ERROR_RESOURCE_TYPE_NOT_FOUND);
     210        return NULL;
     211    }
     212    pResDirRet = getResSubDirW(pResDirRet, lpszName);
     213    if(!pResDirRet) {
     214        SetLastError(ERROR_RESOURCE_NAME_NOT_FOUND);
     215        return NULL;
     216    }
     217
     218    switch(lang) {
     219    case LANG_SYSTEM_DEFAULT:
     220        lang = GetSystemDefaultLangID();
     221        break;
     222    case LANG_USER_DEFAULT:
     223        lang = GetUserDefaultLangID();
     224        break;   
     225    case LANG_NEUTRAL:
     226        //TODO: Not correct; should take language associated with current thread
     227        lang = LANG_NEUTRAL;
     228        break;
     229    case LANG_GETFIRST:
     230        lang = GetUserDefaultLangID();
     231        break;   
     232    }
     233
     234    hRes = (HRSRC)getResDataLang(pResDirRet, lang);
     235    if(!hRes) {
     236        //try primary language with default sublang
     237        lang = MAKELANGID(PRIMARYLANGID(lang), SUBLANG_DEFAULT);
     238        hRes = (HRSRC)getResDataLang(pResDirRet, lang);
     239        if(!hRes) {
     240                //try neutral language or get first entry if nothing found
     241                hRes = (HRSRC)getResDataLang(pResDirRet, LANG_NEUTRAL, TRUE);
    373242        }
    374243    }
    375     if(HIWORD(id)) {
    376             dprintf(("FindResource %s: resource %s (type %d, lang %x)", szModule, id, type, lang));
    377     }
    378     else    dprintf(("FindResource %s: resource %d (type %d, lang %x)", szModule, id, type, lang));
    379 
    380     return (HRSRC) pData;
    381 }
    382 //******************************************************************************
    383 //******************************************************************************
    384 HRSRC Win32ImageBase::findResourceW(LPWSTR lpszName, LPWSTR lpszType, ULONG lang)
    385 {
    386  HRSRC hres;
    387  char *astring1 = NULL, *astring2 = NULL;
    388 
    389     if(HIWORD(lpszName) != 0) {
    390             astring1 = UnicodeToAsciiString(lpszName);
    391     }
    392     else    astring1 = (char *)lpszName;
    393 
    394     if(HIWORD(lpszType) != 0) {
    395             astring2 = UnicodeToAsciiString(lpszType);
    396     }
    397     else    astring2 = (char *)lpszType;
    398 
    399     hres = findResourceA(astring1, astring2, lang);
    400 
    401     if(HIWORD(astring1)) FreeAsciiString(astring1);
    402     if(HIWORD(astring2)) FreeAsciiString(astring2);
    403 
    404     return(hres);
    405 }
    406 //******************************************************************************
    407 //******************************************************************************
    408 ULONG Win32ImageBase::getResourceSizeA(LPCSTR lpszName, LPSTR lpszType, ULONG lang)
    409 {
    410     return getPEResourceSize((ULONG)lpszName, (ULONG)lpszType, lang);
    411 }
    412 //******************************************************************************
    413 //******************************************************************************
    414 ULONG Win32ImageBase::getResourceSizeW(LPCWSTR lpszName, LPWSTR lpszType, ULONG lang)
    415 {
    416  char *astring1 = NULL, *astring2 = NULL;
    417  ULONG ressize;
    418 
    419     if(HIWORD(lpszName) != 0) {
    420             astring1 = UnicodeToAsciiString((LPWSTR)lpszName);
    421     }
    422     else    astring1 = (char *)lpszName;
    423 
    424     if(HIWORD(lpszType) != 0) {
    425             astring2 = UnicodeToAsciiString(lpszType);
    426     }
    427     else    astring2 = (char *)lpszType;
    428 
    429     ressize =  getResourceSizeA(astring2, astring1, lang);
    430 
    431     if(HIWORD(astring1)) FreeAsciiString(astring1);
    432     if(HIWORD(astring2)) FreeAsciiString(astring2);
    433 
    434     return(ressize);
     244
     245    return hRes;
    435246}
    436247//******************************************************************************
    … …  
    438249ULONG Win32ImageBase::getVersionSize()
    439250{
    440     return getResourceSizeA((LPCSTR)1, (LPSTR)NTRT_VERSION);
     251    return getResourceSizeW((LPWSTR)1, (LPWSTR)NTRT_VERSION);
    441252}
    442253//******************************************************************************
    … …  
    444255BOOL Win32ImageBase::getVersionStruct(char *verstruct, ULONG bufLength)
    445256{
    446  PIMAGE_RESOURCE_DATA_ENTRY      pData = NULL;
    447  int                             error;
     257 HRSRC hRes;
    448258
    449259    if(verstruct == NULL || bufLength == 0) {
    … …  
    451261        return FALSE;
    452262    }
    453     pData = getPEResourceEntry(IDLANG_GETFIRST, NTRT_VERSION, IDLANG_GETFIRST, &error);
    454     if(pData == NULL) {
     263    hRes = findResourceW((LPWSTR)ID_GETFIRST, (LPWSTR)NTRT_VERSION, LANG_GETFIRST);
     264    if(hRes == NULL) {
     265        //last error already set by findResourceW
    455266        dprintf(("Win32PeLdrImage::getVersionStruct: couldn't find version resource!"));
    456         SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
    457267        return 0;
    458268    }
    459     char *resdata = (char *)((char *)pResDir + pData->OffsetToData - ulRVAResourceSection);
    460     memcpy(verstruct, resdata, min(bufLength, pData->Size));
     269    memcpy(verstruct, getResourceAddr(hRes), min(bufLength, getResourceSize(hRes)));
    461270    return TRUE;
    462271}
    … …  
    505314    PIMAGE_RESOURCE_DIRECTORY_ENTRY paResDirEntries;
    506315
    507     if (pResDir == NULL)
     316    if (pResRootDir == NULL)
    508317    {
    509318        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
    … …  
    512321
    513322    /* validate parameters - FIXME... Exception handler??? */
    514     if ((unsigned)lpszType >= 0xc0000000) //....
     323    if ((ULONG)lpszType >= 0xc0000000) //....
    515324    {
    516325        SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    518327    }
    519328
    520     if ((unsigned)lpEnumFunc < 0x10000 || (unsigned)lpEnumFunc >= 0xc0000000)
     329    if ((ULONG)lpEnumFunc < 0x10000 || (ULONG)lpEnumFunc >= 0xc0000000)
    521330    {
    522331        SetLastError(ERROR_NOACCESS);
    … …  
    529338    //3rd level -> language
    530339
    531     pResDirOurType = getResSubDirA(pResDir, lpszType);
     340    pResDirOurType = getResSubDirA(pResRootDir, lpszType);
    532341    if (pResDirOurType != NULL)
    533342    {
    … …  
    539348        fRet = TRUE;
    540349        cResEntries = pResDirOurType->NumberOfNamedEntries + pResDirOurType->NumberOfIdEntries;
    541         paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((unsigned)pResDirOurType + sizeof(*pResDirOurType));
     350        paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDirOurType + sizeof(*pResDirOurType));
    542351        for (i = 0; i < cResEntries && fRet; i++)
    543352        {
    … …  
    547356            {
    548357                PIMAGE_RESOURCE_DIR_STRING_U pResDirString =
    549                     (PIMAGE_RESOURCE_DIR_STRING_U)(paResDirEntries[i].u1.s.NameOffset + (unsigned)pResDir);
     358                    (PIMAGE_RESOURCE_DIR_STRING_U)(paResDirEntries[i].u1.s.NameOffset + (ULONG)pResRootDir);
    550359
    551360                /* ASCII buffer allocation/adjustment? */
    … …  
    626435    PIMAGE_RESOURCE_DIRECTORY_ENTRY paResDirEntries;
    627436
    628     if (pResDir == NULL)
     437    if (pResRootDir == NULL)
    629438    {
    630439        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
    … …  
    633442
    634443    /* validate parameters - FIXME... Exception handler??? */
    635     if ((unsigned)lpszType >= 0xc0000000) //....
     444    if ((ULONG)lpszType >= 0xc0000000) //....
    636445    {
    637446        SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    639448    }
    640449
    641     if ((unsigned)lpEnumFunc < 0x10000 || (unsigned)lpEnumFunc >= 0xc0000000)
     450    if ((ULONG)lpEnumFunc < 0x10000 || (ULONG)lpEnumFunc >= 0xc0000000)
    642451    {
    643452        SetLastError(ERROR_NOACCESS);
    … …  
    651460    //3rd level -> language
    652461
    653     pResDirOurType = getResSubDirW(pResDir, lpszType);
     462    pResDirOurType = getResSubDirW(pResRootDir, lpszType);
    654463    if (pResDirOurType != NULL)
    655464    {
    … …  
    659468        fRet = TRUE;
    660469        cResEntries = pResDirOurType->NumberOfNamedEntries + pResDirOurType->NumberOfIdEntries;
    661         paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((unsigned)pResDirOurType + sizeof(*pResDirOurType));
     470        paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDirOurType + sizeof(*pResDirOurType));
    662471        for (i = 0; i < cResEntries && fRet; i++)
    663472        {
    … …  
    665474
    666475            if (paResDirEntries[i].u1.s.NameIsString)
    667                 lpszName = (LPWSTR)(paResDirEntries[i].u1.s.NameOffset + (unsigned)pResDir + 2);
     476                lpszName = (LPWSTR)(paResDirEntries[i].u1.s.NameOffset + (ULONG)pResRootDir + 2);
    668477            else
    669478                lpszName = (LPWSTR)paResDirEntries[i].u1.Id;
    … …  
    692501 * @author    knut st. osmundsen
    693502 */
    694 PIMAGE_RESOURCE_DIRECTORY Win32ImageBase::getResSubDirW(PIMAGE_RESOURCE_DIRECTORY pResDirToSearch, LPCWSTR lpszName)
     503PIMAGE_RESOURCE_DIRECTORY Win32ImageBase::getResSubDirW(PIMAGE_RESOURCE_DIRECTORY pResDirToSearch,
     504                                                        LPCWSTR lpszName)
    695505{
    696506    PIMAGE_RESOURCE_DIRECTORY_ENTRY paResDirEntries;
    … …  
    699509
    700510    /* lpszName */
    701     if (HIWORD(lpszName) != 0)
     511    if ((ULONG)lpszName != ID_GETFIRST && HIWORD(lpszName) != 0)
    702512    {
    703513        if (lpszName[0] == '#')
    … …  
    711521        idName = (int)lpszName;
    712522
    713     paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((unsigned)pResDirToSearch + sizeof(*pResDirToSearch));
     523    paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDirToSearch + sizeof(*pResDirToSearch));
     524    if(idName == ID_GETFIRST) {
     525        return paResDirEntries[0].u2.s.DataIsDirectory ?
     526               (PIMAGE_RESOURCE_DIRECTORY) (paResDirEntries[0].u2.s.OffsetToDirectory + (ULONG)pResRootDir)
     527               : NULL;
     528    }
     529
    714530    if (idName != -1)
    715531    {   /* idName */
    … …  
    719535            if (paResDirEntries[i].u1.Id == (WORD)idName)
    720536                return paResDirEntries[i].u2.s.DataIsDirectory ?
    721                     (PIMAGE_RESOURCE_DIRECTORY) (paResDirEntries[i].u2.s.OffsetToDirectory + (unsigned)pResDir /*?*/
     537                    (PIMAGE_RESOURCE_DIRECTORY) (paResDirEntries[i].u2.s.OffsetToDirectory + (ULONG)pResRootDir /*?*/
    722538                                                 /*- ulRVAResourceSection*/)
    723539                    : NULL;
    … …  
    730546        {
    731547            PIMAGE_RESOURCE_DIR_STRING_U pResDirStr =
    732                 (PIMAGE_RESOURCE_DIR_STRING_U)(paResDirEntries[i].u1.s.NameOffset + (unsigned)pResDir /*?*/);
    733 
     548                (PIMAGE_RESOURCE_DIR_STRING_U)(paResDirEntries[i].u1.s.NameOffset + (ULONG)pResRootDir /*?*/);
     549
     550            //SvL: Must do case insensitive string compare here
    734551            if (pResDirStr->Length == cusName
    735                 && UniStrncmp(pResDirStr->NameString, lpszName, cusName) == 0)
     552                && lstrncmpiW(pResDirStr->NameString, lpszName, cusName) == 0)
    736553            {
    737554                return paResDirEntries[i].u2.s.DataIsDirectory ?
    738                     (PIMAGE_RESOURCE_DIRECTORY) (paResDirEntries[i].u2.s.OffsetToDirectory + (unsigned)pResDir
     555                    (PIMAGE_RESOURCE_DIRECTORY) (paResDirEntries[i].u2.s.OffsetToDirectory + (ULONG)pResRootDir
    739556                                                 /*- ulRVAResourceSection*/)
    740557                    : NULL;
    … …  
    755572 * @author    knut st. osmundsen
    756573 */
    757 PIMAGE_RESOURCE_DIRECTORY Win32ImageBase::getResSubDirA(PIMAGE_RESOURCE_DIRECTORY pResDirToSearch, LPCTSTR lpszName)
     574PIMAGE_RESOURCE_DIRECTORY Win32ImageBase::getResSubDirA(PIMAGE_RESOURCE_DIRECTORY pResDirToSearch,
     575                                                        LPCTSTR lpszName)
    758576{
    759577    PIMAGE_RESOURCE_DIRECTORY   pResDirRet;
    … …  
    761579
    762580    /* lpszName */
    763     if (HIWORD(lpszName) != 0)
     581    if ((ULONG)lpszName != ID_GETFIRST && HIWORD(lpszName) != 0)
    764582    {
    765583        lpszwName = AsciiToUnicodeString((char*)lpszName);
    … …  
    772590    pResDirRet = getResSubDirW(pResDirToSearch, lpszwName);
    773591
    774     if (HIWORD(lpszwName) != 0)
     592    if ((ULONG)lpszName != ID_GETFIRST && HIWORD(lpszwName) != 0)
    775593        free((void*)lpszwName);
    776594
    777595    return pResDirRet;
     596}
     597//******************************************************************************
     598/**
     599 * This function finds a resource data entry within a given resource directory.
     600 * @returns   Pointer to resource data entry. NULL if not found
     601 * @param     pResDirToSearch  Pointer to resource directory to search. (lang level)
     602 * @param     language         Resource language id
     603 * @param     fGetDefault      TRUE -> get first available resource if not found
     604 * @sketch
     605 * @status    completely implemented
     606 * @author    Sander van Leeuwen
     607 */
     608//******************************************************************************
     609PIMAGE_RESOURCE_DATA_ENTRY
     610     Win32ImageBase::getResDataLang(PIMAGE_RESOURCE_DIRECTORY pResDirToSearch,
     611                                    ULONG language, BOOL fGetDefault)
     612{
     613    PIMAGE_RESOURCE_DIRECTORY_ENTRY paResDirEntries;
     614    int     i;
     615
     616    paResDirEntries = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDirToSearch + sizeof(*pResDirToSearch));
     617
     618    if(pResDirToSearch->NumberOfNamedEntries) {
     619        DebugInt3();
     620    }
     621    paResDirEntries += pResDirToSearch->NumberOfNamedEntries;
     622
     623    for (i = 0; i < pResDirToSearch->NumberOfIdEntries; i++) {
     624        if (paResDirEntries[i].u1.Id == language)
     625        {
     626                return (PIMAGE_RESOURCE_DATA_ENTRY) (paResDirEntries[i].u2.s.OffsetToDirectory + (ULONG)pResRootDir);
     627        }
     628    }
     629
     630    // if nothing found and fGetDefault is true, return first entry
     631    if(fGetDefault)
     632    {
     633        return (PIMAGE_RESOURCE_DATA_ENTRY) (paResDirEntries[0].u2.s.OffsetToDirectory + (ULONG)pResRootDir);
     634    }
     635    return NULL;
    778636}
    779637//******************************************************************************
    … …  
    788646 BOOL   fRet;
    789647
    790     if (pResDir == NULL)
     648    if (pResRootDir == NULL)
    791649    {
    792650        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
    … …  
    794652    }
    795653
    796     if ((unsigned)lpEnumFunc < 0x10000 || (unsigned)lpEnumFunc >= 0xc0000000)
     654    if ((ULONG)lpEnumFunc < 0x10000 || (ULONG)lpEnumFunc >= 0xc0000000)
    797655    {
    798656        SetLastError(ERROR_NOACCESS);
    … …  
    806664
    807665    /* set pointer to first resource type entry */
    808     prde = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
    809 
    810     for (i=0; i<pResDir->NumberOfNamedEntries+pResDir->NumberOfIdEntries && fRet; i++)
     666    prde = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResRootDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
     667
     668    for (i=0; i<pResRootDir->NumberOfNamedEntries+pResRootDir->NumberOfIdEntries && fRet; i++)
    811669    {
    812670        /* locate directory or each resource type */
    813         prdType = (PIMAGE_RESOURCE_DIRECTORY)((int)pResDir + (int)prde->u2.OffsetToData);
     671        prdType = (PIMAGE_RESOURCE_DIRECTORY)((int)pResRootDir + (int)prde->u2.OffsetToData);
    814672
    815673        if (prde->u1.s.NameIsString)
    … …  
    818676                nameOffset = prde->u1.Name & ~0x80000000;
    819677       
    820                 pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResDir + nameOffset);
     678                pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResRootDir + nameOffset);
    821679                char *typename = (char *)malloc(pstring->Length+1);
    822680                lstrcpynWtoA(typename, pstring->NameString, pstring->Length+1);
    … …  
    846704 BOOL   fRet;
    847705
    848     if (pResDir == NULL)
     706    if (pResRootDir == NULL)
    849707    {
    850708        SetLastError(ERROR_RESOURCE_DATA_NOT_FOUND);
    … …  
    852710    }
    853711
    854     if ((unsigned)lpEnumFunc < 0x10000 || (unsigned)lpEnumFunc >= 0xc0000000)
     712    if ((ULONG)lpEnumFunc < 0x10000 || (ULONG)lpEnumFunc >= 0xc0000000)
    855713    {
    856714        SetLastError(ERROR_NOACCESS);
    … …  
    864722
    865723    /* set pointer to first resource type entry */
    866     prde = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
    867 
    868     for (i=0; i<pResDir->NumberOfNamedEntries+pResDir->NumberOfIdEntries && fRet; i++)
     724    prde = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)((ULONG)pResRootDir + sizeof(IMAGE_RESOURCE_DIRECTORY));
     725
     726    for (i=0; i<pResRootDir->NumberOfNamedEntries+pResRootDir->NumberOfIdEntries && fRet; i++)
    869727    {
    870728        /* locate directory or each resource type */
    871         prdType = (PIMAGE_RESOURCE_DIRECTORY)((int)pResDir + (int)prde->u2.OffsetToData);
     729        prdType = (PIMAGE_RESOURCE_DIRECTORY)((int)pResRootDir + (int)prde->u2.OffsetToData);
    872730
    873731        if (prde->u1.s.NameIsString)
    … …  
    876734                nameOffset = prde->u1.Name & ~0x80000000;
    877735       
    878                 pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResDir + nameOffset);
     736                pstring = (PIMAGE_RESOURCE_DIR_STRING_U)((ULONG)pResRootDir + nameOffset);
    879737                fRet = lpEnumFunc(hmod, pstring->NameString, lParam);
    880738        }
Note: See TracChangeset for help on using the changeset viewer.