Release 970202
Sun Feb 2 12:31:03 1997 Alexandre Julliard <julliard@lrc.epfl.ch>
* [files/drive.c]
Fixed SetCurrentDirectory() to also change the current drive.
* [win32/except.c] [tools/build.c]
Use Win32 register functions to implement exception handling.
Fixed UnhandledExceptionFilter.
Fri Jan 31 15:42:41 1997 David Faure <david.faure@ihamy.insa-lyon.fr>
* [windows/keyboard.c]
Added KEYBOARD_GenerateMsg to generate Caps Lock and NumLock events
Added calls to KEYBOARD_GenerateMsg when the key is pressed/released
or when the state has changed, out of wine.
Changed type 3-state 'ToggleKeyState' to boolean. The On/Off is given
by InputKeyStateTable.
Wed Jan 29 21:53:04 1997 Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>
* [loader/*resource.c][if1632/thunk.c]
EnumResource* added.
* [loader/pe_resource.] [loader/resource.c]
SizeofResource32(), LoadAccelerators32() added.
* [misc/lstr.c]
FormatMessage %n added.
* [misc/crtdll.c][include/ctrdll.h][if1632/crtdll.spec]
_chdrive,_errno,_isctype added.
* [misc/cpu.c]
Replaced runtime_cpu by GetSystemInfo().
* [windows/hook.c][include/hook.h]
Fixed mapping of hooks to win32/unicode.
* [windows/keyboard.c] [windows/defwnd.c]
Updated to win32 standard.
ALT-<Menukey> fixed.
* [windows/queue.c]
GetWindowThreadProcessId() implemented.
Mon Jan 27 16:42:49 1997 John Harvey <john@division.co.uk>
* [graphics/metafiledrv/*] [graphics/x11drv/*]
[objects/bitmap.c] [objects/brush.c] [objects/font.c]
[objects/gdiobj.c] [objects/pen.c]
Moved SelectObject to graphics drivers. Printer support now works
in a few cases but is definitely not complete. Generic/text driver
works. The postscript driver works if true type fonts are disabled
from the control panel. To enable printer support add Printer=on
to the wine section of your wine.conf file. This causes write not
to work properly. I know that several other printer drivers do not
work.
* [tools/build.c]
Make .stabs not used for svr4 since it doesn't use GNU assembler.
* [misc/fontengine.c]
Make sure a printf doesn't crash the system.
Sat Jan 25 15:53:35 1997 Huw D M Davies <h.davies1@physics.oxford.ac.uk>
* [objects/metafile.c]
Fixed some problems with PlayMetaFileRecord().
* [objects/dc.c]
hClipRgn gets initialized in GetDCState().
Fri Jan 24 21:22:26 1997 Philippe De Muyter <phdm@info.ucl.ac.be>
* [debugger/stabs.c]
Handle file names beginning with '/'.
Fri Jan 24 18:33:04 1997 Robert Pouliot <krynos@clic.net>
* [*/*]
Some more patches for OS/2 support.
Fri Jan 24 11:30:41 1997 Bang Jun-Young <bangjy@nownuri.nowcom.co.kr>
* [resources/sysres_Ko.rc]
Updated support for Korean (Ko) language.
diff --git a/loader/main.c b/loader/main.c
index f78ee78..1c1ee9c 100644
--- a/loader/main.c
+++ b/loader/main.c
@@ -61,7 +61,6 @@
extern BOOL32 WIN16DRV_Init(void);
extern BOOL32 SIGNAL_Init(void);
extern BOOL32 WIDGETS_Init(void);
- extern int KERN32_Init(void);
int queueSize;
@@ -144,9 +143,6 @@
/* Initialize message spying */
if (!SPY_Init()) return 0;
- /* Initialize Win32 data structures */
- if (!KERN32_Init()) return 0;
-
/* Create system message queue */
queueSize = GetProfileInt32A( "windows", "TypeAhead", 120 );
if (!QUEUE_CreateSysMsgQueue( queueSize )) return 0;
diff --git a/loader/pe_image.c b/loader/pe_image.c
index 9d4816c..d30b09b 100644
--- a/loader/pe_image.c
+++ b/loader/pe_image.c
@@ -17,9 +17,6 @@
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
-#ifndef __EMX__
-#include <sys/mman.h>
-#endif
#include "windows.h"
#include "winbase.h"
#include "callback.h"
@@ -65,14 +62,14 @@
if (i<pe_exports->NumberOfNames) {
ename=(char*)RVA(*name++);
dprintf_win32(stddeb,"%-32s %4d %8.8lx (%8.8lx)\n",ename,*ordinal,functions[*ordinal],*function);
- sprintf(buffer,"%s.%s",Module,ename);
+ sprintf(buffer,"%s_%s",Module,ename);
daddr.off=RVA(functions[*ordinal]);
ordinal++;
function++;
} else {
/* ordinals/names no longer valid, but we still got functions */
dprintf_win32(stddeb,"%-32s %4s %8s %8.8lx\n","","","",*function);
- sprintf(buffer,"%s.%d",Module,i);
+ sprintf(buffer,"%s_%d",Module,i);
daddr.off=RVA(*functions);
function++;
}
@@ -541,7 +538,7 @@
if (pe->pe_export) {
/* add start of sections as debugsymbols */
for(i=0;i<pe->pe_header->FileHeader.NumberOfSections;i++) {
- sprintf(buffer,"%s.%s",
+ sprintf(buffer,"%s_%s",
(char*)RVA(pe->pe_export->Name),
pe->pe_seg[i].Name
);
@@ -549,7 +546,7 @@
DEBUG_AddSymbol(buffer,&daddr, NULL, SYM_WIN32 | SYM_FUNC);
}
/* add entry point */
- sprintf(buffer,"%s.EntryPoint",(char*)RVA(pe->pe_export->Name));
+ sprintf(buffer,"%s_EntryPoint",(char*)RVA(pe->pe_export->Name));
daddr.off=RVA(pe->pe_header->OptionalHeader.AddressOfEntryPoint);
DEBUG_AddSymbol(buffer,&daddr, NULL, SYM_WIN32 | SYM_FUNC);
/* add start of DLL */
diff --git a/loader/pe_resource.c b/loader/pe_resource.c
index 7c7e6af..08655d0 100644
--- a/loader/pe_resource.c
+++ b/loader/pe_resource.c
@@ -8,8 +8,7 @@
* Based on the Win16 resource handling code in loader/resource.c
* Copyright 1993 Robert J. Amstadt
* Copyright 1995 Alexandre Julliard
- *
- * This is not even at ALPHA level yet. Don't expect it to work!
+ * Copyright 1997 Marcus Meissner
*/
#include <sys/types.h>
@@ -18,22 +17,28 @@
#include "pe_image.h"
#include "module.h"
#include "heap.h"
-#include "handle32.h"
#include "libres.h"
#include "stackframe.h"
#include "neexe.h"
-#include "accel.h"
-#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
-#define PrintIdA(name) \
- if (HIWORD((DWORD)name)) \
- dprintf_resource( stddeb, "'%s'", name); \
- else \
- dprintf_resource( stddeb, "#%04x", LOWORD(name));
-#define PrintIdW(name)
-#define PrintId(name)
+/**********************************************************************
+ * HMODULE32toPE_MODULE
+ *
+ * small helper function to get a PE_MODULE from a passed HMODULE32
+ */
+static PE_MODULE*
+HMODULE32toPE_MODULE(HMODULE32 hmod) {
+ NE_MODULE *pModule;
+
+ if (!hmod) hmod = GetTaskDS(); /* FIXME: correct? */
+ hmod = GetExePtr( hmod ); /* In case we were passed an hInstance */
+
+ if (!(pModule = MODULE_GetPtr( hmod ))) return 0;
+ if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0;
+ return pModule->pe_module;
+}
/**********************************************************************
* GetResDirEntryW
@@ -87,50 +92,18 @@
}
/**********************************************************************
- * GetResDirEntryA
- *
- * Helper function - goes down one level of PE resource tree
- *
- */
-LPIMAGE_RESOURCE_DIRECTORY GetResDirEntryA(LPIMAGE_RESOURCE_DIRECTORY resdirptr,
- LPCSTR name,
- DWORD root)
-{
- LPWSTR xname;
- LPIMAGE_RESOURCE_DIRECTORY ret;
-
- if (HIWORD((DWORD)name))
- xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
- else
- xname = (LPWSTR)name;
-
- ret=GetResDirEntryW(resdirptr,xname,root);
- if (HIWORD((DWORD)name))
- HeapFree( GetProcessHeap(), 0, xname );
- return ret;
-}
-
-/**********************************************************************
* PE_FindResourceEx32W
*/
HANDLE32 PE_FindResourceEx32W(
HINSTANCE32 hModule,LPCWSTR name,LPCWSTR type,WORD lang
) {
- PE_MODULE *pe;
- NE_MODULE *pModule;
LPIMAGE_RESOURCE_DIRECTORY resdirptr;
DWORD root;
HANDLE32 result;
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hModule);
- hModule = GetExePtr( hModule ); /* In case we were passed an hInstance */
- dprintf_resource(stddeb, "FindResource: module=%08x type=", hModule );
- PrintId( type );
- dprintf_resource( stddeb, " name=" );
- PrintId( name );
- dprintf_resource( stddeb, "\n" );
- if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
- if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0; /* FIXME? */
- if (!(pe = pModule->pe_module) || !pe->pe_resource) return 0;
+ if (!pe || !pe->pe_resource)
+ return 0;
resdirptr = pe->pe_resource;
root = (DWORD) resdirptr;
@@ -151,18 +124,287 @@
*/
HANDLE32 PE_LoadResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
{
- NE_MODULE *pModule;
- PE_MODULE *pe;
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hModule);
- if (!hModule) hModule = GetTaskDS(); /* FIXME: see FindResource32W */
- hModule = GetExePtr( hModule ); /* In case we were passed an hInstance */
- dprintf_resource(stddeb, "PE_LoadResource32: module=%04x res=%04x\n",
- hModule, hRsrc );
+ if (!pe || !pe->pe_resource)
+ return 0;
+ if (!hRsrc)
+ return 0;
+ return (HANDLE32) (pe->load_addr+((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
+}
+
+
+/**********************************************************************
+ * PE_SizeofResource32
+ */
+void
+_check_ptr(DWORD x,DWORD start,LPDWORD lastmax) {
+ if ((x>start) && (x<*lastmax))
+ *lastmax=x;
+}
+
+static void
+walk_resdir(DWORD loadaddr,DWORD rootresdir,DWORD xres,DWORD data,DWORD lvl,LPDWORD max){
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DATA_ENTRY dataent;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ int i;
+
+ if (lvl==3) {
+ dataent = (LPIMAGE_RESOURCE_DATA_ENTRY)(rootresdir+xres);
+ _check_ptr(loadaddr+dataent->OffsetToData,data,max);
+ return;
+ }
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)(rootresdir+xres);
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++)
+ walk_resdir(loadaddr,rootresdir,(lvl==2)?et[i].u2.OffsetToData:et[i].u2.s.OffsetToDirectory,data,lvl+1,max);
+}
+
+DWORD PE_SizeofResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
+{
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hModule);
+ DWORD max,data;
+ IMAGE_DATA_DIRECTORY dir;
+
+ if (!pe || !pe->pe_resource)
+ return 0;
if (!hRsrc) return 0;
- if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
- if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0; /* FIXME? */
- if (!(pe = pModule->pe_module) || !pe->pe_resource) return 0;
- return (HANDLE32) (pe->load_addr+((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
+ max=(DWORD)-1;
+ dir=pe->pe_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE];
+ if(dir.Size)
+ max=(DWORD)pe->pe_resource+dir.Size;
+
+ data=((DWORD)pe->load_addr+((LPIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
+ walk_resdir(pe->load_addr,(DWORD)pe->pe_resource,0,data,0,&max);
+ return max-data;
+}
+
+/**********************************************************************
+ * PE_EnumResourceTypes32A
+ */
+BOOL32
+PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+ HANDLE32 heap = GetProcessHeap();
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ LPSTR name;
+
+ if (HIWORD(et[i].u1.Name))
+ name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pe->pe_resource+et[i].u1.Name));
+ else
+ name = (LPSTR)et[i].u1.Name;
+ ret = lpfun(hmod,name,lparam);
+ if (HIWORD(name))
+ HeapFree(heap,0,name);
+ if (!ret)
+ break;
+ }
+ return ret;
+}
+
+/**********************************************************************
+ * PE_EnumResourceTypes32W
+ */
+BOOL32
+PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ LPWSTR type;
+ if (HIWORD(et[i].u1.Name))
+ type = (LPWSTR)((LPBYTE)pe->pe_resource+et[i].u1.Name);
+ else
+ type = (LPWSTR)et[i].u1.Name;
+
+ ret = lpfun(hmod,type,lparam);
+ if (!ret)
+ break;
+ }
+ return ret;
+}
+
+/**********************************************************************
+ * PE_EnumResourceNames32A
+ */
+BOOL32
+PE_EnumResourceNames32A(
+ HMODULE32 hmod,LPCSTR type,ENUMRESNAMEPROC32A lpfun,LONG lparam
+) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+ HANDLE32 heap = GetProcessHeap();
+ LPWSTR typeW;
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ if (HIWORD(type))
+ typeW = HEAP_strdupAtoW(heap,0,type);
+ else
+ typeW = (LPWSTR)type;
+ resdir = GetResDirEntryW(resdir,typeW,(DWORD)pe->pe_resource);
+ if (HIWORD(typeW))
+ HeapFree(heap,0,typeW);
+ if (!resdir)
+ return FALSE;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ LPSTR name;
+
+ if (HIWORD(et[i].u1.Name))
+ name = HEAP_strdupWtoA(heap,0,(LPWSTR)((LPBYTE)pe->pe_resource+et[i].u1.Name));
+ else
+ name = (LPSTR)et[i].u1.Name;
+ ret = lpfun(hmod,type,name,lparam);
+ if (HIWORD(name)) HeapFree(heap,0,name);
+ if (!ret)
+ break;
+ }
+ return ret;
+}
+
+/**********************************************************************
+ * PE_EnumResourceNames32W
+ */
+BOOL32
+PE_EnumResourceNames32W(
+ HMODULE32 hmod,LPCWSTR type,ENUMRESNAMEPROC32W lpfun,LONG lparam
+) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ resdir = GetResDirEntryW(resdir,type,(DWORD)pe->pe_resource);
+ if (!resdir)
+ return FALSE;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ LPWSTR name;
+ if (HIWORD(et[i].u1.Name))
+ name = (LPWSTR)((LPBYTE)pe->pe_resource+et[i].u1.Name);
+ else
+ name = (LPWSTR)et[i].u1.Name;
+ ret = lpfun(hmod,type,name,lparam);
+ if (!ret)
+ break;
+ }
+ return ret;
+}
+
+/**********************************************************************
+ * PE_EnumResourceNames32A
+ */
+BOOL32
+PE_EnumResourceLanguages32A(
+ HMODULE32 hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROC32A lpfun,
+ LONG lparam
+) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+ HANDLE32 heap = GetProcessHeap();
+ LPWSTR nameW,typeW;
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ if (HIWORD(name))
+ nameW = HEAP_strdupAtoW(heap,0,name);
+ else
+ nameW = (LPWSTR)name;
+ resdir = GetResDirEntryW(resdir,nameW,(DWORD)pe->pe_resource);
+ if (HIWORD(nameW))
+ HeapFree(heap,0,nameW);
+ if (!resdir)
+ return FALSE;
+ if (HIWORD(type))
+ typeW = HEAP_strdupAtoW(heap,0,type);
+ else
+ typeW = (LPWSTR)type;
+ resdir = GetResDirEntryW(resdir,typeW,(DWORD)pe->pe_resource);
+ if (HIWORD(typeW))
+ HeapFree(heap,0,typeW);
+ if (!resdir)
+ return FALSE;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ /* languages are just ids... I hope */
+ ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
+ if (!ret)
+ break;
+ }
+ return ret;
+}
+
+/**********************************************************************
+ * PE_EnumResourceLanguages32W
+ */
+BOOL32
+PE_EnumResourceLanguages32W(
+ HMODULE32 hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROC32W lpfun,
+ LONG lparam
+) {
+ PE_MODULE *pe = HMODULE32toPE_MODULE(hmod);
+ int i;
+ LPIMAGE_RESOURCE_DIRECTORY resdir;
+ LPIMAGE_RESOURCE_DIRECTORY_ENTRY et;
+ BOOL32 ret;
+
+ if (!pe || !pe->pe_resource)
+ return FALSE;
+
+ resdir = (LPIMAGE_RESOURCE_DIRECTORY)pe->pe_resource;
+ resdir = GetResDirEntryW(resdir,name,(DWORD)pe->pe_resource);
+ if (!resdir)
+ return FALSE;
+ resdir = GetResDirEntryW(resdir,type,(DWORD)pe->pe_resource);
+ if (!resdir)
+ return FALSE;
+ et =(LPIMAGE_RESOURCE_DIRECTORY_ENTRY)((LPBYTE)resdir+sizeof(IMAGE_RESOURCE_DIRECTORY));
+ ret = FALSE;
+ for (i=0;i<resdir->NumberOfNamedEntries+resdir->NumberOfIdEntries;i++) {
+ ret = lpfun(hmod,name,type,et[i].u1.Id,lparam);
+ if (!ret)
+ break;
+ }
+ return ret;
}
#endif
diff --git a/loader/resource.c b/loader/resource.c
index de289b6..d2f50fe 100644
--- a/loader/resource.c
+++ b/loader/resource.c
@@ -345,8 +345,12 @@
hModule = GetExePtr( hModule ); /* In case we were passed an hInstance */
dprintf_resource(stddeb, "SizeofResource32: module=%04x res=%04x\n",
hModule, hRsrc );
+#ifndef WINELIB
+ return PE_SizeofResource32(hModule,hRsrc);
+#else
fprintf(stderr,"SizeofResource32: not implemented\n");
return 0;
+#endif
}
@@ -441,10 +445,15 @@
/**********************************************************************
* LoadAccelerators32W [USER.177]
+ * The image layout seems to look like this (not 100% sure):
+ * 00: BYTE type type of accelerator
+ * 01: BYTE pad (to WORD boundary)
+ * 02: WORD event
+ * 04: WORD IDval
+ * 06: WORD pad (to DWORD boundary)
*/
HACCEL32 LoadAccelerators32W(HINSTANCE32 instance,LPCWSTR lpTableName)
{
-#if 0
HACCEL32 hAccel;
HGLOBAL32 rsc_mem;
HRSRC32 hRsrc;
@@ -471,11 +480,12 @@
lpAccelTbl = (LPACCELHEADER)GlobalLock16(hAccel);
lpAccelTbl->wCount = 0;
for (i = 0; i < n; i++) {
- lpAccelTbl->tbl[i].type = *(lp++);
+ lpAccelTbl->tbl[i].type = *lp;
+ lp += 2;
lpAccelTbl->tbl[i].wEvent = *((WORD *)lp);
lp += 2;
lpAccelTbl->tbl[i].wIDval = *((WORD *)lp);
- lp += 2;
+ lp += 4;
if (lpAccelTbl->tbl[i].wEvent == 0) break;
dprintf_accel(stddeb,
"Accelerator #%u / event=%04X id=%04X type=%02X \n",
@@ -486,10 +496,6 @@
GlobalUnlock16(hAccel);
FreeResource32(rsc_mem);
return hAccel;
-#else
- fprintf(stderr,"LoadAcceleratorsW: not implemented\n");
- return 0x100; /* Return something anyway */
-#endif
}
HACCEL32 LoadAccelerators32A(HINSTANCE32 instance,LPCSTR lpTableName)
@@ -744,3 +750,51 @@
fprintf(stderr,"SetResourceHandler(%04x,0x%04x,%p), empty STUB!\n",instance,LOWORD(s),farproc);
return NULL;
}
+
+#ifndef WINELIB
+/**********************************************************************
+ * EnumResourceTypesA (KERNEL32.90)
+ */
+BOOL32
+EnumResourceTypes32A(HMODULE32 hmodule,ENUMRESTYPEPROC32A lpfun,LONG lParam) {
+ return PE_EnumResourceTypes32A(hmodule,lpfun,lParam);
+}
+
+/**********************************************************************
+ * EnumResourceTypesW (KERNEL32.91)
+ */
+BOOL32
+EnumResourceTypes32W(HMODULE32 hmodule,ENUMRESTYPEPROC32W lpfun,LONG lParam) {
+ return PE_EnumResourceTypes32W(hmodule,lpfun,lParam);
+}
+
+/**********************************************************************
+ * EnumResourceNamesA (KERNEL32.88)
+ */
+BOOL32
+EnumResourceNames32A(HMODULE32 hmodule,LPCSTR type,ENUMRESNAMEPROC32A lpfun,LONG lParam) {
+ return PE_EnumResourceNames32A(hmodule,type,lpfun,lParam);
+}
+/**********************************************************************
+ * EnumResourceNamesW (KERNEL32.89)
+ */
+BOOL32
+EnumResourceNames32W(HMODULE32 hmodule,LPCWSTR type,ENUMRESNAMEPROC32W lpfun,LONG lParam) {
+ return PE_EnumResourceNames32W(hmodule,type,lpfun,lParam);
+}
+
+/**********************************************************************
+ * EnumResourceLanguagesA (KERNEL32.86)
+ */
+BOOL32
+EnumResourceLanguages32A(HMODULE32 hmodule,LPCSTR type,LPCSTR name,ENUMRESLANGPROC32A lpfun,LONG lParam) {
+ return PE_EnumResourceLanguages32A(hmodule,type,name,lpfun,lParam);
+}
+/**********************************************************************
+ * EnumResourceLanguagesW (KERNEL32.87)
+ */
+BOOL32
+EnumResourceLanguages32W(HMODULE32 hmodule,LPCWSTR type,LPCWSTR name,ENUMRESLANGPROC32W lpfun,LONG lParam) {
+ return PE_EnumResourceLanguages32W(hmodule,type,name,lpfun,lParam);
+}
+#endif /* WINELIB */
diff --git a/loader/signal.c b/loader/signal.c
index 2d97ed5..769b510 100644
--- a/loader/signal.c
+++ b/loader/signal.c
@@ -143,7 +143,6 @@
static void SIGNAL_fault(int signal, int code, SIGCONTEXT *context)
{
#endif
-#ifndef __EMX__ /* FIXME: XX_sig(constext)=pointer to incomplete type (EMX) */
if (CS_sig(context) == WINE_CODE_SELECTOR)
{
fprintf( stderr, "Segmentation fault in Wine program (%x:%lx)."
@@ -157,7 +156,6 @@
CS_sig(context), EIP_sig(context) );
}
wine_debug( signal, context );
-#endif
}
diff --git a/loader/task.c b/loader/task.c
index 0b721e6..864abad 100644
--- a/loader/task.c
+++ b/loader/task.c
@@ -361,7 +361,6 @@
/* FIXME: all this is an ugly hack */
extern void InitTask( CONTEXT *context );
- extern void PE_InitializeDLLs( HMODULE16 hModule );
InitTask( NULL );
InitApp( pTask->hModule );
@@ -536,7 +535,15 @@
/* Create the Win32 part of the task */
pdb32 = PROCESS_Create( pTask );
- pTask->thdb = THREAD_Create( pdb32, 0 );
+ if (pModule->flags & NE_FFLAGS_WIN32)
+ {
+ LPTHREAD_START_ROUTINE start =
+ (LPTHREAD_START_ROUTINE)(pModule->pe_module->load_addr +
+ pModule->pe_module->pe_header->OptionalHeader.AddressOfEntryPoint);
+ pTask->thdb = THREAD_Create( pdb32, 0, start );
+ }
+ else
+ pTask->thdb = THREAD_Create( pdb32, 0, NULL );
/* Create the 32-bit stack frame */
@@ -1274,21 +1281,31 @@
/***********************************************************************
- * SetErrorMode (KERNEL.107)
+ * SetErrorMode16 (KERNEL.107)
*/
-UINT SetErrorMode( UINT mode )
+UINT16 SetErrorMode16( UINT16 mode )
{
TDB *pTask;
- UINT oldMode;
+ UINT16 oldMode;
if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
oldMode = pTask->error_mode;
pTask->error_mode = mode;
+ pTask->thdb->process->error_mode = mode;
return oldMode;
}
/***********************************************************************
+ * SetErrorMode32 (KERNEL32.486)
+ */
+UINT32 SetErrorMode32( UINT32 mode )
+{
+ return SetErrorMode16( (UINT16)mode );
+}
+
+
+/***********************************************************************
* GetDOSEnvironment (KERNEL.131)
*/
SEGPTR GetDOSEnvironment(void)
