4 * Copyright 1995 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
39 #include "wine/winbase16.h"
42 #include "wine/server.h"
43 #include "stackframe.h"
46 #include "kernel_private.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(task
);
51 WINE_DECLARE_DEBUG_CHANNEL(relay
);
52 WINE_DECLARE_DEBUG_CHANNEL(toolhelp
);
56 /* Segment containing MakeProcInstance() thunks */
59 WORD next
; /* Selector of next segment */
60 WORD magic
; /* Thunks signature */
62 WORD free
; /* Head of the free list */
63 WORD thunks
[4]; /* Each thunk is 4 words long */
68 #define THUNK_MAGIC ('P' | ('T' << 8))
70 /* Min. number of thunks allocated when creating a new segment */
73 #define TDB_MAGIC ('T' | ('D' << 8))
75 static THHOOK DefaultThhook
;
76 THHOOK
*pThhook
= &DefaultThhook
;
78 #define hFirstTask (pThhook->HeadTDB)
79 #define hLockedTask (pThhook->LockTDB)
81 static UINT16 nTaskCount
= 0;
83 static HTASK16 initial_task
;
85 /***********************************************************************
88 void TASK_InstallTHHook( THHOOK
*pNewThhook
)
90 THHOOK
*pOldThhook
= pThhook
;
92 pThhook
= pNewThhook
? pNewThhook
: &DefaultThhook
;
94 *pThhook
= *pOldThhook
;
97 /***********************************************************************
100 static TDB
*TASK_GetPtr( HTASK16 hTask
)
102 return GlobalLock16( hTask
);
106 /***********************************************************************
109 TDB
*TASK_GetCurrent(void)
111 return TASK_GetPtr( GetCurrentTask() );
115 /***********************************************************************
118 static void TASK_LinkTask( HTASK16 hTask
)
123 if (!(pTask
= TASK_GetPtr( hTask
))) return;
124 prevTask
= &hFirstTask
;
127 TDB
*prevTaskPtr
= TASK_GetPtr( *prevTask
);
128 if (prevTaskPtr
->priority
>= pTask
->priority
) break;
129 prevTask
= &prevTaskPtr
->hNext
;
131 pTask
->hNext
= *prevTask
;
137 /***********************************************************************
140 static void TASK_UnlinkTask( HTASK16 hTask
)
145 prevTask
= &hFirstTask
;
146 while (*prevTask
&& (*prevTask
!= hTask
))
148 pTask
= TASK_GetPtr( *prevTask
);
149 prevTask
= &pTask
->hNext
;
153 pTask
= TASK_GetPtr( *prevTask
);
154 *prevTask
= pTask
->hNext
;
161 /***********************************************************************
164 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
165 * and containing 'count' entries.
167 static void TASK_CreateThunks( HGLOBAL16 handle
, WORD offset
, WORD count
)
173 pThunk
= (THUNKS
*)((BYTE
*)GlobalLock16( handle
) + offset
);
175 pThunk
->magic
= THUNK_MAGIC
;
176 pThunk
->free
= (int)&pThunk
->thunks
- (int)pThunk
;
178 for (i
= 0; i
< count
-1; i
++)
180 free
+= 8; /* Offset of next thunk */
181 pThunk
->thunks
[4*i
] = free
;
183 pThunk
->thunks
[4*i
] = 0; /* Last thunk */
187 /***********************************************************************
190 * Allocate a thunk for MakeProcInstance().
192 static SEGPTR
TASK_AllocThunk(void)
198 if (!(pTask
= TASK_GetCurrent())) return 0;
199 sel
= pTask
->hCSAlias
;
200 pThunk
= (THUNKS
*)&pTask
->thunks
;
201 base
= (char *)pThunk
- (char *)pTask
;
202 while (!pThunk
->free
)
205 if (!sel
) /* Allocate a new segment */
207 sel
= GLOBAL_Alloc( GMEM_FIXED
, sizeof(THUNKS
) + (MIN_THUNKS
-1)*8,
208 pTask
->hPDB
, WINE_LDT_FLAGS_CODE
);
209 if (!sel
) return (SEGPTR
)0;
210 TASK_CreateThunks( sel
, 0, MIN_THUNKS
);
213 pThunk
= (THUNKS
*)GlobalLock16( sel
);
216 base
+= pThunk
->free
;
217 pThunk
->free
= *(WORD
*)((BYTE
*)pThunk
+ pThunk
->free
);
218 return MAKESEGPTR( sel
, base
);
222 /***********************************************************************
225 * Free a MakeProcInstance() thunk.
227 static BOOL
TASK_FreeThunk( SEGPTR thunk
)
233 if (!(pTask
= TASK_GetCurrent())) return 0;
234 sel
= pTask
->hCSAlias
;
235 pThunk
= (THUNKS
*)&pTask
->thunks
;
236 base
= (char *)pThunk
- (char *)pTask
;
237 while (sel
&& (sel
!= HIWORD(thunk
)))
240 pThunk
= (THUNKS
*)GlobalLock16( sel
);
243 if (!sel
) return FALSE
;
244 *(WORD
*)((BYTE
*)pThunk
+ LOWORD(thunk
) - base
) = pThunk
->free
;
245 pThunk
->free
= LOWORD(thunk
) - base
;
250 /***********************************************************************
253 * NOTE: This routine might be called by a Win32 thread. Thus, we need
254 * to be careful to protect global data structures. We do this
255 * by entering the Win16Lock while linking the task into the
258 static TDB
*TASK_Create( NE_MODULE
*pModule
, UINT16 cmdShow
, LPCSTR cmdline
, BYTE len
)
263 char curdir
[MAX_PATH
];
264 HMODULE16 hModule
= pModule
? pModule
->self
: 0;
266 /* Allocate the task structure */
268 hTask
= GlobalAlloc16( GMEM_FIXED
| GMEM_ZEROINIT
, sizeof(TDB
) );
269 if (!hTask
) return NULL
;
270 pTask
= TASK_GetPtr( hTask
);
271 FarSetOwner16( hTask
, hModule
);
273 /* Fill the task structure */
275 pTask
->hSelf
= hTask
;
277 pTask
->version
= pModule
? pModule
->expected_version
: 0x0400;
278 pTask
->hModule
= hModule
;
279 pTask
->hParent
= GetCurrentTask();
280 pTask
->magic
= TDB_MAGIC
;
281 pTask
->nCmdShow
= cmdShow
;
283 GetCurrentDirectoryA( sizeof(curdir
), curdir
);
284 GetShortPathNameA( curdir
, curdir
, sizeof(curdir
) );
285 pTask
->curdrive
= (curdir
[0] - 'A') | 0x80;
286 lstrcpynA( pTask
->curdir
, curdir
+ 2, sizeof(pTask
->curdir
) );
288 /* Create the thunks block */
290 TASK_CreateThunks( hTask
, (char *)&pTask
->thunks
- (char *)pTask
, 7 );
292 /* Copy the module name */
297 GetModuleName16( hModule
, name
, sizeof(name
) );
298 strncpy( pTask
->module_name
, name
, sizeof(pTask
->module_name
) );
299 pTask
->compat_flags
= GetProfileIntA( "Compatibility", name
, 0 );
302 /* Allocate a selector for the PDB */
304 pTask
->hPDB
= GLOBAL_CreateBlock( GMEM_FIXED
, &pTask
->pdb
, sizeof(PDB16
),
305 hModule
, WINE_LDT_FLAGS_DATA
);
309 pTask
->pdb
.int20
= 0x20cd;
310 pTask
->pdb
.dispatcher
[0] = 0x9a; /* ljmp */
311 proc
= GetProcAddress16( GetModuleHandle16("KERNEL"), "DOS3Call" );
312 memcpy( &pTask
->pdb
.dispatcher
[1], &proc
, sizeof(proc
) );
313 pTask
->pdb
.savedint22
= 0;
314 pTask
->pdb
.savedint23
= 0;
315 pTask
->pdb
.savedint24
= 0;
316 pTask
->pdb
.fileHandlesPtr
=
317 MAKESEGPTR( GlobalHandleToSel16(pTask
->hPDB
), (int)&((PDB16
*)0)->fileHandles
);
318 pTask
->pdb
.hFileHandles
= 0;
319 memset( pTask
->pdb
.fileHandles
, 0xff, sizeof(pTask
->pdb
.fileHandles
) );
320 /* FIXME: should we make a copy of the environment? */
321 pTask
->pdb
.environment
= SELECTOROF(GetDOSEnvironment16());
322 pTask
->pdb
.nbFiles
= 20;
324 /* Fill the command line */
328 cmdline
= GetCommandLineA();
329 /* remove the first word (program name) */
331 if (!(cmdline
= strchr( cmdline
+1, '"' ))) cmdline
= GetCommandLineA();
332 while (*cmdline
&& (*cmdline
!= ' ') && (*cmdline
!= '\t')) cmdline
++;
333 while ((*cmdline
== ' ') || (*cmdline
== '\t')) cmdline
++;
334 len
= strlen(cmdline
);
336 if (len
>= sizeof(pTask
->pdb
.cmdLine
)) len
= sizeof(pTask
->pdb
.cmdLine
)-1;
337 pTask
->pdb
.cmdLine
[0] = len
;
338 memcpy( pTask
->pdb
.cmdLine
+ 1, cmdline
, len
);
339 /* pTask->pdb.cmdLine[len+1] = 0; */
341 TRACE("cmdline='%.*s' task=%04x\n", len
, cmdline
, hTask
);
343 /* Allocate a code segment alias for the TDB */
345 pTask
->hCSAlias
= GLOBAL_CreateBlock( GMEM_FIXED
, (void *)pTask
,
346 sizeof(TDB
), pTask
->hPDB
, WINE_LDT_FLAGS_CODE
);
348 /* Default DTA overwrites command line */
350 pTask
->dta
= MAKESEGPTR( pTask
->hPDB
, (int)&pTask
->pdb
.cmdLine
- (int)&pTask
->pdb
);
352 /* Create scheduler event for 16-bit tasks */
354 if ( !(pTask
->flags
& TDBF_WIN32
) )
355 NtCreateEvent( &pTask
->hEvent
, EVENT_ALL_ACCESS
, NULL
, TRUE
, FALSE
);
357 if (!initial_task
) initial_task
= hTask
;
363 /***********************************************************************
366 static void TASK_DeleteTask( HTASK16 hTask
)
371 if (!(pTask
= TASK_GetPtr( hTask
))) return;
374 pTask
->magic
= 0xdead; /* invalidate signature */
376 /* Free the selector aliases */
378 GLOBAL_FreeBlock( pTask
->hCSAlias
);
379 GLOBAL_FreeBlock( pTask
->hPDB
);
381 /* Free the task module */
383 FreeModule16( pTask
->hModule
);
385 /* Free the task structure itself */
387 GlobalFree16( hTask
);
389 /* Free all memory used by this task (including the 32-bit stack, */
390 /* the environment block and the thunk segments). */
392 GlobalFreeAll16( hPDB
);
396 /***********************************************************************
397 * TASK_CreateMainTask
399 * Create a task for the main (32-bit) process.
401 void TASK_CreateMainTask(void)
404 STARTUPINFOA startup_info
;
405 UINT cmdShow
= 1; /* SW_SHOWNORMAL but we don't want to include winuser.h here */
407 GetStartupInfoA( &startup_info
);
408 if (startup_info
.dwFlags
& STARTF_USESHOWWINDOW
) cmdShow
= startup_info
.wShowWindow
;
409 pTask
= TASK_Create( NULL
, cmdShow
, NULL
, 0 );
412 ERR("could not create task for main process\n");
416 pTask
->flags
|= TDBF_WIN32
;
417 pTask
->hInstance
= 0;
418 pTask
->hPrevInstance
= 0;
419 pTask
->teb
= NtCurrentTeb();
421 NtCurrentTeb()->htask16
= pTask
->hSelf
;
423 /* Add the task to the linked list */
424 /* (no need to get the win16 lock, we are the only thread at this point) */
425 TASK_LinkTask( pTask
->hSelf
);
429 /* allocate the win16 TIB for a new 16-bit task */
430 static WIN16_SUBSYSTEM_TIB
*allocate_win16_tib( TDB
*pTask
)
432 WCHAR path
[MAX_PATH
];
433 WIN16_SUBSYSTEM_TIB
*tib
;
434 UNICODE_STRING
*curdir
;
435 NE_MODULE
*pModule
= NE_GetPtr( pTask
->hModule
);
437 if (!(tib
= HeapAlloc( GetProcessHeap(), 0, sizeof(*tib
) ))) return NULL
;
438 MultiByteToWideChar( CP_ACP
, 0, NE_MODULE_NAME(pModule
), -1, path
, MAX_PATH
);
439 GetLongPathNameW( path
, path
, MAX_PATH
);
440 if (RtlCreateUnicodeString( &tib
->exe_str
, path
)) tib
->exe_name
= &tib
->exe_str
;
441 else tib
->exe_name
= NULL
;
444 curdir
= &NtCurrentTeb()->Peb
->ProcessParameters
->CurrentDirectory
.DosPath
;
445 tib
->curdir
.DosPath
.MaximumLength
= sizeof(tib
->curdir_buffer
);
446 tib
->curdir
.DosPath
.Length
= min( curdir
->Length
, tib
->curdir
.DosPath
.MaximumLength
-sizeof(WCHAR
) );
447 tib
->curdir
.DosPath
.Buffer
= tib
->curdir_buffer
;
448 tib
->curdir
.Handle
= 0;
449 memcpy( tib
->curdir_buffer
, curdir
->Buffer
, tib
->curdir
.DosPath
.Length
);
450 tib
->curdir_buffer
[tib
->curdir
.DosPath
.Length
/sizeof(WCHAR
)] = 0;
455 /* startup routine for a new 16-bit thread */
456 static DWORD CALLBACK
task_start( LPVOID p
)
458 TDB
*pTask
= (TDB
*)p
;
461 NtCurrentTeb()->htask16
= pTask
->hSelf
;
462 NtCurrentTeb()->Tib
.SubSystemTib
= allocate_win16_tib( pTask
);
465 TASK_LinkTask( pTask
->hSelf
);
466 pTask
->teb
= NtCurrentTeb();
467 ret
= NE_StartTask();
473 /***********************************************************************
476 * Spawn a new 16-bit task.
478 HTASK16
TASK_SpawnTask( NE_MODULE
*pModule
, WORD cmdShow
,
479 LPCSTR cmdline
, BYTE len
, HANDLE
*hThread
)
483 if (!(pTask
= TASK_Create( pModule
, cmdShow
, cmdline
, len
))) return 0;
484 if (!(*hThread
= CreateThread( NULL
, 0, task_start
, pTask
, 0, NULL
)))
486 TASK_DeleteTask( pTask
->hSelf
);
493 /***********************************************************************
494 * TASK_GetTaskFromThread
496 HTASK16
TASK_GetTaskFromThread( DWORD thread
)
498 TDB
*p
= TASK_GetPtr( hFirstTask
);
501 if (p
->teb
->ClientId
.UniqueThread
== (HANDLE
)thread
) return p
->hSelf
;
502 p
= TASK_GetPtr( p
->hNext
);
508 /***********************************************************************
509 * TASK_CallTaskSignalProc
511 static void TASK_CallTaskSignalProc( UINT16 uCode
, HANDLE16 hTaskOrModule
)
514 TDB
*pTask
= TASK_GetCurrent();
516 if ( !pTask
|| !pTask
->userhandler
) return;
518 args
[4] = hTaskOrModule
;
521 args
[1] = pTask
->hInstance
;
522 args
[0] = pTask
->hQueue
;
523 WOWCallback16Ex( (DWORD
)pTask
->userhandler
, WCB16_PASCAL
, sizeof(args
), args
, NULL
);
527 /***********************************************************************
530 void TASK_ExitTask(void)
532 WIN16_SUBSYSTEM_TIB
*tib
;
536 /* Enter the Win16Lock to protect global data structures */
539 pTask
= TASK_GetCurrent();
546 TRACE("Killing task %04x\n", pTask
->hSelf
);
548 /* Perform USER cleanup */
550 TASK_CallTaskSignalProc( USIG16_TERMINATION
, pTask
->hSelf
);
552 /* Remove the task from the list to be sure we never switch back to it */
553 TASK_UnlinkTask( pTask
->hSelf
);
555 if (!nTaskCount
|| (nTaskCount
== 1 && hFirstTask
== initial_task
))
557 TRACE("this is the last task, exiting\n" );
563 if ( hLockedTask
== pTask
->hSelf
)
566 TASK_DeleteTask( pTask
->hSelf
);
568 if ((tib
= NtCurrentTeb()->Tib
.SubSystemTib
))
570 if (tib
->exe_name
) RtlFreeUnicodeString( tib
->exe_name
);
571 HeapFree( GetProcessHeap(), 0, tib
);
572 NtCurrentTeb()->Tib
.SubSystemTib
= NULL
;
575 /* ... and completely release the Win16Lock, just in case. */
576 ReleaseThunkLock( &lockCount
);
580 /***********************************************************************
581 * ExitKernel (KERNEL.2)
583 * Clean-up everything and exit the Wine process.
585 void WINAPI
ExitKernel16(void)
587 WriteOutProfiles16();
588 TerminateProcess( GetCurrentProcess(), 0 );
592 /***********************************************************************
593 * InitTask (KERNEL.91)
595 * Called by the application startup code.
597 void WINAPI
InitTask16( CONTEXT86
*context
)
600 INSTANCEDATA
*pinstance
;
604 if (!(pTask
= TASK_GetCurrent())) return;
606 /* Note: we need to trust that BX/CX contain the stack/heap sizes,
607 as some apps, notably Visual Basic apps, *modify* the heap/stack
608 size of the instance data segment before calling InitTask() */
610 /* Initialize the INSTANCEDATA structure */
611 pinstance
= MapSL( MAKESEGPTR(CURRENT_DS
, 0) );
612 pinstance
->stackmin
= OFFSETOF( NtCurrentTeb()->cur_stack
) + sizeof( STACK16FRAME
);
613 pinstance
->stackbottom
= pinstance
->stackmin
; /* yup, that's right. Confused me too. */
614 pinstance
->stacktop
= ( pinstance
->stackmin
> LOWORD(context
->Ebx
) ?
615 pinstance
->stackmin
- LOWORD(context
->Ebx
) : 0 ) + 150;
617 /* Initialize the local heap */
618 if (LOWORD(context
->Ecx
))
619 LocalInit16( GlobalHandleToSel16(pTask
->hInstance
), 0, LOWORD(context
->Ecx
) );
621 /* Initialize implicitly loaded DLLs */
622 NE_InitializeDLLs( pTask
->hModule
);
623 NE_DllProcessAttach( pTask
->hModule
);
625 /* Registers on return are:
626 * ax 1 if OK, 0 on error
627 * cx stack limit in bytes
628 * dx cmdShow parameter
629 * si instance handle of the previous instance
630 * di instance handle of the new task
631 * es:bx pointer to command line inside PSP
633 * 0 (=%bp) is pushed on the stack
635 ptr
= stack16_push( sizeof(WORD
) );
636 *(WORD
*)MapSL(ptr
) = 0;
641 if (!pTask
->pdb
.cmdLine
[0]) context
->Ebx
= 0x80;
644 LPBYTE p
= &pTask
->pdb
.cmdLine
[1];
645 while ((*p
== ' ') || (*p
== '\t')) p
++;
646 context
->Ebx
= 0x80 + (p
- pTask
->pdb
.cmdLine
);
648 context
->Ecx
= pinstance
->stacktop
;
649 context
->Edx
= pTask
->nCmdShow
;
650 context
->Esi
= (DWORD
)pTask
->hPrevInstance
;
651 context
->Edi
= (DWORD
)pTask
->hInstance
;
652 context
->SegEs
= (WORD
)pTask
->hPDB
;
656 /***********************************************************************
657 * WaitEvent (KERNEL.30)
659 BOOL16 WINAPI
WaitEvent16( HTASK16 hTask
)
663 if (!hTask
) hTask
= GetCurrentTask();
664 pTask
= TASK_GetPtr( hTask
);
666 if (pTask
->flags
& TDBF_WIN32
)
668 FIXME("called for Win32 thread (%04lx)!\n", GetCurrentThreadId());
672 if (pTask
->nEvents
> 0)
678 if (pTask
->teb
== NtCurrentTeb())
682 NtResetEvent( pTask
->hEvent
, NULL
);
683 ReleaseThunkLock( &lockCount
);
684 SYSLEVEL_CheckNotLevel( 1 );
685 WaitForSingleObject( pTask
->hEvent
, INFINITE
);
686 RestoreThunkLock( lockCount
);
687 if (pTask
->nEvents
> 0) pTask
->nEvents
--;
689 else FIXME("for other task %04x cur=%04x\n",pTask
->hSelf
,GetCurrentTask());
695 /***********************************************************************
696 * PostEvent (KERNEL.31)
698 void WINAPI
PostEvent16( HTASK16 hTask
)
702 if (!hTask
) hTask
= GetCurrentTask();
703 if (!(pTask
= TASK_GetPtr( hTask
))) return;
705 if (pTask
->flags
& TDBF_WIN32
)
707 FIXME("called for Win32 thread (%04lx)!\n", (DWORD
)pTask
->teb
->ClientId
.UniqueThread
);
713 if (pTask
->nEvents
== 1) NtSetEvent( pTask
->hEvent
, NULL
);
717 /***********************************************************************
718 * SetPriority (KERNEL.32)
720 void WINAPI
SetPriority16( HTASK16 hTask
, INT16 delta
)
725 if (!hTask
) hTask
= GetCurrentTask();
726 if (!(pTask
= TASK_GetPtr( hTask
))) return;
727 newpriority
= pTask
->priority
+ delta
;
728 if (newpriority
< -32) newpriority
= -32;
729 else if (newpriority
> 15) newpriority
= 15;
731 pTask
->priority
= newpriority
+ 1;
732 TASK_UnlinkTask( pTask
->hSelf
);
733 TASK_LinkTask( pTask
->hSelf
);
738 /***********************************************************************
739 * LockCurrentTask (KERNEL.33)
741 HTASK16 WINAPI
LockCurrentTask16( BOOL16 bLock
)
743 if (bLock
) hLockedTask
= GetCurrentTask();
744 else hLockedTask
= 0;
749 /***********************************************************************
750 * IsTaskLocked (KERNEL.122)
752 HTASK16 WINAPI
IsTaskLocked16(void)
758 /***********************************************************************
759 * OldYield (KERNEL.117)
761 void WINAPI
OldYield16(void)
765 ReleaseThunkLock(&count
);
766 RestoreThunkLock(count
);
769 /***********************************************************************
770 * WIN32_OldYield (KERNEL.447)
772 void WINAPI
WIN32_OldYield16(void)
776 ReleaseThunkLock(&count
);
777 RestoreThunkLock(count
);
780 /***********************************************************************
781 * DirectedYield (KERNEL.150)
783 void WINAPI
DirectedYield16( HTASK16 hTask
)
788 /***********************************************************************
791 void WINAPI
Yield16(void)
793 TDB
*pCurTask
= TASK_GetCurrent();
795 if (pCurTask
&& pCurTask
->hQueue
)
797 HMODULE mod
= GetModuleHandleA( "user32.dll" );
800 FARPROC proc
= GetProcAddress( mod
, "UserYield16" );
811 /***********************************************************************
812 * KERNEL_490 (KERNEL.490)
814 HTASK16 WINAPI
KERNEL_490( HTASK16 someTask
)
816 if ( !someTask
) return 0;
818 FIXME("(%04x): stub\n", someTask
);
822 /***********************************************************************
823 * MakeProcInstance (KERNEL.51)
825 FARPROC16 WINAPI
MakeProcInstance16( FARPROC16 func
, HANDLE16 hInstance
)
829 WORD hInstanceSelector
;
831 hInstanceSelector
= GlobalHandleToSel16(hInstance
);
833 TRACE("(%08lx, %04x);\n", (DWORD
)func
, hInstance
);
836 /* Win95 actually protects via SEH, but this is better for debugging */
837 WARN("Ouch ! Called with invalid func 0x%08lx !\n", (DWORD
)func
);
841 if ( (GlobalHandleToSel16(CURRENT_DS
) != hInstanceSelector
)
843 && (hInstance
!= 0xffff) )
845 /* calling MPI with a foreign DSEG is invalid ! */
846 WARN("Problem with hInstance? Got %04x, using %04x instead\n",
847 hInstance
,CURRENT_DS
);
850 /* Always use the DSEG that MPI was entered with.
851 * We used to set hInstance to GetTaskDS16(), but this should be wrong
852 * as CURRENT_DS provides the DSEG value we need.
853 * ("calling" DS, *not* "task" DS !) */
854 hInstanceSelector
= CURRENT_DS
;
855 hInstance
= GlobalHandle16(hInstanceSelector
);
857 /* no thunking for DLLs */
858 if (NE_GetPtr(FarGetOwner16(hInstance
))->flags
& NE_FFLAGS_LIBMODULE
)
861 thunkaddr
= TASK_AllocThunk();
862 if (!thunkaddr
) return (FARPROC16
)0;
863 thunk
= MapSL( thunkaddr
);
864 lfunc
= MapSL( (SEGPTR
)func
);
866 TRACE("(%08lx,%04x): got thunk %08lx\n",
867 (DWORD
)func
, hInstance
, (DWORD
)thunkaddr
);
868 if (((lfunc
[0]==0x8c) && (lfunc
[1]==0xd8)) || /* movw %ds, %ax */
869 ((lfunc
[0]==0x1e) && (lfunc
[1]==0x58)) /* pushw %ds, popw %ax */
871 WARN("This was the (in)famous \"thunk useless\" warning. We thought we have to overwrite with nop;nop;, but this isn't true.\n");
874 *thunk
++ = 0xb8; /* movw instance, %ax */
875 *thunk
++ = (BYTE
)(hInstanceSelector
& 0xff);
876 *thunk
++ = (BYTE
)(hInstanceSelector
>> 8);
877 *thunk
++ = 0xea; /* ljmp func */
878 *(DWORD
*)thunk
= (DWORD
)func
;
879 return (FARPROC16
)thunkaddr
;
880 /* CX reg indicates if thunkaddr != NULL, implement if needed */
884 /***********************************************************************
885 * FreeProcInstance (KERNEL.52)
887 void WINAPI
FreeProcInstance16( FARPROC16 func
)
889 TRACE("(%08lx)\n", (DWORD
)func
);
890 TASK_FreeThunk( (SEGPTR
)func
);
893 /**********************************************************************
894 * TASK_GetCodeSegment
896 * Helper function for GetCodeHandle/GetCodeInfo: Retrieve the module
897 * and logical segment number of a given code segment.
899 * 'proc' either *is* already a pair of module handle and segment number,
900 * in which case there's nothing to do. Otherwise, it is a pointer to
901 * a function, and we need to retrieve the code segment. If the pointer
902 * happens to point to a thunk, we'll retrieve info about the code segment
903 * where the function pointed to by the thunk resides, not the thunk itself.
905 * FIXME: if 'proc' is a SNOOP16 return stub, we should retrieve info about
906 * the function the snoop code will return to ...
909 static BOOL
TASK_GetCodeSegment( FARPROC16 proc
, NE_MODULE
**ppModule
,
910 SEGTABLEENTRY
**ppSeg
, int *pSegNr
)
912 NE_MODULE
*pModule
= NULL
;
913 SEGTABLEENTRY
*pSeg
= NULL
;
916 /* Try pair of module handle / segment number */
917 pModule
= (NE_MODULE
*) GlobalLock16( HIWORD( proc
) );
918 if ( pModule
&& pModule
->magic
== IMAGE_OS2_SIGNATURE
)
920 segNr
= LOWORD( proc
);
921 if ( segNr
&& segNr
<= pModule
->seg_count
)
922 pSeg
= NE_SEG_TABLE( pModule
) + segNr
-1;
925 /* Try thunk or function */
928 BYTE
*thunk
= MapSL( (SEGPTR
)proc
);
931 if ((thunk
[0] == 0xb8) && (thunk
[3] == 0xea))
932 selector
= thunk
[6] + (thunk
[7] << 8);
934 selector
= HIWORD( proc
);
936 pModule
= NE_GetPtr( GlobalHandle16( selector
) );
937 pSeg
= pModule
? NE_SEG_TABLE( pModule
) : NULL
;
940 for ( segNr
= 1; segNr
<= pModule
->seg_count
; segNr
++, pSeg
++ )
941 if ( GlobalHandleToSel16(pSeg
->hSeg
) == selector
)
944 if ( pModule
&& segNr
> pModule
->seg_count
)
948 /* Abort if segment not found */
950 if ( !pModule
|| !pSeg
)
953 /* Return segment data */
955 if ( ppModule
) *ppModule
= pModule
;
956 if ( ppSeg
) *ppSeg
= pSeg
;
957 if ( pSegNr
) *pSegNr
= segNr
;
962 /**********************************************************************
963 * GetCodeHandle (KERNEL.93)
965 HANDLE16 WINAPI
GetCodeHandle16( FARPROC16 proc
)
969 if ( !TASK_GetCodeSegment( proc
, NULL
, &pSeg
, NULL
) )
975 /**********************************************************************
976 * GetCodeInfo (KERNEL.104)
978 BOOL16 WINAPI
GetCodeInfo16( FARPROC16 proc
, SEGINFO
*segInfo
)
984 if ( !TASK_GetCodeSegment( proc
, &pModule
, &pSeg
, &segNr
) )
987 /* Fill in segment information */
989 segInfo
->offSegment
= pSeg
->filepos
;
990 segInfo
->cbSegment
= pSeg
->size
;
991 segInfo
->flags
= pSeg
->flags
;
992 segInfo
->cbAlloc
= pSeg
->minsize
;
993 segInfo
->h
= pSeg
->hSeg
;
994 segInfo
->alignShift
= pModule
->alignment
;
996 if ( segNr
== pModule
->dgroup
)
997 segInfo
->cbAlloc
+= pModule
->heap_size
+ pModule
->stack_size
;
999 /* Return module handle in %es */
1001 CURRENT_STACK16
->es
= GlobalHandleToSel16( pModule
->self
);
1007 /**********************************************************************
1008 * DefineHandleTable (KERNEL.94)
1010 BOOL16 WINAPI
DefineHandleTable16( WORD wOffset
)
1012 FIXME("(%04x): stub ?\n", wOffset
);
1017 /***********************************************************************
1018 * SetTaskQueue (KERNEL.34)
1020 HQUEUE16 WINAPI
SetTaskQueue16( HTASK16 hTask
, HQUEUE16 hQueue
)
1025 if (!hTask
) hTask
= GetCurrentTask();
1026 if (!(pTask
= TASK_GetPtr( hTask
))) return 0;
1028 hPrev
= pTask
->hQueue
;
1029 pTask
->hQueue
= hQueue
;
1035 /***********************************************************************
1036 * GetTaskQueue (KERNEL.35)
1038 HQUEUE16 WINAPI
GetTaskQueue16( HTASK16 hTask
)
1042 if (!hTask
) hTask
= GetCurrentTask();
1043 if (!(pTask
= TASK_GetPtr( hTask
))) return 0;
1044 return pTask
->hQueue
;
1047 /***********************************************************************
1048 * SetThreadQueue (KERNEL.463)
1050 HQUEUE16 WINAPI
SetThreadQueue16( DWORD thread
, HQUEUE16 hQueue
)
1052 HQUEUE16 oldQueue
= NtCurrentTeb()->queue
;
1054 if (thread
&& thread
!= GetCurrentThreadId())
1056 FIXME( "not supported on other thread %04lx\n", thread
);
1059 NtCurrentTeb()->queue
= hQueue
;
1060 if ( GetTaskQueue16( NtCurrentTeb()->htask16
) == oldQueue
)
1061 SetTaskQueue16( NtCurrentTeb()->htask16
, hQueue
);
1065 /***********************************************************************
1066 * GetThreadQueue (KERNEL.464)
1068 HQUEUE16 WINAPI
GetThreadQueue16( DWORD thread
)
1070 if (thread
&& thread
!= GetCurrentThreadId())
1072 FIXME( "not supported on other thread %04lx\n", thread
);
1075 return NtCurrentTeb()->queue
;
1078 /***********************************************************************
1079 * SetFastQueue (KERNEL.624)
1081 VOID WINAPI
SetFastQueue16( DWORD thread
, HQUEUE16 hQueue
)
1083 if (!thread
|| thread
== GetCurrentThreadId())
1084 NtCurrentTeb()->queue
= hQueue
;
1086 FIXME( "not supported on other thread %04lx\n", thread
);
1089 /***********************************************************************
1090 * GetFastQueue (KERNEL.625)
1092 HQUEUE16 WINAPI
GetFastQueue16( void )
1094 HQUEUE16 ret
= NtCurrentTeb()->queue
;
1096 if (!ret
) FIXME("(): should initialize thread-local queue, expect failure!\n" );
1100 /***********************************************************************
1101 * SwitchStackTo (KERNEL.108)
1103 void WINAPI
SwitchStackTo16( WORD seg
, WORD ptr
, WORD top
)
1105 STACK16FRAME
*oldFrame
, *newFrame
;
1106 INSTANCEDATA
*pData
;
1109 if (!(pData
= (INSTANCEDATA
*)GlobalLock16( seg
))) return;
1110 TRACE("old=%04x:%04x new=%04x:%04x\n",
1111 SELECTOROF( NtCurrentTeb()->cur_stack
),
1112 OFFSETOF( NtCurrentTeb()->cur_stack
), seg
, ptr
);
1114 /* Save the old stack */
1116 oldFrame
= CURRENT_STACK16
;
1117 /* pop frame + args and push bp */
1118 pData
->old_ss_sp
= NtCurrentTeb()->cur_stack
+ sizeof(STACK16FRAME
)
1120 *(WORD
*)MapSL(pData
->old_ss_sp
) = oldFrame
->bp
;
1121 pData
->stacktop
= top
;
1122 pData
->stackmin
= ptr
;
1123 pData
->stackbottom
= ptr
;
1125 /* Switch to the new stack */
1127 /* Note: we need to take the 3 arguments into account; otherwise,
1128 * the stack will underflow upon return from this function.
1130 copySize
= oldFrame
->bp
- OFFSETOF(pData
->old_ss_sp
);
1131 copySize
+= 3 * sizeof(WORD
) + sizeof(STACK16FRAME
);
1132 NtCurrentTeb()->cur_stack
= MAKESEGPTR( seg
, ptr
- copySize
);
1133 newFrame
= CURRENT_STACK16
;
1135 /* Copy the stack frame and the local variables to the new stack */
1137 memmove( newFrame
, oldFrame
, copySize
);
1139 *(WORD
*)MapSL( MAKESEGPTR( seg
, ptr
) ) = 0; /* clear previous bp */
1143 /***********************************************************************
1144 * SwitchStackBack (KERNEL.109)
1146 void WINAPI
SwitchStackBack16( CONTEXT86
*context
)
1148 STACK16FRAME
*oldFrame
, *newFrame
;
1149 INSTANCEDATA
*pData
;
1151 if (!(pData
= (INSTANCEDATA
*)GlobalLock16(SELECTOROF(NtCurrentTeb()->cur_stack
))))
1153 if (!pData
->old_ss_sp
)
1155 WARN("No previous SwitchStackTo\n" );
1158 TRACE("restoring stack %04x:%04x\n",
1159 SELECTOROF(pData
->old_ss_sp
), OFFSETOF(pData
->old_ss_sp
) );
1161 oldFrame
= CURRENT_STACK16
;
1163 /* Pop bp from the previous stack */
1165 context
->Ebp
= (context
->Ebp
& ~0xffff) | *(WORD
*)MapSL(pData
->old_ss_sp
);
1166 pData
->old_ss_sp
+= sizeof(WORD
);
1168 /* Switch back to the old stack */
1170 NtCurrentTeb()->cur_stack
= pData
->old_ss_sp
- sizeof(STACK16FRAME
);
1171 context
->SegSs
= SELECTOROF(pData
->old_ss_sp
);
1172 context
->Esp
= OFFSETOF(pData
->old_ss_sp
) - sizeof(DWORD
); /*ret addr*/
1173 pData
->old_ss_sp
= 0;
1175 /* Build a stack frame for the return */
1177 newFrame
= CURRENT_STACK16
;
1178 newFrame
->frame32
= oldFrame
->frame32
;
1179 newFrame
->module_cs
= oldFrame
->module_cs
;
1180 newFrame
->callfrom_ip
= oldFrame
->callfrom_ip
;
1181 newFrame
->entry_ip
= oldFrame
->entry_ip
;
1185 /***********************************************************************
1186 * GetTaskQueueDS (KERNEL.118)
1188 void WINAPI
GetTaskQueueDS16(void)
1190 CURRENT_STACK16
->ds
= GlobalHandleToSel16( GetTaskQueue16(0) );
1194 /***********************************************************************
1195 * GetTaskQueueES (KERNEL.119)
1197 void WINAPI
GetTaskQueueES16(void)
1199 CURRENT_STACK16
->es
= GlobalHandleToSel16( GetTaskQueue16(0) );
1203 /***********************************************************************
1204 * GetCurrentTask (KERNEL32.@)
1206 HTASK16 WINAPI
GetCurrentTask(void)
1208 return NtCurrentTeb()->htask16
;
1211 /***********************************************************************
1212 * GetCurrentTask (KERNEL.36)
1214 DWORD WINAPI
WIN16_GetCurrentTask(void)
1216 /* This is the version used by relay code; the first task is */
1217 /* returned in the high word of the result */
1218 return MAKELONG( GetCurrentTask(), hFirstTask
);
1222 /***********************************************************************
1223 * GetCurrentPDB (KERNEL.37)
1225 * UNDOC: returns PSP of KERNEL in high word
1227 DWORD WINAPI
GetCurrentPDB16(void)
1231 if (!(pTask
= TASK_GetCurrent())) return 0;
1232 return MAKELONG(pTask
->hPDB
, 0); /* FIXME */
1236 /***********************************************************************
1237 * GetCurPID (KERNEL.157)
1239 DWORD WINAPI
GetCurPID16( DWORD unused
)
1245 /***********************************************************************
1246 * GetInstanceData (KERNEL.54)
1248 INT16 WINAPI
GetInstanceData16( HINSTANCE16 instance
, WORD buffer
, INT16 len
)
1250 char *ptr
= (char *)GlobalLock16( instance
);
1251 if (!ptr
|| !len
) return 0;
1252 if ((int)buffer
+ len
>= 0x10000) len
= 0x10000 - buffer
;
1253 memcpy( (char *)GlobalLock16(CURRENT_DS
) + buffer
, ptr
+ buffer
, len
);
1258 /***********************************************************************
1259 * GetExeVersion (KERNEL.105)
1261 WORD WINAPI
GetExeVersion16(void)
1265 if (!(pTask
= TASK_GetCurrent())) return 0;
1266 return pTask
->version
;
1270 /***********************************************************************
1271 * SetErrorMode (KERNEL.107)
1273 UINT16 WINAPI
SetErrorMode16( UINT16 mode
)
1276 if (!(pTask
= TASK_GetCurrent())) return 0;
1277 pTask
->error_mode
= mode
;
1278 return SetErrorMode( mode
);
1282 /***********************************************************************
1283 * GetNumTasks (KERNEL.152)
1285 UINT16 WINAPI
GetNumTasks16(void)
1291 /***********************************************************************
1292 * GetTaskDS (KERNEL.155)
1294 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1295 * I don't think we need to bother with this.
1297 HINSTANCE16 WINAPI
GetTaskDS16(void)
1301 if (!(pTask
= TASK_GetCurrent())) return 0;
1302 return GlobalHandleToSel16(pTask
->hInstance
);
1305 /***********************************************************************
1306 * GetDummyModuleHandleDS (KERNEL.602)
1308 WORD WINAPI
GetDummyModuleHandleDS16(void)
1313 if (!(pTask
= TASK_GetCurrent())) return 0;
1314 if (!(pTask
->flags
& TDBF_WIN32
)) return 0;
1315 selector
= GlobalHandleToSel16( pTask
->hModule
);
1316 CURRENT_DS
= selector
;
1320 /***********************************************************************
1321 * IsTask (KERNEL.320)
1323 BOOL16 WINAPI
IsTask16( HTASK16 hTask
)
1327 if (!(pTask
= TASK_GetPtr( hTask
))) return FALSE
;
1328 if (GlobalSize16( hTask
) < sizeof(TDB
)) return FALSE
;
1329 return (pTask
->magic
== TDB_MAGIC
);
1333 /***********************************************************************
1334 * IsWinOldApTask (KERNEL.158)
1336 BOOL16 WINAPI
IsWinOldApTask16( HTASK16 hTask
)
1338 /* should return bit 0 of byte 0x48 in PSP */
1342 /***********************************************************************
1343 * SetTaskSignalProc (KERNEL.38)
1345 FARPROC16 WINAPI
SetTaskSignalProc( HTASK16 hTask
, FARPROC16 proc
)
1350 if (!hTask
) hTask
= GetCurrentTask();
1351 if (!(pTask
= TASK_GetPtr( hTask
))) return NULL
;
1352 oldProc
= pTask
->userhandler
;
1353 pTask
->userhandler
= proc
;
1357 /***********************************************************************
1358 * SetSigHandler (KERNEL.140)
1360 WORD WINAPI
SetSigHandler16( FARPROC16 newhandler
, FARPROC16
* oldhandler
,
1361 UINT16
*oldmode
, UINT16 newmode
, UINT16 flag
)
1363 FIXME("(%p,%p,%p,%d,%d), unimplemented.\n",
1364 newhandler
,oldhandler
,oldmode
,newmode
,flag
);
1366 if (flag
!= 1) return 0;
1367 if (!newmode
) newhandler
= NULL
; /* Default handler */
1372 if (!(pTask
= TASK_GetCurrent())) return 0;
1373 if (oldmode
) *oldmode
= pTask
->signal_flags
;
1374 pTask
->signal_flags
= newmode
;
1375 if (oldhandler
) *oldhandler
= pTask
->sighandler
;
1376 pTask
->sighandler
= newhandler
;
1382 /***********************************************************************
1383 * GlobalNotify (KERNEL.154)
1385 * Note that GlobalNotify does _not_ return the old NotifyProc
1386 * -- contrary to LocalNotify !!
1388 VOID WINAPI
GlobalNotify16( FARPROC16 proc
)
1392 if (!(pTask
= TASK_GetCurrent())) return;
1393 pTask
->discardhandler
= proc
;
1397 /***********************************************************************
1400 static inline HMODULE16
GetExePtrHelper( HANDLE16 handle
, HTASK16
*hTask
)
1405 /* Check for module handle */
1407 if (!(ptr
= GlobalLock16( handle
))) return 0;
1408 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return handle
;
1410 /* Search for this handle inside all tasks */
1412 *hTask
= hFirstTask
;
1415 TDB
*pTask
= TASK_GetPtr( *hTask
);
1416 if ((*hTask
== handle
) ||
1417 (pTask
->hInstance
== handle
) ||
1418 (pTask
->hQueue
== handle
) ||
1419 (pTask
->hPDB
== handle
)) return pTask
->hModule
;
1420 *hTask
= pTask
->hNext
;
1423 /* Check the owner for module handle */
1425 owner
= FarGetOwner16( handle
);
1426 if (!(ptr
= GlobalLock16( owner
))) return 0;
1427 if (((NE_MODULE
*)ptr
)->magic
== IMAGE_OS2_SIGNATURE
) return owner
;
1429 /* Search for the owner inside all tasks */
1431 *hTask
= hFirstTask
;
1434 TDB
*pTask
= TASK_GetPtr( *hTask
);
1435 if ((*hTask
== owner
) ||
1436 (pTask
->hInstance
== owner
) ||
1437 (pTask
->hQueue
== owner
) ||
1438 (pTask
->hPDB
== owner
)) return pTask
->hModule
;
1439 *hTask
= pTask
->hNext
;
1445 /***********************************************************************
1446 * GetExePtr (KERNEL.133)
1448 HMODULE16 WINAPI
WIN16_GetExePtr( HANDLE16 handle
)
1451 HMODULE16 hModule
= GetExePtrHelper( handle
, &hTask
);
1452 STACK16FRAME
*frame
= CURRENT_STACK16
;
1453 frame
->ecx
= hModule
;
1454 if (hTask
) frame
->es
= hTask
;
1459 /***********************************************************************
1462 HMODULE16 WINAPI
GetExePtr( HANDLE16 handle
)
1465 return GetExePtrHelper( handle
, &hTask
);
1469 /***********************************************************************
1470 * TaskFirst (TOOLHELP.63)
1472 BOOL16 WINAPI
TaskFirst16( TASKENTRY
*lpte
)
1474 lpte
->hNext
= hFirstTask
;
1475 return TaskNext16( lpte
);
1479 /***********************************************************************
1480 * TaskNext (TOOLHELP.64)
1482 BOOL16 WINAPI
TaskNext16( TASKENTRY
*lpte
)
1485 INSTANCEDATA
*pInstData
;
1487 TRACE_(toolhelp
)("(%p): task=%04x\n", lpte
, lpte
->hNext
);
1488 if (!lpte
->hNext
) return FALSE
;
1490 /* make sure that task and hInstance are valid (skip initial Wine task !) */
1492 pTask
= TASK_GetPtr( lpte
->hNext
);
1493 if (!pTask
|| pTask
->magic
!= TDB_MAGIC
) return FALSE
;
1494 if (pTask
->hInstance
)
1496 lpte
->hNext
= pTask
->hNext
;
1498 pInstData
= MapSL( MAKESEGPTR( GlobalHandleToSel16(pTask
->hInstance
), 0 ) );
1499 lpte
->hTask
= lpte
->hNext
;
1500 lpte
->hTaskParent
= pTask
->hParent
;
1501 lpte
->hInst
= pTask
->hInstance
;
1502 lpte
->hModule
= pTask
->hModule
;
1503 lpte
->wSS
= SELECTOROF( pTask
->teb
->cur_stack
);
1504 lpte
->wSP
= OFFSETOF( pTask
->teb
->cur_stack
);
1505 lpte
->wStackTop
= pInstData
->stacktop
;
1506 lpte
->wStackMinimum
= pInstData
->stackmin
;
1507 lpte
->wStackBottom
= pInstData
->stackbottom
;
1508 lpte
->wcEvents
= pTask
->nEvents
;
1509 lpte
->hQueue
= pTask
->hQueue
;
1510 lstrcpynA( lpte
->szModule
, pTask
->module_name
, sizeof(lpte
->szModule
) );
1511 lpte
->wPSPOffset
= 0x100; /*??*/
1512 lpte
->hNext
= pTask
->hNext
;
1517 /***********************************************************************
1518 * TaskFindHandle (TOOLHELP.65)
1520 BOOL16 WINAPI
TaskFindHandle16( TASKENTRY
*lpte
, HTASK16 hTask
)
1522 lpte
->hNext
= hTask
;
1523 return TaskNext16( lpte
);
1527 typedef INT (WINAPI
*MessageBoxA_funcptr
)(HWND hWnd
, LPCSTR text
, LPCSTR title
, UINT type
);
1529 /**************************************************************************
1530 * FatalAppExit (KERNEL.137)
1532 void WINAPI
FatalAppExit16( UINT16 action
, LPCSTR str
)
1534 TDB
*pTask
= TASK_GetCurrent();
1536 if (!pTask
|| !(pTask
->error_mode
& SEM_NOGPFAULTERRORBOX
))
1538 HMODULE mod
= GetModuleHandleA( "user32.dll" );
1541 MessageBoxA_funcptr pMessageBoxA
= (MessageBoxA_funcptr
)GetProcAddress( mod
, "MessageBoxA" );
1544 pMessageBoxA( 0, str
, NULL
, MB_SYSTEMMODAL
| MB_OK
);
1548 ERR( "%s\n", debugstr_a(str
) );
1555 /***********************************************************************
1556 * TerminateApp (TOOLHELP.77)
1558 * See "Undocumented Windows".
1560 void WINAPI
TerminateApp16(HTASK16 hTask
, WORD wFlags
)
1562 if (hTask
&& hTask
!= GetCurrentTask())
1564 FIXME("cannot terminate task %x\n", hTask
);
1568 if (wFlags
& NO_UAE_BOX
)
1571 old_mode
= SetErrorMode16(0);
1572 SetErrorMode16(old_mode
|SEM_NOGPFAULTERRORBOX
);
1574 FatalAppExit16( 0, NULL
);
1576 /* hmm, we're still alive ?? */
1578 /* check undocumented flag */
1579 if (!(wFlags
& 0x8000))
1580 TASK_CallTaskSignalProc( USIG16_TERMINATION
, hTask
);
1582 /* UndocWin says to call int 0x21/0x4c exit=0xff here,
1583 but let's just call ExitThread */
1588 /***********************************************************************
1589 * GetAppCompatFlags (KERNEL.354)
1591 DWORD WINAPI
GetAppCompatFlags16( HTASK16 hTask
)
1595 if (!hTask
) hTask
= GetCurrentTask();
1596 if (!(pTask
=TASK_GetPtr( hTask
))) return 0;
1597 if (GlobalSize16(hTask
) < sizeof(TDB
)) return 0;
1598 return pTask
->compat_flags
;
1602 /***********************************************************************
1603 * GetDOSEnvironment (KERNEL.131)
1605 * Note: the environment is allocated once, it doesn't track changes
1606 * made using the Win32 API. This shouldn't matter.
1608 * Format of a 16-bit environment block:
1609 * ASCIIZ string 1 (xx=yy format)
1614 * ASCIIZ program name (e.g. C:\WINDOWS\SYSTEM\KRNL386.EXE)
1616 SEGPTR WINAPI
GetDOSEnvironment16(void)
1618 static const char ENV_program_name
[] = "C:\\WINDOWS\\SYSTEM\\KRNL386.EXE";
1619 static HGLOBAL16 handle
; /* handle to the 16 bit environment */
1626 p
= env
= GetEnvironmentStringsA();
1627 while (*p
) p
+= strlen(p
) + 1;
1628 p
++; /* skip last null */
1629 size
= (p
- env
) + sizeof(WORD
) + sizeof(ENV_program_name
);
1630 handle
= GlobalAlloc16( GMEM_FIXED
, size
);
1634 LPSTR env16
= GlobalLock16( handle
);
1635 memcpy( env16
, env
, p
- env
);
1636 memcpy( env16
+ (p
- env
), &one
, sizeof(one
));
1637 memcpy( env16
+ (p
- env
) + sizeof(WORD
), ENV_program_name
, sizeof(ENV_program_name
));
1638 GlobalUnlock16( handle
);
1640 FreeEnvironmentStringsA( env
);
1642 return K32WOWGlobalLock16( handle
);