Large-scale renaming of all Win32 functions and types to use the
standard Windows names.
diff --git a/if1632/thunk.c b/if1632/thunk.c
index ff1fbe9..d275ab0 100644
--- a/if1632/thunk.c
+++ b/if1632/thunk.c
@@ -30,8 +30,8 @@
/* by the build program to generate the file if1632/callto16.S */
/* ### start build ### */
-extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT32 offset);
-extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT32 offset);
+extern LONG CALLBACK CallTo16_sreg_(const CONTEXT *context, INT offset);
+extern LONG CALLBACK CallTo16_lreg_(const CONTEXT *context, INT offset);
extern WORD CALLBACK CallTo16_word_ (FARPROC16);
extern LONG CALLBACK CallTo16_long_ (FARPROC16);
extern WORD CALLBACK CallTo16_word_w (FARPROC16,WORD);
@@ -116,7 +116,7 @@
{
BYTE popl_eax; /* 0x58 popl %eax (return address)*/
BYTE pushl_func; /* 0x68 pushl $proc */
- FARPROC32 proc WINE_PACKED;
+ FARPROC proc WINE_PACKED;
BYTE pushl_eax; /* 0x50 pushl %eax */
BYTE jmp; /* 0xe9 jmp relay (relative jump)*/
RELAY relay WINE_PACKED;
@@ -126,7 +126,7 @@
#pragma pack(4)
#define DECL_THUNK(name,proc,relay) \
- THUNK name = { 0x58, 0x68, (FARPROC32)(proc), 0x50, 0xe9, \
+ THUNK name = { 0x58, 0x68, (FARPROC)(proc), 0x50, 0xe9, \
(RELAY)((char *)(relay) - (char *)(&(name).next)), NULL }
@@ -135,14 +135,14 @@
static LRESULT WINAPI THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
UINT16 msg, WPARAM16 wParam,
LPARAM lParam );
-static BOOL32 WINAPI THUNK_CallTaskReschedule(void);
-static BOOL32 WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
+static BOOL WINAPI THUNK_CallTaskReschedule(void);
+static BOOL WINAPI THUNK_WOWCallback16Ex( FARPROC16,DWORD,DWORD,
LPVOID,LPDWORD );
/* TASK_Reschedule() 16-bit entry point */
static FARPROC16 TASK_RescheduleProc;
-static BOOL32 THUNK_ThunkletInit( void );
+static BOOL THUNK_ThunkletInit( void );
extern void CallFrom16_p_long_wwwll(void);
@@ -182,7 +182,7 @@
/***********************************************************************
* THUNK_Init
*/
-BOOL32 THUNK_Init(void)
+BOOL THUNK_Init(void)
{
/* Set the window proc calling functions */
Callbacks = &CALLBACK_EmulatorTable;
@@ -195,7 +195,7 @@
/***********************************************************************
* THUNK_Alloc
*/
-static THUNK *THUNK_Alloc( FARPROC32 func, RELAY relay )
+static THUNK *THUNK_Alloc( FARPROC func, RELAY relay )
{
THUNK *thunk = HeapAlloc( GetProcessHeap(), 0, sizeof(*thunk) );
if (thunk)
@@ -216,7 +216,7 @@
/***********************************************************************
* THUNK_Find
*/
-static THUNK *THUNK_Find( FARPROC32 func )
+static THUNK *THUNK_Find( FARPROC func )
{
THUNK *thunk = firstThunk;
while (thunk && (thunk->proc != func)) thunk = thunk->next;
@@ -313,7 +313,7 @@
/***********************************************************************
* THUNK_CallTaskReschedule
*/
-static BOOL32 WINAPI THUNK_CallTaskReschedule(void)
+static BOOL WINAPI THUNK_CallTaskReschedule(void)
{
return CallTo16_word_(TASK_RescheduleProc);
}
@@ -450,7 +450,7 @@
*/
FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
{
- HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) );
+ HINSTANCE16 hInst = FarGetOwner16( HIWORD(proc) );
HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
if (!thunk) return 0;
@@ -514,11 +514,11 @@
thunk = THUNK_Alloc( proc, (RELAY)CallTo16_word_wwll );
if (!thunk) return FALSE;
}
- else thunk = (THUNK *)DCHook;
+ else thunk = (THUNK *)DCHook16;
/* Free the previous thunk */
GetDCHook( hdc, (FARPROC16 *)&oldThunk );
- if (oldThunk && (oldThunk != (THUNK *)DCHook)) THUNK_Free( oldThunk );
+ if (oldThunk && (oldThunk != (THUNK *)DCHook16)) THUNK_Free( oldThunk );
return SetDCHook( hdc, (FARPROC16)thunk, dwHookData );
}
@@ -533,7 +533,7 @@
DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
if (thunk)
{
- if (thunk == (THUNK *)DCHook)
+ if (thunk == (THUNK *)DCHook16)
{
if (!defDCHookProc) /* Get DCHook Win16 entry point */
defDCHookProc = NE_GetEntryPoint(GetModuleHandle16("USER"),362);
@@ -588,12 +588,12 @@
return CallTo16_long_l( start, param );
}
-HANDLE32 WINAPI THUNK_CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
+HANDLE WINAPI THUNK_CreateThread16( SECURITY_ATTRIBUTES *sa, DWORD stack,
FARPROC16 start, SEGPTR param,
DWORD flags, LPDWORD id )
{
DWORD *threadArgs = HeapAlloc( GetProcessHeap(), 0, 2*sizeof(DWORD) );
- if (!threadArgs) return INVALID_HANDLE_VALUE32;
+ if (!threadArgs) return INVALID_HANDLE_VALUE;
threadArgs[0] = (DWORD)start;
threadArgs[1] = (DWORD)param;
@@ -607,7 +607,7 @@
* RETURNS
* TRUE if the call was done
*/
-static BOOL32 WINAPI THUNK_WOWCallback16Ex(
+static BOOL WINAPI THUNK_WOWCallback16Ex(
FARPROC16 proc, /* [in] 16bit function to call */
DWORD dwFlags, /* [in] flags (WCB_*) */
DWORD cbArgs, /* [in] number of arguments */
@@ -744,7 +744,7 @@
/***********************************************************************
* GetMouseEventProc (USER.337)
*/
-FARPROC16 WINAPI GetMouseEventProc(void)
+FARPROC16 WINAPI GetMouseEventProc16(void)
{
HMODULE16 hmodule = GetModuleHandle16("USER");
return NE_GetEntryPoint( hmodule, NE_GetOrdinal( hmodule, "mouse_event" ));
@@ -859,26 +859,26 @@
*/
void THUNK_InitCallout(void)
{
- HMODULE32 hModule = GetModuleHandle32A( "USER32" );
+ HMODULE hModule = GetModuleHandleA( "USER32" );
if ( hModule )
{
#define GETADDR( var, name ) \
- *(FARPROC32 *)&Callout.##var = GetProcAddress32( hModule, name )
+ *(FARPROC *)&Callout.##var = GetProcAddress( hModule, name )
- GETADDR( PeekMessage32A, "PeekMessageA" );
- GETADDR( PeekMessage32W, "PeekMessageW" );
- GETADDR( GetMessage32A, "GetMessageA" );
- GETADDR( GetMessage32W, "GetMessageW" );
- GETADDR( SendMessage32A, "SendMessageA" );
- GETADDR( SendMessage32W, "SendMessageW" );
- GETADDR( PostMessage32A, "PostMessageA" );
- GETADDR( PostMessage32W, "PostMessageW" );
- GETADDR( PostThreadMessage32A, "PostThreadMessageA" );
- GETADDR( PostThreadMessage32W, "PostThreadMessageW" );
- GETADDR( TranslateMessage32, "TranslateMessage" );
- GETADDR( DispatchMessage32W, "DispatchMessageW" );
- GETADDR( DispatchMessage32A, "DispatchMessageA" );
- GETADDR( RedrawWindow32, "RedrawWindow" );
+ GETADDR( PeekMessageA, "PeekMessageA" );
+ GETADDR( PeekMessageW, "PeekMessageW" );
+ GETADDR( GetMessageA, "GetMessageA" );
+ GETADDR( GetMessageW, "GetMessageW" );
+ GETADDR( SendMessageA, "SendMessageA" );
+ GETADDR( SendMessageW, "SendMessageW" );
+ GETADDR( PostMessageA, "PostMessageA" );
+ GETADDR( PostMessageW, "PostMessageW" );
+ GETADDR( PostThreadMessageA, "PostThreadMessageA" );
+ GETADDR( PostThreadMessageW, "PostThreadMessageW" );
+ GETADDR( TranslateMessage, "TranslateMessage" );
+ GETADDR( DispatchMessageW, "DispatchMessageW" );
+ GETADDR( DispatchMessageA, "DispatchMessageA" );
+ GETADDR( RedrawWindow, "RedrawWindow" );
#undef GETADDR
}
@@ -887,7 +887,7 @@
if ( hModule )
{
#define GETADDR( var, name, thk ) \
- *(FARPROC32 *)&Callout.##var = (FARPROC32) \
+ *(FARPROC *)&Callout.##var = (FARPROC) \
THUNK_Alloc( WIN32_GetProcAddress16( hModule, name ), \
(RELAY)CallTo16_##thk )
@@ -899,8 +899,8 @@
GETADDR( TranslateMessage16, "TranslateMessage", word_l );
GETADDR( DispatchMessage16, "DispatchMessage", long_l );
GETADDR( RedrawWindow16, "RedrawWindow", word_wlww );
- GETADDR( InitThreadInput, "InitThreadInput", word_ww );
- GETADDR( UserYield, "UserYield", word_ );
+ GETADDR( InitThreadInput16, "InitThreadInput", word_ww );
+ GETADDR( UserYield16, "UserYield", word_ );
#undef GETADDR
}
@@ -914,7 +914,7 @@
* ThunkConnect16 (KERNEL.651)
* Connects a 32bit and a 16bit thunkbuffer.
*/
-UINT32 WINAPI ThunkConnect16(
+UINT WINAPI ThunkConnect16(
LPSTR module16, /* [in] name of win16 dll */
LPSTR module32, /* [in] name of win32 dll */
HINSTANCE16 hInst16, /* [in] hInst of win16 dll */
@@ -923,16 +923,16 @@
LPSTR thunkfun32, /* [in] win32 thunkfunction */
WORD cs /* [in] CS of win16 dll */
) {
- BOOL32 directionSL;
+ BOOL directionSL;
- if (!lstrncmp32A(TD->magic, "SL01", 4))
+ if (!lstrncmpA(TD->magic, "SL01", 4))
{
directionSL = TRUE;
TRACE(thunk, "SL01 thunk %s (%lx) -> %s (%s), Reason: %ld\n",
module16, (DWORD)TD, module32, thunkfun32, dwReason);
}
- else if (!lstrncmp32A(TD->magic, "LS01", 4))
+ else if (!lstrncmpA(TD->magic, "LS01", 4))
{
directionSL = FALSE;
@@ -965,8 +965,8 @@
SL->apiDB = PTR_SEG_TO_LIN(SL16->apiDatabase);
SL->targetDB = NULL;
- lstrcpyn32A(SL->pszDll16, module16, 255);
- lstrcpyn32A(SL->pszDll32, module32, 255);
+ lstrcpynA(SL->pszDll16, module16, 255);
+ lstrcpynA(SL->pszDll32, module32, 255);
/* We should create a SEGPTR to the ThunkDataSL,
but since the contents are not in the original format,
@@ -979,7 +979,7 @@
if (SL->flags2 & 0x80000000)
{
TRACE(thunk, "Preloading 32-bit library\n");
- LoadLibrary32A(module32);
+ LoadLibraryA(module32);
}
}
else
@@ -1110,7 +1110,7 @@
if (!tdb)
{
TRACE(thunk, "Loading 32-bit library %s\n", td->pszDll32);
- LoadLibrary32A(td->pszDll32);
+ LoadLibraryA(td->pszDll32);
for (tdb = td->targetDB; tdb; tdb = tdb->next)
if (tdb->process == PROCESS_Current())
@@ -1181,19 +1181,19 @@
#define THUNKLET_TYPE_LS 1
#define THUNKLET_TYPE_SL 2
-static HANDLE32 ThunkletHeap = 0;
+static HANDLE ThunkletHeap = 0;
static THUNKLET *ThunkletAnchor = NULL;
-static FARPROC32 ThunkletSysthunkGlueLS = 0;
+static FARPROC ThunkletSysthunkGlueLS = 0;
static SEGPTR ThunkletSysthunkGlueSL = 0;
-static FARPROC32 ThunkletCallbackGlueLS = 0;
+static FARPROC ThunkletCallbackGlueLS = 0;
static SEGPTR ThunkletCallbackGlueSL = 0;
/***********************************************************************
* THUNK_ThunkletInit
*/
-static BOOL32 THUNK_ThunkletInit( void )
+static BOOL THUNK_ThunkletInit( void )
{
LPBYTE thunk;
@@ -1203,7 +1203,7 @@
thunk = HeapAlloc( ThunkletHeap, 0, 5 );
if (!thunk) return FALSE;
- ThunkletSysthunkGlueLS = (FARPROC32)thunk;
+ ThunkletSysthunkGlueLS = (FARPROC)thunk;
*thunk++ = 0x58; /* popl eax */
*thunk++ = 0xC3; /* ret */
@@ -1217,7 +1217,7 @@
/***********************************************************************
* SetThunkletCallbackGlue (KERNEL.560)
*/
-void WINAPI SetThunkletCallbackGlue( FARPROC32 glueLS, SEGPTR glueSL )
+void WINAPI SetThunkletCallbackGlue16( FARPROC glueLS, SEGPTR glueSL )
{
ThunkletCallbackGlueLS = glueLS;
ThunkletCallbackGlueSL = glueSL;
@@ -1245,8 +1245,8 @@
/***********************************************************************
* THUNK_AllocLSThunklet
*/
-FARPROC32 THUNK_AllocLSThunklet( SEGPTR target, DWORD relay,
- FARPROC32 glue, HTASK16 owner )
+FARPROC THUNK_AllocLSThunklet( SEGPTR target, DWORD relay,
+ FARPROC glue, HTASK16 owner )
{
THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
THUNKLET_TYPE_LS );
@@ -1272,13 +1272,13 @@
ThunkletAnchor = thunk;
}
- return (FARPROC32)thunk;
+ return (FARPROC)thunk;
}
/***********************************************************************
* THUNK_AllocSLThunklet
*/
-SEGPTR THUNK_AllocSLThunklet( FARPROC32 target, DWORD relay,
+SEGPTR THUNK_AllocSLThunklet( FARPROC target, DWORD relay,
SEGPTR glue, HTASK16 owner )
{
THUNKLET *thunk = THUNK_FindThunklet( (DWORD)target, relay, (DWORD)glue,
@@ -1321,7 +1321,7 @@
/**********************************************************************
* IsSLThunklet (KERNEL.612)
*/
-BOOL16 WINAPI IsSLThunklet( THUNKLET *thunk )
+BOOL16 WINAPI IsSLThunklet16( THUNKLET *thunk )
{
return thunk->prefix_target == 0x66 && thunk->pushl_target == 0x68
&& thunk->prefix_relay == 0x66 && thunk->pushl_relay == 0x68
@@ -1333,8 +1333,8 @@
/***********************************************************************
* AllocLSThunkletSysthunk (KERNEL.607)
*/
-FARPROC32 WINAPI AllocLSThunkletSysthunk( SEGPTR target,
- FARPROC32 relay, DWORD dummy )
+FARPROC WINAPI AllocLSThunkletSysthunk16( SEGPTR target,
+ FARPROC relay, DWORD dummy )
{
return THUNK_AllocLSThunklet( (SEGPTR)relay, (DWORD)target,
ThunkletSysthunkGlueLS, GetCurrentTask() );
@@ -1343,10 +1343,10 @@
/***********************************************************************
* AllocSLThunkletSysthunk (KERNEL.608)
*/
-SEGPTR WINAPI AllocSLThunkletSysthunk( FARPROC32 target,
+SEGPTR WINAPI AllocSLThunkletSysthunk16( FARPROC target,
SEGPTR relay, DWORD dummy )
{
- return THUNK_AllocSLThunklet( (FARPROC32)relay, (DWORD)target,
+ return THUNK_AllocSLThunklet( (FARPROC)relay, (DWORD)target,
ThunkletSysthunkGlueSL, GetCurrentTask() );
}
@@ -1354,13 +1354,13 @@
/***********************************************************************
* AllocLSThunkletCallbackEx (KERNEL.567)
*/
-FARPROC32 WINAPI AllocLSThunkletCallbackEx( SEGPTR target,
+FARPROC WINAPI AllocLSThunkletCallbackEx16( SEGPTR target,
DWORD relay, HTASK16 task )
{
THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
- if ( IsSLThunklet( thunk ) && thunk->relay == relay
+ if ( IsSLThunklet16( thunk ) && thunk->relay == relay
&& thunk->glue == (DWORD)ThunkletCallbackGlueSL )
- return (FARPROC32)thunk->target;
+ return (FARPROC)thunk->target;
return THUNK_AllocLSThunklet( target, relay,
ThunkletCallbackGlueLS, task );
@@ -1369,7 +1369,7 @@
/***********************************************************************
* AllocSLThunkletCallbackEx (KERNEL.568)
*/
-SEGPTR WINAPI AllocSLThunkletCallbackEx( FARPROC32 target,
+SEGPTR WINAPI AllocSLThunkletCallbackEx16( FARPROC target,
DWORD relay, HTASK16 task )
{
THUNKLET *thunk = (THUNKLET *)target;
@@ -1384,39 +1384,39 @@
/***********************************************************************
* AllocLSThunkletCallback (KERNEL.561) (KERNEL.606)
*/
-FARPROC32 WINAPI AllocLSThunkletCallback( SEGPTR target, DWORD relay )
+FARPROC WINAPI AllocLSThunkletCallback16( SEGPTR target, DWORD relay )
{
- return AllocLSThunkletCallbackEx( target, relay, GetCurrentTask() );
+ return AllocLSThunkletCallbackEx16( target, relay, GetCurrentTask() );
}
/***********************************************************************
* AllocSLThunkletCallback (KERNEL.562) (KERNEL.605)
*/
-SEGPTR WINAPI AllocSLThunkletCallback( FARPROC32 target, DWORD relay )
+SEGPTR WINAPI AllocSLThunkletCallback16( FARPROC target, DWORD relay )
{
- return AllocSLThunkletCallbackEx( target, relay, GetCurrentTask() );
+ return AllocSLThunkletCallbackEx16( target, relay, GetCurrentTask() );
}
/***********************************************************************
* FindLSThunkletCallback (KERNEL.563) (KERNEL.609)
*/
-FARPROC32 WINAPI FindLSThunkletCallback( SEGPTR target, DWORD relay )
+FARPROC WINAPI FindLSThunkletCallback( SEGPTR target, DWORD relay )
{
THUNKLET *thunk = (THUNKLET *)PTR_SEG_TO_LIN( target );
- if ( thunk && IsSLThunklet( thunk ) && thunk->relay == relay
+ if ( thunk && IsSLThunklet16( thunk ) && thunk->relay == relay
&& thunk->glue == (DWORD)ThunkletCallbackGlueSL )
- return (FARPROC32)thunk->target;
+ return (FARPROC)thunk->target;
thunk = THUNK_FindThunklet( (DWORD)target, relay,
(DWORD)ThunkletCallbackGlueLS,
THUNKLET_TYPE_LS );
- return (FARPROC32)thunk;
+ return (FARPROC)thunk;
}
/***********************************************************************
* FindSLThunkletCallback (KERNEL.564) (KERNEL.610)
*/
-SEGPTR WINAPI FindSLThunkletCallback( FARPROC32 target, DWORD relay )
+SEGPTR WINAPI FindSLThunkletCallback( FARPROC target, DWORD relay )
{
THUNKLET *thunk = (THUNKLET *)target;
if ( thunk && IsLSThunklet( thunk ) && thunk->relay == relay
@@ -1439,13 +1439,13 @@
#define N_CBC_TOTAL (N_CBC_FIXED + N_CBC_VARIABLE)
static SEGPTR *CBClientRelay16[ N_CBC_TOTAL ];
-static FARPROC32 *CBClientRelay32[ N_CBC_TOTAL ];
+static FARPROC *CBClientRelay32[ N_CBC_TOTAL ];
/***********************************************************************
* RegisterCBClient (KERNEL.619)
*/
-INT16 WINAPI RegisterCBClient( INT16 wCBCId,
- SEGPTR *relay16, FARPROC32 *relay32 )
+INT16 WINAPI RegisterCBClient16( INT16 wCBCId,
+ SEGPTR *relay16, FARPROC *relay32 )
{
/* Search for free Callback ID */
if ( wCBCId == -1 )
@@ -1468,8 +1468,8 @@
/***********************************************************************
* UnRegisterCBClient (KERNEL.622)
*/
-INT16 WINAPI UnRegisterCBClient( INT16 wCBCId,
- SEGPTR *relay16, FARPROC32 *relay32 )
+INT16 WINAPI UnRegisterCBClient16( INT16 wCBCId,
+ SEGPTR *relay16, FARPROC *relay32 )
{
if ( wCBCId >= N_CBC_FIXED && wCBCId < N_CBC_TOTAL
&& CBClientRelay16[ wCBCId ] == relay16
@@ -1488,12 +1488,12 @@
/***********************************************************************
* InitCBClient (KERNEL.623)
*/
-void WINAPI InitCBClient( FARPROC32 glueLS )
+void WINAPI InitCBClient16( FARPROC glueLS )
{
HMODULE16 kernel = GetModuleHandle16( "KERNEL" );
SEGPTR glueSL = (SEGPTR)WIN32_GetProcAddress16( kernel, (LPCSTR)604 );
- SetThunkletCallbackGlue( glueLS, glueSL );
+ SetThunkletCallbackGlue16( glueLS, glueSL );
}
/***********************************************************************
@@ -1527,10 +1527,10 @@
void WINAPI CBClientThunkSL( CONTEXT *context )
{
/* Call 32-bit relay code */
- extern DWORD WINAPI CALL32_CBClient( FARPROC32 proc, LPWORD args );
+ extern DWORD WINAPI CALL32_CBClient( FARPROC proc, LPWORD args );
LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), BP_reg( context ) );
- FARPROC32 proc = CBClientRelay32[ args[2] ][ args[1] ];
+ FARPROC proc = CBClientRelay32[ args[2] ][ args[1] ];
EAX_reg(context) = CALL32_CBClient( proc, args );
}
@@ -1541,12 +1541,12 @@
void WINAPI CBClientThunkSLEx( CONTEXT *context )
{
/* Call 32-bit relay code */
- extern DWORD WINAPI CALL32_CBClientEx( FARPROC32 proc,
- LPWORD args, INT32 *nArgs );
+ extern DWORD WINAPI CALL32_CBClientEx( FARPROC proc,
+ LPWORD args, INT *nArgs );
LPWORD args = PTR_SEG_OFF_TO_LIN( SS_reg( context ), BP_reg( context ) );
- FARPROC32 proc = CBClientRelay32[ args[2] ][ args[1] ];
- INT32 nArgs;
+ FARPROC proc = CBClientRelay32[ args[2] ][ args[1] ];
+ INT nArgs;
LPWORD stackLin;
EAX_reg(context) = CALL32_CBClientEx( proc, args, &nArgs );
