Large-scale renaming of all Win32 functions and types to use the
standard Windows names.
diff --git a/loader/dos/module.c b/loader/dos/module.c
index 7de55e4..69a1aa5 100644
--- a/loader/dos/module.c
+++ b/loader/dos/module.c
@@ -49,7 +49,7 @@
static void MZ_InitPSP( LPVOID lpPSP, LPCSTR cmdline, WORD env )
{
- PDB*psp=lpPSP;
+ PDB16*psp=lpPSP;
const char*cmd=cmdline?strchr(cmdline,' '):NULL;
psp->int20=0x20CD; /* int 20 */
@@ -230,7 +230,7 @@
#endif
old_com=1; /* assume .COM file */
image_start=0;
- image_size=GetFileSize(FILE_GetHandle32(hFile),NULL);
+ image_size=GetFileSize(FILE_GetHandle(hFile),NULL);
min_size=0x10000; max_size=0x100000;
mz_header.e_crlc=0;
mz_header.e_ss=0; mz_header.e_sp=0xFFFE;
@@ -411,13 +411,13 @@
return lpDosTask->hModule;
}
-HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL32 inherit,
- LPSTARTUPINFO32A startup, LPPROCESS_INFORMATION info )
+HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL inherit,
+ LPSTARTUPINFOA startup, LPPROCESS_INFORMATION info )
{
LPDOSTASK lpDosTask = NULL; /* keep gcc from complaining */
HMODULE16 hModule;
HINSTANCE16 hInstance;
- PDB32 *pdb = PROCESS_Current();
+ PDB *pdb = PROCESS_Current();
TDB *pTask = (TDB*)GlobalLock16( GetCurrentTask() );
NE_MODULE *pModule = pTask ? NE_GetPtr( pTask->hModule ) : NULL;
HFILE16 hFile;
@@ -494,8 +494,8 @@
#else /* !MZ_SUPPORTED */
-HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL32 inherit,
- LPSTARTUPINFO32A startup, LPPROCESS_INFORMATION info )
+HINSTANCE16 MZ_CreateProcess( LPCSTR name, LPCSTR cmdline, LPCSTR env, BOOL inherit,
+ LPSTARTUPINFOA startup, LPPROCESS_INFORMATION info )
{
WARN(module,"DOS executables not supported on this architecture\n");
return (HMODULE16)11; /* invalid exe */
diff --git a/loader/elf.c b/loader/elf.c
index 2365537..853ae06 100644
--- a/loader/elf.c
+++ b/loader/elf.c
@@ -31,7 +31,7 @@
PIMAGE_NT_HEADERS nth;
PIMAGE_SECTION_HEADER sh;
WINE_MODREF *wm;
- HMODULE32 hmod;
+ HMODULE hmod;
wm=(WINE_MODREF*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wm) );
wm->type = MODULE32_ELF;
@@ -43,7 +43,7 @@
wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
wm->longname = HEAP_strdupA( GetProcessHeap(), 0, libname );
- hmod = (HMODULE32)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
+ hmod = (HMODULE)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(IMAGE_DOS_HEADER) +
sizeof(IMAGE_NT_HEADERS) +
sizeof(IMAGE_SECTION_HEADER) + 100 );
@@ -96,7 +96,7 @@
#include <dlfcn.h>
-HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags )
+HMODULE ELF_LoadLibraryExA( LPCSTR libname, HANDLE hf, DWORD flags )
{
WINE_MODREF *wm;
char *modname,*s,*t,*x;
@@ -144,7 +144,7 @@
return wm->module;
}
-FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
+FARPROC ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
{
LPVOID fun;
int i,nrofargs = 0;
@@ -153,7 +153,7 @@
assert(wm->type == MODULE32_ELF);
if (!HIWORD(funcName)) {
ERR(win32,"Can't import from UNIX dynamic libs by ordinal, sorry.\n");
- return (FARPROC32)0;
+ return (FARPROC)0;
}
fun = dlsym(wm->binfmt.elf.dlhandle,funcName);
/* we sometimes have an excess '_' at the beginning of the name */
@@ -234,24 +234,24 @@
/* filled out by entrycode */
stub->oldret = 0xdeadbeef;
stub->ret2 = 0xc3;
- fun=(FARPROC32)stub;
+ fun=(FARPROC)stub;
}
if (!fun) {
FIXME(win32,"function %s not found: %s\n",funcName,dlerror());
return fun;
}
- fun = SNOOP_GetProcAddress32(wm->module,funcName,stub-wm->binfmt.elf.stubs,fun);
- return (FARPROC32)fun;
+ fun = SNOOP_GetProcAddress(wm->module,funcName,stub-wm->binfmt.elf.stubs,fun);
+ return (FARPROC)fun;
}
#else
-HMODULE32 ELF_LoadLibraryEx32A( LPCSTR libname, HANDLE32 hf, DWORD flags)
+HMODULE ELF_LoadLibraryExA( LPCSTR libname, HANDLE hf, DWORD flags)
{
return 0;
}
-FARPROC32 ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
+FARPROC ELF_FindExportedFunction( WINE_MODREF *wm, LPCSTR funcName)
{
- return (FARPROC32)0;
+ return (FARPROC)0;
}
#endif
diff --git a/loader/libres.c b/loader/libres.c
index c1485db..d2ed8a1 100644
--- a/loader/libres.c
+++ b/loader/libres.c
@@ -34,7 +34,7 @@
/**********************************************************************
* LIBRES_FindResource
*/
-HRSRC32 LIBRES_FindResource( HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type )
+HRSRC LIBRES_FindResource( HINSTANCE hModule, LPCWSTR name, LPCWSTR type )
{
int nameid=0,typeid;
ResListE* ResBlock;
@@ -77,12 +77,12 @@
for(Res=ResBlock->Resources; *Res; Res++)
if(name)
{
- if((*Res)->restype==typeid && !lstrncmpi32W((LPCWSTR)((*Res)->resname+1), name, *((*Res)->resname)))
- return (HRSRC32)*Res;
+ if((*Res)->restype==typeid && !lstrncmpiW((LPCWSTR)((*Res)->resname+1), name, *((*Res)->resname)))
+ return (HRSRC)*Res;
}
else
if((*Res)->restype==typeid && (*Res)->resid==nameid)
- return (HRSRC32)*Res;
+ return (HRSRC)*Res;
return 0;
}
@@ -90,16 +90,16 @@
/**********************************************************************
* LIBRES_LoadResource
*/
-HGLOBAL32 LIBRES_LoadResource( HINSTANCE32 hModule, HRSRC32 hRsrc )
+HGLOBAL LIBRES_LoadResource( HINSTANCE hModule, HRSRC hRsrc )
{
- return (HGLOBAL32)(((wrc_resource32_t*)hRsrc)->data);
+ return (HGLOBAL)(((wrc_resource32_t*)hRsrc)->data);
}
/**********************************************************************
* LIBRES_SizeofResource
*/
-DWORD LIBRES_SizeofResource( HINSTANCE32 hModule, HRSRC32 hRsrc )
+DWORD LIBRES_SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
{
return (DWORD)(((wrc_resource32_t*)hRsrc)->datasize);
}
diff --git a/loader/main.c b/loader/main.c
index 106452a..761b324 100644
--- a/loader/main.c
+++ b/loader/main.c
@@ -50,7 +50,7 @@
/***********************************************************************
* Main initialisation routine
*/
-BOOL32 MAIN_MainInit(void)
+BOOL MAIN_MainInit(void)
{
/* Set server debug level */
/* To fool make_debug: TRACE(server) */
@@ -95,9 +95,9 @@
/***********************************************************************
* KERNEL initialisation routine
*/
-BOOL32 WINAPI MAIN_KernelInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_KernelInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
- static BOOL32 initDone = FALSE;
+ static BOOL initDone = FALSE;
HMODULE16 hModule;
@@ -111,7 +111,7 @@
WORD cs, ds;
/* Initialize KERNEL.178 (__WINFLAGS) with the correct flags value */
- NE_SetEntryPoint( hModule, 178, GetWinFlags() );
+ NE_SetEntryPoint( hModule, 178, GetWinFlags16() );
/* Initialize KERNEL.454/455 (__FLATCS/__FLATDS) */
GET_CS(cs); GET_DS(ds);
@@ -146,7 +146,7 @@
/***********************************************************************
* GDI initialisation routine
*/
-BOOL32 WINAPI MAIN_GdiInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_GdiInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
NE_MODULE *pModule;
@@ -156,13 +156,13 @@
pModule = NE_GetPtr( GetModuleHandle16( "GDI" ) );
if ( pModule )
{
- GDI_HeapSel = GlobalHandleToSel( (NE_SEG_TABLE( pModule ) +
+ GDI_HeapSel = GlobalHandleToSel16( (NE_SEG_TABLE( pModule ) +
pModule->dgroup - 1)->hSeg );
}
else
{
GDI_HeapSel = GlobalAlloc16( GMEM_FIXED, GDI_HEAP_SIZE );
- LocalInit( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
+ LocalInit16( GDI_HeapSel, 0, GDI_HEAP_SIZE-1 );
}
if (!TWEAK_Init()) return FALSE;
@@ -180,7 +180,7 @@
/***********************************************************************
* USER initialisation routine
*/
-BOOL32 WINAPI MAIN_UserInit(HINSTANCE32 hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+BOOL WINAPI MAIN_UserInit(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
NE_MODULE *pModule;
int queueSize;
@@ -191,13 +191,13 @@
pModule = NE_GetPtr( GetModuleHandle16( "USER" ) );
if ( pModule )
{
- USER_HeapSel = GlobalHandleToSel( (NE_SEG_TABLE( pModule ) +
+ USER_HeapSel = GlobalHandleToSel16( (NE_SEG_TABLE( pModule ) +
pModule->dgroup - 1)->hSeg );
}
else
{
USER_HeapSel = GlobalAlloc16( GMEM_FIXED, 0x10000 );
- LocalInit( USER_HeapSel, 0, 0xffff );
+ LocalInit16( USER_HeapSel, 0, 0xffff );
}
/* Global atom table initialisation */
@@ -232,15 +232,15 @@
if (!TWEAK_CheckConfiguration()) return FALSE;
/* Create system message queue */
- queueSize = GetProfileInt32A( "windows", "TypeAhead", 120 );
+ queueSize = GetProfileIntA( "windows", "TypeAhead", 120 );
if (!QUEUE_CreateSysMsgQueue( queueSize )) return FALSE;
/* Set double click time */
- SetDoubleClickTime32( GetProfileInt32A("windows","DoubleClickSpeed",452) );
+ SetDoubleClickTime( GetProfileIntA("windows","DoubleClickSpeed",452) );
/* Create task message queue for the initial task */
- queueSize = GetProfileInt32A( "windows", "DefaultQueueSize", 8 );
- if (!SetMessageQueue32( queueSize )) return FALSE;
+ queueSize = GetProfileIntA( "windows", "DefaultQueueSize", 8 );
+ if (!SetMessageQueue( queueSize )) return FALSE;
/* Create desktop window */
if (!WIN_CreateDesktopWindow()) return FALSE;
@@ -261,7 +261,7 @@
/***********************************************************************
* Winelib initialisation routine
*/
-HINSTANCE32 MAIN_WinelibInit( int *argc, char *argv[] )
+HINSTANCE MAIN_WinelibInit( int *argc, char *argv[] )
{
WINE_MODREF *wm;
NE_MODULE *pModule;
diff --git a/loader/module.c b/loader/module.c
index 916ce5d..a771e6f 100644
--- a/loader/module.c
+++ b/loader/module.c
@@ -29,14 +29,14 @@
#include "debug.h"
#include "callback.h"
-extern BOOL32 THREAD_InitDone;
+extern BOOL THREAD_InitDone;
/*************************************************************************
* MODULE32_LookupHMODULE
* looks for the referenced HMODULE in the current process
*/
-WINE_MODREF *MODULE32_LookupHMODULE( HMODULE32 hmod )
+WINE_MODREF *MODULE32_LookupHMODULE( HMODULE hmod )
{
WINE_MODREF *wm;
@@ -107,9 +107,9 @@
wm->module, type, lpReserved );
}
-void MODULE_InitializeDLLs( HMODULE32 root, DWORD type, LPVOID lpReserved )
+void MODULE_InitializeDLLs( HMODULE root, DWORD type, LPVOID lpReserved )
{
- BOOL32 inProgress = FALSE;
+ BOOL inProgress = FALSE;
WINE_MODREF *wm;
/* Grab the process critical section to protect the recursion flags */
@@ -176,18 +176,18 @@
*
* Create a dummy NE module for Win32 or Winelib.
*/
-HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs, LPCSTR modName )
+HMODULE MODULE_CreateDummyModule( const OFSTRUCT *ofs, LPCSTR modName )
{
- HMODULE32 hModule;
+ HMODULE hModule;
NE_MODULE *pModule;
SEGTABLEENTRY *pSegment;
char *pStr,*s;
int len;
const char* basename;
- INT32 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
+ INT of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName)
+ strlen(ofs->szPathName) + 1;
- INT32 size = sizeof(NE_MODULE) +
+ INT size = sizeof(NE_MODULE) +
/* loaded file info */
of_size +
/* segment table: DS,CS */
@@ -198,9 +198,9 @@
8;
hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size );
- if (!hModule) return (HMODULE32)11; /* invalid exe */
+ if (!hModule) return (HMODULE)11; /* invalid exe */
- FarSetOwner( hModule, hModule );
+ FarSetOwner16( hModule, hModule );
pModule = (NE_MODULE *)GlobalLock16( hModule );
/* Set all used entries */
@@ -276,34 +276,34 @@
if (__winelib)
{
/* FIXME: hack for Winelib */
- extern LRESULT ColorDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
- extern LRESULT FileOpenDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
- extern LRESULT FileSaveDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
+ extern LRESULT ColorDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+ extern LRESULT FileOpenDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+ extern LRESULT FileSaveDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
extern LRESULT FindTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
- extern LRESULT PrintDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
- extern LRESULT PrintSetupDlgProc(HWND16,UINT16,WPARAM16,LPARAM);
+ extern LRESULT PrintDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
+ extern LRESULT PrintSetupDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
extern LRESULT ReplaceTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM);
if (!strcmp(name,"ColorDlgProc"))
- return (FARPROC16)ColorDlgProc;
+ return (FARPROC16)ColorDlgProc16;
if (!strcmp(name,"FileOpenDlgProc"))
- return (FARPROC16)FileOpenDlgProc;
+ return (FARPROC16)FileOpenDlgProc16;
if (!strcmp(name,"FileSaveDlgProc"))
- return (FARPROC16)FileSaveDlgProc;
+ return (FARPROC16)FileSaveDlgProc16;
if (!strcmp(name,"FindTextDlgProc"))
return (FARPROC16)FindTextDlgProc16;
if (!strcmp(name,"PrintDlgProc"))
- return (FARPROC16)PrintDlgProc;
+ return (FARPROC16)PrintDlgProc16;
if (!strcmp(name,"PrintSetupDlgProc"))
- return (FARPROC16)PrintSetupDlgProc;
+ return (FARPROC16)PrintSetupDlgProc16;
if (!strcmp(name,"ReplaceTextDlgProc"))
return (FARPROC16)ReplaceTextDlgProc16;
if (!strcmp(name,"DefResourceHandler"))
return (FARPROC16)NE_DefResourceHandler;
if (!strcmp(name,"LoadDIBIconHandler"))
- return (FARPROC16)LoadDIBIconHandler;
+ return (FARPROC16)LoadDIBIconHandler16;
if (!strcmp(name,"LoadDIBCursorHandler"))
- return (FARPROC16)LoadDIBCursorHandler;
+ return (FARPROC16)LoadDIBCursorHandler16;
FIXME(module,"No mapping for %s(), add one in library/miscstubs.c\n",name);
assert( FALSE );
return NULL;
@@ -311,7 +311,7 @@
else
{
WORD ordinal;
- static HMODULE32 hModule = 0;
+ static HMODULE hModule = 0;
if (!hModule) hModule = GetModuleHandle16( "WPROCS" );
ordinal = NE_GetOrdinal( hModule, name );
@@ -337,7 +337,7 @@
* the module handle if found
* 0 if not
*/
-HMODULE32 MODULE_FindModule32(
+HMODULE MODULE_FindModule(
LPCSTR path /* [in] pathname of module/library to be found */
) {
LPSTR filename;
@@ -408,7 +408,7 @@
* NE_CreateProcess
*/
static HINSTANCE16 NE_CreateProcess( LPCSTR name, LPCSTR cmd_line, LPCSTR env,
- BOOL32 inherit, LPSTARTUPINFO32A startup,
+ BOOL inherit, LPSTARTUPINFOA startup,
LPPROCESS_INFORMATION info )
{
HINSTANCE16 hInstance, hPrevInstance;
@@ -442,14 +442,14 @@
*/
HINSTANCE16 WINAPI LoadModule16( LPCSTR name, LPVOID paramBlock )
{
- LOADPARAMS *params;
+ LOADPARAMS16 *params;
LPSTR cmd_line, new_cmd_line;
LPCVOID env = NULL;
- STARTUPINFO32A startup;
+ STARTUPINFOA startup;
PROCESS_INFORMATION info;
HINSTANCE16 hInstance, hPrevInstance;
NE_MODULE *pModule;
- PDB32 *pdb;
+ PDB *pdb;
/* Load module */
@@ -465,7 +465,7 @@
pModule->flags |= NE_FFLAGS_GUI; /* FIXME: is this necessary? */
- params = (LOADPARAMS *)paramBlock;
+ params = (LOADPARAMS16 *)paramBlock;
cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine );
if (!cmd_line) cmd_line = "";
else if (*cmd_line) cmd_line++; /* skip the length byte */
@@ -507,13 +507,13 @@
/**********************************************************************
* LoadModule32 (KERNEL32.499)
*/
-HINSTANCE32 WINAPI LoadModule32( LPCSTR name, LPVOID paramBlock )
+HINSTANCE WINAPI LoadModule( LPCSTR name, LPVOID paramBlock )
{
- LOADPARAMS32 *params = (LOADPARAMS32 *)paramBlock;
+ LOADPARAMS *params = (LOADPARAMS *)paramBlock;
PROCESS_INFORMATION info;
- STARTUPINFO32A startup;
- HINSTANCE32 hInstance;
- PDB32 *pdb;
+ STARTUPINFOA startup;
+ HINSTANCE hInstance;
+ PDB *pdb;
TDB *tdb;
memset( &startup, '\0', sizeof(startup) );
@@ -521,7 +521,7 @@
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = params->lpCmdShow? params->lpCmdShow[1] : 0;
- if (!CreateProcess32A( name, params->lpCmdLine,
+ if (!CreateProcessA( name, params->lpCmdLine,
NULL, NULL, FALSE, 0, params->lpEnvAddress,
NULL, &startup, &info ))
return GetLastError(); /* guaranteed to be < 32 */
@@ -541,17 +541,17 @@
/**********************************************************************
* CreateProcess32A (KERNEL32.171)
*/
-BOOL32 WINAPI CreateProcess32A( LPCSTR lpApplicationName, LPSTR lpCommandLine,
+BOOL WINAPI CreateProcessA( LPCSTR lpApplicationName, LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
- BOOL32 bInheritHandles, DWORD dwCreationFlags,
+ BOOL bInheritHandles, DWORD dwCreationFlags,
LPVOID lpEnvironment, LPCSTR lpCurrentDirectory,
- LPSTARTUPINFO32A lpStartupInfo,
+ LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInfo )
{
HINSTANCE16 hInstance;
LPCSTR cmdline;
- PDB32 *pdb;
+ PDB *pdb;
char name[256];
/* Get name and command line */
@@ -565,7 +565,7 @@
cmdline = lpCommandLine? lpCommandLine : lpApplicationName;
if (lpApplicationName)
- lstrcpyn32A(name, lpApplicationName, sizeof(name) - 4);
+ lstrcpynA(name, lpApplicationName, sizeof(name) - 4);
else {
char *ptr;
int len;
@@ -575,10 +575,10 @@
do {
len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
if (len > sizeof(name) - 4) len = sizeof(name) - 4;
- lstrcpyn32A(name, lpCommandLine, len);
+ lstrcpynA(name, lpCommandLine, len);
if (!strchr(name, '\\') && !strchr(name, '.'))
strcat(name, ".exe");
- if (GetFileAttributes32A(name)!=-1)
+ if (GetFileAttributesA(name)!=-1)
break;
/* if there is a space and no file found yet, include the word
* up to the next space too. If there is no next space, just
@@ -590,7 +590,7 @@
ptr = strchr(lpCommandLine, ' ');
len = (ptr? ptr-lpCommandLine : strlen(lpCommandLine)) + 1;
if (len > sizeof(name) - 4) len = sizeof(name) - 4;
- lstrcpyn32A(name, lpCommandLine, len);
+ lstrcpynA(name, lpCommandLine, len);
break;
}
} while (1);
@@ -699,21 +699,21 @@
* NOTES
* lpReserved is not converted
*/
-BOOL32 WINAPI CreateProcess32W( LPCWSTR lpApplicationName, LPWSTR lpCommandLine,
+BOOL WINAPI CreateProcessW( LPCWSTR lpApplicationName, LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
- BOOL32 bInheritHandles, DWORD dwCreationFlags,
+ BOOL bInheritHandles, DWORD dwCreationFlags,
LPVOID lpEnvironment, LPCWSTR lpCurrentDirectory,
- LPSTARTUPINFO32W lpStartupInfo,
+ LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInfo )
-{ BOOL32 ret;
- STARTUPINFO32A StartupInfoA;
+{ BOOL ret;
+ STARTUPINFOA StartupInfoA;
LPSTR lpApplicationNameA = HEAP_strdupWtoA (GetProcessHeap(),0,lpApplicationName);
LPSTR lpCommandLineA = HEAP_strdupWtoA (GetProcessHeap(),0,lpCommandLine);
LPSTR lpCurrentDirectoryA = HEAP_strdupWtoA (GetProcessHeap(),0,lpCurrentDirectory);
- memcpy (&StartupInfoA, lpStartupInfo, sizeof(STARTUPINFO32A));
+ memcpy (&StartupInfoA, lpStartupInfo, sizeof(STARTUPINFOA));
StartupInfoA.lpDesktop = HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo->lpDesktop);
StartupInfoA.lpTitle = HEAP_strdupWtoA (GetProcessHeap(),0,lpStartupInfo->lpTitle);
@@ -722,7 +722,7 @@
if (lpStartupInfo->lpReserved)
FIXME(win32,"StartupInfo.lpReserved is used, please report (%s)\n", debugstr_w(lpStartupInfo->lpReserved));
- ret = CreateProcess32A( lpApplicationNameA, lpCommandLineA,
+ ret = CreateProcessA( lpApplicationNameA, lpCommandLineA,
lpProcessAttributes, lpThreadAttributes,
bInheritHandles, dwCreationFlags,
lpEnvironment, lpCurrentDirectoryA,
@@ -739,19 +739,19 @@
/***********************************************************************
* GetModuleHandle (KERNEL32.237)
*/
-HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module)
+HMODULE WINAPI GetModuleHandleA(LPCSTR module)
{
if (module == NULL)
return PROCESS_Current()->exe_modref->module;
else
- return MODULE_FindModule32( module );
+ return MODULE_FindModule( module );
}
-HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module)
+HMODULE WINAPI GetModuleHandleW(LPCWSTR module)
{
- HMODULE32 hModule;
+ HMODULE hModule;
LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module );
- hModule = GetModuleHandle32A( modulea );
+ hModule = GetModuleHandleA( modulea );
HeapFree( GetProcessHeap(), 0, modulea );
return hModule;
}
@@ -760,8 +760,8 @@
/***********************************************************************
* GetModuleFileName32A (KERNEL32.235)
*/
-DWORD WINAPI GetModuleFileName32A(
- HMODULE32 hModule, /* [in] module handle (32bit) */
+DWORD WINAPI GetModuleFileNameA(
+ HMODULE hModule, /* [in] module handle (32bit) */
LPSTR lpFileName, /* [out] filenamebuffer */
DWORD size /* [in] size of filenamebuffer */
) {
@@ -771,9 +771,9 @@
return 0;
if (PE_HEADER(wm->module)->OptionalHeader.MajorOperatingSystemVersion >= 4.0)
- lstrcpyn32A( lpFileName, wm->longname, size );
+ lstrcpynA( lpFileName, wm->longname, size );
else
- lstrcpyn32A( lpFileName, wm->shortname, size );
+ lstrcpynA( lpFileName, wm->shortname, size );
TRACE(module, "%s\n", lpFileName );
return strlen(lpFileName);
@@ -783,11 +783,11 @@
/***********************************************************************
* GetModuleFileName32W (KERNEL32.236)
*/
-DWORD WINAPI GetModuleFileName32W( HMODULE32 hModule, LPWSTR lpFileName,
+DWORD WINAPI GetModuleFileNameW( HMODULE hModule, LPWSTR lpFileName,
DWORD size )
{
LPSTR fnA = (char*)HeapAlloc( GetProcessHeap(), 0, size );
- DWORD res = GetModuleFileName32A( hModule, fnA, size );
+ DWORD res = GetModuleFileNameA( hModule, fnA, size );
lstrcpynAtoW( lpFileName, fnA, size );
HeapFree( GetProcessHeap(), 0, fnA );
return res;
@@ -798,20 +798,20 @@
* LoadLibraryEx32W (KERNEL.513)
* FIXME
*/
-HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
+HMODULE WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf,
DWORD flags )
{
TRACE(module,"(%s,%d,%08lx)\n",libname,hf,flags);
- return LoadLibraryEx32A(libname, hf,flags);
+ return LoadLibraryExA(libname, hf,flags);
}
/***********************************************************************
* LoadLibraryEx32A (KERNEL32)
*/
-HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags)
+HMODULE WINAPI LoadLibraryExA(LPCSTR libname,HFILE hfile,DWORD flags)
{
- HMODULE32 hmod;
- hmod = MODULE_LoadLibraryEx32A( libname, hfile, flags );
+ HMODULE hmod;
+ hmod = MODULE_LoadLibraryExA( libname, hfile, flags );
/* at least call not the dllmain...*/
if ( DONT_RESOLVE_DLL_REFERENCES==flags || LOAD_LIBRARY_AS_DATAFILE==flags )
@@ -826,39 +826,39 @@
return hmod;
}
-HMODULE32 MODULE_LoadLibraryEx32A( LPCSTR libname, HFILE32 hfile, DWORD flags )
+HMODULE MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD flags )
{
- HMODULE32 hmod;
+ HMODULE hmod;
- hmod = ELF_LoadLibraryEx32A( libname, hfile, flags );
+ hmod = ELF_LoadLibraryExA( libname, hfile, flags );
if (hmod) return hmod;
- hmod = PE_LoadLibraryEx32A( libname, hfile, flags );
+ hmod = PE_LoadLibraryExA( libname, hfile, flags );
return hmod;
}
/***********************************************************************
* LoadLibraryA (KERNEL32)
*/
-HMODULE32 WINAPI LoadLibrary32A(LPCSTR libname) {
- return LoadLibraryEx32A(libname,0,0);
+HMODULE WINAPI LoadLibraryA(LPCSTR libname) {
+ return LoadLibraryExA(libname,0,0);
}
/***********************************************************************
* LoadLibraryW (KERNEL32)
*/
-HMODULE32 WINAPI LoadLibrary32W(LPCWSTR libnameW)
+HMODULE WINAPI LoadLibraryW(LPCWSTR libnameW)
{
- return LoadLibraryEx32W(libnameW,0,0);
+ return LoadLibraryExW(libnameW,0,0);
}
/***********************************************************************
* LoadLibraryExW (KERNEL32)
*/
-HMODULE32 WINAPI LoadLibraryEx32W(LPCWSTR libnameW,HFILE32 hfile,DWORD flags)
+HMODULE WINAPI LoadLibraryExW(LPCWSTR libnameW,HFILE hfile,DWORD flags)
{
LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
- HMODULE32 ret = LoadLibraryEx32A( libnameA , hfile, flags );
+ HMODULE ret = LoadLibraryExA( libnameA , hfile, flags );
HeapFree( GetProcessHeap(), 0, libnameA );
return ret;
@@ -867,7 +867,7 @@
/***********************************************************************
* FreeLibrary
*/
-BOOL32 WINAPI FreeLibrary32(HINSTANCE32 hLibModule)
+BOOL WINAPI FreeLibrary(HINSTANCE hLibModule)
{
FIXME(module,"(0x%08x): stub\n", hLibModule);
return TRUE; /* FIXME */
@@ -879,9 +879,9 @@
*
* FIXME: rough guesswork, don't know what "Private" means
*/
-HINSTANCE32 WINAPI PrivateLoadLibrary(LPCSTR libname)
+HINSTANCE WINAPI PrivateLoadLibrary(LPCSTR libname)
{
- return (HINSTANCE32)LoadLibrary16(libname);
+ return (HINSTANCE)LoadLibrary16(libname);
}
@@ -891,7 +891,7 @@
*
* FIXME: rough guesswork, don't know what "Private" means
*/
-void WINAPI PrivateFreeLibrary(HINSTANCE32 handle)
+void WINAPI PrivateFreeLibrary(HINSTANCE handle)
{
FreeLibrary16((HINSTANCE16)handle);
}
@@ -902,19 +902,19 @@
*/
HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow )
{
- return WinExec32( lpCmdLine, nCmdShow );
+ return WinExec( lpCmdLine, nCmdShow );
}
/***********************************************************************
* WinExec32 (KERNEL32.566)
*/
-HINSTANCE32 WINAPI WinExec32( LPCSTR lpCmdLine, UINT32 nCmdShow )
+HINSTANCE WINAPI WinExec( LPCSTR lpCmdLine, UINT nCmdShow )
{
- HINSTANCE32 handle = 2;
+ HINSTANCE handle = 2;
char *p, filename[256];
int spacelimit = 0, exhausted = 0;
- LOADPARAMS32 params;
+ LOADPARAMS params;
UINT16 paramCmdShow[2];
if (!lpCmdLine)
@@ -939,7 +939,7 @@
/* Build the filename and command-line */
- lstrcpyn32A(filename, lpCmdLine,
+ lstrcpynA(filename, lpCmdLine,
sizeof(filename) - 4 /* for extension */);
/* Keep grabbing characters until end-of-string, tab, or until the
@@ -966,7 +966,7 @@
if (!__winelib)
{
- handle = LoadModule32( filename, ¶ms );
+ handle = LoadModule( filename, ¶ms );
if (handle == 2) /* file not found */
{
/* Check that the original file name did not have a suffix */
@@ -976,7 +976,7 @@
{
p = filename + strlen(filename);
strcpy( p, ".exe" );
- handle = LoadModule32( filename, ¶ms );
+ handle = LoadModule( filename, ¶ms );
*p = '\0'; /* Remove extension */
}
}
@@ -1058,7 +1058,7 @@
* WIN32_GetProcAddress16 (KERNEL32.36)
* Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func)
*/
-FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hModule, LPCSTR name )
+FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE hModule, LPCSTR name )
{
WORD ordinal;
FARPROC16 ret;
@@ -1084,7 +1084,7 @@
}
if (!ordinal) return (FARPROC16)0;
ret = NE_GetEntryPoint( hModule, ordinal );
- TRACE(module,"returning %08x\n",(UINT32)ret);
+ TRACE(module,"returning %08x\n",(UINT)ret);
return ret;
}
@@ -1115,7 +1115,7 @@
ret = NE_GetEntryPoint( hModule, ordinal );
- TRACE(module, "returning %08x\n", (UINT32)ret );
+ TRACE(module, "returning %08x\n", (UINT)ret );
return ret;
}
@@ -1123,26 +1123,26 @@
/***********************************************************************
* GetProcAddress32 (KERNEL32.257)
*/
-FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function )
+FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function )
{
- return MODULE_GetProcAddress32( hModule, function, TRUE );
+ return MODULE_GetProcAddress( hModule, function, TRUE );
}
/***********************************************************************
* WIN16_GetProcAddress32 (KERNEL.453)
*/
-FARPROC32 WINAPI WIN16_GetProcAddress32( HMODULE32 hModule, LPCSTR function )
+FARPROC WINAPI GetProcAddress32_16( HMODULE hModule, LPCSTR function )
{
- return MODULE_GetProcAddress32( hModule, function, FALSE );
+ return MODULE_GetProcAddress( hModule, function, FALSE );
}
/***********************************************************************
* MODULE_GetProcAddress32 (internal)
*/
-FARPROC32 MODULE_GetProcAddress32(
- HMODULE32 hModule, /* [in] current module handle */
+FARPROC MODULE_GetProcAddress(
+ HMODULE hModule, /* [in] current module handle */
LPCSTR function, /* [in] function to be looked up */
- BOOL32 snoop )
+ BOOL snoop )
{
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
@@ -1151,7 +1151,7 @@
else
TRACE(win32,"(%08lx,%p)\n",(DWORD)hModule,function);
if (!wm)
- return (FARPROC32)0;
+ return (FARPROC)0;
switch (wm->type)
{
case MODULE32_PE:
@@ -1160,7 +1160,7 @@
return ELF_FindExportedFunction( wm, function);
default:
ERR(module,"wine_modref type %d not handled.\n",wm->type);
- return (FARPROC32)0;
+ return (FARPROC)0;
}
}
@@ -1168,7 +1168,7 @@
/***********************************************************************
* RtlImageNtHeaders (NTDLL)
*/
-PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule)
+PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule)
{
/* basically:
* return hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew);
@@ -1195,14 +1195,14 @@
} GPHANDLERDEF;
#pragma pack(4)
-SEGPTR WINAPI HasGPHandler( SEGPTR address )
+SEGPTR WINAPI HasGPHandler16( SEGPTR address )
{
HMODULE16 hModule;
int gpOrdinal;
SEGPTR gpPtr;
GPHANDLERDEF *gpHandler;
- if ( (hModule = FarGetOwner( SELECTOROF(address) )) != 0
+ if ( (hModule = FarGetOwner16( SELECTOROF(address) )) != 0
&& (gpOrdinal = NE_GetOrdinal( hModule, "__GP" )) != 0
&& (gpPtr = (SEGPTR)NE_GetEntryPointEx( hModule, gpOrdinal, FALSE )) != 0
&& !IsBadReadPtr16( gpPtr, sizeof(GPHANDLERDEF) )
diff --git a/loader/ne/convert.c b/loader/ne/convert.c
index a342072..e421236 100644
--- a/loader/ne/convert.c
+++ b/loader/ne/convert.c
@@ -42,8 +42,8 @@
case 0xffff: ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff;
*((WORD *)dialog16)++ = *((WORD *)p)++; break;
default: lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
break;
}
@@ -54,15 +54,15 @@
case 0xffff: ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff;
*((WORD *)dialog16)++ = *((WORD *)p)++; break;
default: lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
break;
}
/* Transfer window caption */
lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
/* Transfer font info */
if (style & DS_SETFONT)
@@ -74,8 +74,8 @@
*((WORD *)dialog16)++ = *((WORD *)p)++; /* italic */
}
lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p ); /* faceName */
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
}
/* Transfer dialog items */
@@ -116,8 +116,8 @@
case 0xffff: ((WORD *)p)++;
*((BYTE *)dialog16)++ = (BYTE)*((WORD *)p)++; break;
default: lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
break;
}
@@ -128,8 +128,8 @@
case 0xffff: ((WORD *)p)++; *((BYTE *)dialog16)++ = 0xff;
*((WORD *)dialog16)++ = *((WORD *)p)++; break;
default: lstrcpyWtoA( (LPSTR)dialog16, (LPWSTR)p );
- ((LPSTR)dialog16) += lstrlen32A( (LPSTR)dialog16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)dialog16) += lstrlenA( (LPSTR)dialog16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
break;
}
@@ -155,7 +155,7 @@
/**********************************************************************
* GetDialog32Size (KERNEL.618)
*/
-WORD WINAPI GetDialog32Size( LPVOID dialog32 )
+WORD WINAPI GetDialog32Size16( LPVOID dialog32 )
{
LPVOID p = dialog32;
WORD nbItems, data, dialogEx;
@@ -183,7 +183,7 @@
{
case 0x0000: ((WORD *)p)++; break;
case 0xffff: ((WORD *)p) += 2; break;
- default: ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+ default: ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
}
/* Skip class name */
@@ -191,11 +191,11 @@
{
case 0x0000: ((WORD *)p)++; break;
case 0xffff: ((WORD *)p) += 2; break;
- default: ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+ default: ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
}
/* Skip window caption */
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
/* Skip font info */
if (style & DS_SETFONT)
@@ -206,7 +206,7 @@
((WORD *)p)++; /* weight */
((WORD *)p)++; /* italic */
}
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; /* faceName */
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; /* faceName */
}
/* Skip dialog items */
@@ -242,7 +242,7 @@
{
case 0x0000: ((WORD *)p)++; break;
case 0xffff: ((WORD *)p) += 2; break;
- default: ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+ default: ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
}
/* Skip window name */
@@ -250,7 +250,7 @@
{
case 0x0000: ((WORD *)p)++; break;
case 0xffff: ((WORD *)p) += 2; break;
- default: ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1; break;
+ default: ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1; break;
}
/* Skip data */
@@ -291,8 +291,8 @@
level++;
lstrcpyWtoA( (LPSTR)menu16, (LPWSTR)p );
- ((LPSTR)menu16) += lstrlen32A( (LPSTR)menu16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)menu16) += lstrlenA( (LPSTR)menu16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
if ( flags & MF_END )
level--;
@@ -305,8 +305,8 @@
flags = *((BYTE *)menu16)++ = (BYTE)*((WORD *)p)++;
lstrcpyWtoA( (LPSTR)menu16, (LPWSTR)p );
- ((LPSTR)menu16) += lstrlen32A( (LPSTR)menu16 ) + 1;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPSTR)menu16) += lstrlenA( (LPSTR)menu16 ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
/* align on DWORD boundary (32-bit only) */
p = (LPVOID)((((int)p) + 3) & ~3);
@@ -326,7 +326,7 @@
/**********************************************************************
* GetMenu32Size (KERNEL.617)
*/
-WORD WINAPI GetMenu32Size( LPVOID menu32 )
+WORD WINAPI GetMenu32Size16( LPVOID menu32 )
{
LPVOID p = menu32;
WORD version, headersize, flags, level = 1;
@@ -344,7 +344,7 @@
else
level++;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
if ( flags & MF_END )
level--;
@@ -356,7 +356,7 @@
((DWORD *)p)++; /* ID */
flags = *((WORD *)p)++;
- ((LPWSTR)p) += lstrlen32W( (LPWSTR)p ) + 1;
+ ((LPWSTR)p) += lstrlenW( (LPWSTR)p ) + 1;
/* align on DWORD boundary (32-bit only) */
p = (LPVOID)((((int)p) + 3) & ~3);
diff --git a/loader/ne/module.c b/loader/ne/module.c
index c68c784..f8c53c2 100644
--- a/loader/ne/module.c
+++ b/loader/ne/module.c
@@ -33,8 +33,8 @@
static NE_MODULE *pCachedModule = 0; /* Module cached by NE_OpenFile */
-static HMODULE16 NE_LoadBuiltin(LPCSTR name,BOOL32 force) { return 0; }
-HMODULE16 (*fnBUILTIN_LoadModule)(LPCSTR name,BOOL32 force) = NE_LoadBuiltin;
+static HMODULE16 NE_LoadBuiltin(LPCSTR name,BOOL force) { return 0; }
+HMODULE16 (*fnBUILTIN_LoadModule)(LPCSTR name,BOOL force) = NE_LoadBuiltin;
/***********************************************************************
@@ -131,7 +131,7 @@
for (i = 0; i < pModule->modref_count; i++, pword++)
{
char name[10];
- GetModuleName( *pword, name, sizeof(name) );
+ GetModuleName16( *pword, name, sizeof(name) );
DUMP( "%d: %04x -> '%s'\n", i, *pword, name );
}
}
@@ -249,7 +249,7 @@
/* Now copy and uppercase the string */
strcpy( buffer, name );
- CharUpper32A( buffer );
+ CharUpperA( buffer );
len = strlen( buffer );
/* First search the resident names */
@@ -340,7 +340,7 @@
}
if (sel == 0xfe) sel = 0xffff; /* constant entry */
- else sel = GlobalHandleToSel(NE_SEG_TABLE(pModule)[sel-1].hSeg);
+ else sel = GlobalHandleToSel16(NE_SEG_TABLE(pModule)[sel-1].hSeg);
if (sel==0xffff)
return (FARPROC16)PTR_SEG_OFF_TO_SEGPTR( sel, offset );
if (!snoop || !fnSNOOP16_GetProcAddress16)
@@ -399,11 +399,11 @@
/***********************************************************************
* NE_OpenFile
*/
-HANDLE32 NE_OpenFile( NE_MODULE *pModule )
+HANDLE NE_OpenFile( NE_MODULE *pModule )
{
char *name;
- static HANDLE32 cachedfd = -1;
+ static HANDLE cachedfd = -1;
TRACE( module, "(%p) cache: mod=%p fd=%d\n",
pModule, pCachedModule, cachedfd );
@@ -411,7 +411,7 @@
CloseHandle( cachedfd );
pCachedModule = pModule;
name = NE_MODULE_NAME( pModule );
- if ((cachedfd = CreateFile32A( name, GENERIC_READ, FILE_SHARE_READ,
+ if ((cachedfd = CreateFileA( name, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, -1 )) == -1)
MSG( "Can't open file '%s' for module %04x\n", name, pModule->self );
else
@@ -482,7 +482,7 @@
hModule = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, size );
if (!hModule) return (HMODULE16)11; /* invalid exe */
- FarSetOwner( hModule, hModule );
+ FarSetOwner16( hModule, hModule );
pModule = (NE_MODULE *)GlobalLock16( hModule );
memcpy( pModule, &ne_header, sizeof(ne_header) );
pModule->count = 0;
@@ -686,7 +686,7 @@
*
* Load all DLLs implicitly linked to a module.
*/
-static BOOL32 NE_LoadDLLs( NE_MODULE *pModule )
+static BOOL NE_LoadDLLs( NE_MODULE *pModule )
{
int i;
WORD *pModRef = (WORD *)((char *)pModule + pModule->modref_table);
@@ -748,7 +748,7 @@
* Implementation of LoadModule16().
*/
HINSTANCE16 NE_LoadModule( LPCSTR name, HINSTANCE16 *hPrevInstance,
- BOOL32 implicit, BOOL32 lib_only )
+ BOOL implicit, BOOL lib_only )
{
HMODULE16 hModule;
HINSTANCE16 hInstance;
@@ -801,7 +801,7 @@
if (!NE_CreateSegments( pModule ) ||
!(hInstance = NE_CreateInstance( pModule, NULL, lib_only )))
{
- GlobalFreeAll( hModule );
+ GlobalFreeAll16( hModule );
return 8; /* Insufficient memory */
}
@@ -891,7 +891,7 @@
*
* Implementation of FreeModule16().
*/
-static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL32 call_wep )
+static BOOL16 NE_FreeModule( HMODULE16 hModule, BOOL call_wep )
{
HMODULE16 *hPrevModule;
NE_MODULE *pModule;
@@ -950,7 +950,7 @@
/* Free the module storage */
- GlobalFreeAll( hModule );
+ GlobalFreeAll16( hModule );
/* Remove module from cache */
@@ -981,7 +981,7 @@
/**********************************************************************
* GetModuleName (KERNEL.27)
*/
-BOOL16 WINAPI GetModuleName( HINSTANCE16 hinst, LPSTR buf, INT16 count )
+BOOL16 WINAPI GetModuleName16( HINSTANCE16 hinst, LPSTR buf, INT16 count )
{
NE_MODULE *pModule;
BYTE *p;
@@ -1001,7 +1001,7 @@
/**********************************************************************
* GetModuleUsage (KERNEL.48)
*/
-INT16 WINAPI GetModuleUsage( HINSTANCE16 hModule )
+INT16 WINAPI GetModuleUsage16( HINSTANCE16 hModule )
{
NE_MODULE *pModule = NE_GetPtr( hModule );
return pModule ? pModule->count : 0;
@@ -1011,7 +1011,7 @@
/**********************************************************************
* GetExpWinVer (KERNEL.167)
*/
-WORD WINAPI GetExpWinVer( HMODULE16 hModule )
+WORD WINAPI GetExpWinVer16( HMODULE16 hModule )
{
NE_MODULE *pModule = NE_GetPtr( hModule );
return pModule ? pModule->expected_version : 0;
@@ -1028,7 +1028,7 @@
if (!hModule) hModule = GetCurrentTask();
if (!(pModule = NE_GetPtr( hModule ))) return 0;
- lstrcpyn32A( lpFileName, NE_MODULE_NAME(pModule), nSize );
+ lstrcpynA( lpFileName, NE_MODULE_NAME(pModule), nSize );
TRACE(module, "%s\n", lpFileName );
return strlen(lpFileName);
}
@@ -1073,10 +1073,10 @@
if (!(modulename = strrchr( modulepath, '\\' )))
modulename = modulepath;
else modulename++;
- if (!lstrcmpi32A( modulename, filename )) return hModule;
+ if (!lstrcmpiA( modulename, filename )) return hModule;
name_table = (BYTE *)pModule + pModule->name_table;
- if ((*name_table == len) && !lstrncmpi32A(filename, name_table+1, len))
+ if ((*name_table == len) && !lstrncmpiA(filename, name_table+1, len))
return hModule;
hModule = pModule->next;
}
@@ -1087,17 +1087,17 @@
/**********************************************************************
* ModuleFirst (TOOLHELP.59)
*/
-BOOL16 WINAPI ModuleFirst( MODULEENTRY *lpme )
+BOOL16 WINAPI ModuleFirst16( MODULEENTRY *lpme )
{
lpme->wNext = hFirstModule;
- return ModuleNext( lpme );
+ return ModuleNext16( lpme );
}
/**********************************************************************
* ModuleNext (TOOLHELP.60)
*/
-BOOL16 WINAPI ModuleNext( MODULEENTRY *lpme )
+BOOL16 WINAPI ModuleNext16( MODULEENTRY *lpme )
{
NE_MODULE *pModule;
char *name;
@@ -1109,7 +1109,7 @@
lpme->szModule[min(*name, MAX_MODULE_NAME)] = '\0';
lpme->hModule = lpme->wNext;
lpme->wcUsage = pModule->count;
- lstrcpyn32A( lpme->szExePath, NE_MODULE_NAME(pModule), sizeof(lpme->szExePath) );
+ lstrcpynA( lpme->szExePath, NE_MODULE_NAME(pModule), sizeof(lpme->szExePath) );
lpme->wNext = pModule->next;
return TRUE;
}
@@ -1118,27 +1118,27 @@
/**********************************************************************
* ModuleFindName (TOOLHELP.61)
*/
-BOOL16 WINAPI ModuleFindName( MODULEENTRY *lpme, LPCSTR name )
+BOOL16 WINAPI ModuleFindName16( MODULEENTRY *lpme, LPCSTR name )
{
lpme->wNext = GetModuleHandle16( name );
- return ModuleNext( lpme );
+ return ModuleNext16( lpme );
}
/**********************************************************************
* ModuleFindHandle (TOOLHELP.62)
*/
-BOOL16 WINAPI ModuleFindHandle( MODULEENTRY *lpme, HMODULE16 hModule )
+BOOL16 WINAPI ModuleFindHandle16( MODULEENTRY *lpme, HMODULE16 hModule )
{
hModule = GetExePtr( hModule );
lpme->wNext = hModule;
- return ModuleNext( lpme );
+ return ModuleNext16( lpme );
}
/***************************************************************************
* MapHModuleLS (KERNEL32.520)
*/
-HMODULE16 WINAPI MapHModuleLS(HMODULE32 hmod) {
+HMODULE16 WINAPI MapHModuleLS(HMODULE hmod) {
NE_MODULE *pModule;
if (!hmod)
@@ -1157,7 +1157,7 @@
/***************************************************************************
* MapHModuleSL (KERNEL32.521)
*/
-HMODULE32 WINAPI MapHModuleSL(HMODULE16 hmod) {
+HMODULE WINAPI MapHModuleSL(HMODULE16 hmod) {
NE_MODULE *pModule;
if (!hmod) {
diff --git a/loader/ne/resource.c b/loader/ne/resource.c
index 06e740d..359f6c9 100644
--- a/loader/ne/resource.c
+++ b/loader/ne/resource.c
@@ -63,7 +63,7 @@
if (p[1] & 0x8000)
{
if (!HIWORD(typeId)) continue;
- if (lstrcmpi32A( typeId,
+ if (lstrcmpiA( typeId,
(char *)(p + 3) )) continue;
}
else if (HIWORD(typeId) || (((DWORD)typeId & ~0x8000)!= p[1]))
@@ -74,7 +74,7 @@
if (p[2] & 0x8000)
{
if (!HIWORD(resId)) continue;
- if (lstrcmpi32A( resId,
+ if (lstrcmpiA( resId,
(char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
}
@@ -113,7 +113,7 @@
if (!(pTypeInfo->type_id & 0x8000))
{
BYTE *p = pResTab + pTypeInfo->type_id;
- if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
+ if ((*p == len) && !lstrncmpiA( p+1, str, len ))
{
TRACE(resource, " Found type '%s'\n", str );
return pTypeInfo;
@@ -160,7 +160,7 @@
{
if (pNameInfo->id & 0x8000) continue;
p = pResTab + pNameInfo->id;
- if ((*p == len) && !lstrncmpi32A( p+1, str, len ))
+ if ((*p == len) && !lstrncmpiA( p+1, str, len ))
return pNameInfo;
}
}
@@ -183,7 +183,7 @@
HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule,
HRSRC16 hRsrc )
{
- HANDLE32 fd;
+ HANDLE fd;
NE_MODULE* pModule = NE_GetPtr( hModule );
if (pModule && (fd = NE_OpenFile( pModule )) >= 0)
{
@@ -197,7 +197,7 @@
if( hMemObj )
handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 );
else
- handle = AllocResource( hModule, hRsrc, 0 );
+ handle = AllocResource16( hModule, hRsrc, 0 );
if( handle )
{
@@ -216,7 +216,7 @@
*
* Fill in 'resloader' fields in the resource table.
*/
-BOOL32 NE_InitResourceHandler( HMODULE16 hModule )
+BOOL NE_InitResourceHandler( HMODULE16 hModule )
{
NE_MODULE *pModule = NE_GetPtr( hModule );
NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->res_table + 2);
@@ -237,7 +237,7 @@
/**********************************************************************
* SetResourceHandler (KERNEL.43)
*/
-FARPROC16 WINAPI SetResourceHandler( HMODULE16 hModule, SEGPTR typeId,
+FARPROC16 WINAPI SetResourceHandler16( HMODULE16 hModule, SEGPTR typeId,
FARPROC16 resourceHandler )
{
FARPROC16 prevHandler = NULL;
@@ -333,7 +333,7 @@
/**********************************************************************
* AllocResource (KERNEL.66)
*/
-HGLOBAL16 WINAPI AllocResource( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
+HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
{
NE_NAMEINFO *pNameInfo=NULL;
WORD sizeShift;
@@ -356,7 +356,7 @@
*
* Check Schulman, p. 232 for details
*/
-HGLOBAL16 WINAPI DirectResAlloc( HINSTANCE16 hInstance, WORD wType,
+HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType,
UINT16 wSize )
{
TRACE(resource,"(%04x,%04x,%04x)\n",
diff --git a/loader/ne/segment.c b/loader/ne/segment.c
index 0fd0605..ef7b842 100644
--- a/loader/ne/segment.c
+++ b/loader/ne/segment.c
@@ -28,7 +28,7 @@
#include "debug.h"
#include "xmalloc.h"
-#define SEL(x) GlobalHandleToSel(x)
+#define SEL(x) GlobalHandleToSel16(x)
/***********************************************************************
* NE_GetRelocAddrName
@@ -51,14 +51,14 @@
/***********************************************************************
* NE_LoadSegment
*/
-BOOL32 NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
+BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
{
SEGTABLEENTRY *pSegTable, *pSeg;
WORD *pModuleTable;
WORD count, i, offset, next_offset;
HMODULE16 module;
FARPROC16 address = 0;
- HFILE32 hf;
+ HFILE hf;
DWORD res;
struct relocation_entry_s *rep, *reloc_entries;
BYTE *func_name;
@@ -94,7 +94,7 @@
DWORD oldstack;
WORD old_hSeg, new_hSeg;
THDB *thdb = THREAD_Current();
- HFILE32 hFile32;
+ HFILE hFile32;
HFILE16 hFile16;
selfloadheader = (SELFLOADHEADER *)
@@ -130,12 +130,12 @@
memcpy(PTR_SEG_OFF_TO_LIN(SEL(old_hSeg),0),
PTR_SEG_OFF_TO_LIN(SEL(new_hSeg),0),
pSeg->minsize ? pSeg->minsize : 0x10000);
- FreeSelector(SEL(new_hSeg));
+ FreeSelector16(SEL(new_hSeg));
pSeg->hSeg = old_hSeg;
TRACE(module, "New hSeg allocated for dgroup segment:Old=%d,New=%d\n",
old_hSeg, new_hSeg);
} else {
- FreeSelector(SEL(pSeg->hSeg));
+ FreeSelector16(SEL(pSeg->hSeg));
pSeg->hSeg = new_hSeg;
}
}
@@ -308,7 +308,7 @@
if (rep->address_type > NE_RADDR_OFFSET32)
{
char module[10];
- GetModuleName( pModule->self, module, sizeof(module) );
+ GetModuleName16( pModule->self, module, sizeof(module) );
ERR( fixup, "WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
module, rep->address_type );
}
@@ -387,14 +387,14 @@
/***********************************************************************
* NE_LoadAllSegments
*/
-BOOL32 NE_LoadAllSegments( NE_MODULE *pModule )
+BOOL NE_LoadAllSegments( NE_MODULE *pModule )
{
int i;
SEGTABLEENTRY * pSegTable = (SEGTABLEENTRY *) NE_SEG_TABLE(pModule);
if (pModule->flags & NE_FFLAGS_SELFLOAD)
{
- HFILE32 hf;
+ HFILE hf;
HFILE16 hFile16;
/* Handle self loading modules */
SELFLOADHEADER *selfloadheader;
@@ -413,7 +413,7 @@
selfloadheader->EntryAddrProc = NE_GetEntryPoint(hselfload,27);
selfloadheader->MyAlloc = NE_GetEntryPoint(hselfload,28);
selfloadheader->SetOwner = NE_GetEntryPoint(GetModuleHandle16("KERNEL"),403);
- pModule->self_loading_sel = GlobalHandleToSel(GLOBAL_Alloc(GMEM_ZEROINIT, 0xFF00, pModule->self, FALSE, FALSE, FALSE));
+ pModule->self_loading_sel = GlobalHandleToSel16(GLOBAL_Alloc(GMEM_ZEROINIT, 0xFF00, pModule->self, FALSE, FALSE, FALSE));
oldstack = thdb->cur_stack;
thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(*stack16Top) );
@@ -459,7 +459,7 @@
*/
/* It does nothing */
-DWORD WINAPI PatchCodeHandle(HANDLE16 hSel)
+DWORD WINAPI PatchCodeHandle16(HANDLE16 hSel)
{
FIXME(module,"(%04x): stub.\n",hSel);
return (DWORD)NULL;
@@ -606,7 +606,7 @@
*
* Call the DLL initialization code
*/
-static BOOL32 NE_InitDLL( TDB* pTask, NE_MODULE *pModule )
+static BOOL NE_InitDLL( TDB* pTask, NE_MODULE *pModule )
{
SEGTABLEENTRY *pSegTable;
WORD hInst, ds, heap;
@@ -741,7 +741,7 @@
* If lib_only is TRUE, handle the module like a library even if it is a .EXE
*/
HINSTANCE16 NE_CreateInstance( NE_MODULE *pModule, HINSTANCE16 *prev,
- BOOL32 lib_only )
+ BOOL lib_only )
{
SEGTABLEENTRY *pSegment;
int minsize;
@@ -812,20 +812,20 @@
if ( (wFlags & NE_SEGFLAGS_EXECUTEONLY) ||
!(wFlags & NE_SEGFLAGS_DATA)
) {
- WORD hSel = GlobalHandleToSel(hMem);
- WORD access = SelectorAccessRights(hSel,0,0);
+ WORD hSel = GlobalHandleToSel16(hMem);
+ WORD access = SelectorAccessRights16(hSel,0,0);
access |= 2<<2; /* SEGMENT_CODE */
- SelectorAccessRights(hSel,1,access);
+ SelectorAccessRights16(hSel,1,access);
}
- return MAKELONG( hMem, GlobalHandleToSel(hMem) );
+ return MAKELONG( hMem, GlobalHandleToSel16(hMem) );
}
/***********************************************************************
* NE_CreateSegments
*/
-BOOL32 NE_CreateSegments( NE_MODULE *pModule )
+BOOL NE_CreateSegments( NE_MODULE *pModule )
{
SEGTABLEENTRY *pSegment;
int i, minsize;
@@ -857,7 +857,7 @@
/**********************************************************************
* IsSharedSelector (KERNEL.345)
*/
-BOOL16 WINAPI IsSharedSelector( HANDLE16 selector )
+BOOL16 WINAPI IsSharedSelector16( HANDLE16 selector )
{
/* Check whether the selector belongs to a DLL */
NE_MODULE *pModule = NE_GetPtr( selector );
diff --git a/loader/pe_image.c b/loader/pe_image.c
index accf038..619fea6 100644
--- a/loader/pe_image.c
+++ b/loader/pe_image.c
@@ -63,7 +63,7 @@
#define AdjustPtr(ptr,delta) ((char *)(ptr) + (delta))
-void dump_exports( HMODULE32 hModule )
+void dump_exports( HMODULE hModule )
{
char *Module;
int i, j;
@@ -115,10 +115,10 @@
* If it is a ordinal:
* - use ordinal-pe_export->Base as offset into the functionlist
*/
-FARPROC32 PE_FindExportedFunction(
+FARPROC PE_FindExportedFunction(
WINE_MODREF *wm, /* [in] WINE modreference */
LPCSTR funcName, /* [in] function name */
- BOOL32 snoop )
+ BOOL snoop )
{
u_short * ordinal;
u_long * function;
@@ -159,8 +159,8 @@
addr = function[*ordinal];
if (!addr) return NULL;
if ((addr < rva_start) || (addr >= rva_end))
- return snoop? SNOOP_GetProcAddress32(wm->module,ename,*ordinal,(FARPROC32)RVA(addr))
- : (FARPROC32)RVA(addr);
+ return snoop? SNOOP_GetProcAddress(wm->module,ename,*ordinal,(FARPROC)RVA(addr))
+ : (FARPROC)RVA(addr);
forward = (char *)RVA(addr);
break;
}
@@ -189,13 +189,13 @@
ename = "";
}
if ((addr < rva_start) || (addr >= rva_end))
- return snoop? SNOOP_GetProcAddress32(wm->module,ename,(DWORD)funcName-exports->Base,(FARPROC32)RVA(addr))
- : (FARPROC32)RVA(addr);
+ return snoop? SNOOP_GetProcAddress(wm->module,ename,(DWORD)funcName-exports->Base,(FARPROC)RVA(addr))
+ : (FARPROC)RVA(addr);
forward = (char *)RVA(addr);
}
if (forward)
{
- HMODULE32 hMod;
+ HMODULE hMod;
char module[256];
char *end = strchr(forward, '.');
@@ -203,9 +203,9 @@
assert(end-forward<256);
strncpy(module, forward, (end - forward));
module[end-forward] = 0;
- hMod = MODULE_FindModule32( module );
+ hMod = MODULE_FindModule( module );
assert(hMod);
- return MODULE_GetProcAddress32( hMod, end + 1, snoop );
+ return MODULE_GetProcAddress( hMod, end + 1, snoop );
}
return NULL;
}
@@ -255,7 +255,7 @@
*/
for (i = 0, pe_imp = pem->pe_import; pe_imp->Name ; pe_imp++) {
- HMODULE32 hImpModule;
+ HMODULE hImpModule;
IMAGE_IMPORT_BY_NAME *pe_name;
PIMAGE_THUNK_DATA import_list,thunk_list;
char *name = (char *) RVA(pe_imp->Name);
@@ -264,7 +264,7 @@
break;
/* don't use MODULE_Load, Win32 creates new task differently */
- hImpModule = MODULE_LoadLibraryEx32A( name, 0, 0 );
+ hImpModule = MODULE_LoadLibraryExA( name, 0, 0 );
if (!hImpModule) {
char *p,buffer[2000];
@@ -273,7 +273,7 @@
if (!(p = strrchr (buffer, '\\')))
p = buffer;
strcpy (p + 1, name);
- hImpModule = MODULE_LoadLibraryEx32A( buffer, 0, 0 );
+ hImpModule = MODULE_LoadLibraryExA( buffer, 0, 0 );
}
if (!hImpModule) {
ERR (module, "Module %s not found\n", name);
@@ -295,24 +295,24 @@
int ordinal = IMAGE_ORDINAL(import_list->u1.Ordinal);
TRACE(win32, "--- Ordinal %s,%d\n", name, ordinal);
- thunk_list->u1.Function=MODULE_GetProcAddress32(
+ thunk_list->u1.Function=MODULE_GetProcAddress(
hImpModule, (LPCSTR)ordinal, TRUE
);
if (!thunk_list->u1.Function) {
ERR(win32,"No implementation for %s.%d, setting to 0xdeadbeef\n",
name, ordinal);
- thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+ thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
} else { /* import by name */
pe_name = (PIMAGE_IMPORT_BY_NAME)RVA(import_list->u1.AddressOfData);
TRACE(win32, "--- %s %s.%d\n", pe_name->Name, name, pe_name->Hint);
- thunk_list->u1.Function=MODULE_GetProcAddress32(
+ thunk_list->u1.Function=MODULE_GetProcAddress(
hImpModule, pe_name->Name, TRUE
);
if (!thunk_list->u1.Function) {
ERR(win32,"No implementation for %s.%d(%s), setting to 0xdeadbeef\n",
name,pe_name->Hint,pe_name->Name);
- thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+ thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
}
import_list++;
@@ -327,25 +327,25 @@
int ordinal = IMAGE_ORDINAL(thunk_list->u1.Ordinal);
TRACE(win32,"--- Ordinal %s.%d\n",name,ordinal);
- thunk_list->u1.Function=MODULE_GetProcAddress32(
+ thunk_list->u1.Function=MODULE_GetProcAddress(
hImpModule, (LPCSTR) ordinal, TRUE
);
if (!thunk_list->u1.Function) {
ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
name,ordinal);
- thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+ thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
} else {
pe_name=(PIMAGE_IMPORT_BY_NAME) RVA(thunk_list->u1.AddressOfData);
TRACE(win32,"--- %s %s.%d\n",
pe_name->Name,name,pe_name->Hint);
- thunk_list->u1.Function=MODULE_GetProcAddress32(
+ thunk_list->u1.Function=MODULE_GetProcAddress(
hImpModule, pe_name->Name, TRUE
);
if (!thunk_list->u1.Function) {
ERR(win32, "No implementation for %s.%d, setting to 0xdeadbeef\n",
name, pe_name->Hint);
- thunk_list->u1.Function = (FARPROC32)0xdeadbeef;
+ thunk_list->u1.Function = (FARPROC)0xdeadbeef;
}
}
thunk_list++;
@@ -355,7 +355,7 @@
return 0;
}
-static int calc_vma_size( HMODULE32 hModule )
+static int calc_vma_size( HMODULE hModule )
{
int i,vma_size = 0;
IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(hModule);
@@ -452,11 +452,11 @@
* BUT we have to map the whole image anyway, for Win32 programs sometimes
* want to access them. (HMODULE32 point to the start of it)
*/
-HMODULE32 PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
+HMODULE PE_LoadImage( LPCSTR name, OFSTRUCT *ofs, LPCSTR *modName )
{
- HMODULE32 hModule;
- HFILE32 hFile;
- HANDLE32 mapping;
+ HMODULE hModule;
+ HFILE hFile;
+ HANDLE mapping;
IMAGE_NT_HEADERS *nt;
IMAGE_SECTION_HEADER *pe_sec;
@@ -472,8 +472,8 @@
if (!strchr( p, '.' )) strcat( dllname, ".DLL" );
/* Open PE file */
- hFile = OpenFile32( dllname, ofs, OF_READ | OF_SHARE_DENY_WRITE );
- if ( hFile == HFILE_ERROR32 )
+ hFile = OpenFile( dllname, ofs, OF_READ | OF_SHARE_DENY_WRITE );
+ if ( hFile == HFILE_ERROR )
{
WARN( win32, "OpenFile error %ld\n", GetLastError() );
return 2;
@@ -484,7 +484,7 @@
file_size = bhfi.nFileSizeLow; /* FIXME: 64 bit */
/* Map the PE file somewhere */
- mapping = CreateFileMapping32A( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
+ mapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY | SEC_COMMIT,
0, 0, NULL );
CloseHandle( hFile );
if (!mapping)
@@ -492,7 +492,7 @@
WARN( win32, "CreateFileMapping error %ld\n", GetLastError() );
return 0;
}
- hModule = (HMODULE32)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
+ hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
CloseHandle( mapping );
if (!hModule)
{
@@ -638,7 +638,7 @@
/* We don't need the orignal mapping any more */
UnmapViewOfFile( (LPVOID)hModule );
- return (HMODULE32)load_addr;
+ return (HMODULE)load_addr;
error:
UnmapViewOfFile( (LPVOID)hModule );
@@ -658,8 +658,8 @@
* Note: This routine must always be called in the context of the
* process that is to own the module to be created.
*/
-WINE_MODREF *PE_CreateModule( HMODULE32 hModule,
- OFSTRUCT *ofs, DWORD flags, BOOL32 builtin )
+WINE_MODREF *PE_CreateModule( HMODULE hModule,
+ OFSTRUCT *ofs, DWORD flags, BOOL builtin )
{
DWORD load_addr = (DWORD)hModule; /* for RVA */
IMAGE_NT_HEADERS *nt = PE_HEADER(hModule);
@@ -749,9 +749,9 @@
}
wm->modname = HEAP_strdupA( GetProcessHeap(), 0, modname );
- result = GetLongPathName32A( ofs->szPathName, NULL, 0 );
+ result = GetLongPathNameA( ofs->szPathName, NULL, 0 );
wm->longname = (char *)HeapAlloc( GetProcessHeap(), 0, result+1 );
- GetLongPathName32A( ofs->szPathName, wm->longname, result+1 );
+ GetLongPathNameA( ofs->szPathName, wm->longname, result+1 );
wm->shortname = HEAP_strdupA( GetProcessHeap(), 0, ofs->szPathName );
@@ -801,19 +801,19 @@
* The PE Library Loader frontend.
* FIXME: handle the flags.
*/
-HMODULE32 PE_LoadLibraryEx32A (LPCSTR name,
- HFILE32 hFile, DWORD flags)
+HMODULE PE_LoadLibraryExA (LPCSTR name,
+ HFILE hFile, DWORD flags)
{
LPCSTR modName = NULL;
OFSTRUCT ofs;
- HMODULE32 hModule32;
+ HMODULE hModule32;
HMODULE16 hModule16;
NE_MODULE *pModule;
WINE_MODREF *wm;
- BOOL32 builtin;
+ BOOL builtin;
/* Check for already loaded module */
- if ((hModule32 = MODULE_FindModule32( name )))
+ if ((hModule32 = MODULE_FindModule( name )))
return hModule32;
/* try to load builtin, enabled modules first */
@@ -858,16 +858,16 @@
* due to the PROCESS_Create stuff.
*/
HINSTANCE16 PE_CreateProcess( LPCSTR name, LPCSTR cmd_line,
- LPCSTR env, BOOL32 inherit, LPSTARTUPINFO32A startup,
+ LPCSTR env, BOOL inherit, LPSTARTUPINFOA startup,
LPPROCESS_INFORMATION info )
{
LPCSTR modName = NULL;
HMODULE16 hModule16;
- HMODULE32 hModule32;
+ HMODULE hModule32;
HINSTANCE16 hInstance;
NE_MODULE *pModule;
OFSTRUCT ofs;
- PDB32 *process;
+ PDB *process;
/* Load file */
if ((hModule32 = PE_LoadImage( name, &ofs, &modName )) < 32)
@@ -897,7 +897,7 @@
/*********************************************************************
* PE_UnloadImage [internal]
*/
-int PE_UnloadImage( HMODULE32 hModule )
+int PE_UnloadImage( HMODULE hModule )
{
FIXME(win32,"stub.\n");
/* free resources, image, unmap */
@@ -934,7 +934,7 @@
if ((PE_HEADER(wm->module)->FileHeader.Characteristics & IMAGE_FILE_DLL) &&
(PE_HEADER(wm->module)->OptionalHeader.AddressOfEntryPoint)
) {
- DLLENTRYPROC32 entry = (void*)RVA_PTR( wm->module,OptionalHeader.AddressOfEntryPoint );
+ DLLENTRYPROC entry = (void*)RVA_PTR( wm->module,OptionalHeader.AddressOfEntryPoint );
TRACE(relay, "CallTo32(entryproc=%p,module=%08x,type=%ld,res=%p)\n",
entry, wm->module, type, lpReserved );
@@ -957,7 +957,7 @@
DWORD size,datasize;
LPVOID mem;
PIMAGE_TLS_DIRECTORY pdir;
- PDB32 *pdb = thdb->process;
+ PDB *pdb = thdb->process;
int delta;
for (wm = pdb->modref_list;wm;wm=wm->next) {
@@ -997,7 +997,7 @@
* DisableThreadLibraryCalls (KERNEL32.74)
* Don't call DllEntryPoint for DLL_THREAD_{ATTACH,DETACH} if set.
*/
-BOOL32 WINAPI DisableThreadLibraryCalls(HMODULE32 hModule)
+BOOL WINAPI DisableThreadLibraryCalls(HMODULE hModule)
{
WINE_MODREF *wm;
diff --git a/loader/pe_resource.c b/loader/pe_resource.c
index 531b71b..1b4c58a 100644
--- a/loader/pe_resource.c
+++ b/loader/pe_resource.c
@@ -30,7 +30,7 @@
* small helper function to get a PE_MODREF from a passed HMODULE32
*/
static PE_MODREF*
-HMODULE32toPE_MODREF(HMODULE32 hmod) {
+HMODULE32toPE_MODREF(HMODULE hmod) {
WINE_MODREF *wm;
wm = MODULE32_LookupHMODULE( hmod );
@@ -47,7 +47,7 @@
*/
PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY resdirptr,
LPCWSTR name,DWORD root,
- BOOL32 allowdefault)
+ BOOL allowdefault)
{
int entrynum;
PIMAGE_RESOURCE_DIRECTORY_ENTRY entryTable;
@@ -63,7 +63,7 @@
entryTable = (PIMAGE_RESOURCE_DIRECTORY_ENTRY) (
(BYTE *) resdirptr +
sizeof(IMAGE_RESOURCE_DIRECTORY));
- namelen = lstrlen32W(name);
+ namelen = lstrlenW(name);
for (entrynum = 0; entrynum < resdirptr->NumberOfNamedEntries; entrynum++)
{
PIMAGE_RESOURCE_DIR_STRING_U str =
@@ -71,7 +71,7 @@
entryTable[entrynum].u1.s.NameOffset);
if(namelen != str->Length)
continue;
- if(lstrncmpi32W(name,str->NameString,str->Length)==0)
+ if(lstrncmpiW(name,str->NameString,str->Length)==0)
return (PIMAGE_RESOURCE_DIRECTORY) (
root +
entryTable[entrynum].u2.s.OffsetToDirectory);
@@ -101,7 +101,7 @@
*/
PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA( PIMAGE_RESOURCE_DIRECTORY resdirptr,
LPCSTR name, DWORD root,
- BOOL32 allowdefault )
+ BOOL allowdefault )
{
PIMAGE_RESOURCE_DIRECTORY retv;
LPWSTR nameW = HIWORD(name)? HEAP_strdupAtoW( GetProcessHeap(), 0, name )
@@ -117,12 +117,12 @@
/**********************************************************************
* PE_FindResourceEx32W
*/
-HANDLE32 PE_FindResourceEx32W(
+HANDLE PE_FindResourceExW(
WINE_MODREF *wm,LPCWSTR name,LPCWSTR type,WORD lang
) {
PIMAGE_RESOURCE_DIRECTORY resdirptr;
DWORD root;
- HANDLE32 result;
+ HANDLE result;
PE_MODREF *pem = &(wm->binfmt.pe);
if (!pem || !pem->pe_resource)
@@ -134,10 +134,10 @@
return 0;
if ((resdirptr = GetResDirEntryW(resdirptr, name, root, FALSE)) == NULL)
return 0;
- result = (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT32)lang, root, FALSE);
+ result = (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)(UINT)lang, root, FALSE);
/* Try LANG_NEUTRAL, too */
if(!result)
- return (HANDLE32)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
+ return (HANDLE)GetResDirEntryW(resdirptr, (LPCWSTR)0, root, TRUE);
return result;
}
@@ -145,18 +145,18 @@
/**********************************************************************
* PE_LoadResource32
*/
-HANDLE32 PE_LoadResource32( WINE_MODREF *wm, HANDLE32 hRsrc )
+HANDLE PE_LoadResource( WINE_MODREF *wm, HANDLE hRsrc )
{
if (!hRsrc || !wm || wm->type!=MODULE32_PE)
return 0;
- return (HANDLE32) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
+ return (HANDLE) (wm->module + ((PIMAGE_RESOURCE_DATA_ENTRY)hRsrc)->OffsetToData);
}
/**********************************************************************
* PE_SizeofResource32
*/
-DWORD PE_SizeofResource32( HINSTANCE32 hModule, HANDLE32 hRsrc )
+DWORD PE_SizeofResource( HINSTANCE hModule, HANDLE hRsrc )
{
/* we don't need hModule */
if (!hRsrc)
@@ -167,14 +167,14 @@
/**********************************************************************
* PE_EnumResourceTypes32A
*/
-BOOL32
-PE_EnumResourceTypes32A(HMODULE32 hmod,ENUMRESTYPEPROC32A lpfun,LONG lparam) {
+BOOL
+PE_EnumResourceTypesA(HMODULE hmod,ENUMRESTYPEPROCA lpfun,LONG lparam) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
- HANDLE32 heap = GetProcessHeap();
+ BOOL ret;
+ HANDLE heap = GetProcessHeap();
if (!pem || !pem->pe_resource)
return FALSE;
@@ -201,13 +201,13 @@
/**********************************************************************
* PE_EnumResourceTypes32W
*/
-BOOL32
-PE_EnumResourceTypes32W(HMODULE32 hmod,ENUMRESTYPEPROC32W lpfun,LONG lparam) {
+BOOL
+PE_EnumResourceTypesW(HMODULE hmod,ENUMRESTYPEPROCW lpfun,LONG lparam) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
+ BOOL ret;
if (!pem || !pem->pe_resource)
return FALSE;
@@ -232,16 +232,16 @@
/**********************************************************************
* PE_EnumResourceNames32A
*/
-BOOL32
-PE_EnumResourceNames32A(
- HMODULE32 hmod,LPCSTR type,ENUMRESNAMEPROC32A lpfun,LONG lparam
+BOOL
+PE_EnumResourceNamesA(
+ HMODULE hmod,LPCSTR type,ENUMRESNAMEPROCA lpfun,LONG lparam
) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
- HANDLE32 heap = GetProcessHeap();
+ BOOL ret;
+ HANDLE heap = GetProcessHeap();
LPWSTR typeW;
if (!pem || !pem->pe_resource)
@@ -276,15 +276,15 @@
/**********************************************************************
* PE_EnumResourceNames32W
*/
-BOOL32
-PE_EnumResourceNames32W(
- HMODULE32 hmod,LPCWSTR type,ENUMRESNAMEPROC32W lpfun,LONG lparam
+BOOL
+PE_EnumResourceNamesW(
+ HMODULE hmod,LPCWSTR type,ENUMRESNAMEPROCW lpfun,LONG lparam
) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
+ BOOL ret;
if (!pem || !pem->pe_resource)
return FALSE;
@@ -311,17 +311,17 @@
/**********************************************************************
* PE_EnumResourceNames32A
*/
-BOOL32
-PE_EnumResourceLanguages32A(
- HMODULE32 hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROC32A lpfun,
+BOOL
+PE_EnumResourceLanguagesA(
+ HMODULE hmod,LPCSTR name,LPCSTR type,ENUMRESLANGPROCA lpfun,
LONG lparam
) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
- HANDLE32 heap = GetProcessHeap();
+ BOOL ret;
+ HANDLE heap = GetProcessHeap();
LPWSTR nameW,typeW;
if (!pem || !pem->pe_resource)
@@ -360,16 +360,16 @@
/**********************************************************************
* PE_EnumResourceLanguages32W
*/
-BOOL32
-PE_EnumResourceLanguages32W(
- HMODULE32 hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROC32W lpfun,
+BOOL
+PE_EnumResourceLanguagesW(
+ HMODULE hmod,LPCWSTR name,LPCWSTR type,ENUMRESLANGPROCW lpfun,
LONG lparam
) {
PE_MODREF *pem = HMODULE32toPE_MODREF(hmod);
int i;
PIMAGE_RESOURCE_DIRECTORY resdir;
PIMAGE_RESOURCE_DIRECTORY_ENTRY et;
- BOOL32 ret;
+ BOOL ret;
if (!pem || !pem->pe_resource)
return FALSE;
diff --git a/loader/resource.c b/loader/resource.c
index 38b2dd7..55c0722 100644
--- a/loader/resource.c
+++ b/loader/resource.c
@@ -36,7 +36,7 @@
typedef struct _HRSRC_ELEM
{
- HANDLE32 hRsrc;
+ HANDLE hRsrc;
WORD type;
} HRSRC_ELEM;
@@ -50,7 +50,7 @@
/**********************************************************************
* MapHRsrc32To16
*/
-static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE32 hRsrc32, WORD type )
+static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE hRsrc32, WORD type )
{
HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
HRSRC_ELEM *newElem;
@@ -99,7 +99,7 @@
/**********************************************************************
* MapHRsrc16To32
*/
-static HANDLE32 MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
+static HANDLE MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
{
HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
if ( !map || !hRsrc16 || (int)hRsrc16 > map->nUsed ) return 0;
@@ -131,7 +131,7 @@
if ( pModule->module32 )
{
- HANDLE32 hRsrc32 = FindResource32A( pModule->module32, nameStr, typeStr );
+ HANDLE hRsrc32 = FindResourceA( pModule->module32, nameStr, typeStr );
return MapHRsrc32To16( pModule, hRsrc32, HIWORD(type)? 0 : type );
}
@@ -141,19 +141,19 @@
/**********************************************************************
* FindResource32A (KERNEL32.128)
*/
-HANDLE32 WINAPI FindResource32A( HMODULE32 hModule, LPCSTR name, LPCSTR type)
+HANDLE WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type)
{
- return FindResourceEx32A(hModule,type,name,WINE_LanguageId);
+ return FindResourceExA(hModule,type,name,WINE_LanguageId);
}
/**********************************************************************
* FindResourceEx32A (KERNEL32.129)
*/
-HANDLE32 WINAPI FindResourceEx32A( HMODULE32 hModule, LPCSTR type, LPCSTR name,
+HANDLE WINAPI FindResourceExA( HMODULE hModule, LPCSTR type, LPCSTR name,
WORD lang
) {
LPWSTR xname,xtype;
- HANDLE32 ret;
+ HANDLE ret;
if (HIWORD((DWORD)name))
xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
@@ -163,7 +163,7 @@
xtype = HEAP_strdupAtoW( GetProcessHeap(), 0, type);
else
xtype = (LPWSTR)type;
- ret = FindResourceEx32W( hModule, xtype, xname, lang );
+ ret = FindResourceExW( hModule, xtype, xname, lang );
if (HIWORD((DWORD)name)) HeapFree( GetProcessHeap(), 0, xname );
if (HIWORD((DWORD)type)) HeapFree( GetProcessHeap(), 0, xtype );
return ret;
@@ -173,23 +173,23 @@
/**********************************************************************
* FindResourceEx32W (KERNEL32.130)
*/
-HRSRC32 WINAPI FindResourceEx32W( HMODULE32 hModule, LPCWSTR type,
+HRSRC WINAPI FindResourceExW( HMODULE hModule, LPCWSTR type,
LPCWSTR name, WORD lang )
{
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
- HRSRC32 hrsrc;
+ HRSRC hrsrc;
TRACE(resource, "module=%08x(%s) type=%s name=%s\n",
hModule, wm->modname,
debugres_w (type),
debugres_w (name));
- if (!wm) return (HRSRC32)0;
+ if (!wm) return (HRSRC)0;
switch (wm->type)
{
case MODULE32_PE:
- hrsrc = PE_FindResourceEx32W(wm,name,type,lang);
+ hrsrc = PE_FindResourceExW(wm,name,type,lang);
break;
case MODULE32_ELF:
@@ -198,7 +198,7 @@
default:
ERR(module,"unknown module type %d\n",wm->type);
- return (HRSRC32)0;
+ return (HRSRC)0;
}
if ( !hrsrc )
@@ -212,9 +212,9 @@
/**********************************************************************
* FindResource32W (KERNEL32.131)
*/
-HRSRC32 WINAPI FindResource32W(HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type)
+HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
{
- return FindResourceEx32W(hModule,type,name,WINE_LanguageId);
+ return FindResourceExW(hModule,type,name,WINE_LanguageId);
}
/**********************************************************************
@@ -227,11 +227,11 @@
if ( pModule->module32 )
{
- HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+ HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
WORD type = MapHRsrc16ToType( pModule, hRsrc );
- HGLOBAL32 image = LoadResource32( pModule->module32, hRsrc32 );
- DWORD size = SizeofResource32( pModule->module32, hRsrc32 );
- LPVOID bits = LockResource32( image );
+ HGLOBAL image = LoadResource( pModule->module32, hRsrc32 );
+ DWORD size = SizeofResource( pModule->module32, hRsrc32 );
+ LPVOID bits = LockResource( image );
return NE_LoadPEResource( pModule, type, bits, size );
}
@@ -246,9 +246,9 @@
* RETURNS
* pointer into the mapped resource of the passed module
*/
-HGLOBAL32 WINAPI LoadResource32(
- HINSTANCE32 hModule, /* [in] module handle */
- HRSRC32 hRsrc ) /* [in] resource handle */
+HGLOBAL WINAPI LoadResource(
+ HINSTANCE hModule, /* [in] module handle */
+ HRSRC hRsrc ) /* [in] resource handle */
{
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
@@ -263,7 +263,7 @@
switch (wm->type)
{
case MODULE32_PE:
- return PE_LoadResource32(wm,hRsrc);
+ return PE_LoadResource(wm,hRsrc);
case MODULE32_ELF:
return LIBRES_LoadResource( hModule, hRsrc );
@@ -294,7 +294,7 @@
/**********************************************************************
* LockResource32 (KERNEL32.384)
*/
-LPVOID WINAPI LockResource32( HGLOBAL32 handle )
+LPVOID WINAPI LockResource( HGLOBAL handle )
{
return (LPVOID)handle;
}
@@ -305,7 +305,7 @@
*/
BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
{
- NE_MODULE *pModule = NE_GetPtr( FarGetOwner(handle) );
+ NE_MODULE *pModule = NE_GetPtr( FarGetOwner16(handle) );
if ( !pModule ) return handle;
if ( pModule->module32 )
@@ -317,7 +317,7 @@
/**********************************************************************
* FreeResource32 (KERNEL32.145)
*/
-BOOL32 WINAPI FreeResource32( HGLOBAL32 handle )
+BOOL WINAPI FreeResource( HGLOBAL handle )
{
/* no longer used in Win32 */
return TRUE;
@@ -333,8 +333,8 @@
if ( pModule->module32 )
{
- HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
- HFILE32 hFile32 = AccessResource32( pModule->module32, hRsrc32 );
+ HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+ HFILE hFile32 = AccessResource( pModule->module32, hRsrc32 );
return FILE_AllocDosHandle( hFile32 );
}
@@ -344,7 +344,7 @@
/**********************************************************************
* AccessResource32 (KERNEL32.64)
*/
-INT32 WINAPI AccessResource32( HMODULE32 hModule, HRSRC32 hRsrc )
+INT WINAPI AccessResource( HMODULE hModule, HRSRC hRsrc )
{
FIXME(resource,"(module=%08x res=%08x),not implemented\n", hModule, hRsrc);
return 0;
@@ -361,8 +361,8 @@
if ( pModule->module32 )
{
- HANDLE32 hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
- return SizeofResource32( hModule, hRsrc32 );
+ HANDLE hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
+ return SizeofResource( hModule, hRsrc32 );
}
return NE_SizeofResource( pModule, hRsrc );
@@ -371,7 +371,7 @@
/**********************************************************************
* SizeofResource32 (KERNEL32.522)
*/
-DWORD WINAPI SizeofResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
+DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
{
WINE_MODREF *wm = MODULE32_LookupHMODULE( hModule );
@@ -381,7 +381,7 @@
switch (wm->type)
{
case MODULE32_PE:
- return PE_SizeofResource32(hModule,hRsrc);
+ return PE_SizeofResource(hModule,hRsrc);
case MODULE32_ELF:
return LIBRES_SizeofResource( hModule, hRsrc );
@@ -426,10 +426,10 @@
* 04: WORD IDval
* 06: WORD pad (to DWORD boundary)
*/
-HACCEL32 WINAPI LoadAccelerators32W(HINSTANCE32 instance,LPCWSTR lpTableName)
+HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance,LPCWSTR lpTableName)
{
- HRSRC32 hRsrc;
- HACCEL32 hMem,hRetval=0;
+ HRSRC hRsrc;
+ HACCEL hMem,hRetval=0;
DWORD size;
if (HIWORD(lpTableName))
@@ -439,12 +439,12 @@
TRACE(accel, "%p 0x%04x\n",
(LPVOID)instance, LOWORD(lpTableName) );
- if (!(hRsrc = FindResource32W( instance, lpTableName, RT_ACCELERATOR32W )))
+ if (!(hRsrc = FindResourceW( instance, lpTableName, RT_ACCELERATORW )))
{
WARN(accel, "couldn't find accelerator table resource\n");
} else {
- hMem = LoadResource32( instance, hRsrc );
- size = SizeofResource32( instance, hRsrc );
+ hMem = LoadResource( instance, hRsrc );
+ size = SizeofResource( instance, hRsrc );
if(size>=sizeof(PE_ACCEL))
{
LPPE_ACCEL accel_table = (LPPE_ACCEL) hMem;
@@ -465,15 +465,15 @@
return hRetval;
}
-HACCEL32 WINAPI LoadAccelerators32A(HINSTANCE32 instance,LPCSTR lpTableName)
+HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
{
LPWSTR uni;
- HACCEL32 result;
+ HACCEL result;
if (HIWORD(lpTableName))
uni = HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName );
else
uni = (LPWSTR)lpTableName;
- result = LoadAccelerators32W(instance,uni);
+ result = LoadAcceleratorsW(instance,uni);
if (HIWORD(uni)) HeapFree( GetProcessHeap(), 0, uni);
return result;
}
@@ -481,9 +481,9 @@
/**********************************************************************
* CopyAcceleratorTable32A (USER32.58)
*/
-INT32 WINAPI CopyAcceleratorTable32A(HACCEL32 src, LPACCEL32 dst, INT32 entries)
+INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT entries)
{
- return CopyAcceleratorTable32W(src, dst, entries);
+ return CopyAcceleratorTableW(src, dst, entries);
}
/**********************************************************************
@@ -491,16 +491,16 @@
*
* By mortene@pvv.org 980321
*/
-INT32 WINAPI CopyAcceleratorTable32W(HACCEL32 src, LPACCEL32 dst,
- INT32 entries)
+INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst,
+ INT entries)
{
int i,xsize;
LPACCEL16 accel = (LPACCEL16)GlobalLock16(src);
- BOOL32 done = FALSE;
+ BOOL done = FALSE;
/* Do parameter checking to avoid the explosions and the screaming
as far as possible. */
- if((dst && (entries < 1)) || (src == (HACCEL32)NULL) || !accel) {
+ if((dst && (entries < 1)) || (src == (HACCEL)NULL) || !accel) {
WARN(accel, "Application sent invalid parameters (%p %p %d).\n",
(LPVOID)src, (LPVOID)dst, entries);
return 0;
@@ -545,9 +545,9 @@
*
* By mortene@pvv.org 980321
*/
-HACCEL32 WINAPI CreateAcceleratorTable32A(LPACCEL32 lpaccel, INT32 cEntries)
+HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT cEntries)
{
- HACCEL32 hAccel;
+ HACCEL hAccel;
LPACCEL16 accel;
int i;
@@ -557,7 +557,7 @@
WARN(accel, "Application sent invalid parameters (%p %d).\n",
lpaccel, cEntries);
SetLastError(ERROR_INVALID_PARAMETER);
- return (HACCEL32)NULL;
+ return (HACCEL)NULL;
}
FIXME(accel, "should check that the accelerator descriptions are valid,"
" return NULL and SetLastError() if not.\n");
@@ -570,7 +570,7 @@
if(!hAccel) {
ERR(accel, "Out of memory.\n");
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
- return (HACCEL32)NULL;
+ return (HACCEL)NULL;
}
accel = GlobalLock16(hAccel);
for (i=0;i<cEntries;i++) {
@@ -598,7 +598,7 @@
*
* RETURNS STD
*/
-BOOL32 WINAPI DestroyAcceleratorTable( HACCEL32 handle )
+BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
{
FIXME(accel, "(0x%x): stub\n", handle);
/* FIXME: GlobalFree16(handle); */
@@ -654,27 +654,27 @@
/**********************************************************************
* LoadString32W (USER32.376)
*/
-INT32 WINAPI LoadString32W( HINSTANCE32 instance, UINT32 resource_id,
- LPWSTR buffer, INT32 buflen )
+INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
+ LPWSTR buffer, INT buflen )
{
- HGLOBAL32 hmem;
- HRSRC32 hrsrc;
+ HGLOBAL hmem;
+ HRSRC hrsrc;
WCHAR *p;
int string_num;
int i;
if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
- resource_id = (UINT32)(-((INT32)resource_id));
+ resource_id = (UINT)(-((INT)resource_id));
TRACE(resource, "instance = %04x, id = %04x, buffer = %08x, "
"length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
- hrsrc = FindResource32W( instance, (LPCWSTR)((resource_id>>4)+1),
- RT_STRING32W );
+ hrsrc = FindResourceW( instance, (LPCWSTR)((resource_id>>4)+1),
+ RT_STRINGW );
if (!hrsrc) return 0;
- hmem = LoadResource32( instance, hrsrc );
+ hmem = LoadResource( instance, hrsrc );
if (!hmem) return 0;
- p = LockResource32(hmem);
+ p = LockResource(hmem);
string_num = resource_id & 0x000f;
for (i = 0; i < string_num; i++)
p += *p + 1;
@@ -704,20 +704,20 @@
/**********************************************************************
* LoadString32A (USER32.375)
*/
-INT32 WINAPI LoadString32A( HINSTANCE32 instance, UINT32 resource_id,
- LPSTR buffer, INT32 buflen )
+INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
+ LPSTR buffer, INT buflen )
{
- INT32 retval;
+ INT retval;
LPWSTR buffer2 = NULL;
if (buffer && buflen)
buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen * 2 );
- retval = LoadString32W(instance,resource_id,buffer2,buflen);
+ retval = LoadStringW(instance,resource_id,buffer2,buflen);
if (buffer2)
{
if (retval) {
lstrcpynWtoA( buffer, buffer2, buflen );
- retval = lstrlen32A( buffer );
+ retval = lstrlenA( buffer );
}
else
*buffer = 0;
@@ -751,11 +751,11 @@
/**********************************************************************
* LoadMessage32A (internal)
*/
-INT32 WINAPI LoadMessage32A( HMODULE32 instance, UINT32 id, WORD lang,
- LPSTR buffer, INT32 buflen )
+INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
+ LPSTR buffer, INT buflen )
{
- HGLOBAL32 hmem;
- HRSRC32 hrsrc;
+ HGLOBAL hmem;
+ HRSRC hrsrc;
BYTE *p;
int nrofentries,i,slen;
struct _subentry {
@@ -772,12 +772,12 @@
TRACE(resource, "instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
/*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
- hrsrc = FindResourceEx32W(instance,RT_MESSAGELIST32W,(LPWSTR)1,lang);
+ hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
if (!hrsrc) return 0;
- hmem = LoadResource32( instance, hrsrc );
+ hmem = LoadResource( instance, hrsrc );
if (!hmem) return 0;
- p = LockResource32(hmem);
+ p = LockResource(hmem);
nrofentries = *(DWORD*)p;
stre = NULL;
se = (struct _subentry*)(p+4);
@@ -802,7 +802,7 @@
if (buffer == NULL)
return slen; /* different to LoadString */
if (i>0) {
- lstrcpyn32A(buffer,stre->str,i);
+ lstrcpynA(buffer,stre->str,i);
buffer[i]=0;
} else {
if (buflen>1) {
@@ -818,19 +818,19 @@
/**********************************************************************
* LoadMessage32W (internal)
*/
-INT32 WINAPI LoadMessage32W( HMODULE32 instance, UINT32 id, WORD lang,
- LPWSTR buffer, INT32 buflen )
+INT WINAPI LoadMessageW( HMODULE instance, UINT id, WORD lang,
+ LPWSTR buffer, INT buflen )
{
- INT32 retval;
+ INT retval;
LPSTR buffer2 = NULL;
if (buffer && buflen)
buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
- retval = LoadMessage32A(instance,id,lang,buffer2,buflen);
+ retval = LoadMessageA(instance,id,lang,buffer2,buflen);
if (buffer)
{
if (retval) {
lstrcpynAtoW( buffer, buffer2, buflen );
- retval = lstrlen32W( buffer );
+ retval = lstrlenW( buffer );
}
HeapFree( GetProcessHeap(), 0, buffer2 );
}
@@ -841,59 +841,59 @@
/**********************************************************************
* EnumResourceTypesA (KERNEL32.90)
*/
-BOOL32 WINAPI EnumResourceTypes32A( HMODULE32 hmodule,ENUMRESTYPEPROC32A lpfun,
+BOOL WINAPI EnumResourceTypesA( HMODULE hmodule,ENUMRESTYPEPROCA lpfun,
LONG lParam)
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceTypes32A(hmodule,lpfun,lParam);
+ return PE_EnumResourceTypesA(hmodule,lpfun,lParam);
}
/**********************************************************************
* EnumResourceTypesW (KERNEL32.91)
*/
-BOOL32 WINAPI EnumResourceTypes32W( HMODULE32 hmodule,ENUMRESTYPEPROC32W lpfun,
+BOOL WINAPI EnumResourceTypesW( HMODULE hmodule,ENUMRESTYPEPROCW lpfun,
LONG lParam)
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceTypes32W(hmodule,lpfun,lParam);
+ return PE_EnumResourceTypesW(hmodule,lpfun,lParam);
}
/**********************************************************************
* EnumResourceNamesA (KERNEL32.88)
*/
-BOOL32 WINAPI EnumResourceNames32A( HMODULE32 hmodule, LPCSTR type,
- ENUMRESNAMEPROC32A lpfun, LONG lParam )
+BOOL WINAPI EnumResourceNamesA( HMODULE hmodule, LPCSTR type,
+ ENUMRESNAMEPROCA lpfun, LONG lParam )
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceNames32A(hmodule,type,lpfun,lParam);
+ return PE_EnumResourceNamesA(hmodule,type,lpfun,lParam);
}
/**********************************************************************
* EnumResourceNamesW (KERNEL32.89)
*/
-BOOL32 WINAPI EnumResourceNames32W( HMODULE32 hmodule, LPCWSTR type,
- ENUMRESNAMEPROC32W lpfun, LONG lParam )
+BOOL WINAPI EnumResourceNamesW( HMODULE hmodule, LPCWSTR type,
+ ENUMRESNAMEPROCW lpfun, LONG lParam )
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceNames32W(hmodule,type,lpfun,lParam);
+ return PE_EnumResourceNamesW(hmodule,type,lpfun,lParam);
}
/**********************************************************************
* EnumResourceLanguagesA (KERNEL32.86)
*/
-BOOL32 WINAPI EnumResourceLanguages32A( HMODULE32 hmodule, LPCSTR type,
- LPCSTR name, ENUMRESLANGPROC32A lpfun,
+BOOL WINAPI EnumResourceLanguagesA( HMODULE hmodule, LPCSTR type,
+ LPCSTR name, ENUMRESLANGPROCA lpfun,
LONG lParam)
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceLanguages32A(hmodule,type,name,lpfun,lParam);
+ return PE_EnumResourceLanguagesA(hmodule,type,name,lpfun,lParam);
}
/**********************************************************************
* EnumResourceLanguagesW (KERNEL32.87)
*/
-BOOL32 WINAPI EnumResourceLanguages32W( HMODULE32 hmodule, LPCWSTR type,
- LPCWSTR name, ENUMRESLANGPROC32W lpfun,
+BOOL WINAPI EnumResourceLanguagesW( HMODULE hmodule, LPCWSTR type,
+ LPCWSTR name, ENUMRESLANGPROCW lpfun,
LONG lParam)
{
/* FIXME: move WINE_MODREF stuff here */
- return PE_EnumResourceLanguages32W(hmodule,type,name,lpfun,lParam);
+ return PE_EnumResourceLanguagesW(hmodule,type,name,lpfun,lParam);
}
diff --git a/loader/signal.c b/loader/signal.c
index 8e4d863..2851fb0 100644
--- a/loader/signal.c
+++ b/loader/signal.c
@@ -41,7 +41,7 @@
void (*fnWINE_Debugger)(int,SIGCONTEXT*) = NULL;
void (*ctx_debug_call)(int sig,CONTEXT*ctx)=NULL;
-BOOL32 (*fnINSTR_EmulateInstruction)(SIGCONTEXT*ctx)=NULL;
+BOOL (*fnINSTR_EmulateInstruction)(SIGCONTEXT*ctx)=NULL;
#ifdef __i386__
@@ -191,7 +191,7 @@
/**********************************************************************
* SIGNAL_MaskAsyncEvents
*/
-void SIGNAL_MaskAsyncEvents( BOOL32 flag )
+void SIGNAL_MaskAsyncEvents( BOOL flag )
{
sigprocmask( (flag) ? SIG_BLOCK : SIG_UNBLOCK , &async_signal_set, NULL);
}
@@ -291,7 +291,7 @@
/**********************************************************************
* SIGNAL_Init
*/
-BOOL32 SIGNAL_Init(void)
+BOOL SIGNAL_Init(void)
{
#ifdef HAVE_WORKING_SIGALTSTACK
struct sigaltstack ss;
diff --git a/loader/task.c b/loader/task.c
index 84d90c9..6f90cd7 100644
--- a/loader/task.c
+++ b/loader/task.c
@@ -59,7 +59,7 @@
static void TASK_YieldToSystem(TDB*);
-extern BOOL32 THREAD_InitDone;
+extern BOOL THREAD_InitDone;
/***********************************************************************
@@ -197,7 +197,7 @@
*
* Free a MakeProcInstance() thunk.
*/
-static BOOL32 TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
+static BOOL TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
{
TDB *pTask;
THUNKS *pThunk;
@@ -260,7 +260,7 @@
AllocConsole();
if (pModule->heap_size)
- LocalInit( pTask->hInstance, 0, pModule->heap_size );
+ LocalInit16( pTask->hInstance, 0, pModule->heap_size );
MODULE_InitializeDLLs( 0, DLL_PROCESS_ATTACH, (LPVOID)-1 );
TRACE(relay, "(entryproc=%p)\n", entry );
@@ -278,7 +278,7 @@
while ( thdb->exit_code == 0x103 )
{
- WaitEvent( 0 );
+ WaitEvent16( 0 );
QUEUE_Signal( pTask->hSelf );
}
@@ -308,8 +308,8 @@
CONTEXT context;
memset( &context, 0, sizeof(context) );
- CS_reg(&context) = GlobalHandleToSel(pSegTable[pModule->cs - 1].hSeg);
- DS_reg(&context) = GlobalHandleToSel(pSegTable[pModule->dgroup - 1].hSeg);
+ CS_reg(&context) = GlobalHandleToSel16(pSegTable[pModule->cs - 1].hSeg);
+ DS_reg(&context) = GlobalHandleToSel16(pSegTable[pModule->dgroup - 1].hSeg);
ES_reg(&context) = pTask->hPDB;
EIP_reg(&context) = pModule->ip;
EBX_reg(&context) = pModule->stack_size;
@@ -347,7 +347,7 @@
char name[10];
STACK16FRAME *frame16;
STACK32FRAME *frame32;
- PDB32 *pdb32 = thdb->process;
+ PDB *pdb32 = thdb->process;
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
/* Allocate the task structure */
@@ -378,7 +378,7 @@
pTask->thdb = thdb;
pTask->curdrive = DRIVE_GetCurrentDrive() | 0x80;
strcpy( pTask->curdir, "\\" );
- lstrcpyn32A( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
+ lstrcpynA( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
sizeof(pTask->curdir) - 1 );
/* Create the thunks block */
@@ -387,12 +387,12 @@
/* Copy the module name */
- GetModuleName( pModule->self, name, sizeof(name) );
+ GetModuleName16( pModule->self, name, sizeof(name) );
strncpy( pTask->module_name, name, sizeof(pTask->module_name) );
/* Allocate a selector for the PDB */
- pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB),
+ pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB16),
pModule->self, FALSE, FALSE, FALSE, NULL );
/* Fill the PDB */
@@ -405,8 +405,8 @@
pTask->pdb.savedint23 = INT_GetPMHandler( 0x23 );
pTask->pdb.savedint24 = INT_GetPMHandler( 0x24 );
pTask->pdb.fileHandlesPtr =
- PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask->hPDB),
- (int)&((PDB *)0)->fileHandles );
+ PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel16(pTask->hPDB),
+ (int)&((PDB16 *)0)->fileHandles );
pTask->pdb.hFileHandles = 0;
memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
pTask->pdb.environment = pdb32->env_db->env_sel;
@@ -417,12 +417,12 @@
cmd_line = pdb32->env_db->cmd_line;
while (*cmd_line && (*cmd_line != ' ') && (*cmd_line != '\t')) cmd_line++;
while ((*cmd_line == ' ') || (*cmd_line == '\t')) cmd_line++;
- lstrcpyn32A( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
+ lstrcpynA( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
pTask->pdb.cmdLine[0] = strlen( pTask->pdb.cmdLine + 1 );
/* Get the compatibility flags */
- pTask->compat_flags = GetProfileInt32A( "Compatibility", name, 0 );
+ pTask->compat_flags = GetProfileIntA( "Compatibility", name, 0 );
/* Allocate a code segment alias for the TDB */
@@ -432,7 +432,7 @@
/* Set the owner of the environment block */
- FarSetOwner( pTask->pdb.environment, pTask->hPDB );
+ FarSetOwner16( pTask->pdb.environment, pTask->hPDB );
/* Default DTA overwrites command-line */
@@ -509,7 +509,7 @@
the main process somehow (NOT YET IMPLEMENTED!) */
if ( THREAD_IsWin16( THREAD_Current() ) )
- OldYield();
+ OldYield16();
else
/* wake-up the scheduler waiting in EVENT_WaitNetEvent */
EVENT_WakeUp();
@@ -550,7 +550,7 @@
/* Free all memory used by this task (including the 32-bit stack, */
/* the environment block and the thunk segments). */
- GlobalFreeAll( hPDB );
+ GlobalFreeAll16( hPDB );
}
@@ -657,12 +657,12 @@
*
* It must not call functions that may yield control.
*/
-BOOL32 TASK_Reschedule(void)
+BOOL TASK_Reschedule(void)
{
TDB *pOldTask = NULL, *pNewTask;
HTASK16 hTask = 0;
STACK16FRAME *newframe16;
- BOOL32 pending = FALSE;
+ BOOL pending = FALSE;
/* Get the initial task up and running */
if (!hCurrentTask && GetCurrentTask())
@@ -851,7 +851,7 @@
*
* Called by the application startup code.
*/
-void WINAPI InitTask( CONTEXT *context )
+void WINAPI InitTask16( CONTEXT *context )
{
TDB *pTask;
NE_MODULE *pModule;
@@ -901,7 +901,7 @@
/* Initialize the local heap */
if ( pModule->heap_size )
{
- LocalInit( pTask->hInstance, 0, pModule->heap_size );
+ LocalInit16( pTask->hInstance, 0, pModule->heap_size );
}
/* Initialize the INSTANCEDATA structure */
@@ -919,7 +919,7 @@
/***********************************************************************
* WaitEvent (KERNEL.30)
*/
-BOOL16 WINAPI WaitEvent( HTASK16 hTask )
+BOOL16 WINAPI WaitEvent16( HTASK16 hTask )
{
TDB *pTask;
@@ -949,7 +949,7 @@
/***********************************************************************
* PostEvent (KERNEL.31)
*/
-void WINAPI PostEvent( HTASK16 hTask )
+void WINAPI PostEvent16( HTASK16 hTask )
{
TDB *pTask;
@@ -969,7 +969,7 @@
/***********************************************************************
* SetPriority (KERNEL.32)
*/
-void WINAPI SetPriority( HTASK16 hTask, INT16 delta )
+void WINAPI SetPriority16( HTASK16 hTask, INT16 delta )
{
TDB *pTask;
INT16 newpriority;
@@ -990,7 +990,7 @@
/***********************************************************************
* LockCurrentTask (KERNEL.33)
*/
-HTASK16 WINAPI LockCurrentTask( BOOL16 bLock )
+HTASK16 WINAPI LockCurrentTask16( BOOL16 bLock )
{
if (bLock) hLockedTask = GetCurrentTask();
else hLockedTask = 0;
@@ -1001,7 +1001,7 @@
/***********************************************************************
* IsTaskLocked (KERNEL.122)
*/
-HTASK16 WINAPI IsTaskLocked(void)
+HTASK16 WINAPI IsTaskLocked16(void)
{
return hLockedTask;
}
@@ -1010,7 +1010,7 @@
/***********************************************************************
* OldYield (KERNEL.117)
*/
-void WINAPI OldYield(void)
+void WINAPI OldYield16(void)
{
TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
@@ -1029,7 +1029,7 @@
/***********************************************************************
* DirectedYield (KERNEL.150)
*/
-void WINAPI DirectedYield( HTASK16 hTask )
+void WINAPI DirectedYield16( HTASK16 hTask )
{
TDB *pCurTask = (TDB *)GlobalLock16( GetCurrentTask() );
@@ -1042,7 +1042,7 @@
TRACE(task, "%04x: DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
pCurTask->hYieldTo = hTask;
- OldYield();
+ OldYield16();
TRACE(task, "%04x: back from DirectedYield(%04x)\n", pCurTask->hSelf, hTask );
}
@@ -1061,8 +1061,8 @@
}
if (pCurTask) pCurTask->hYieldTo = 0;
- if (pCurTask && pCurTask->hQueue) Callout.UserYield();
- else OldYield();
+ if (pCurTask && pCurTask->hQueue) Callout.UserYield16();
+ else OldYield16();
}
/***********************************************************************
@@ -1126,7 +1126,7 @@
/**********************************************************************
* GetCodeHandle (KERNEL.93)
*/
-HANDLE16 WINAPI GetCodeHandle( FARPROC16 proc )
+HANDLE16 WINAPI GetCodeHandle16( FARPROC16 proc )
{
HANDLE16 handle;
BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
@@ -1146,7 +1146,7 @@
/**********************************************************************
* GetCodeInfo (KERNEL.104)
*/
-VOID WINAPI GetCodeInfo( FARPROC16 proc, SEGINFO *segInfo )
+VOID WINAPI GetCodeInfo16( FARPROC16 proc, SEGINFO *segInfo )
{
BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
NE_MODULE *pModule = NULL;
@@ -1165,7 +1165,7 @@
if ( pModule )
for ( segNr = 0; segNr < pModule->seg_count; segNr++, pSeg++ )
- if ( GlobalHandleToSel(pSeg->hSeg) == selector )
+ if ( GlobalHandleToSel16(pSeg->hSeg) == selector )
break;
if ( pModule && segNr >= pModule->seg_count )
@@ -1203,7 +1203,7 @@
/***********************************************************************
* SetTaskQueue (KERNEL.34)
*/
-HQUEUE16 WINAPI SetTaskQueue( HTASK16 hTask, HQUEUE16 hQueue )
+HQUEUE16 WINAPI SetTaskQueue16( HTASK16 hTask, HQUEUE16 hQueue )
{
HQUEUE16 hPrev;
TDB *pTask;
@@ -1223,7 +1223,7 @@
/***********************************************************************
* GetTaskQueue (KERNEL.35)
*/
-HQUEUE16 WINAPI GetTaskQueue( HTASK16 hTask )
+HQUEUE16 WINAPI GetTaskQueue16( HTASK16 hTask )
{
TDB *pTask;
@@ -1235,7 +1235,7 @@
/***********************************************************************
* SetThreadQueue (KERNEL.463)
*/
-HQUEUE16 WINAPI SetThreadQueue( DWORD thread, HQUEUE16 hQueue )
+HQUEUE16 WINAPI SetThreadQueue16( DWORD thread, HQUEUE16 hQueue )
{
THDB *thdb = thread? THREAD_IdToTHDB( thread ) : THREAD_Current();
HQUEUE16 oldQueue = thdb? thdb->teb.queue : 0;
@@ -1244,8 +1244,8 @@
{
thdb->teb.queue = hQueue;
- if ( GetTaskQueue( thdb->process->task ) == oldQueue )
- SetTaskQueue( thdb->process->task, hQueue );
+ if ( GetTaskQueue16( thdb->process->task ) == oldQueue )
+ SetTaskQueue16( thdb->process->task, hQueue );
}
return oldQueue;
@@ -1254,14 +1254,14 @@
/***********************************************************************
* GetThreadQueue (KERNEL.464)
*/
-HQUEUE16 WINAPI GetThreadQueue( DWORD thread )
+HQUEUE16 WINAPI GetThreadQueue16( DWORD thread )
{
THDB *thdb = NULL;
if ( !thread )
thdb = THREAD_Current();
else if ( HIWORD(thread) )
thdb = THREAD_IdToTHDB( thread );
- else if ( IsTask( (HTASK16)thread ) )
+ else if ( IsTask16( (HTASK16)thread ) )
thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
return (HQUEUE16)(thdb? thdb->teb.queue : 0);
@@ -1270,14 +1270,14 @@
/***********************************************************************
* SetFastQueue (KERNEL.624)
*/
-VOID WINAPI SetFastQueue( DWORD thread, HANDLE32 hQueue )
+VOID WINAPI SetFastQueue16( DWORD thread, HANDLE hQueue )
{
THDB *thdb = NULL;
if ( !thread )
thdb = THREAD_Current();
else if ( HIWORD(thread) )
thdb = THREAD_IdToTHDB( thread );
- else if ( IsTask( (HTASK16)thread ) )
+ else if ( IsTask16( (HTASK16)thread ) )
thdb = ((TDB *)GlobalLock16( (HANDLE16)thread ))->thdb;
if ( thdb ) thdb->teb.queue = (HQUEUE16) hQueue;
@@ -1286,24 +1286,24 @@
/***********************************************************************
* GetFastQueue (KERNEL.625)
*/
-HANDLE32 WINAPI GetFastQueue( void )
+HANDLE WINAPI GetFastQueue16( void )
{
THDB *thdb = THREAD_Current();
if (!thdb) return 0;
if (!thdb->teb.queue)
- Callout.InitThreadInput( 0, THREAD_IsWin16(thdb)? 4 : 5 );
+ Callout.InitThreadInput16( 0, THREAD_IsWin16(thdb)? 4 : 5 );
if (!thdb->teb.queue)
FIXME( task, "(): should initialize thread-local queue, expect failure!\n" );
- return (HANDLE32)thdb->teb.queue;
+ return (HANDLE)thdb->teb.queue;
}
/***********************************************************************
* SwitchStackTo (KERNEL.108)
*/
-void WINAPI SwitchStackTo( WORD seg, WORD ptr, WORD top )
+void WINAPI SwitchStackTo16( WORD seg, WORD ptr, WORD top )
{
TDB *pTask;
STACK16FRAME *oldFrame, *newFrame;
@@ -1348,7 +1348,7 @@
/***********************************************************************
* SwitchStackBack (KERNEL.109)
*/
-void WINAPI SwitchStackBack( CONTEXT *context )
+void WINAPI SwitchStackBack16( CONTEXT *context )
{
TDB *pTask;
STACK16FRAME *oldFrame, *newFrame;
@@ -1394,18 +1394,18 @@
/***********************************************************************
* GetTaskQueueDS (KERNEL.118)
*/
-void WINAPI GetTaskQueueDS( CONTEXT *context )
+void WINAPI GetTaskQueueDS16( CONTEXT *context )
{
- DS_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
+ DS_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
}
/***********************************************************************
* GetTaskQueueES (KERNEL.119)
*/
-void WINAPI GetTaskQueueES( CONTEXT *context )
+void WINAPI GetTaskQueueES16( CONTEXT *context )
{
- ES_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
+ ES_reg(context) = GlobalHandleToSel16( GetTaskQueue16(0) );
}
@@ -1430,7 +1430,7 @@
*
* UNDOC: returns PSP of KERNEL in high word
*/
-DWORD WINAPI GetCurrentPDB(void)
+DWORD WINAPI GetCurrentPDB16(void)
{
TDB *pTask;
@@ -1442,7 +1442,7 @@
/***********************************************************************
* GetInstanceData (KERNEL.54)
*/
-INT16 WINAPI GetInstanceData( HINSTANCE16 instance, WORD buffer, INT16 len )
+INT16 WINAPI GetInstanceData16( HINSTANCE16 instance, WORD buffer, INT16 len )
{
char *ptr = (char *)GlobalLock16( instance );
if (!ptr || !len) return 0;
@@ -1455,7 +1455,7 @@
/***********************************************************************
* GetExeVersion (KERNEL.105)
*/
-WORD WINAPI GetExeVersion(void)
+WORD WINAPI GetExeVersion16(void)
{
TDB *pTask;
@@ -1483,7 +1483,7 @@
/***********************************************************************
* SetErrorMode32 (KERNEL32.486)
*/
-UINT32 WINAPI SetErrorMode32( UINT32 mode )
+UINT WINAPI SetErrorMode( UINT mode )
{
return SetErrorMode16( (UINT16)mode );
}
@@ -1492,7 +1492,7 @@
/***********************************************************************
* GetDOSEnvironment (KERNEL.131)
*/
-SEGPTR WINAPI GetDOSEnvironment(void)
+SEGPTR WINAPI GetDOSEnvironment16(void)
{
TDB *pTask;
@@ -1504,7 +1504,7 @@
/***********************************************************************
* GetNumTasks (KERNEL.152)
*/
-UINT16 WINAPI GetNumTasks(void)
+UINT16 WINAPI GetNumTasks16(void)
{
return nTaskCount;
}
@@ -1516,7 +1516,7 @@
* Note: this function apparently returns a DWORD with LOWORD == HIWORD.
* I don't think we need to bother with this.
*/
-HINSTANCE16 WINAPI GetTaskDS(void)
+HINSTANCE16 WINAPI GetTaskDS16(void)
{
TDB *pTask;
@@ -1527,7 +1527,7 @@
/***********************************************************************
* GetDummyModuleHandleDS (KERNEL.602)
*/
-VOID WINAPI GetDummyModuleHandleDS( CONTEXT *context )
+VOID WINAPI GetDummyModuleHandleDS16( CONTEXT *context )
{
TDB *pTask;
WORD selector;
@@ -1536,7 +1536,7 @@
if (!(pTask = (TDB *)GlobalLock16( GetCurrentTask() ))) return;
if (!(pTask->flags & TDBF_WIN32)) return;
- selector = GlobalHandleToSel( pTask->hModule );
+ selector = GlobalHandleToSel16( pTask->hModule );
DS_reg( context ) = selector;
AX_reg( context ) = selector;
}
@@ -1544,7 +1544,7 @@
/***********************************************************************
* IsTask (KERNEL.320)
*/
-BOOL16 WINAPI IsTask( HTASK16 hTask )
+BOOL16 WINAPI IsTask16( HTASK16 hTask )
{
TDB *pTask;
@@ -1575,7 +1575,7 @@
/***********************************************************************
* SetSigHandler (KERNEL.140)
*/
-WORD WINAPI SetSigHandler( FARPROC16 newhandler, FARPROC16* oldhandler,
+WORD WINAPI SetSigHandler16( FARPROC16 newhandler, FARPROC16* oldhandler,
UINT16 *oldmode, UINT16 newmode, UINT16 flag )
{
FIXME(task,"(%p,%p,%p,%d,%d), unimplemented.\n",
@@ -1603,7 +1603,7 @@
* Note that GlobalNotify does _not_ return the old NotifyProc
* -- contrary to LocalNotify !!
*/
-VOID WINAPI GlobalNotify( FARPROC16 proc )
+VOID WINAPI GlobalNotify16( FARPROC16 proc )
{
TDB *pTask;
@@ -1640,7 +1640,7 @@
/* Check the owner for module handle */
- owner = FarGetOwner( handle );
+ owner = FarGetOwner16( handle );
if (!(ptr = GlobalLock16( owner ))) return 0;
if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return owner;
@@ -1682,17 +1682,17 @@
/***********************************************************************
* TaskFirst (TOOLHELP.63)
*/
-BOOL16 WINAPI TaskFirst( TASKENTRY *lpte )
+BOOL16 WINAPI TaskFirst16( TASKENTRY *lpte )
{
lpte->hNext = hFirstTask;
- return TaskNext( lpte );
+ return TaskNext16( lpte );
}
/***********************************************************************
* TaskNext (TOOLHELP.64)
*/
-BOOL16 WINAPI TaskNext( TASKENTRY *lpte )
+BOOL16 WINAPI TaskNext16( TASKENTRY *lpte )
{
TDB *pTask;
INSTANCEDATA *pInstData;
@@ -1724,10 +1724,10 @@
/***********************************************************************
* TaskFindHandle (TOOLHELP.65)
*/
-BOOL16 WINAPI TaskFindHandle( TASKENTRY *lpte, HTASK16 hTask )
+BOOL16 WINAPI TaskFindHandle16( TASKENTRY *lpte, HTASK16 hTask )
{
lpte->hNext = hTask;
- return TaskNext( lpte );
+ return TaskNext16( lpte );
}
@@ -1736,14 +1736,14 @@
*/
DWORD WINAPI GetAppCompatFlags16( HTASK16 hTask )
{
- return GetAppCompatFlags32( hTask );
+ return GetAppCompatFlags( hTask );
}
/***********************************************************************
* GetAppCompatFlags32 (USER32.206)
*/
-DWORD WINAPI GetAppCompatFlags32( HTASK32 hTask )
+DWORD WINAPI GetAppCompatFlags( HTASK hTask )
{
TDB *pTask;