Large-scale renaming of all Win32 functions and types to use the
standard Windows names.
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;
