source: trunk/src/kernel32/kobjects.cpp@ 7560

Last change on this file since 7560 was 7560, checked in by sandervl, 24 years ago

overlapped io updates
File size: 24.9 KB
Line 
1/* $Id: kobjects.cpp,v 1.14 2001-12-06 15:57:51 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 compatibility file functions for OS/2
6 * Copyright 1998 Sander van Leeuven
7 * Copyright 1998 Patrick Haller
8 * Copyright 1998 Peter Fitzsimmons
9 * Copyright 1998 Knut St. Osmundsen
10 */
11
12
13/*****************************************************************************
14 * Includes *
15 *****************************************************************************/
16
17#include <odin.h>
18#include <odinwrap.h>
19#include <os2sel.h>
20
21#include <os2win.h>
22#include <misc.h>
23#include <unicode.h>
24#include <handlemanager.h>
25
26#define DBG_LOCALLOG DBG_kobjects
27#include "dbglocal.h"
28
29
30ODINDEBUGCHANNEL(KERNEL32-KOBJECTS)
31
32
33// REMARK: THIS IS IN PREPARATION FOR HANDLEMANAGER SUPPORT (PH) !!
34//#define HMCreateEvent O32_CreateEvent
35//#define HMCreateMutex O32_CreateMutex
36//#define HMCreateSemaphore O32_CreateSemaphore
37//#define HMSetEvent O32_SetEvent
38//#define HMReleaseMutex O32_ReleaseMutex
39//#define HMWaitForSingleObject O32_WaitForSingleObject
40//#define HMWaitForSingleObjectEx O32_WaitForSingleObjectEx
41//#define HMGetOverlappedResult O32_GetOverlappedResult
42//#define HMOpenEvent O32_OpenEvent
43//#define HMOpenMutex O32_OpenMutex
44//#define HMOpenSemaphore O32_OpenSemaphore
45//#define HMPulseEvent O32_PulseEvent
46//#define HMReleaseSemaphore O32_ReleaseSemaphore
47//#define HMResetEvent O32_ResetEvent
48//#define HMWaitForMultipleObjects O32_WaitForMultipleObjects
49//#define HMWaitForMultipleObjectsEx O32_WaitForMultipleObjectsEx
50//#define HMFlushFileBuffers O32_FlushFileBuffers
51#define HMSetHandleCount O32_SetHandleCount
52#define HMGetHandleCount O32_GetHandleCount
53//#define HMDuplicateHandle O32_DuplicateHandle
54
55
56
57/*****************************************************************************
58 * Defines *
59 *****************************************************************************/
60
61 /* this define enables certain less important debug messages */
62//#define DEBUG_LOCAL 1
63
64
65
66/*****************************************************************************
67 * Name : BOOL CreateEventA
68 * Purpose : forward call to Open32
69 * Parameters:
70 * Variables :
71 * Result :
72 * Remark :
73 * Status :
74 *
75 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
76 *****************************************************************************/
77
78ODINFUNCTION4(HANDLE, CreateEventA,
79 LPSECURITY_ATTRIBUTES, lpsa,
80 BOOL, fManualReset,
81 BOOL, fInitialState,
82 LPCTSTR, lpszEventName)
83{
84 return(HMCreateEvent(lpsa, /* create event semaphore */
85 fManualReset,
86 fInitialState,
87 lpszEventName));
88}
89
90
91/*****************************************************************************
92 * Name : BOOL CreateEventW
93 * Purpose : forward call to Open32
94 * Parameters:
95 * Variables :
96 * Result :
97 * Remark : handle translation is done in CreateEventA
98 * Status :
99 *
100 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
101 *****************************************************************************/
102
103ODINFUNCTION4(HANDLE, CreateEventW,
104 LPSECURITY_ATTRIBUTES, arg1,
105 BOOL, arg2,
106 BOOL, arg3,
107 LPCWSTR, arg4)
108{
109 HANDLE rc;
110 char *astring;
111
112 if (arg4 != NULL) // support for unnamed semaphores
113 astring = UnicodeToAsciiString((LPWSTR)arg4);
114 else
115 astring = NULL;
116
117 dprintf(("KERNEL32: CreateEventW(%s)\n",
118 astring));
119
120 rc = HMCreateEvent(arg1,
121 arg2,
122 arg3,
123 astring);
124
125 if (astring != NULL)
126 FreeAsciiString(astring);
127
128 return(rc);
129}
130
131
132/*****************************************************************************
133 * Name : BOOL CreateMutexA
134 * Purpose : forward call to Open32
135 * Parameters:
136 * Variables :
137 * Result :
138 * Remark : handle translation is done in CreateMutexA
139 * Status :
140 *
141 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
142 *****************************************************************************/
143
144ODINFUNCTION3(HANDLE, CreateMutexA,
145 LPSECURITY_ATTRIBUTES, lpsa,
146 BOOL, fInitialOwner,
147 LPCTSTR, lpszMutexName)
148{
149 dprintf(("KERNEL32: CreateMutexA(%s)\n",
150 lpszMutexName));
151
152 return(HMCreateMutex(lpsa,
153 fInitialOwner,
154 lpszMutexName));
155}
156
157
158/*****************************************************************************
159 * Name : BOOL CreateMutexW
160 * Purpose : forward call to Open32
161 * Parameters:
162 * Variables :
163 * Result :
164 * Remark : handle translation is done in CreateMutexW
165 * Status :
166 *
167 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
168 *****************************************************************************/
169
170ODINFUNCTION3(HANDLE, CreateMutexW,
171 PSECURITY_ATTRIBUTES, arg1,
172 BOOL, arg2,
173 LPCWSTR, arg3)
174{
175 HANDLE rc;
176 char *astring;
177
178 if (arg3 != NULL) // support for unnamed mutexes
179 astring = UnicodeToAsciiString((LPWSTR)arg3);
180 else
181 astring = NULL;
182
183 dprintf(("KERNEL32: CreateMutexW(%s)\n",
184 astring));
185
186 rc = HMCreateMutex(arg1,
187 arg2,
188 astring);
189
190 if (astring != NULL)
191 FreeAsciiString(astring);
192
193 return(rc);
194}
195
196
197/*****************************************************************************
198 * Name : BOOL ReleaseMutex
199 * Purpose : forward call to Open32
200 * Parameters:
201 * Variables :
202 * Result :
203 * Remark : handle translation is done in ReleaseMutex
204 * Status :
205 *
206 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
207 *****************************************************************************/
208
209ODINFUNCTION1(BOOL, ReleaseMutex,
210 HANDLE, mutex)
211{
212 return(HMReleaseMutex(mutex));
213}
214
215
216/*****************************************************************************
217 * Name : BOOL SetEvent
218 * Purpose : forward call to Open32
219 * Parameters:
220 * Variables :
221 * Result :
222 * Remark : handle translation is done in SetEvent
223 * Status :
224 *
225 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
226 *****************************************************************************/
227
228ODINFUNCTION1(BOOL, SetEvent,
229 HANDLE, hEvent)
230{
231 return(HMSetEvent(hEvent));
232}
233
234
235/*****************************************************************************
236 * Name : BOOL WaitForSingleObject
237 * Purpose : forward call to Open32
238 * Parameters:
239 * Variables :
240 * Result :
241 * Remark : handle translation is done in WaitForSingleObject
242 * Status :
243 *
244 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
245 *****************************************************************************/
246
247ODINFUNCTION2(DWORD, WaitForSingleObject,
248 HANDLE, hObject,
249 DWORD, timeout)
250{
251 return(HMWaitForSingleObject(hObject,
252 timeout));
253}
254
255
256/*****************************************************************************
257 * Name : DWORD WaitForSingleObjectEx
258 * Purpose : The WaitForSingleObjectEx function is an extended wait function
259 * that can be used to perform an alertable wait. This enables the
260 * function to return when the system queues an I/O completion
261 * routine to be executed by the calling thread. The function also
262 * returns when the specified object is in the signaled state or
263 * when the time-out interval elapses.
264 * Parameters: HANDLE hObject handle of object to wait for
265 * DWORD dwTimeout time-out interval in milliseconds
266 * BOOL fAlertable alertable wait flag
267 * Variables :
268 * Result : 0xFFFFFFFF in case of error
269 * Remark : only really required for async I/O
270 * Status : UNTESTED STUB
271 *
272 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
273 *****************************************************************************/
274
275ODINFUNCTION3(DWORD, WaitForSingleObjectEx,
276 HANDLE, hObject,
277 DWORD, dwTimeout,
278 BOOL, fAlertable)
279{
280 dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
281 hObject,
282 dwTimeout,
283 fAlertable));
284
285 return(HMWaitForSingleObjectEx(hObject,
286 dwTimeout,
287 fAlertable));
288}
289
290
291/*****************************************************************************
292 * Name : BOOL FlushFileBuffers
293 * Purpose : forward call to Open32
294 * Parameters:
295 * Variables :
296 * Result :
297 * Remark : handle translation is done in FlushFileBuffers
298 * Status :
299 *
300 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
301 *****************************************************************************/
302
303ODINFUNCTION1(BOOL, FlushFileBuffers,
304 HANDLE, hFile)
305{
306 return(HMFlushFileBuffers(hFile));
307}
308
309
310/*****************************************************************************
311 * Name : UINT SetHandleCount
312 * Purpose : forward call to Open32
313 * Parameters:
314 * Variables :
315 * Result :
316 * Remark : handle translation is done in SetHandleCount
317 * Status :
318 *
319 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
320 *****************************************************************************/
321
322ODINFUNCTION1(UINT, SetHandleCount,
323 UINT, cHandles)
324{
325 //SvL: Has no effect in NT; also ignore it
326 return cHandles;
327}
328
329
330/*****************************************************************************
331 * Name : BOOL DuplicateHandle
332 * Purpose : forward call to Open32
333 * Parameters:
334 * Variables :
335 * Result :
336 * Remark : handle translation is done in DuplicateHandle
337 * Status :
338 *
339 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
340 *****************************************************************************/
341
342//******************************************************************************
343//SvL: 24-6-'97 - Added
344//SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
345//******************************************************************************
346ODINFUNCTION7(BOOL, DuplicateHandle,
347 HANDLE, srcprocess,
348 HANDLE, srchandle,
349 HANDLE, destprocess,
350 PHANDLE, desthandle,
351 DWORD, arg5,
352 BOOL, arg6,
353 DWORD, arg7)
354{
355 BOOL rc;
356
357 rc = HMDuplicateHandle(srcprocess,
358 srchandle,
359 destprocess,
360 desthandle,
361 arg5,
362 arg6,
363 arg7);
364 //@@@PH: (temporary) fix for non-HandleManager handles
365 if (rc == FALSE)
366 rc = O32_DuplicateHandle(srcprocess,
367 srchandle,
368 destprocess,
369 desthandle,
370 arg5,
371 arg6,
372 arg7);
373
374 return(rc);
375}
376
377
378/*****************************************************************************
379 * Name : BOOL CreateSemaphoreA
380 * Purpose : forward call to Open32
381 * Parameters:
382 * Variables :
383 * Result :
384 * Remark : handle translation is done in CreateSemaphoreA
385 * Status :
386 *
387 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
388 *****************************************************************************/
389
390ODINFUNCTION4(HANDLE, CreateSemaphoreA,
391 LPSECURITY_ATTRIBUTES, arg1,
392 LONG, arg2,
393 LONG, arg3,
394 LPCSTR, arg4)
395{
396 return HMCreateSemaphore(arg1,
397 arg2,
398 arg3,
399 (LPSTR)arg4);
400}
401
402
403/*****************************************************************************
404 * Name : BOOL CreateSemaphoreW
405 * Purpose : forward call to Open32
406 * Parameters:
407 * Variables :
408 * Result :
409 * Remark : handle translation is done in CreateSemaphoreW
410 * Status :
411 *
412 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
413 *****************************************************************************/
414
415ODINFUNCTION4(HANDLE, CreateSemaphoreW,
416 PSECURITY_ATTRIBUTES, arg1,
417 LONG, arg2,
418 LONG, arg3,
419 LPCWSTR, arg4)
420{
421 HANDLE rc;
422 char *astring;
423
424 if (arg4 != NULL) // support for unnamed semaphores
425 astring = UnicodeToAsciiString((LPWSTR)arg4);
426 else
427 astring = NULL;
428
429 dprintf(("KERNEL32: CreateSemaphoreW(%s)\n",
430 astring));
431
432 rc = HMCreateSemaphore(arg1,
433 arg2,
434 arg3,
435 astring);
436
437 if (astring != NULL)
438 FreeAsciiString(astring);
439 return(rc);
440}
441
442/*****************************************************************************
443 * Name : BOOL OpenEventA
444 * Purpose : forward call to Open32
445 * Parameters:
446 * Variables :
447 * Result :
448 * Remark : handle translation is done in OpenEventA
449 * Status :
450 *
451 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
452 *****************************************************************************/
453
454ODINFUNCTION3(HANDLE, OpenEventA,
455 DWORD, arg1,
456 BOOL, arg2,
457 LPCSTR, arg3)
458{
459 dprintf(("KERNEL32: OpenEventA(%s)\n",
460 arg3));
461
462 return HMOpenEvent(arg1,
463 arg2,
464 arg3);
465}
466
467
468/*****************************************************************************
469 * Name : BOOL
470 * Purpose : forward call to Open32
471 * Parameters:
472 * Variables :
473 * Result :
474 * Remark : handle translation is done in OpenEventW
475 * Status :
476 *
477 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
478 *****************************************************************************/
479
480ODINFUNCTION3(HANDLE, OpenEventW,
481 DWORD, dwDesiredAccess,
482 BOOL, bInheritHandle,
483 LPCWSTR, lpName)
484{
485 char *asciiname;
486 HANDLE rc;
487
488 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
489
490 dprintf(("KERNEL32: OpenEventW(%s)\n",
491 asciiname));
492
493 rc = HMOpenEvent(dwDesiredAccess,
494 bInheritHandle,
495 asciiname);
496 FreeAsciiString(asciiname);
497 return(rc);
498}
499
500
501/*****************************************************************************
502 * Name : BOOL OpenMutexA
503 * Purpose : forward call to Open32
504 * Parameters:
505 * Variables :
506 * Result :
507 * Remark : handle translation is done in OpenMutexA
508 * Status :
509 *
510 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
511 *****************************************************************************/
512
513ODINFUNCTION3(HANDLE, OpenMutexA,
514 DWORD, arg1,
515 BOOL, arg2,
516 LPCSTR, arg3)
517{
518 dprintf(("KERNEL32: OpenMutexA(%s)\n",
519 arg3));
520
521 return HMOpenMutex(arg1,
522 arg2,
523 arg3);
524}
525
526
527/*****************************************************************************
528 * Name : BOOL OpenMutexW
529 * Purpose : forward call to Open32
530 * Parameters:
531 * Variables :
532 * Result :
533 * Remark : handle translation is done in OpenMutexW
534 * Status :
535 *
536 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
537 *****************************************************************************/
538
539ODINFUNCTION3(HANDLE, OpenMutexW,
540 DWORD, dwDesiredAccess,
541 BOOL, bInheritHandle,
542 LPCWSTR, lpName)
543{
544 char *asciiname;
545 HANDLE rc;
546
547 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
548
549 dprintf(("KERNEL32: OpenMutexW(%s)\n",
550 asciiname));
551
552 rc = HMOpenMutex(dwDesiredAccess,
553 bInheritHandle,
554 asciiname);
555 FreeAsciiString(asciiname);
556 return(rc);
557}
558
559
560/*****************************************************************************
561 * Name : BOOL OpenSemaphoreA
562 * Purpose : forward call to Open32
563 * Parameters:
564 * Variables :
565 * Result :
566 * Remark : handle translation is done in OpenSemaphoreA
567 * Status :
568 *
569 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
570 *****************************************************************************/
571
572ODINFUNCTION3(HANDLE, OpenSemaphoreA,
573 DWORD, arg1,
574 BOOL, arg2,
575 LPCSTR, arg3)
576{
577 dprintf(("KERNEL32: OpenSemaphoreA(%s)\n",
578 arg3));
579
580 return HMOpenSemaphore(arg1,
581 arg2,
582 arg3);
583}
584
585
586/*****************************************************************************
587 * Name : BOOL OpenSemaphoreW
588 * Purpose : forward call to Open32
589 * Parameters:
590 * Variables :
591 * Result :
592 * Remark : handle translation is done in OpenSemaphoreW
593 * Status :
594 *
595 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
596 *****************************************************************************/
597
598ODINFUNCTION3(HANDLE, OpenSemaphoreW,
599 DWORD, dwDesiredAccess,
600 BOOL, bInheritHandle,
601 LPCWSTR, lpName)
602{
603 char *asciiname;
604 HANDLE rc;
605
606 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
607
608 dprintf(("KERNEL32: OpenSemaphoreW(%s)\n",
609 asciiname));
610
611 rc = HMOpenSemaphore(dwDesiredAccess,
612 bInheritHandle,
613 asciiname);
614 FreeAsciiString(asciiname);
615 return(rc);
616}
617
618
619/*****************************************************************************
620 * Name : BOOL PulseEvent
621 * Purpose : forward call to Open32
622 * Parameters:
623 * Variables :
624 * Result :
625 * Remark : handle translation is done in PulseEvent
626 * Status :
627 *
628 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
629 *****************************************************************************/
630
631ODINFUNCTION1(BOOL, PulseEvent,
632 HANDLE, arg1)
633{
634 return HMPulseEvent(arg1);
635}
636
637
638/*****************************************************************************
639 * Name : BOOL ReleaseSemaphore
640 * Purpose : forward call to Open32
641 * Parameters:
642 * Variables :
643 * Result :
644 * Remark : handle translation is done in ReleaseSemaphore
645 * Status :
646 *
647 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
648 *****************************************************************************/
649
650ODINFUNCTION3(BOOL, ReleaseSemaphore,
651 HANDLE, arg1,
652 LONG, arg2,
653 PLONG, arg3)
654{
655 return HMReleaseSemaphore(arg1,
656 arg2,
657 arg3);
658}
659
660
661/*****************************************************************************
662 * Name : BOOL ResetEvent
663 * Purpose : forward call to Open32
664 * Parameters:
665 * Variables :
666 * Result :
667 * Remark : handle translation is done in ResetEvent
668 * Status :
669 *
670 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
671 *****************************************************************************/
672
673ODINFUNCTION1(BOOL, ResetEvent,
674 HANDLE, arg1)
675{
676 return HMResetEvent(arg1);
677}
678
679
680/*****************************************************************************
681 * Name : BOOL WaitForMultipleObjects
682 * Purpose : forward call to Open32
683 * Parameters:
684 * Variables :
685 * Result :
686 * Remark : handle translation is done in WaitForMultipleObjects
687 * Status :
688 *
689 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
690 *****************************************************************************/
691
692ODINFUNCTION4(DWORD, WaitForMultipleObjects,
693 DWORD, arg1,
694 const HANDLE *, arg2,
695 BOOL, arg3,
696 DWORD, arg4)
697{
698 return HMWaitForMultipleObjects(arg1,
699 (PHANDLE)arg2,
700 arg3,
701 arg4);
702}
703
704
705/*****************************************************************************
706 * Name : DWORD OS2WaitForMultipleObjectsEx
707 * Purpose : The WaitForMultipleObjectsEx function is an extended wait
708 * function that can be used to perform an alertable wait. This
709 * enables the function to return when the system queues an I/O
710 * completion routine to be executed by the calling thread. The
711 * function also returns either when any one or when all of the
712 * specified objects are in the signaled state, or when the
713 * time-out interval elapses.
714 * Parameters: DWORD cObjects number of handles in handle array
715 * HANDLE *lphObjects address of object-handle array
716 * BOOL fWaitAll wait flag
717 * DWORD dwTimeout time-out interval in milliseconds
718 * BOOL fAlertable alertable wait flag
719 * Variables :
720 * Result : 0xFFFFFFFF in case of error
721 * Remark : only really required for async I/O
722 * Status : UNTESTED STUB
723 *
724 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
725 *****************************************************************************/
726
727ODINFUNCTION5(DWORD, WaitForMultipleObjectsEx,
728 DWORD, cObjects,
729 CONST HANDLE *, lphObjects,
730 BOOL, fWaitAll,
731 DWORD, dwTimeout,
732 BOOL, fAlertable)
733{
734 return(HMWaitForMultipleObjectsEx(cObjects,
735 (PHANDLE)lphObjects,
736 fWaitAll,
737 dwTimeout,
738 fAlertable));
739}
740
741
742/*****************************************************************************
743 * Name : HANDLE ConvertToGlobalHandle
744 * Purpose : forward call to Open32
745 * Parameters:
746 * Variables :
747 * Result :
748 * Remark : handle translation is done in ConvertToGlobalHandle
749 * Status :
750 *
751 * Author : Patrick Haller [Fri, 1999/06/18 03:44]
752 *****************************************************************************/
753
754ODINFUNCTION1(HANDLE, ConvertToGlobalHandle,
755 HANDLE, hHandle)
756
757//ODINFUNCTION2(HANDLE, ConvertToGlobalHandle,
758// HANDLE, hHandle,
759// BOOL, fInherit)
760{
761 return (hHandle);
762}
763
764//******************************************************************************
765//******************************************************************************
766ODINFUNCTION6(HANDLE,CreateThread,LPSECURITY_ATTRIBUTES, lpsa,
767 DWORD, cbStack,
768 LPTHREAD_START_ROUTINE, lpStartAddr,
769 LPVOID, lpvThreadParm,
770 DWORD, fdwCreate,
771 LPDWORD, lpIDThread)
772{
773 return HMCreateThread(lpsa, cbStack, lpStartAddr, lpvThreadParm, fdwCreate, lpIDThread);
774}
775//******************************************************************************
776//******************************************************************************
777INT WIN32API GetThreadPriority(HANDLE hThread)
778{
779 return HMGetThreadPriority(hThread);
780}
781//******************************************************************************
782//******************************************************************************
783DWORD WIN32API SuspendThread(HANDLE hThread)
784{
785 return HMSuspendThread(hThread);
786}
787//******************************************************************************
788//******************************************************************************
789BOOL WIN32API SetThreadPriority(HANDLE hThread, int priority)
790{
791 return HMSetThreadPriority(hThread, priority);
792}
793//******************************************************************************
794//******************************************************************************
795BOOL WIN32API GetThreadContext(HANDLE hThread, PCONTEXT lpContext)
796{
797 return HMGetThreadContext(hThread, lpContext);
798}
799//******************************************************************************
800//******************************************************************************
801BOOL WIN32API SetThreadContext(HANDLE hThread, const CONTEXT *lpContext)
802{
803 return HMSetThreadContext(hThread, lpContext);
804}
805//******************************************************************************
806//******************************************************************************
807BOOL WIN32API TerminateThread(HANDLE hThread, DWORD exitcode)
808{
809 return HMTerminateThread(hThread, exitcode);
810}
811//******************************************************************************
812//******************************************************************************
813DWORD WIN32API ResumeThread(HANDLE hThread)
814{
815 return HMResumeThread(hThread);
816}
817//******************************************************************************
818//******************************************************************************
819BOOL WIN32API GetExitCodeThread(HANDLE hThread, LPDWORD arg2)
820{
821 return HMGetExitCodeThread(hThread, arg2);
822}
823//******************************************************************************
824//******************************************************************************
Note: See TracBrowser for help on using the repository browser.