?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980601
[wine.git] / loader / task.c
bloba842c08a701771ebc3ed903329adedff737cf94b
1 /*
2 * Task functions
3 *
4 * Copyright 1995 Alexandre Julliard
5 */
6
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "windows.h"
11 #include "user.h"
12 #include "callback.h"
13 #include "drive.h"
14 #include "file.h"
15 #include "global.h"
16 #include "instance.h"
17 #include "message.h"
18 #include "miscemu.h"
19 #include "module.h"
20 #include "neexe.h"
21 #include "peexe.h"
22 #include "pe_image.h"
23 #include "process.h"
24 #include "queue.h"
25 #include "selectors.h"
26 #include "stackframe.h"
27 #include "task.h"
28 #include "thread.h"
29 #include "toolhelp.h"
30 #include "winnt.h"
31 #include "winsock.h"
32 #include "thread.h"
33 #include "debug.h"
34 #include "dde_proc.h"
35
36 /* Min. number of thunks allocated when creating a new segment */
37 #define MIN_THUNKS 32
38
39 /* Pointer to function to switch to a larger stack */
40 int (*IF1632_CallLargeStack)( int (*func)(), void *arg ) = NULL;
41
42 static HTASK16 hFirstTask = 0;
43 static HTASK16 hCurrentTask = 0;
44 static HTASK16 hTaskToKill = 0;
45 static HTASK16 hLockedTask = 0;
46 static UINT16 nTaskCount = 0;
47
48 static void TASK_YieldToSystem(TDB*);
49
50
51 /***********************************************************************
52 * TASK_GetNextTask
53 */
54 HTASK16 TASK_GetNextTask( HTASK16 hTask )
55 {
56 TDB* pTask = (TDB*)GlobalLock16(hTask);
57
58 if (pTask->hNext) return pTask->hNext;
59 return (hFirstTask != hTask) ? hFirstTask : 0;
60 }
61
62
63 /***********************************************************************
64 * TASK_LinkTask
65 */
66 static void TASK_LinkTask( HTASK16 hTask )
67 {
68 HTASK16 *prevTask;
69 TDB *pTask;
70
71 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
72 prevTask = &hFirstTask;
73 while (*prevTask)
74 {
75 TDB *prevTaskPtr = (TDB *)GlobalLock16( *prevTask );
76 if (prevTaskPtr->priority >= pTask->priority) break;
77 prevTask = &prevTaskPtr->hNext;
78 }
79 pTask->hNext = *prevTask;
80 *prevTask = hTask;
81 nTaskCount++;
82 }
83
84
85 /***********************************************************************
86 * TASK_UnlinkTask
87 */
88 static void TASK_UnlinkTask( HTASK16 hTask )
89 {
90 HTASK16 *prevTask;
91 TDB *pTask;
92
93 prevTask = &hFirstTask;
94 while (*prevTask && (*prevTask != hTask))
95 {
96 pTask = (TDB *)GlobalLock16( *prevTask );
97 prevTask = &pTask->hNext;
98 }
99 if (*prevTask)
100 {
101 pTask = (TDB *)GlobalLock16( *prevTask );
102 *prevTask = pTask->hNext;
103 pTask->hNext = 0;
104 nTaskCount--;
105 }
106 }
107
108
109 /***********************************************************************
110 * TASK_CreateThunks
111 *
112 * Create a thunk free-list in segment 'handle', starting from offset 'offset'
113 * and containing 'count' entries.
114 */
115 static void TASK_CreateThunks( HGLOBAL16 handle, WORD offset, WORD count )
116 {
117 int i;
118 WORD free;
119 THUNKS *pThunk;
120
121 pThunk = (THUNKS *)((BYTE *)GlobalLock16( handle ) + offset);
122 pThunk->next = 0;
123 pThunk->magic = THUNK_MAGIC;
124 pThunk->free = (int)&pThunk->thunks - (int)pThunk;
125 free = pThunk->free;
126 for (i = 0; i < count-1; i++)
127 {
128 free += 8; /* Offset of next thunk */
129 pThunk->thunks[4*i] = free;
130 }
131 pThunk->thunks[4*i] = 0; /* Last thunk */
132 }
133
134
135 /***********************************************************************
136 * TASK_AllocThunk
137 *
138 * Allocate a thunk for MakeProcInstance().
139 */
140 static SEGPTR TASK_AllocThunk( HTASK16 hTask )
141 {
142 TDB *pTask;
143 THUNKS *pThunk;
144 WORD sel, base;
145
146 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
147 sel = pTask->hCSAlias;
148 pThunk = &pTask->thunks;
149 base = (int)pThunk - (int)pTask;
150 while (!pThunk->free)
151 {
152 sel = pThunk->next;
153 if (!sel) /* Allocate a new segment */
154 {
155 sel = GLOBAL_Alloc( GMEM_FIXED, sizeof(THUNKS) + (MIN_THUNKS-1)*8,
156 pTask->hPDB, TRUE, FALSE, FALSE );
157 if (!sel) return (SEGPTR)0;
158 TASK_CreateThunks( sel, 0, MIN_THUNKS );
159 pThunk->next = sel;
160 }
161 pThunk = (THUNKS *)GlobalLock16( sel );
162 base = 0;
163 }
164 base += pThunk->free;
165 pThunk->free = *(WORD *)((BYTE *)pThunk + pThunk->free);
166 return PTR_SEG_OFF_TO_SEGPTR( sel, base );
167 }
168
169
170 /***********************************************************************
171 * TASK_FreeThunk
172 *
173 * Free a MakeProcInstance() thunk.
174 */
175 static BOOL32 TASK_FreeThunk( HTASK16 hTask, SEGPTR thunk )
176 {
177 TDB *pTask;
178 THUNKS *pThunk;
179 WORD sel, base;
180
181 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
182 sel = pTask->hCSAlias;
183 pThunk = &pTask->thunks;
184 base = (int)pThunk - (int)pTask;
185 while (sel && (sel != HIWORD(thunk)))
186 {
187 sel = pThunk->next;
188 pThunk = (THUNKS *)GlobalLock16( sel );
189 base = 0;
190 }
191 if (!sel) return FALSE;
192 *(WORD *)((BYTE *)pThunk + LOWORD(thunk) - base) = pThunk->free;
193 pThunk->free = LOWORD(thunk) - base;
194 return TRUE;
195 }
196
197
198 /***********************************************************************
199 * TASK_CallToStart
200 *
201 * 32-bit entry point for a new task. This function is responsible for
202 * setting up the registers and jumping to the 16-bit entry point.
203 */
204 static void TASK_CallToStart(void)
205 {
206 int exit_code = 1;
207 TDB *pTask = (TDB *)GlobalLock16( hCurrentTask );
208 NE_MODULE *pModule = NE_GetPtr( pTask->hModule );
209 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
210
211 SET_CUR_THREAD( pTask->thdb );
212 /* Terminate the stack frame */
213 THREAD_STACK16(pTask->thdb)->frame32 = NULL;
214 if (pModule->flags & NE_FFLAGS_WIN32)
215 {
216 /* FIXME: all this is an ugly hack */
217
218 FARPROC32 entry = (FARPROC32)RVA_PTR( PROCESS_Current()->exe_modref->module, OptionalHeader.AddressOfEntryPoint );
219
220 pTask->userhandler = (USERSIGNALPROC)&USER_SignalProc;
221 if (pModule->heap_size)
222 LocalInit( pTask->hInstance, 0, pModule->heap_size );
223
224 InitApp( pTask->hModule );
225 PE_InitializeDLLs( PROCESS_Current(), DLL_PROCESS_ATTACH, (LPVOID)-1 );
226 TRACE(relay, "(entryproc=%p)\n", entry );
227 exit_code = entry();
228 TASK_KillCurrentTask( exit_code );
229 }
230 else
231 {
232 /* Registers at initialization must be:
233 * ax zero
234 * bx stack size in bytes
235 * cx heap size in bytes
236 * si previous app instance
237 * di current app instance
238 * bp zero
239 * es selector to the PSP
240 * ds dgroup of the application
241 * ss stack selector
242 * sp top of the stack
243 */
244 CONTEXT context;
245
246 memset( &context, 0, sizeof(context) );
247 CS_reg(&context) = pSegTable[pModule->cs - 1].selector;
248 DS_reg(&context) = pSegTable[pModule->dgroup - 1].selector;
249 ES_reg(&context) = pTask->hPDB;
250 EIP_reg(&context) = pModule->ip;
251 EBX_reg(&context) = pModule->stack_size;
252 ECX_reg(&context) = pModule->heap_size;
253 EDI_reg(&context) = context.SegDs;
254
255 TRACE(task, "Starting main program: cs:ip=%04lx:%04x ds=%04lx ss:sp=%04x:%04x\n",
256 CS_reg(&context), IP_reg(&context), DS_reg(&context),
257 SELECTOROF(pTask->thdb->cur_stack),
258 OFFSETOF(pTask->thdb->cur_stack) );
259
260 Callbacks->CallRegisterShortProc( &context, 0 );
261 /* This should never return */
262 ERR( task, "Main program returned! (should never happen)\n" );
263 TASK_KillCurrentTask( 1 );
264 }
265 }
266
267
268 /***********************************************************************
269 * TASK_Create
270 */
271 HTASK16 TASK_Create( THDB *thdb, NE_MODULE *pModule, HINSTANCE16 hInstance,
272 HINSTANCE16 hPrevInstance, UINT16 cmdShow)
273 {
274 HTASK16 hTask;
275 TDB *pTask;
276 LPSTR cmd_line;
277 WORD sp;
278 char *stack32Top;
279 char name[10];
280 STACK16FRAME *frame16;
281 STACK32FRAME *frame32;
282 PDB32 *pdb32 = thdb->process;
283 SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
284
285 /* Allocate the task structure */
286
287 hTask = GLOBAL_Alloc( GMEM_FIXED | GMEM_ZEROINIT, sizeof(TDB),
288 pModule->self, FALSE, FALSE, FALSE );
289 if (!hTask) return 0;
290 pTask = (TDB *)GlobalLock16( hTask );
291
292 /* Fill the task structure */
293
294 pTask->nEvents = 1; /* So the task can be started */
295 pTask->hSelf = hTask;
296 pTask->flags = 0;
297
298 if (pModule->flags & NE_FFLAGS_WIN32)
299 pTask->flags |= TDBF_WIN32;
300
301 pTask->version = pModule->expected_version;
302 pTask->hInstance = hInstance;
303 pTask->hPrevInstance = hPrevInstance;
304 pTask->hModule = pModule->self;
305 pTask->hParent = hCurrentTask;
306 pTask->magic = TDB_MAGIC;
307 pTask->nCmdShow = cmdShow;
308 pTask->thdb = thdb;
309 pTask->curdrive = DRIVE_GetCurrentDrive() | 0x80;
310 strcpy( pTask->curdir, "\\" );
311 lstrcpyn32A( pTask->curdir + 1, DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() ),
312 sizeof(pTask->curdir) - 1 );
313
314 /* Create the thunks block */
315
316 TASK_CreateThunks( hTask, (int)&pTask->thunks - (int)pTask, 7 );
317
318 /* Copy the module name */
319
320 GetModuleName( pModule->self, name, sizeof(name) );
321 strncpy( pTask->module_name, name, sizeof(pTask->module_name) );
322
323 /* Allocate a selector for the PDB */
324
325 pTask->hPDB = GLOBAL_CreateBlock( GMEM_FIXED, &pTask->pdb, sizeof(PDB),
326 pModule->self, FALSE, FALSE, FALSE, NULL );
327
328 /* Fill the PDB */
329
330 pTask->pdb.int20 = 0x20cd;
331 pTask->pdb.dispatcher[0] = 0x9a; /* ljmp */
332 PUT_DWORD(&pTask->pdb.dispatcher[1], (DWORD)NE_GetEntryPoint(
333 GetModuleHandle16("KERNEL"), 102 )); /* KERNEL.102 is DOS3Call() */
334 pTask->pdb.savedint22 = INT_GetHandler( 0x22 );
335 pTask->pdb.savedint23 = INT_GetHandler( 0x23 );
336 pTask->pdb.savedint24 = INT_GetHandler( 0x24 );
337 pTask->pdb.fileHandlesPtr =
338 PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(pTask->hPDB),
339 (int)&((PDB *)0)->fileHandles );
340 pTask->pdb.hFileHandles = 0;
341 memset( pTask->pdb.fileHandles, 0xff, sizeof(pTask->pdb.fileHandles) );
342 pTask->pdb.environment = pdb32->env_db->env_sel;
343 pTask->pdb.nbFiles = 20;
344
345 /* Fill the command line */
346
347 cmd_line = pdb32->env_db->cmd_line;
348 while (*cmd_line && (*cmd_line != ' ') && (*cmd_line != '\t')) cmd_line++;
349 lstrcpyn32A( pTask->pdb.cmdLine+1, cmd_line, sizeof(pTask->pdb.cmdLine)-1);
350 pTask->pdb.cmdLine[0] = strlen( pTask->pdb.cmdLine + 1 );
351
352 /* Get the compatibility flags */
353
354 pTask->compat_flags = GetProfileInt32A( "Compatibility", name, 0 );
355
356 /* Allocate a code segment alias for the TDB */
357
358 pTask->hCSAlias = GLOBAL_CreateBlock( GMEM_FIXED, (void *)pTask,
359 sizeof(TDB), pTask->hPDB, TRUE,
360 FALSE, FALSE, NULL );
361
362 /* Set the owner of the environment block */
363
364 FarSetOwner( pTask->pdb.environment, pTask->hPDB );
365
366 /* Default DTA overwrites command-line */
367
368 pTask->dta = PTR_SEG_OFF_TO_SEGPTR( pTask->hPDB,
369 (int)&pTask->pdb.cmdLine - (int)&pTask->pdb );
370
371 /* Create the 16-bit stack frame */
372
373 if (!(sp = pModule->sp))
374 sp = pSegTable[pModule->ss-1].minsize + pModule->stack_size;
375 sp &= ~1;
376 pTask->thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( pTask->hInstance, sp );
377 pTask->thdb->cur_stack -= sizeof(STACK16FRAME) + sizeof(STACK32FRAME *);
378 frame16 = (STACK16FRAME *)PTR_SEG_TO_LIN( pTask->thdb->cur_stack );
379 frame16->ebp = sp + (int)&((STACK16FRAME *)0)->bp;
380 frame16->bp = LOWORD(frame16->ebp);
381 frame16->ds = frame16->es = pTask->hInstance;
382 frame16->entry_point = 0;
383 frame16->entry_cs = 0;
384 /* The remaining fields will be initialized in TASK_Reschedule */
385
386 /* Create the 32-bit stack frame */
387
388 stack32Top = (char*)pTask->thdb->teb.stack_top;
389 frame16->frame32 = frame32 = (STACK32FRAME *)stack32Top - 1;
390 frame32->frame16 = pTask->thdb->cur_stack + sizeof(STACK16FRAME);
391 frame32->edi = 0;
392 frame32->esi = 0;
393 frame32->edx = 0;
394 frame32->ecx = 0;
395 frame32->ebx = 0;
396 frame32->retaddr = (DWORD)TASK_CallToStart;
397 /* The remaining fields will be initialized in TASK_Reschedule */
398
399 if (!THREAD_Current()->cur_stack)
400 THREAD_Current()->cur_stack = pTask->thdb->cur_stack;
401
402 /* Add the task to the linked list */
403
404 TASK_LinkTask( hTask );
405
406 TRACE(task, "module='%s' cmdline='%s' task=%04x\n",
407 name, cmd_line, hTask );
408
409 return hTask;
410 }
411
412
413 /***********************************************************************
414 * TASK_DeleteTask
415 */
416 static void TASK_DeleteTask( HTASK16 hTask )
417 {
418 TDB *pTask;
419 HGLOBAL16 hPDB;
420
421 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
422 hPDB = pTask->hPDB;
423
424 pTask->magic = 0xdead; /* invalidate signature */
425
426 /* Delete the Win32 part of the task */
427
428 K32OBJ_DecCount( &pTask->thdb->process->header );
429 K32OBJ_DecCount( &pTask->thdb->header );
430
431 /* Free the task module */
432
433 FreeModule16( pTask->hModule );
434
435 /* Free the selector aliases */
436
437 GLOBAL_FreeBlock( pTask->hCSAlias );
438 GLOBAL_FreeBlock( pTask->hPDB );
439
440 /* Free the task structure itself */
441
442 GlobalFree16( hTask );
443
444 /* Free all memory used by this task (including the 32-bit stack, */
445 /* the environment block and the thunk segments). */
446
447 GlobalFreeAll( hPDB );
448 }
449
450
451 /***********************************************************************
452 * TASK_KillCurrentTask
453 *
454 * Kill the currently running task. As it's not possible to kill the
455 * current task like this, it is simply marked for destruction, and will
456 * be killed when either TASK_Reschedule or this function is called again
457 * in the context of another task.
458 */
459 void TASK_KillCurrentTask( INT16 exitCode )
460 {
461 TDB* pTask = (TDB*) GlobalLock16( hCurrentTask );
462 if (!pTask) USER_ExitWindows(); /* No current task yet */
463
464 TRACE(task, "Killing task %04x\n", hCurrentTask );
465
466 /* Delete active sockets */
467
468 if( pTask->pwsi )
469 WINSOCK_DeleteTaskWSI( pTask, pTask->pwsi );
470
471 /* Perform USER cleanup */
472
473 if (pTask->userhandler)
474 pTask->userhandler( hCurrentTask, USIG_TERMINATION, 0,
475 pTask->hInstance, pTask->hQueue );
476
477 if (hTaskToKill && (hTaskToKill != hCurrentTask))
478 {
479 /* If another task is already marked for destruction, */
480 /* we can kill it now, as we are in another context. */
481 TASK_DeleteTask( hTaskToKill );
482 }
483
484 if (nTaskCount <= 1)
485 {
486 TRACE(task, "this is the last task, exiting\n" );
487 USER_ExitWindows();
488 }
489
490 /* Remove the task from the list to be sure we never switch back to it */
491 TASK_UnlinkTask( hCurrentTask );
492 if( nTaskCount )
493 {
494 TDB* p = (TDB *)GlobalLock16( hFirstTask );
495 while( p )
496 {
497 if( p->hYieldTo == hCurrentTask ) p->hYieldTo = 0;
498 p = (TDB *)GlobalLock16( p->hNext );
499 }
500 }
501
502 hTaskToKill = hCurrentTask;
503 hLockedTask = 0;
504
505 pTask->nEvents = 0;
506 TASK_YieldToSystem(pTask);
507
508 /* We should never return from this Yield() */
509
510 ERR(task,"Return of the living dead %04x!!!\n", hCurrentTask);
511 exit(1);
512 }
513
514 /***********************************************************************
515 * TASK_Reschedule
516 *
517 * This is where all the magic of task-switching happens!
518 *
519 * Note: This function should only be called via the TASK_YieldToSystem()
520 * wrapper, to make sure that all the context is saved correctly.
521 *
522 * It must not call functions that may yield control.
523 */
524 void TASK_Reschedule(void)
525 {
526 TDB *pOldTask = NULL, *pNewTask;
527 HTASK16 hTask = 0;
528 STACK16FRAME *newframe16;
529
530 #ifdef CONFIG_IPC
531 dde_reschedule();
532 #endif
533 /* First check if there's a task to kill */
534
535 if (hTaskToKill && (hTaskToKill != hCurrentTask))
536 {
537 TASK_DeleteTask( hTaskToKill );
538 hTaskToKill = 0;
539 }
540
541 /* Find a task to yield to */
542
543 pOldTask = (TDB *)GlobalLock16( hCurrentTask );
544 if (pOldTask && pOldTask->hYieldTo)
545 {
546 /* check for DirectedYield() */
547
548 hTask = pOldTask->hYieldTo;
549 pNewTask = (TDB *)GlobalLock16( hTask );
550 if( !pNewTask || !pNewTask->nEvents) hTask = 0;
551 pOldTask->hYieldTo = 0;
552 }
553
554 /* extract hardware events only! */
555
556 if (!hTask) EVENT_WaitNetEvent( FALSE, TRUE );
557
558 while (!hTask)
559 {
560 /* Find a task that has an event pending */
561
562 hTask = hFirstTask;
563 while (hTask)
564 {
565 pNewTask = (TDB *)GlobalLock16( hTask );
566
567 TRACE(task, "\ttask = %04x, events = %i\n", hTask, pNewTask->nEvents);
568
569 if (pNewTask->nEvents) break;
570 hTask = pNewTask->hNext;
571 }
572 if (hLockedTask && (hTask != hLockedTask)) hTask = 0;
573 if (hTask) break;
574
575 /* No task found, wait for some events to come in */
576
577 EVENT_WaitNetEvent( TRUE, TRUE );
578 }
579
580 if (hTask == hCurrentTask)
581 {
582 TRACE(task, "returning to the current task(%04x)\n", hTask );
583 return; /* Nothing to do */
584 }
585 pNewTask = (TDB *)GlobalLock16( hTask );
586 TRACE(task, "Switching to task %04x (%.8s)\n",
587 hTask, pNewTask->module_name );
588
589 /* Make the task the last in the linked list (round-robin scheduling) */
590
591 pNewTask->priority++;
592 TASK_UnlinkTask( hTask );
593 TASK_LinkTask( hTask );
594 pNewTask->priority--;
595
596 /* Finish initializing the new task stack if necessary */
597
598 newframe16 = THREAD_STACK16( pNewTask->thdb );
599 if (!newframe16->entry_cs)
600 {
601 STACK16FRAME *oldframe16 = CURRENT_STACK16;
602 STACK32FRAME *oldframe32 = oldframe16->frame32;
603 STACK32FRAME *newframe32 = newframe16->frame32;
604 newframe16->entry_ip = oldframe16->entry_ip;
605 newframe16->entry_cs = oldframe16->entry_cs;
606 newframe16->ip = oldframe16->ip;
607 newframe16->cs = oldframe16->cs;
608 newframe32->ebp = oldframe32->ebp;
609 newframe32->restore_addr = oldframe32->restore_addr;
610 newframe32->codeselector = oldframe32->codeselector;
611 }
612
613 /* Switch to the new stack */
614
615 hCurrentTask = hTask;
616 SET_CUR_THREAD( pNewTask->thdb );
617 pNewTask->ss_sp = pNewTask->thdb->cur_stack;
618 }
619
620
621 /***********************************************************************
622 * TASK_YieldToSystem
623 *
624 * Scheduler interface, this way we ensure that all "unsafe" events are
625 * processed outside the scheduler.
626 */
627 void TASK_YieldToSystem(TDB* pTask)
628 {
629 MESSAGEQUEUE* pQ;
630
631 Callbacks->CallTaskRescheduleProc();
632
633 if( pTask )
634 {
635 pQ = (MESSAGEQUEUE*)GlobalLock16(pTask->hQueue);
636 if( pQ && pQ->flags & QUEUE_FLAG_XEVENT &&
637 !(pQ->wakeBits & (QS_SENDMESSAGE | QS_SMRESULT)) )
638 {
639 pQ->flags &= ~QUEUE_FLAG_XEVENT;
640 EVENT_WaitNetEvent( FALSE, FALSE );
641 }
642 }
643 }
644
645
646 /***********************************************************************
647 * InitTask (KERNEL.91)
648 *
649 * Called by the application startup code.
650 */
651 void WINAPI InitTask( CONTEXT *context )
652 {
653 TDB *pTask;
654 NE_MODULE *pModule;
655 SEGTABLEENTRY *pSegTable;
656 INSTANCEDATA *pinstance;
657 LONG stacklow, stackhi;
658
659 if (context) EAX_reg(context) = 0;
660 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
661 if (!(pModule = NE_GetPtr( pTask->hModule ))) return;
662
663 /* This is a hack to install task USER signal handler before
664 * implicitly loaded DLLs are initialized (see windows/user.c) */
665
666 pTask->userhandler = (USERSIGNALPROC)&USER_SignalProc;
667
668 /* Initialize implicitly loaded DLLs */
669 NE_InitializeDLLs( pTask->hModule );
670
671 if (context)
672 {
673 /* Registers on return are:
674 * ax 1 if OK, 0 on error
675 * cx stack limit in bytes
676 * dx cmdShow parameter
677 * si instance handle of the previous instance
678 * di instance handle of the new task
679 * es:bx pointer to command-line inside PSP
680 */
681 EAX_reg(context) = 1;
682
683 if (!pTask->pdb.cmdLine[0]) EBX_reg(context) = 0x80;
684 else
685 {
686 LPBYTE p = &pTask->pdb.cmdLine[1];
687 while ((*p == ' ') || (*p == '\t')) p++;
688 EBX_reg(context) = 0x80 + (p - pTask->pdb.cmdLine);
689 }
690 ECX_reg(context) = pModule->stack_size;
691 EDX_reg(context) = pTask->nCmdShow;
692 ESI_reg(context) = (DWORD)pTask->hPrevInstance;
693 EDI_reg(context) = (DWORD)pTask->hInstance;
694 ES_reg (context) = (WORD)pTask->hPDB;
695 }
696
697 /* Initialize the local heap */
698 if ( pModule->heap_size )
699 {
700 LocalInit( pTask->hInstance, 0, pModule->heap_size );
701 }
702
703 /* Initialize the INSTANCEDATA structure */
704 pSegTable = NE_SEG_TABLE( pModule );
705 stacklow = pSegTable[pModule->ss - 1].minsize;
706 stackhi = stacklow + pModule->stack_size;
707 if (stackhi > 0xffff) stackhi = 0xffff;
708 pinstance = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN(CURRENT_DS, 0);
709 pinstance->stackbottom = stackhi; /* yup, that's right. Confused me too. */
710 pinstance->stacktop = stacklow;
711 pinstance->stackmin = OFFSETOF( pTask->thdb->cur_stack );
712 }
713
714
715 /***********************************************************************
716 * WaitEvent (KERNEL.30)
717 */
718 BOOL16 WINAPI WaitEvent( HTASK16 hTask )
719 {
720 TDB *pTask;
721
722 if (!hTask) hTask = hCurrentTask;
723 pTask = (TDB *)GlobalLock16( hTask );
724 if (pTask->nEvents > 0)
725 {
726 pTask->nEvents--;
727 return FALSE;
728 }
729 TASK_YieldToSystem(pTask);
730
731 /* When we get back here, we have an event */
732
733 if (pTask->nEvents > 0) pTask->nEvents--;
734 return TRUE;
735 }
736
737
738 /***********************************************************************
739 * PostEvent (KERNEL.31)
740 */
741 void WINAPI PostEvent( HTASK16 hTask )
742 {
743 TDB *pTask;
744
745 if (!hTask) hTask = hCurrentTask;
746 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
747 pTask->nEvents++;
748 }
749
750
751 /***********************************************************************
752 * SetPriority (KERNEL.32)
753 */
754 void WINAPI SetPriority( HTASK16 hTask, INT16 delta )
755 {
756 TDB *pTask;
757 INT16 newpriority;
758
759 if (!hTask) hTask = hCurrentTask;
760 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return;
761 newpriority = pTask->priority + delta;
762 if (newpriority < -32) newpriority = -32;
763 else if (newpriority > 15) newpriority = 15;
764
765 pTask->priority = newpriority + 1;
766 TASK_UnlinkTask( hTask );
767 TASK_LinkTask( hTask );
768 pTask->priority--;
769 }
770
771
772 /***********************************************************************
773 * LockCurrentTask (KERNEL.33)
774 */
775 HTASK16 WINAPI LockCurrentTask( BOOL16 bLock )
776 {
777 if (bLock) hLockedTask = hCurrentTask;
778 else hLockedTask = 0;
779 return hLockedTask;
780 }
781
782
783 /***********************************************************************
784 * IsTaskLocked (KERNEL.122)
785 */
786 HTASK16 WINAPI IsTaskLocked(void)
787 {
788 return hLockedTask;
789 }
790
791
792 /***********************************************************************
793 * OldYield (KERNEL.117)
794 */
795 void WINAPI OldYield(void)
796 {
797 TDB *pCurTask;
798
799 pCurTask = (TDB *)GlobalLock16( hCurrentTask );
800 if (pCurTask) pCurTask->nEvents++; /* Make sure we get back here */
801 TASK_YieldToSystem(pCurTask);
802 if (pCurTask) pCurTask->nEvents--;
803 }
804
805
806 /***********************************************************************
807 * DirectedYield (KERNEL.150)
808 */
809 void WINAPI DirectedYield( HTASK16 hTask )
810 {
811 TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
812 pCurTask->hYieldTo = hTask;
813 OldYield();
814 }
815
816
817 /***********************************************************************
818 * UserYield (USER.332)
819 */
820 void WINAPI UserYield(void)
821 {
822 TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
823 MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( pCurTask->hQueue );
824 /* Handle sent messages */
825 while (queue && (queue->wakeBits & QS_SENDMESSAGE))
826 QUEUE_ReceiveMessage( queue );
827
828 OldYield();
829
830 queue = (MESSAGEQUEUE *)GlobalLock16( pCurTask->hQueue );
831 while (queue && (queue->wakeBits & QS_SENDMESSAGE))
832 QUEUE_ReceiveMessage( queue );
833 }
834
835
836 /***********************************************************************
837 * Yield16 (KERNEL.29)
838 */
839 void WINAPI Yield16(void)
840 {
841 TDB *pCurTask = (TDB *)GlobalLock16( hCurrentTask );
842 if (pCurTask) pCurTask->hYieldTo = 0;
843 if (pCurTask && pCurTask->hQueue) UserYield();
844 else OldYield();
845 }
846
847
848 /***********************************************************************
849 * MakeProcInstance16 (KERNEL.51)
850 */
851 FARPROC16 WINAPI MakeProcInstance16( FARPROC16 func, HANDLE16 hInstance )
852 {
853 BYTE *thunk,*lfunc;
854 SEGPTR thunkaddr;
855
856 if (!hInstance) hInstance = CURRENT_DS;
857 thunkaddr = TASK_AllocThunk( hCurrentTask );
858 if (!thunkaddr) return (FARPROC16)0;
859 thunk = PTR_SEG_TO_LIN( thunkaddr );
860 lfunc = PTR_SEG_TO_LIN( func );
861
862 TRACE(task, "(%08lx,%04x): got thunk %08lx\n",
863 (DWORD)func, hInstance, (DWORD)thunkaddr );
864 if (((lfunc[0]==0x8c) && (lfunc[1]==0xd8)) ||
865 ((lfunc[0]==0x1e) && (lfunc[1]==0x58))
866 ) {
867 FIXME(task,"thunk would be useless for %p, overwriting with nop;nop;\n", func );
868 lfunc[0]=0x90; /* nop */
869 lfunc[1]=0x90; /* nop */
870 }
871
872 *thunk++ = 0xb8; /* movw instance, %ax */
873 *thunk++ = (BYTE)(hInstance & 0xff);
874 *thunk++ = (BYTE)(hInstance >> 8);
875 *thunk++ = 0xea; /* ljmp func */
876 *(DWORD *)thunk = (DWORD)func;
877 return (FARPROC16)thunkaddr;
878 }
879
880
881 /***********************************************************************
882 * FreeProcInstance16 (KERNEL.52)
883 */
884 void WINAPI FreeProcInstance16( FARPROC16 func )
885 {
886 TRACE(task, "(%08lx)\n", (DWORD)func );
887 TASK_FreeThunk( hCurrentTask, (SEGPTR)func );
888 }
889
890
891 /**********************************************************************
892 * GetCodeHandle (KERNEL.93)
893 */
894 HANDLE16 WINAPI GetCodeHandle( FARPROC16 proc )
895 {
896 HANDLE16 handle;
897 BYTE *thunk = (BYTE *)PTR_SEG_TO_LIN( proc );
898
899 /* Return the code segment containing 'proc'. */
900 /* Not sure if this is really correct (shouldn't matter that much). */
901
902 /* Check if it is really a thunk */
903 if ((thunk[0] == 0xb8) && (thunk[3] == 0xea))
904 handle = GlobalHandle16( thunk[6] + (thunk[7] << 8) );
905 else
906 handle = GlobalHandle16( HIWORD(proc) );
907
908 return handle;
909 }
910
911
912 /**********************************************************************
913 * DefineHandleTable16 (KERNEL.94)
914 */
915 BOOL16 WINAPI DefineHandleTable16( WORD wOffset )
916 {
917 return TRUE; /* FIXME */
918 }
919
920
921 /***********************************************************************
922 * SetTaskQueue (KERNEL.34)
923 */
924 HQUEUE16 WINAPI SetTaskQueue( HTASK16 hTask, HQUEUE16 hQueue )
925 {
926 HQUEUE16 hPrev;
927 TDB *pTask;
928
929 if (!hTask) hTask = hCurrentTask;
930 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
931
932 hPrev = pTask->hQueue;
933 pTask->hQueue = hQueue;
934
935 TIMER_SwitchQueue( hPrev, hQueue );
936
937 return hPrev;
938 }
939
940
941 /***********************************************************************
942 * GetTaskQueue (KERNEL.35)
943 */
944 HQUEUE16 WINAPI GetTaskQueue( HTASK16 hTask )
945 {
946 TDB *pTask;
947
948 if (!hTask) hTask = hCurrentTask;
949 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return 0;
950 return pTask->hQueue;
951 }
952
953
954 /***********************************************************************
955 * SwitchStackTo (KERNEL.108)
956 */
957 void WINAPI SwitchStackTo( WORD seg, WORD ptr, WORD top )
958 {
959 TDB *pTask;
960 STACK16FRAME *oldFrame, *newFrame;
961 INSTANCEDATA *pData;
962 UINT16 copySize;
963
964 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
965 if (!(pData = (INSTANCEDATA *)GlobalLock16( seg ))) return;
966 TRACE(task, "old=%04x:%04x new=%04x:%04x\n",
967 SELECTOROF( pTask->thdb->cur_stack ),
968 OFFSETOF( pTask->thdb->cur_stack ), seg, ptr );
969
970 /* Save the old stack */
971
972 oldFrame = THREAD_STACK16( pTask->thdb );
973 /* pop frame + args and push bp */
974 pData->old_ss_sp = pTask->thdb->cur_stack - sizeof(STACK16FRAME)
975 - 2 * sizeof(WORD);
976 *(WORD *)PTR_SEG_TO_LIN(pData->old_ss_sp) = oldFrame->bp;
977 pData->stacktop = top;
978 pData->stackmin = ptr;
979 pData->stackbottom = ptr;
980
981 /* Switch to the new stack */
982
983 /* Note: we need to take the 3 arguments into account; otherwise,
984 * the stack will underflow upon return from this function.
985 */
986 copySize = oldFrame->bp - OFFSETOF(pData->old_ss_sp);
987 copySize += 3 * sizeof(WORD) + sizeof(STACK16FRAME);
988 pTask->thdb->cur_stack = PTR_SEG_OFF_TO_SEGPTR( seg, ptr - copySize );
989 newFrame = THREAD_STACK16( pTask->thdb );
990
991 /* Copy the stack frame and the local variables to the new stack */
992
993 memmove( newFrame, oldFrame, copySize );
994 newFrame->bp = ptr;
995 *(WORD *)PTR_SEG_OFF_TO_LIN( seg, ptr ) = 0; /* clear previous bp */
996 }
997
998
999 /***********************************************************************
1000 * SwitchStackBack (KERNEL.109)
1001 */
1002 void WINAPI SwitchStackBack( CONTEXT *context )
1003 {
1004 TDB *pTask;
1005 STACK16FRAME *oldFrame, *newFrame;
1006 INSTANCEDATA *pData;
1007
1008 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
1009 if (!(pData = (INSTANCEDATA *)GlobalLock16(SELECTOROF(pTask->thdb->cur_stack))))
1010 return;
1011 if (!pData->old_ss_sp)
1012 {
1013 WARN( task, "No previous SwitchStackTo\n" );
1014 return;
1015 }
1016 TRACE(task, "restoring stack %04x:%04x\n",
1017 SELECTOROF(pData->old_ss_sp), OFFSETOF(pData->old_ss_sp) );
1018
1019 oldFrame = THREAD_STACK16( pTask->thdb );
1020
1021 /* Pop bp from the previous stack */
1022
1023 BP_reg(context) = *(WORD *)PTR_SEG_TO_LIN(pData->old_ss_sp);
1024 pData->old_ss_sp += sizeof(WORD);
1025
1026 /* Switch back to the old stack */
1027
1028 pTask->thdb->cur_stack = pData->old_ss_sp - sizeof(STACK16FRAME);
1029 SS_reg(context) = SELECTOROF(pData->old_ss_sp);
1030 ESP_reg(context) = OFFSETOF(pData->old_ss_sp) - sizeof(DWORD); /*ret addr*/
1031 pData->old_ss_sp = 0;
1032
1033 /* Build a stack frame for the return */
1034
1035 newFrame = THREAD_STACK16( pTask->thdb );
1036 newFrame->frame32 = oldFrame->frame32;
1037 if (TRACE_ON(relay))
1038 {
1039 newFrame->entry_ip = oldFrame->entry_ip;
1040 newFrame->entry_cs = oldFrame->entry_cs;
1041 }
1042 }
1043
1044
1045 /***********************************************************************
1046 * GetTaskQueueDS (KERNEL.118)
1047 */
1048 void WINAPI GetTaskQueueDS( CONTEXT *context )
1049 {
1050 DS_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
1051 }
1052
1053
1054 /***********************************************************************
1055 * GetTaskQueueES (KERNEL.119)
1056 */
1057 void WINAPI GetTaskQueueES( CONTEXT *context )
1058 {
1059 ES_reg(context) = GlobalHandleToSel( GetTaskQueue(0) );
1060 }
1061
1062
1063 /***********************************************************************
1064 * GetCurrentTask (KERNEL.36)
1065 */
1066 HTASK16 WINAPI GetCurrentTask(void)
1067 {
1068 return hCurrentTask;
1069 }
1070
1071 DWORD WINAPI WIN16_GetCurrentTask(void)
1072 {
1073 /* This is the version used by relay code; the first task is */
1074 /* returned in the high word of the result */
1075 return MAKELONG( hCurrentTask, hFirstTask );
1076 }
1077
1078
1079 /***********************************************************************
1080 * GetCurrentPDB (KERNEL.37)
1081 */
1082 HANDLE16 WINAPI GetCurrentPDB(void)
1083 {
1084 TDB *pTask;
1085
1086 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1087 return pTask->hPDB;
1088 }
1089
1090
1091 /***********************************************************************
1092 * GetInstanceData (KERNEL.54)
1093 */
1094 INT16 WINAPI GetInstanceData( HINSTANCE16 instance, WORD buffer, INT16 len )
1095 {
1096 char *ptr = (char *)GlobalLock16( instance );
1097 if (!ptr || !len) return 0;
1098 if ((int)buffer + len >= 0x10000) len = 0x10000 - buffer;
1099 memcpy( (char *)GlobalLock16(CURRENT_DS) + buffer, ptr + buffer, len );
1100 return len;
1101 }
1102
1103
1104 /***********************************************************************
1105 * GetExeVersion (KERNEL.105)
1106 */
1107 WORD WINAPI GetExeVersion(void)
1108 {
1109 TDB *pTask;
1110
1111 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1112 return pTask->version;
1113 }
1114
1115
1116 /***********************************************************************
1117 * SetErrorMode16 (KERNEL.107)
1118 */
1119 UINT16 WINAPI SetErrorMode16( UINT16 mode )
1120 {
1121 TDB *pTask;
1122 UINT16 oldMode;
1123
1124 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1125 oldMode = pTask->error_mode;
1126 pTask->error_mode = mode;
1127 pTask->thdb->process->error_mode = mode;
1128 return oldMode;
1129 }
1130
1131
1132 /***********************************************************************
1133 * SetErrorMode32 (KERNEL32.486)
1134 */
1135 UINT32 WINAPI SetErrorMode32( UINT32 mode )
1136 {
1137 return SetErrorMode16( (UINT16)mode );
1138 }
1139
1140
1141 /***********************************************************************
1142 * GetDOSEnvironment (KERNEL.131)
1143 */
1144 SEGPTR WINAPI GetDOSEnvironment(void)
1145 {
1146 TDB *pTask;
1147
1148 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1149 return PTR_SEG_OFF_TO_SEGPTR( pTask->pdb.environment, 0 );
1150 }
1151
1152
1153 /***********************************************************************
1154 * GetNumTasks (KERNEL.152)
1155 */
1156 UINT16 WINAPI GetNumTasks(void)
1157 {
1158 return nTaskCount;
1159 }
1160
1161
1162 /***********************************************************************
1163 * GetTaskDS (KERNEL.155)
1164 *
1165 * Note: this function apparently returns a DWORD with LOWORD == HIWORD.
1166 * I don't think we need to bother with this.
1167 */
1168 HINSTANCE16 WINAPI GetTaskDS(void)
1169 {
1170 TDB *pTask;
1171
1172 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1173 return pTask->hInstance;
1174 }
1175
1176
1177 /***********************************************************************
1178 * IsTask (KERNEL.320)
1179 */
1180 BOOL16 WINAPI IsTask( HTASK16 hTask )
1181 {
1182 TDB *pTask;
1183
1184 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return FALSE;
1185 if (GlobalSize16( hTask ) < sizeof(TDB)) return FALSE;
1186 return (pTask->magic == TDB_MAGIC);
1187 }
1188
1189
1190 /***********************************************************************
1191 * SetTaskSignalProc (KERNEL.38)
1192 *
1193 * Real 16-bit interface is provided by the THUNK_SetTaskSignalProc.
1194 */
1195 FARPROC16 WINAPI SetTaskSignalProc( HTASK16 hTask, FARPROC16 proc )
1196 {
1197 TDB *pTask;
1198 FARPROC16 oldProc;
1199
1200 if (!hTask) hTask = hCurrentTask;
1201 if (!(pTask = (TDB *)GlobalLock16( hTask ))) return NULL;
1202 oldProc = (FARPROC16)pTask->userhandler;
1203 pTask->userhandler = (USERSIGNALPROC)proc;
1204 return oldProc;
1205 }
1206
1207
1208 /***********************************************************************
1209 * SetSigHandler (KERNEL.140)
1210 */
1211 WORD WINAPI SetSigHandler( FARPROC16 newhandler, FARPROC16* oldhandler,
1212 UINT16 *oldmode, UINT16 newmode, UINT16 flag )
1213 {
1214 FIXME(task,"(%p,%p,%p,%d,%d), unimplemented.\n",
1215 newhandler,oldhandler,oldmode,newmode,flag );
1216
1217 if (flag != 1) return 0;
1218 if (!newmode) newhandler = NULL; /* Default handler */
1219 if (newmode != 4)
1220 {
1221 TDB *pTask;
1222
1223 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return 0;
1224 if (oldmode) *oldmode = pTask->signal_flags;
1225 pTask->signal_flags = newmode;
1226 if (oldhandler) *oldhandler = pTask->sighandler;
1227 pTask->sighandler = newhandler;
1228 }
1229 return 0;
1230 }
1231
1232
1233 /***********************************************************************
1234 * GlobalNotify (KERNEL.154)
1235 */
1236 VOID WINAPI GlobalNotify( FARPROC16 proc )
1237 {
1238 TDB *pTask;
1239
1240 if (!(pTask = (TDB *)GlobalLock16( hCurrentTask ))) return;
1241 pTask->discardhandler = proc;
1242 }
1243
1244
1245 /***********************************************************************
1246 * GetExePtr (KERNEL.133)
1247 */
1248 HMODULE16 WINAPI GetExePtr( HANDLE16 handle )
1249 {
1250 char *ptr;
1251 HTASK16 hTask;
1252 HANDLE16 owner;
1253
1254 /* Check for module handle */
1255
1256 if (!(ptr = GlobalLock16( handle ))) return 0;
1257 if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return handle;
1258
1259 /* Check the owner for module handle */
1260
1261 owner = FarGetOwner( handle );
1262 if (!(ptr = GlobalLock16( owner ))) return 0;
1263 if (((NE_MODULE *)ptr)->magic == IMAGE_OS2_SIGNATURE) return owner;
1264
1265 /* Search for this handle and its owner inside all tasks */
1266
1267 hTask = hFirstTask;
1268 while (hTask)
1269 {
1270 TDB *pTask = (TDB *)GlobalLock16( hTask );
1271 if ((hTask == handle) ||
1272 (pTask->hInstance == handle) ||
1273 (pTask->hQueue == handle) ||
1274 (pTask->hPDB == handle)) return pTask->hModule;
1275 if ((hTask == owner) ||
1276 (pTask->hInstance == owner) ||
1277 (pTask->hQueue == owner) ||
1278 (pTask->hPDB == owner)) return pTask->hModule;
1279 hTask = pTask->hNext;
1280 }
1281 return 0;
1282 }
1283
1284 /***********************************************************************
1285 * TaskFirst (TOOLHELP.63)
1286 */
1287 BOOL16 WINAPI TaskFirst( TASKENTRY *lpte )
1288 {
1289 lpte->hNext = hFirstTask;
1290 return TaskNext( lpte );
1291 }
1292
1293
1294 /***********************************************************************
1295 * TaskNext (TOOLHELP.64)
1296 */
1297 BOOL16 WINAPI TaskNext( TASKENTRY *lpte )
1298 {
1299 TDB *pTask;
1300 INSTANCEDATA *pInstData;
1301
1302 TRACE(toolhelp, "(%p): task=%04x\n", lpte, lpte->hNext );
1303 if (!lpte->hNext) return FALSE;
1304 pTask = (TDB *)GlobalLock16( lpte->hNext );
1305 if (!pTask || pTask->magic != TDB_MAGIC) return FALSE;
1306 pInstData = (INSTANCEDATA *)PTR_SEG_OFF_TO_LIN( pTask->hInstance, 0 );
1307 lpte->hTask = lpte->hNext;
1308 lpte->hTaskParent = pTask->hParent;
1309 lpte->hInst = pTask->hInstance;
1310 lpte->hModule = pTask->hModule;
1311 lpte->wSS = SELECTOROF( pTask->thdb->cur_stack );
1312 lpte->wSP = OFFSETOF( pTask->thdb->cur_stack );
1313 lpte->wStackTop = pInstData->stacktop;
1314 lpte->wStackMinimum = pInstData->stackmin;
1315 lpte->wStackBottom = pInstData->stackbottom;
1316 lpte->wcEvents = pTask->nEvents;
1317 lpte->hQueue = pTask->hQueue;
1318 strncpy( lpte->szModule, pTask->module_name, 8 );
1319 lpte->szModule[8] = '\0';
1320 lpte->wPSPOffset = 0x100; /*??*/
1321 lpte->hNext = pTask->hNext;
1322 return TRUE;
1323 }
1324
1325
1326 /***********************************************************************
1327 * TaskFindHandle (TOOLHELP.65)
1328 */
1329 BOOL16 WINAPI TaskFindHandle( TASKENTRY *lpte, HTASK16 hTask )
1330 {
1331 lpte->hNext = hTask;
1332 return TaskNext( lpte );
1333 }
1334
1335
1336 /***********************************************************************
1337 * GetAppCompatFlags16 (KERNEL.354)
1338 */
1339 DWORD WINAPI GetAppCompatFlags16( HTASK16 hTask )
1340 {
1341 return GetAppCompatFlags32( hTask );
1342 }
1343
1344
1345 /***********************************************************************
1346 * GetAppCompatFlags32 (USER32.206)
1347 */
1348 DWORD WINAPI GetAppCompatFlags32( HTASK32 hTask )
1349 {
1350 TDB *pTask;
1351
1352 if (!hTask) hTask = GetCurrentTask();
1353 if (!(pTask=(TDB *)GlobalLock16( (HTASK16)hTask ))) return 0;
1354 if (GlobalSize16(hTask) < sizeof(TDB)) return 0;
1355 return pTask->compat_flags;
1356 }
Windows API implementation