ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Renamed all LPIMAGE_* types to PIMAGE_*.

This commit is contained in:
Uwe Bonnes 1998-10-16 09:30:33 +00:00 committed by Alexandre Julliard
parent bbf2efe38e
commit 73d6c134c2
13 changed files with 126 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
debugger/dbgmain.c
View File

@ -159,9 +159,9 @@ struct deferred_debug_info
char * module_name; char * module_name;
char * dbg_info; char * dbg_info;
int dbg_size; int dbg_size;
LPIMAGE_DEBUG_DIRECTORY dbgdir; PIMAGE_DEBUG_DIRECTORY dbgdir;
struct pe_data * pe; struct pe_data * pe;
LPIMAGE_SECTION_HEADER sectp; PIMAGE_SECTION_HEADER sectp;
int nsect; int nsect;
short int dbg_index; short int dbg_index;
char loaded; char loaded;

20
debugger/msc.c
View File

@ -510,8 +510,8 @@ struct deferred_debug_info
char * dbg_info; char * dbg_info;
int dbg_size; int dbg_size;
HMODULE32 module; HMODULE32 module;
LPIMAGE_DEBUG_DIRECTORY dbgdir; PIMAGE_DEBUG_DIRECTORY dbgdir;
LPIMAGE_SECTION_HEADER sectp; PIMAGE_SECTION_HEADER sectp;
int nsect; int nsect;
short int dbg_index; short int dbg_index;
char loaded; char loaded;
@ -887,11 +887,11 @@ DEBUG_RegisterDebugInfo( HMODULE32 hModule, const char *module_name,
int has_codeview = FALSE; int has_codeview = FALSE;
int rtn = FALSE; int rtn = FALSE;
int orig_size; int orig_size;
LPIMAGE_DEBUG_DIRECTORY dbgptr; PIMAGE_DEBUG_DIRECTORY dbgptr;
struct deferred_debug_info * deefer; struct deferred_debug_info * deefer;
orig_size = size; orig_size = size;
dbgptr = (LPIMAGE_DEBUG_DIRECTORY) (hModule + v_addr); dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ ) for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
{ {
switch(dbgptr->Type) switch(dbgptr->Type)
@ -904,7 +904,7 @@ DEBUG_RegisterDebugInfo( HMODULE32 hModule, const char *module_name,
} }
size = orig_size; size = orig_size;
dbgptr = (LPIMAGE_DEBUG_DIRECTORY) (hModule + v_addr); dbgptr = (PIMAGE_DEBUG_DIRECTORY) (hModule + v_addr);
for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ ) for(; size >= sizeof(*dbgptr); size -= sizeof(*dbgptr), dbgptr++ )
{ {
switch(dbgptr->Type) switch(dbgptr->Type)
@ -2126,14 +2126,14 @@ DEBUG_ProcessDBGFile(struct deferred_debug_info * deefer, char * filename)
char * codeview; char * codeview;
struct CV4_DirHead * codeview_dir; struct CV4_DirHead * codeview_dir;
struct CV4_DirEnt * codeview_dent; struct CV4_DirEnt * codeview_dent;
LPIMAGE_DEBUG_DIRECTORY dbghdr; PIMAGE_DEBUG_DIRECTORY dbghdr;
struct deferred_debug_info deefer2; struct deferred_debug_info deefer2;
int fd = -1; int fd = -1;
int i; int i;
int j; int j;
struct codeview_linetab_hdr * linetab; struct codeview_linetab_hdr * linetab;
int nsect; int nsect;
LPIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL; PIMAGE_SEPARATE_DEBUG_HEADER pdbg = NULL;
IMAGE_SECTION_HEADER * sectp; IMAGE_SECTION_HEADER * sectp;
struct stat statbuf; struct stat statbuf;
int status; int status;
@ -2167,7 +2167,7 @@ DEBUG_ProcessDBGFile(struct deferred_debug_info * deefer, char * filename)
goto leave; goto leave;
} }
pdbg = (LPIMAGE_SEPARATE_DEBUG_HEADER) addr; pdbg = (PIMAGE_SEPARATE_DEBUG_HEADER) addr;
if( pdbg->TimeDateStamp != deefer->dbgdir->TimeDateStamp ) if( pdbg->TimeDateStamp != deefer->dbgdir->TimeDateStamp )
{ {
@ -2178,11 +2178,11 @@ DEBUG_ProcessDBGFile(struct deferred_debug_info * deefer, char * filename)
fprintf(stderr, "Processing symbols from %s...\n", filename); fprintf(stderr, "Processing symbols from %s...\n", filename);
dbghdr = (LPIMAGE_DEBUG_DIRECTORY) ( addr + sizeof(*pdbg) dbghdr = (PIMAGE_DEBUG_DIRECTORY) ( addr + sizeof(*pdbg)
+ pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER) + pdbg->NumberOfSections * sizeof(IMAGE_SECTION_HEADER)
+ pdbg->ExportedNamesSize); + pdbg->ExportedNamesSize);
sectp = (LPIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg)); sectp = (PIMAGE_SECTION_HEADER) ((char *) pdbg + sizeof(*pdbg));
nsect = pdbg->NumberOfSections; nsect = pdbg->NumberOfSections;
for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ ) for( i=0; i < pdbg->DebugDirectorySize / sizeof(*pdbg); i++, dbghdr++ )

4
include/neexe.h
View File

@ -32,7 +32,7 @@ typedef struct
WORD e_oeminfo; /* 26: OEM information; e_oemid specific */ WORD e_oeminfo; /* 26: OEM information; e_oemid specific */
WORD e_res2[10]; /* 28: Reserved words */ WORD e_res2[10]; /* 28: Reserved words */
DWORD e_lfanew; /* 3c: Offset to extended header */ DWORD e_lfanew; /* 3c: Offset to extended header */
} IMAGE_DOS_HEADER,*LPIMAGE_DOS_HEADER; } IMAGE_DOS_HEADER,*PIMAGE_DOS_HEADER;
#define IMAGE_DOS_SIGNATURE 0x5A4D /* MZ */ #define IMAGE_DOS_SIGNATURE 0x5A4D /* MZ */
#define IMAGE_OS2_SIGNATURE 0x454E /* NE */ #define IMAGE_OS2_SIGNATURE 0x454E /* NE */
@ -79,7 +79,7 @@ typedef struct
WORD fastload_length; /* 3a Length of fast load area */ WORD fastload_length; /* 3a Length of fast load area */
WORD reserved2; /* 3c Reserved by Microsoft */ WORD reserved2; /* 3c Reserved by Microsoft */
WORD expect_version; /* 3e Expected Windows version number */ WORD expect_version; /* 3e Expected Windows version number */
} IMAGE_OS2_HEADER,*LPIMAGE_OS2_HEADER; } IMAGE_OS2_HEADER,*PIMAGE_OS2_HEADER;
/* /*
* NE Header FORMAT FLAGS * NE Header FORMAT FLAGS

10
include/pe_image.h
View File

@ -10,10 +10,10 @@
* all section are calculated here, relocations etc. * all section are calculated here, relocations etc.
*/ */
typedef struct { typedef struct {
LPIMAGE_IMPORT_DESCRIPTOR pe_import; PIMAGE_IMPORT_DESCRIPTOR pe_import;
LPIMAGE_EXPORT_DIRECTORY pe_export; PIMAGE_EXPORT_DIRECTORY pe_export;
LPIMAGE_RESOURCE_DIRECTORY pe_resource; PIMAGE_RESOURCE_DIRECTORY pe_resource;
LPIMAGE_BASE_RELOCATION pe_reloc; PIMAGE_BASE_RELOCATION pe_reloc;
int flags; int flags;
#define PE_MODREF_PROCESS_ATTACHED 0x00000001 #define PE_MODREF_PROCESS_ATTACHED 0x00000001
#define PE_MODREF_NO_DLL_CALLS 0x00000002 #define PE_MODREF_NO_DLL_CALLS 0x00000002
@ -48,7 +48,7 @@ struct _THDB; /* forward definition */
extern void PE_InitTls(struct _THDB*); extern void PE_InitTls(struct _THDB*);
extern void PE_InitDLL(struct _wine_modref *wm, DWORD type, LPVOID lpReserved); extern void PE_InitDLL(struct _wine_modref *wm, DWORD type, LPVOID lpReserved);
extern LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(LPIMAGE_RESOURCE_DIRECTORY,LPCWSTR,DWORD,BOOL32); extern PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY,LPCWSTR,DWORD,BOOL32);
typedef DWORD (CALLBACK*DLLENTRYPROC32)(HMODULE32,DWORD,LPVOID); typedef DWORD (CALLBACK*DLLENTRYPROC32)(HMODULE32,DWORD,LPVOID);

48
include/peexe.h
View File

@ -15,7 +15,7 @@ typedef struct _IMAGE_FILE_HEADER {
DWORD NumberOfSymbols; /* 0c */ DWORD NumberOfSymbols; /* 0c */
WORD SizeOfOptionalHeader; /* 10 */ WORD SizeOfOptionalHeader; /* 10 */
WORD Characteristics; /* 12 */ WORD Characteristics; /* 12 */
} IMAGE_FILE_HEADER,*LPIMAGE_FILE_HEADER; } IMAGE_FILE_HEADER,*PIMAGE_FILE_HEADER;
#define IMAGE_SIZEOF_FILE_HEADER 20 #define IMAGE_SIZEOF_FILE_HEADER 20
@ -48,7 +48,7 @@ typedef struct _IMAGE_DATA_DIRECTORY
{ {
DWORD VirtualAddress; DWORD VirtualAddress;
DWORD Size; DWORD Size;
} IMAGE_DATA_DIRECTORY,*LPIMAGE_DATA_DIRECTORY; } IMAGE_DATA_DIRECTORY,*PIMAGE_DATA_DIRECTORY;
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
@ -96,7 +96,7 @@ typedef struct _IMAGE_OPTIONAL_HEADER
DWORD NumberOfRvaAndSizes; /* 5C */ DWORD NumberOfRvaAndSizes; /* 5C */
/* 60: */ /* 60: */
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER,*LPIMAGE_OPTIONAL_HEADER; } IMAGE_OPTIONAL_HEADER,*PIMAGE_OPTIONAL_HEADER;
/* Possible Magic values */ /* Possible Magic values */
#define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b #define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
@ -145,7 +145,7 @@ typedef struct _IMAGE_NT_HEADERS {
DWORD Signature; /* 00: PE\0\0 */ DWORD Signature; /* 00: PE\0\0 */
IMAGE_FILE_HEADER FileHeader; /* 04: Fileheader */ IMAGE_FILE_HEADER FileHeader; /* 04: Fileheader */
IMAGE_OPTIONAL_HEADER OptionalHeader; /* 18: Optional Header */ IMAGE_OPTIONAL_HEADER OptionalHeader; /* 18: Optional Header */
} IMAGE_NT_HEADERS,*LPIMAGE_NT_HEADERS; } IMAGE_NT_HEADERS,*PIMAGE_NT_HEADERS;
#define PE_HEADER(module) \ #define PE_HEADER(module) \
@ -177,7 +177,7 @@ typedef struct _IMAGE_SECTION_HEADER {
WORD NumberOfLinenumbers; /* 1E: */ WORD NumberOfLinenumbers; /* 1E: */
DWORD Characteristics; /* 20: */ DWORD Characteristics; /* 20: */
/* 24: */ /* 24: */
} IMAGE_SECTION_HEADER,*LPIMAGE_SECTION_HEADER; } IMAGE_SECTION_HEADER,*PIMAGE_SECTION_HEADER;
#define IMAGE_SIZEOF_SECTION_HEADER 40 #define IMAGE_SIZEOF_SECTION_HEADER 40
@ -234,7 +234,7 @@ typedef struct _IMAGE_SECTION_HEADER {
typedef struct _IMAGE_IMPORT_BY_NAME { typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint; WORD Hint;
BYTE Name[1]; BYTE Name[1];
} IMAGE_IMPORT_BY_NAME,*LPIMAGE_IMPORT_BY_NAME; } IMAGE_IMPORT_BY_NAME,*PIMAGE_IMPORT_BY_NAME;
/* Import thunk */ /* Import thunk */
typedef struct _IMAGE_THUNK_DATA { typedef struct _IMAGE_THUNK_DATA {
@ -242,16 +242,16 @@ typedef struct _IMAGE_THUNK_DATA {
LPBYTE ForwarderString; LPBYTE ForwarderString;
FARPROC32 Function; FARPROC32 Function;
DWORD Ordinal; DWORD Ordinal;
LPIMAGE_IMPORT_BY_NAME AddressOfData; PIMAGE_IMPORT_BY_NAME AddressOfData;
} u1; } u1;
} IMAGE_THUNK_DATA,*LPIMAGE_THUNK_DATA; } IMAGE_THUNK_DATA,*PIMAGE_THUNK_DATA;
/* Import module directory */ /* Import module directory */
typedef struct _IMAGE_IMPORT_DESCRIPTOR { typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union { union {
DWORD Characteristics; /* 0 for terminating null import descriptor */ DWORD Characteristics; /* 0 for terminating null import descriptor */
LPIMAGE_THUNK_DATA OriginalFirstThunk; /* RVA to original unbound IAT */ PIMAGE_THUNK_DATA OriginalFirstThunk; /* RVA to original unbound IAT */
} u; } u;
DWORD TimeDateStamp; /* 0 if not bound, DWORD TimeDateStamp; /* 0 if not bound,
* -1 if bound, and real date\time stamp * -1 if bound, and real date\time stamp
@ -263,8 +263,8 @@ typedef struct _IMAGE_IMPORT_DESCRIPTOR {
DWORD ForwarderChain; /* -1 if no forwarders */ DWORD ForwarderChain; /* -1 if no forwarders */
DWORD Name; DWORD Name;
/* RVA to IAT (if bound this IAT has actual addresses) */ /* RVA to IAT (if bound this IAT has actual addresses) */
LPIMAGE_THUNK_DATA FirstThunk; PIMAGE_THUNK_DATA FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR,*LPIMAGE_IMPORT_DESCRIPTOR; } IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;
#define IMAGE_ORDINAL_FLAG 0x80000000 #define IMAGE_ORDINAL_FLAG 0x80000000
#define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0) #define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0)
@ -285,7 +285,7 @@ typedef struct _IMAGE_EXPORT_DIRECTORY {
LPDWORD *AddressOfNames; LPDWORD *AddressOfNames;
LPWORD *AddressOfNameOrdinals; LPWORD *AddressOfNameOrdinals;
/* u_char ModuleName[1]; */ /* u_char ModuleName[1]; */
} IMAGE_EXPORT_DIRECTORY,*LPIMAGE_EXPORT_DIRECTORY; } IMAGE_EXPORT_DIRECTORY,*PIMAGE_EXPORT_DIRECTORY;
/* /*
@ -299,7 +299,7 @@ typedef struct _IMAGE_RESOURCE_DIRECTORY {
WORD NumberOfNamedEntries; WORD NumberOfNamedEntries;
WORD NumberOfIdEntries; WORD NumberOfIdEntries;
/* IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[]; */ /* IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[]; */
} IMAGE_RESOURCE_DIRECTORY,*LPIMAGE_RESOURCE_DIRECTORY; } IMAGE_RESOURCE_DIRECTORY,*PIMAGE_RESOURCE_DIRECTORY;
#define IMAGE_RESOURCE_NAME_IS_STRING 0x80000000 #define IMAGE_RESOURCE_NAME_IS_STRING 0x80000000
#define IMAGE_RESOURCE_DATA_IS_DIRECTORY 0x80000000 #define IMAGE_RESOURCE_DATA_IS_DIRECTORY 0x80000000
@ -320,32 +320,32 @@ typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
DWORD DataIsDirectory:1; DWORD DataIsDirectory:1;
} s; } s;
} u2; } u2;
} IMAGE_RESOURCE_DIRECTORY_ENTRY,*LPIMAGE_RESOURCE_DIRECTORY_ENTRY; } IMAGE_RESOURCE_DIRECTORY_ENTRY,*PIMAGE_RESOURCE_DIRECTORY_ENTRY;
typedef struct _IMAGE_RESOURCE_DIRECTORY_STRING { typedef struct _IMAGE_RESOURCE_DIRECTORY_STRING {
WORD Length; WORD Length;
CHAR NameString[ 1 ]; CHAR NameString[ 1 ];
} IMAGE_RESOURCE_DIRECTORY_STRING,*LPIMAGE_RESOURCE_DIRECTORY_STRING; } IMAGE_RESOURCE_DIRECTORY_STRING,*PIMAGE_RESOURCE_DIRECTORY_STRING;
typedef struct _IMAGE_RESOURCE_DIR_STRING_U { typedef struct _IMAGE_RESOURCE_DIR_STRING_U {
WORD Length; WORD Length;
WCHAR NameString[ 1 ]; WCHAR NameString[ 1 ];
} IMAGE_RESOURCE_DIR_STRING_U,*LPIMAGE_RESOURCE_DIR_STRING_U; } IMAGE_RESOURCE_DIR_STRING_U,*PIMAGE_RESOURCE_DIR_STRING_U;
typedef struct _IMAGE_RESOURCE_DATA_ENTRY { typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
DWORD OffsetToData; DWORD OffsetToData;
DWORD Size; DWORD Size;
DWORD CodePage; DWORD CodePage;
DWORD ResourceHandle; DWORD ResourceHandle;
} IMAGE_RESOURCE_DATA_ENTRY,*LPIMAGE_RESOURCE_DATA_ENTRY; } IMAGE_RESOURCE_DATA_ENTRY,*PIMAGE_RESOURCE_DATA_ENTRY;
typedef struct _IMAGE_BASE_RELOCATION typedef struct _IMAGE_BASE_RELOCATION
{ {
DWORD VirtualAddress; DWORD VirtualAddress;
DWORD SizeOfBlock; DWORD SizeOfBlock;
WORD TypeOffset[1]; WORD TypeOffset[1];
} IMAGE_BASE_RELOCATION,*LPIMAGE_BASE_RELOCATION; } IMAGE_BASE_RELOCATION,*PIMAGE_BASE_RELOCATION;
typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY { typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY {
DWORD Characteristics; DWORD Characteristics;
@ -362,9 +362,9 @@ typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY {
DWORD VirtualMemoryThreshold; DWORD VirtualMemoryThreshold;
DWORD ProcessHeapFlags; DWORD ProcessHeapFlags;
DWORD Reserved[ 4 ]; DWORD Reserved[ 4 ];
} IMAGE_LOAD_CONFIG_DIRECTORY,*LPIMAGE_LOAD_CONFIG_DIRECTORY; } IMAGE_LOAD_CONFIG_DIRECTORY,*PIMAGE_LOAD_CONFIG_DIRECTORY;
typedef VOID (CALLBACK *LPIMAGE_TLS_CALLBACK)( typedef VOID (CALLBACK *PIMAGE_TLS_CALLBACK)(
LPVOID DllHandle,DWORD Reason,LPVOID Reserved LPVOID DllHandle,DWORD Reason,LPVOID Reserved
); );
@ -372,10 +372,10 @@ typedef struct _IMAGE_TLS_DIRECTORY {
DWORD StartAddressOfRawData; DWORD StartAddressOfRawData;
DWORD EndAddressOfRawData; DWORD EndAddressOfRawData;
LPDWORD AddressOfIndex; LPDWORD AddressOfIndex;
LPIMAGE_TLS_CALLBACK *AddressOfCallBacks; PIMAGE_TLS_CALLBACK *AddressOfCallBacks;
DWORD SizeOfZeroFill; DWORD SizeOfZeroFill;
DWORD Characteristics; DWORD Characteristics;
} IMAGE_TLS_DIRECTORY,*LPIMAGE_TLS_DIRECTORY; } IMAGE_TLS_DIRECTORY,*PIMAGE_TLS_DIRECTORY;
/* /*
* The IMAGE_DEBUG_DIRECTORY data directory points to an array of * The IMAGE_DEBUG_DIRECTORY data directory points to an array of
@ -390,7 +390,7 @@ typedef struct _IMAGE_DEBUG_DIRECTORY {
DWORD SizeOfData; DWORD SizeOfData;
DWORD AddressOfRawData; DWORD AddressOfRawData;
DWORD PointerToRawData; DWORD PointerToRawData;
} IMAGE_DEBUG_DIRECTORY,*LPIMAGE_DEBUG_DIRECTORY; } IMAGE_DEBUG_DIRECTORY,*PIMAGE_DEBUG_DIRECTORY;
/* /*
* The type field above can take these (plus a few other * The type field above can take these (plus a few other
@ -430,7 +430,7 @@ typedef struct _IMAGE_SEPARATE_DEBUG_HEADER {
DWORD ExportedNamesSize; DWORD ExportedNamesSize;
DWORD DebugDirectorySize; DWORD DebugDirectorySize;
DWORD Reserved[ 3 ]; DWORD Reserved[ 3 ];
} IMAGE_SEPARATE_DEBUG_HEADER,*LPIMAGE_SEPARATE_DEBUG_HEADER; } IMAGE_SEPARATE_DEBUG_HEADER,*PIMAGE_SEPARATE_DEBUG_HEADER;
#define IMAGE_SEPARATE_DEBUG_SIGNATURE 0x4944 #define IMAGE_SEPARATE_DEBUG_SIGNATURE 0x4944

10
loader/elf.c
View File

@ -38,9 +38,9 @@ ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
WINE_MODREF *wm; WINE_MODREF *wm;
char *modname,*s,*t,*x; char *modname,*s,*t,*x;
LPVOID *dlhandle; LPVOID *dlhandle;
LPIMAGE_DOS_HEADER dh; PIMAGE_DOS_HEADER dh;
LPIMAGE_NT_HEADERS nth; PIMAGE_NT_HEADERS nth;
LPIMAGE_SECTION_HEADER sh; PIMAGE_SECTION_HEADER sh;
HMODULE32 hmod; HMODULE32 hmod;
t = HeapAlloc(process->heap,HEAP_ZERO_MEMORY,strlen(libname)+strlen("lib.so")+1); t = HeapAlloc(process->heap,HEAP_ZERO_MEMORY,strlen(libname)+strlen("lib.so")+1);
@ -88,7 +88,7 @@ ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
wm->longname = HEAP_strdupA(process->heap,0,t); wm->longname = HEAP_strdupA(process->heap,0,t);
hmod = (HMODULE32)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(IMAGE_DOS_HEADER)+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)+100); hmod = (HMODULE32)HeapAlloc(process->heap,HEAP_ZERO_MEMORY,sizeof(IMAGE_DOS_HEADER)+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)+100);
dh = (LPIMAGE_DOS_HEADER)hmod; dh = (PIMAGE_DOS_HEADER)hmod;
dh->e_magic = IMAGE_DOS_SIGNATURE; dh->e_magic = IMAGE_DOS_SIGNATURE;
dh->e_lfanew = sizeof(IMAGE_DOS_HEADER); dh->e_lfanew = sizeof(IMAGE_DOS_HEADER);
nth = PE_HEADER(hmod); nth = PE_HEADER(hmod);
@ -117,7 +117,7 @@ ELF_LoadLibraryEx32A(LPCSTR libname,PDB32 *process,HANDLE32 hf,DWORD flags) {
/* allocate one code section that crosses the whole process range /* allocate one code section that crosses the whole process range
* (we could find out from internal tables ... hmm ) * (we could find out from internal tables ... hmm )
*/ */
sh=(LPIMAGE_SECTION_HEADER)(nth+1); sh=(PIMAGE_SECTION_HEADER)(nth+1);
strcpy(sh->Name,".text"); strcpy(sh->Name,".text");
sh->Misc.VirtualSize = 0x7fffffff; sh->Misc.VirtualSize = 0x7fffffff;
sh->VirtualAddress = 0x42; /* so snoop can use it ... */ sh->VirtualAddress = 0x42; /* so snoop can use it ... */

4
loader/module.c
View File

@ -1105,7 +1105,7 @@ FARPROC32 MODULE_GetProcAddress32(
/*********************************************************************** /***********************************************************************
* RtlImageNtHeaders (NTDLL) * RtlImageNtHeaders (NTDLL)
*/ */
LPIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule) PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
{ {
/* basically: /* basically:
* return hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew); * return hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew);
@ -1113,7 +1113,7 @@ LPIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
*/ */
WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule ); WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule );
if (!wm || (wm->type != MODULE32_PE)) return (LPIMAGE_NT_HEADERS)0; if (!wm || (wm->type != MODULE32_PE)) return (PIMAGE_NT_HEADERS)0;
return PE_HEADER(wm->module); return PE_HEADER(wm->module);
} }

32
loader/pe_image.c
View File

@ -254,7 +254,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
for (i = 0, pe_imp = pem->pe_import; pe_imp->Name; pe_imp++) { for (i = 0, pe_imp = pem->pe_import; pe_imp->Name; pe_imp++) {
HMODULE32 hImpModule; HMODULE32 hImpModule;
IMAGE_IMPORT_BY_NAME *pe_name; IMAGE_IMPORT_BY_NAME *pe_name;
LPIMAGE_THUNK_DATA import_list,thunk_list; PIMAGE_THUNK_DATA import_list,thunk_list;
char *name = (char *) RVA(pe_imp->Name); char *name = (char *) RVA(pe_imp->Name);
/* don't use MODULE_Load, Win32 creates new task differently */ /* don't use MODULE_Load, Win32 creates new task differently */
@ -281,8 +281,8 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
if (pe_imp->u.OriginalFirstThunk != 0) { /* original MS style */ if (pe_imp->u.OriginalFirstThunk != 0) { /* original MS style */
TRACE(win32, "Microsoft style imports used\n"); TRACE(win32, "Microsoft style imports used\n");
import_list =(LPIMAGE_THUNK_DATA) RVA(pe_imp->u.OriginalFirstThunk); import_list =(PIMAGE_THUNK_DATA) RVA(pe_imp->u.OriginalFirstThunk);
thunk_list = (LPIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk); thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
while (import_list->u1.Ordinal) { while (import_list->u1.Ordinal) {
if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal)) { if (IMAGE_SNAP_BY_ORDINAL(import_list->u1.Ordinal)) {
@ -298,7 +298,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
thunk_list->u1.Function = (FARPROC32)0xdeadbeef; thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
} }
} else { /* import by name */ } else { /* import by name */
pe_name = (LPIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData); pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint); TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
thunk_list->u1.Function=MODULE_GetProcAddress32( thunk_list->u1.Function=MODULE_GetProcAddress32(
process, hImpModule, pe_name->Name, TRUE process, hImpModule, pe_name->Name, TRUE
@ -314,7 +314,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
} }
} else { /* Borland style */ } else { /* Borland style */
TRACE(win32, "Borland style imports used\n"); TRACE(win32, "Borland style imports used\n");
thunk_list = (LPIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk); thunk_list = (PIMAGE_THUNK_DATA) RVA(pe_imp->FirstThunk);
while (thunk_list->u1.Ordinal) { while (thunk_list->u1.Ordinal) {
if (IMAGE_SNAP_BY_ORDINAL(thunk_list->u1.Ordinal)) { if (IMAGE_SNAP_BY_ORDINAL(thunk_list->u1.Ordinal)) {
/* not sure about this branch, but it seems to work */ /* not sure about this branch, but it seems to work */
@ -330,7 +330,7 @@ DWORD fixup_imports (PDB32 *process,WINE_MODREF *wm)
thunk_list->u1.Function = (FARPROC32)0xdeadbeef; thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
} }
} else { } else {
pe_name=(LPIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData); pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
TRACE(win32,"--- %s %s.%d\n", TRACE(win32,"--- %s %s.%d\n",
pe_name->Name,name,pe_name->Hint); pe_name->Name,name,pe_name->Hint);
thunk_list->u1.Function=MODULE_GetProcAddress32( thunk_list->u1.Function=MODULE_GetProcAddress32(
@ -613,16 +613,16 @@ static BOOL32 PE_MapImage( PDB32 *process,WINE_MODREF *wm, OFSTRUCT *ofs, DWORD
#endif #endif
if(strcmp(pe_seg->Name, ".idata") == 0) if(strcmp(pe_seg->Name, ".idata") == 0)
pem->pe_import = (LPIMAGE_IMPORT_DESCRIPTOR) result; pem->pe_import = (PIMAGE_IMPORT_DESCRIPTOR) result;
if(strcmp(pe_seg->Name, ".edata") == 0) if(strcmp(pe_seg->Name, ".edata") == 0)
pem->pe_export = (LPIMAGE_EXPORT_DIRECTORY) result; pem->pe_export = (PIMAGE_EXPORT_DIRECTORY) result;
if(strcmp(pe_seg->Name, ".rsrc") == 0) if(strcmp(pe_seg->Name, ".rsrc") == 0)
pem->pe_resource = (LPIMAGE_RESOURCE_DIRECTORY) result; pem->pe_resource = (PIMAGE_RESOURCE_DIRECTORY) result;
if(strcmp(pe_seg->Name, ".reloc") == 0) if(strcmp(pe_seg->Name, ".reloc") == 0)
pem->pe_reloc = (LPIMAGE_BASE_RELOCATION) result; pem->pe_reloc = (PIMAGE_BASE_RELOCATION) result;
} }
/* There is word that the actual loader does not care about the /* There is word that the actual loader does not care about the
@ -633,7 +633,7 @@ static BOOL32 PE_MapImage( PDB32 *process,WINE_MODREF *wm, OFSTRUCT *ofs, DWORD
if(pem->pe_export && (int)pem->pe_export!=RVA(dir.VirtualAddress)) if(pem->pe_export && (int)pem->pe_export!=RVA(dir.VirtualAddress))
WARN(win32,"wrong export directory??\n"); WARN(win32,"wrong export directory??\n");
/* always trust the directory */ /* always trust the directory */
pem->pe_export = (LPIMAGE_EXPORT_DIRECTORY) RVA(dir.VirtualAddress); pem->pe_export = (PIMAGE_EXPORT_DIRECTORY) RVA(dir.VirtualAddress);
} }
dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]; dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
@ -643,7 +643,7 @@ static BOOL32 PE_MapImage( PDB32 *process,WINE_MODREF *wm, OFSTRUCT *ofs, DWORD
if(pem->pe_import && (int)pem->pe_import!=RVA(dir.VirtualAddress)) if(pem->pe_import && (int)pem->pe_import!=RVA(dir.VirtualAddress))
WARN(win32,"wrong import directory??\n"); WARN(win32,"wrong import directory??\n");
*/ */
pem->pe_import = (LPIMAGE_IMPORT_DESCRIPTOR) RVA(dir.VirtualAddress); pem->pe_import = (PIMAGE_IMPORT_DESCRIPTOR) RVA(dir.VirtualAddress);
} }
dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE]; dir=nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
@ -651,7 +651,7 @@ static BOOL32 PE_MapImage( PDB32 *process,WINE_MODREF *wm, OFSTRUCT *ofs, DWORD
{ {
if(pem->pe_resource && (int)pem->pe_resource!=RVA(dir.VirtualAddress)) if(pem->pe_resource && (int)pem->pe_resource!=RVA(dir.VirtualAddress))
WARN(win32,"wrong resource directory??\n"); WARN(win32,"wrong resource directory??\n");
pem->pe_resource = (LPIMAGE_RESOURCE_DIRECTORY) RVA(dir.VirtualAddress); pem->pe_resource = (PIMAGE_RESOURCE_DIRECTORY) RVA(dir.VirtualAddress);
} }
if(nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size) if(nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size)
@ -934,7 +934,7 @@ void PE_InitTls(THDB *thdb)
IMAGE_NT_HEADERS *peh; IMAGE_NT_HEADERS *peh;
DWORD size,datasize; DWORD size,datasize;
LPVOID mem; LPVOID mem;
LPIMAGE_TLS_DIRECTORY pdir; PIMAGE_TLS_DIRECTORY pdir;
PDB32 *pdb = thdb->process; PDB32 *pdb = thdb->process;
int delta; int delta;
@ -965,8 +965,8 @@ void PE_InitTls(THDB *thdb)
/* don't use TlsSetValue, we are in the wrong thread */ /* don't use TlsSetValue, we are in the wrong thread */
if (pdir->AddressOfCallBacks) { if (pdir->AddressOfCallBacks) {
LPIMAGE_TLS_CALLBACK *cbs = PIMAGE_TLS_CALLBACK *cbs =
(LPIMAGE_TLS_CALLBACK *) (PIMAGE_TLS_CALLBACK *)
AdjustPtr(pdir->AddressOfCallBacks, delta); AdjustPtr(pdir->AddressOfCallBacks, delta);
if (*cbs) { if (*cbs) {

72
loader/pe_resource.c
View File

@ -46,12 +46,12 @@ HMODULE32toPE_MODREF(HMODULE32 hmod) {
* Helper function - goes down one level of PE resource tree * Helper function - goes down one level of PE resource tree
* *
*/ */
LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(LPIMAGE_RESOURCE_DIRECTORY resdirptr, PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
LPCWSTR name,DWORD root, LPCWSTR name,DWORD root,
BOOL32 allowdefault) BOOL32 allowdefault)
{ {
int entrynum; int entrynum;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable; PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
int namelen; int namelen;
if (HIWORD(name)) { if (HIWORD(name)) {
@ -61,36 +61,36 @@ LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(LPIMAGE_RESOURCE_DIRECTORY resdirptr,
lstrcpynWtoA(buf,name+1,10); lstrcpynWtoA(buf,name+1,10);
return GetResDirEntryW(resdirptr,(LPCWSTR)atoi(buf),root,allowdefault); return GetResDirEntryW(resdirptr,(LPCWSTR)atoi(buf),root,allowdefault);
} }
entryTable = (LPIMAGE_RESOURCE_DIRECTORY_ENTRY) ( entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
(BYTE *) resdirptr + (BYTE *) resdirptr +
sizeof(IMAGE_RESOURCE_DIRECTORY)); sizeof(IMAGE_RESOURCE_DIRECTORY));
namelen = lstrlen32W(name); namelen = lstrlen32W(name);
for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++) for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
{ {
LPIMAGE_RESOURCE_DIR_STRING_U str = PIMAGE_RESOURCE_DIR_STRING_U str =
(LPIMAGE_RESOURCE_DIR_STRING_U) (root + (PIMAGE_RESOURCE_DIR_STRING_U) (root +
entryTable[entrynum].u1.s.NameOffset); entryTable[entrynum].u1.s.NameOffset);
if(namelen != str->Length) if(namelen != str->Length)
continue; continue;
if(lstrncmpi32W(name,str->NameString,str->Length)==0) if(lstrncmpi32W(name,str->NameString,str->Length)==0)
return (LPIMAGE_RESOURCE_DIRECTORY) ( return (PIMAGE_RESOURCE_DIRECTORY) (
root + root +
entryTable[entrynum].u2.s.OffsetToDirectory); entryTable[entrynum].u2.s.OffsetToDirectory);
} }
return NULL; return NULL;
} else { } else {
entryTable = (LPIMAGE_RESOURCE_DIRECTORY_ENTRY) ( entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
(BYTE *) resdirptr + (BYTE *) resdirptr +
sizeof(IMAGE_RESOURCE_DIRECTORY) + sizeof(IMAGE_RESOURCE_DIRECTORY) +
resdirptr->NumberOfNamedEntries * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)); resdirptr->NumberOfNamedEntries * sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
for (entrynum = 0; entrynum < resdirptr->NumberOfIdEntries; entrynum++) for (entrynum = 0; entrynum < resdirptr->NumberOfIdEntries; entrynum++)
if ((DWORD)entryTable[entrynum].u1.Name == (DWORD)name) if ((DWORD)entryTable[entrynum].u1.Name == (DWORD)name)
return (LPIMAGE_RESOURCE_DIRECTORY) ( return (PIMAGE_RESOURCE_DIRECTORY) (
root + root +
entryTable[entrynum].u2.s.OffsetToDirectory); entryTable[entrynum].u2.s.OffsetToDirectory);
/* just use first entry if no default can be found */ /* just use first entry if no default can be found */
if (allowdefault && !name && resdirptr->NumberOfIdEntries) if (allowdefault && !name && resdirptr->NumberOfIdEntries)
return (LPIMAGE_RESOURCE_DIRECTORY) ( return (PIMAGE_RESOURCE_DIRECTORY) (
root + root +
entryTable[0].u2.s.OffsetToDirectory); entryTable[0].u2.s.OffsetToDirectory);
return NULL; return NULL;
@ -103,7 +103,7 @@ LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(LPIMAGE_RESOURCE_DIRECTORY resdirptr,
HANDLE32 PE_FindResourceEx32W( HANDLE32 PE_FindResourceEx32W(
WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang
) { ) {
LPIMAGE_RESOURCE_DIRECTORY resdirptr; PIMAGE_RESOURCE_DIRECTORY resdirptr;
DWORD root; DWORD root;
HANDLE32 result; HANDLE32 result;
PE_MODREF *pem = &(wm->binfmt.pe); PE_MODREF *pem = &(wm->binfmt.pe);
@ -132,7 +132,7 @@ HANDLE32 PE_LoadResource32( WINE_MODREF *wm, HANDLE32 hRsrc )
{ {
if (!hRsrc || !wm || wm->type!=MODULE32_PE) if (!hRsrc || !wm || wm->type!=MODULE32_PE)
return 0; return 0;
return (HANDLE32) (wm->module + ((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData); return (HANDLE32) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
} }
@ -144,7 +144,7 @@ DWORD PE_SizeofResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
/* we don't need hModule */ /* we don't need hModule */
if (!hRsrc) if (!hRsrc)
return 0; return 0;
return ((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size; return ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->Size;
} }
/********************************************************************** /**********************************************************************
@ -154,16 +154,16 @@ BOOL32
PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) { PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
HANDLE32 heap = GetProcessHeap(); HANDLE32 heap = GetProcessHeap();
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
LPSTR name; LPSTR name;
@ -188,15 +188,15 @@ BOOL32
PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) { PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
LPWSTR type; LPWSTR type;
@ -221,15 +221,15 @@ PE_EnumResourceNames32A(
) { ) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
HANDLE32 heap = GetProcessHeap(); HANDLE32 heap = GetProcessHeap();
LPWSTR typeW; LPWSTR typeW;
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
if (HIWORD(type)) if (HIWORD(type))
typeW = HEAP_strdupAtoW(heap,0,type); typeW = HEAP_strdupAtoW(heap,0,type);
else else
@ -239,7 +239,7 @@ PE_EnumResourceNames32A(
HeapFree(heap,0,typeW); HeapFree(heap,0,typeW);
if (!resdir) if (!resdir)
return FALSE; return FALSE;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
LPSTR name; LPSTR name;
@ -265,18 +265,18 @@ PE_EnumResourceNames32W(
) { ) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE); resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
if (!resdir) if (!resdir)
return FALSE; return FALSE;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
LPWSTR name; LPWSTR name;
@ -301,8 +301,8 @@ PE_EnumResourceLanguages32A(
) { ) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
HANDLE32 heap = GetProcessHeap(); HANDLE32 heap = GetProcessHeap();
LPWSTR nameW,typeW; LPWSTR nameW,typeW;
@ -310,7 +310,7 @@ PE_EnumResourceLanguages32A(
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
if (HIWORD(name)) if (HIWORD(name))
nameW = HEAP_strdupAtoW(heap,0,name); nameW = HEAP_strdupAtoW(heap,0,name);
else else
@ -329,7 +329,7 @@ PE_EnumResourceLanguages32A(
HeapFree(heap,0,typeW); HeapFree(heap,0,typeW);
if (!resdir) if (!resdir)
return FALSE; return FALSE;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
/* languages are just ids... I hopem */ /* languages are just ids... I hopem */
@ -350,21 +350,21 @@ PE_EnumResourceLanguages32W(
) { ) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod); PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i; int i;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY et; PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
BOOL32 ret; BOOL32 ret;
if (!pem || !pem->pe_resource) if (!pem || !pem->pe_resource)
return FALSE; return FALSE;
resdir = (LPIMAGE_RESOURCE_DIRECTORY)pem->pe_resource; resdir = (PIMAGE_RESOURCE_DIRECTORY)pem->pe_resource;
resdir = GetResDirEntryW(resdir,name,(DWORD)pem->pe_resource,FALSE); resdir = GetResDirEntryW(resdir,name,(DWORD)pem->pe_resource,FALSE);
if (!resdir) if (!resdir)
return FALSE; return FALSE;
resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE); resdir = GetResDirEntryW(resdir,type,(DWORD)pem->pe_resource,FALSE);
if (!resdir) if (!resdir)
return FALSE; return FALSE;
et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY)); et =(PIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
ret = FALSE; ret = FALSE;
for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) { for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
ret = lpfun(hmod,name,type,et[i].u1.Id,lparam); ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);

32
misc/shell.c
View File

@ -602,14 +602,14 @@ HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
if( sig == IMAGE_NT_SIGNATURE) if( sig == IMAGE_NT_SIGNATURE)
{ {
LPBYTE peimage,idata,igdata; LPBYTE peimage,idata,igdata;
LPIMAGE_DOS_HEADER dheader; PIMAGE_DOS_HEADER dheader;
LPIMAGE_NT_HEADERS pe_header; PIMAGE_NT_HEADERS pe_header;
LPIMAGE_SECTION_HEADER pe_sections; PIMAGE_SECTION_HEADER pe_sections;
LPIMAGE_RESOURCE_DIRECTORY rootresdir,iconresdir,icongroupresdir; PIMAGE_RESOURCE_DIRECTORY rootresdir,iconresdir,icongroupresdir;
LPIMAGE_RESOURCE_DATA_ENTRY idataent,igdataent; PIMAGE_RESOURCE_DATA_ENTRY idataent,igdataent;
HANDLE32 fmapping; HANDLE32 fmapping;
int i,j; int i,j;
LPIMAGE_RESOURCE_DIRECTORY_ENTRY xresent; PIMAGE_RESOURCE_DIRECTORY_ENTRY xresent;
CURSORICONDIR **cids; CURSORICONDIR **cids;
fmapping = CreateFileMapping32A(hFile,NULL,PAGE_READONLY|SEC_COMMIT,0,0,NULL); fmapping = CreateFileMapping32A(hFile,NULL,PAGE_READONLY|SEC_COMMIT,0,0,NULL);
@ -625,20 +625,20 @@ HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
_lclose32( hFile); _lclose32( hFile);
return 0; return 0;
} }
dheader = (LPIMAGE_DOS_HEADER)peimage; dheader = (PIMAGE_DOS_HEADER)peimage;
/* it is a pe header, SHELL_GetResourceTable checked that */ /* it is a pe header, SHELL_GetResourceTable checked that */
pe_header = (LPIMAGE_NT_HEADERS)(peimage+dheader->e_lfanew); pe_header = (PIMAGE_NT_HEADERS)(peimage+dheader->e_lfanew);
/* probably makes problems with short PE headers... but I haven't seen /* probably makes problems with short PE headers... but I haven't seen
* one yet... * one yet...
*/ */
pe_sections = (LPIMAGE_SECTION_HEADER)(((char*)pe_header)+sizeof(*pe_header)); pe_sections = (PIMAGE_SECTION_HEADER)(((char*)pe_header)+sizeof(*pe_header));
rootresdir = NULL; rootresdir = NULL;
for (i=0;i<pe_header->FileHeader.NumberOfSections;i++) { for (i=0;i<pe_header->FileHeader.NumberOfSections;i++) {
if (pe_sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) if (pe_sections[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
continue; continue;
/* FIXME: doesn't work when the resources are not in a seperate section */ /* FIXME: doesn't work when the resources are not in a seperate section */
if (pe_sections[i].VirtualAddress == pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress) { if (pe_sections[i].VirtualAddress == pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress) {
rootresdir = (LPIMAGE_RESOURCE_DIRECTORY)((char*)peimage+pe_sections[i].PointerToRawData); rootresdir = (PIMAGE_RESOURCE_DIRECTORY)((char*)peimage+pe_sections[i].PointerToRawData);
break; break;
} }
} }
@ -682,7 +682,7 @@ HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
/* caller just wanted the number of entries */ /* caller just wanted the number of entries */
xresent = (LPIMAGE_RESOURCE_DIRECTORY_ENTRY)(icongroupresdir+1); xresent = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(icongroupresdir+1);
/* assure we don't get too much ... */ /* assure we don't get too much ... */
if( n > iconDirCount - nIconIndex ) n = iconDirCount - nIconIndex; if( n > iconDirCount - nIconIndex ) n = iconDirCount - nIconIndex;
@ -691,13 +691,13 @@ HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
for (i=0;i<n;i++,xresent++) { for (i=0;i<n;i++,xresent++) {
CURSORICONDIR *cid; CURSORICONDIR *cid;
LPIMAGE_RESOURCE_DIRECTORY resdir; PIMAGE_RESOURCE_DIRECTORY resdir;
/* go down this resource entry, name */ /* go down this resource entry, name */
resdir = (LPIMAGE_RESOURCE_DIRECTORY)((DWORD)rootresdir+(xresent->u2.s.OffsetToDirectory)); resdir = (PIMAGE_RESOURCE_DIRECTORY)((DWORD)rootresdir+(xresent->u2.s.OffsetToDirectory));
/* default language (0) */ /* default language (0) */
resdir = GetResDirEntryW(resdir,(LPWSTR)0,(DWORD)rootresdir,TRUE); resdir = GetResDirEntryW(resdir,(LPWSTR)0,(DWORD)rootresdir,TRUE);
igdataent = (LPIMAGE_RESOURCE_DATA_ENTRY)resdir; igdataent = (PIMAGE_RESOURCE_DATA_ENTRY)resdir;
/* lookup address in mapped image for virtual address */ /* lookup address in mapped image for virtual address */
igdata = NULL; igdata = NULL;
@ -730,12 +730,12 @@ HGLOBAL16 WINAPI InternalExtractIcon(HINSTANCE16 hInstance,
return 0; return 0;
} }
for (i=0;i<n;i++) { for (i=0;i<n;i++) {
LPIMAGE_RESOURCE_DIRECTORY xresdir; PIMAGE_RESOURCE_DIRECTORY xresdir;
xresdir = GetResDirEntryW(iconresdir,(LPWSTR)RetPtr[i],(DWORD)rootresdir,FALSE); xresdir = GetResDirEntryW(iconresdir,(LPWSTR)RetPtr[i],(DWORD)rootresdir,FALSE);
xresdir = GetResDirEntryW(xresdir,(LPWSTR)0,(DWORD)rootresdir,TRUE); xresdir = GetResDirEntryW(xresdir,(LPWSTR)0,(DWORD)rootresdir,TRUE);
idataent = (LPIMAGE_RESOURCE_DATA_ENTRY)xresdir; idataent = (PIMAGE_RESOURCE_DATA_ENTRY)xresdir;
idata = NULL; idata = NULL;
/* map virtual to address in image */ /* map virtual to address in image */

12
misc/ver.c
View File

@ -439,9 +439,9 @@ find_pe_resource(
DWORD imagesize,pehdoffset; DWORD imagesize,pehdoffset;
BYTE *image; BYTE *image;
IMAGE_DATA_DIRECTORY resdir; IMAGE_DATA_DIRECTORY resdir;
LPIMAGE_RESOURCE_DIRECTORY resourcedir,xresdir; PIMAGE_RESOURCE_DIRECTORY resourcedir,xresdir;
LPIMAGE_RESOURCE_DATA_ENTRY xresdata; PIMAGE_RESOURCE_DATA_ENTRY xresdata;
LPIMAGE_SECTION_HEADER sections; PIMAGE_SECTION_HEADER sections;
pehdoffset = LZTELL(lzfd); pehdoffset = LZTELL(lzfd);
LZREAD(&pehd); LZREAD(&pehd);
@ -455,7 +455,7 @@ find_pe_resource(
image = HeapAlloc(GetProcessHeap(),0,imagesize); image = HeapAlloc(GetProcessHeap(),0,imagesize);
nrofsections = pehd.FileHeader.NumberOfSections; nrofsections = pehd.FileHeader.NumberOfSections;
sections = (LPIMAGE_SECTION_HEADER)HeapAlloc(GetProcessHeap(),0,pehd.FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER)); sections = (PIMAGE_SECTION_HEADER)HeapAlloc(GetProcessHeap(),0,pehd.FileHeader.NumberOfSections*sizeof(IMAGE_SECTION_HEADER));
LZSeek32(lzfd, LZSeek32(lzfd,
pehdoffset+ pehdoffset+
sizeof(DWORD)+ /* Signature */ sizeof(DWORD)+ /* Signature */
@ -480,7 +480,7 @@ find_pe_resource(
return 0; return 0;
} }
} }
resourcedir = (LPIMAGE_RESOURCE_DIRECTORY)(image+resdir.VirtualAddress); resourcedir = (PIMAGE_RESOURCE_DIRECTORY)(image+resdir.VirtualAddress);
xresdir = GetResDirEntryW(resourcedir,typeid,(DWORD)resourcedir,FALSE); xresdir = GetResDirEntryW(resourcedir,typeid,(DWORD)resourcedir,FALSE);
if (!xresdir) { if (!xresdir) {
TRACE(ver,"...no typeid entry found for %p\n",typeid); TRACE(ver,"...no typeid entry found for %p\n",typeid);
@ -500,7 +500,7 @@ find_pe_resource(
HeapFree(GetProcessHeap(),0,image); HeapFree(GetProcessHeap(),0,image);
return 0; return 0;
} }
xresdata = (LPIMAGE_RESOURCE_DATA_ENTRY)xresdir; xresdata = (PIMAGE_RESOURCE_DATA_ENTRY)xresdir;
*reslen = xresdata->Size; *reslen = xresdata->Size;
*resdata= (LPBYTE)xmalloc(*reslen); *resdata= (LPBYTE)xmalloc(*reslen);
memcpy(*resdata,image+xresdata->OffsetToData,*reslen); memcpy(*resdata,image+xresdata->OffsetToData,*reslen);

2
misc/version.c
View File

@ -105,7 +105,7 @@ void VERSION_ParseVersion( char *arg )
*/ */
WINDOWS_VERSION VERSION_GetVersion(void) WINDOWS_VERSION VERSION_GetVersion(void)
{ {
LPIMAGE_NT_HEADERS peheader; PIMAGE_NT_HEADERS peheader;
if (versionForced) /* user has overridden any sensible checks */ if (versionForced) /* user has overridden any sensible checks */
return defaultVersion; return defaultVersion;

2
objects/cursoricon.c
View File

@ -567,7 +567,7 @@ static HGLOBAL32 CURSORICON_Load32( HINSTANCE32 hInstance, LPCWSTR name,
/* Hack to keep LoadCursor/Icon32() from spawning multiple /* Hack to keep LoadCursor/Icon32() from spawning multiple
* copies of the same object. * copies of the same object.
*/ */
#define pRsrcEntry ((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc) #define pRsrcEntry ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)
if( !pRsrcEntry->ResourceHandle ) if( !pRsrcEntry->ResourceHandle )
{ {
LPBYTE bits = (LPBYTE)LockResource32( handle ); LPBYTE bits = (LPBYTE)LockResource32( handle );