source: trunk/src/kernel32/old/kobjects.cpp@ 2017

Last change on this file since 2017 was 955, checked in by sandervl, 26 years ago

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