source: trunk/src/kernel32/KERNEL32.CPP@ 112

Last change on this file since 112 was 111, checked in by phaller, 26 years ago

Fix: major restructuring of Open32 handle management, HandleManager
File size: 58.5 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.5 1999-06-17 18:21:36 phaller Exp $ */
2
3/*
4 *
5 * Project Odin Software License can be found in LICENSE.TXT
6 *
7 */
8/*
9 * Win32 compatibility file functions for OS/2
10 *
11 * Copyright 1998 Sander van Leeuven
12 * Copyright 1998 Patrick Haller
13 * Copyright 1998 Peter Fitzsimmons
14 * Copyright 1998 Knut St. Osmundsen
15 *
16 * @(#) KERNEL32.CPP 1.0.1 1998/06/12 PH added HandleManager support
17 */
18
19
20/*****************************************************************************
21 * Includes *
22 *****************************************************************************/
23#include <os2win.h>
24#include <winnt.h>
25#include <winnls.h>
26#include <stdlib.h>
27#include <string.h>
28#include "misc.h"
29#include "devio.h"
30#include "except.h"
31#include <builtin.h>
32#include "heap.h"
33#include "handlemanager.h"
34#include "os2util.h"
35#include "wprocess.h"
36
37
38/*****************************************************************************
39 * Defines *
40 *****************************************************************************/
41
42 /* this define enables certain less important debug messages */
43//#define DEBUG_LOCAL 1
44
45
46
47/*****************************************************************************
48 * Name : BOOL WIN32API CreateEventA
49 * Purpose : forward call to Open32
50 * Parameters:
51 * Variables :
52 * Result :
53 * Remark :
54 * Status :
55 *
56 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
57 *****************************************************************************/
58
59HANDLE WIN32API CreateEventA(LPSECURITY_ATTRIBUTES lpsa,
60 BOOL fManualReset,
61 BOOL fInitialState,
62 LPCTSTR lpszEventName)
63{
64 ULONG rc; /* API returncode */
65 HANDLE hOS2; /* 32-bit OS/2 handle */
66 HANDLE hWindows; /* 16-bit Windows handle */
67
68 dprintf(("KERNEL32::CreateEventA(%08xh, %08xh, %08xh, %s)\n",
69 lpsa,
70 fManualReset,
71 fInitialState,
72 lpszEventName));
73
74 hOS2 = O32_CreateEvent(lpsa, /* create event semaphore */
75 fManualReset,
76 fInitialState,
77 lpszEventName);
78 if (hOS2 != 0) /* check handle */
79 {
80 rc = HMHandleAllocate(&hWindows, /* allocate handle */
81 hOS2);
82 if (rc == NO_ERROR) /* check for errors */
83 return (hWindows); /* return translated handle */
84 else
85 return (0); /* raise error condition */
86 }
87
88 return (hOS2); /* should have the correct error value here */
89}
90
91/*****************************************************************************
92 * Name : BOOL WIN32API CloseHandle
93 * Purpose : forward call to Open32
94 * Parameters:
95 * Variables :
96 * Result :
97 * Remark :
98 * Status :
99 *
100 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
101 *****************************************************************************/
102BOOL WIN32API CloseHandle(HANDLE hHandle)
103{
104 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
105 hHandle));
106
107 return HMCloseHandle(hHandle);
108}
109
110
111/*****************************************************************************
112 * Name : BOOL WIN32API CreateEventW
113 * Purpose : forward call to Open32
114 * Parameters:
115 * Variables :
116 * Result :
117 * Remark : handle translation is done in CreateEventA
118 * Status :
119 *
120 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
121 *****************************************************************************/
122
123HANDLE WIN32API CreateEventW(PSECURITY_ATTRIBUTES arg1,
124 BOOL arg2,
125 BOOL arg3,
126 LPCWSTR arg4)
127{
128 HANDLE rc;
129 char *astring;
130
131 dprintf(("KERNEL32::CreateEventW>(%08xh, %08xh, %08xh, %s)\n",
132 arg1,
133 arg2,
134 arg3,
135 arg4));
136
137 astring = UnicodeToAsciiString((LPWSTR)arg4);
138
139 rc = O32_CreateEvent(arg1,
140 arg2,
141 arg3,
142 astring);
143
144 FreeAsciiString(astring);
145
146 return(rc);
147}
148///@@@PH handlemanager
149//******************************************************************************
150//******************************************************************************
151HANDLE WIN32API CreateMutexA(LPSECURITY_ATTRIBUTES lpsa,
152 BOOL fInitialOwner,
153 LPCTSTR lpszMutexName)
154{
155 dprintf(("KERNEL32: CreateMutex\n"));
156
157 return(O32_CreateMutex(lpsa,
158 fInitialOwner,
159 lpszMutexName));
160}
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: OS2CreateMutexW\n"));
171
172 astring = UnicodeToAsciiString((LPWSTR)arg3);
173 rc = O32_CreateMutex(arg1,
174 arg2,
175 astring);
176 FreeAsciiString(astring);
177
178 return(rc);
179}
180//******************************************************************************
181//******************************************************************************
182HANDLE WIN32API GetModuleHandleA(LPCTSTR lpszModule)
183{
184 HANDLE hMod;
185
186 hMod = OS2iGetModuleHandleA( (PSZ) lpszModule);
187 eprintf(("KERNEL32: GetModuleHandle %s returned %X\n", lpszModule, hMod));
188 return(hMod);
189}
190//******************************************************************************
191//******************************************************************************
192HMODULE WIN32API GetModuleHandleW(LPCWSTR arg1)
193{
194 HMODULE rc;
195 char *astring;
196
197 astring = UnicodeToAsciiString((LPWSTR)arg1);
198 rc = O32_GetModuleHandle(astring);
199 dprintf(("KERNEL32: OS2GetModuleHandleW %s returned %X\n", astring, rc));
200 FreeAsciiString(astring);
201 return(rc);
202}
203//******************************************************************************
204//******************************************************************************
205HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
206{
207 HANDLE handle;
208
209 /* @@@PH 1998/02/12 Handle Manager Support */
210 handle = HMGetStdHandle(fdwDevice);
211
212 //@@@PH translate handle
213
214 /* handle = GetStdHandle(fdwDevice); */
215 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
216 return(handle);
217}
218//******************************************************************************
219//******************************************************************************
220BOOL WIN32API ReleaseMutex(HANDLE mutex)
221{
222 dprintf(("KERNEL32: ReleaseMutex\n"));
223 return(O32_ReleaseMutex(mutex));
224}
225//******************************************************************************
226//******************************************************************************
227BOOL WIN32API SetEvent(HANDLE hEvent)
228{
229 dprintf(("KERNEL32: SetEvent\n"));
230 return(O32_SetEvent(hEvent));
231}
232//******************************************************************************
233//******************************************************************************
234BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
235 HANDLE hHandle)
236{
237 dprintf(("KERNEL32: SetStdHandle\n"));
238
239 ///@@@PH translate handle
240
241 return (HMSetStdHandle(IDStdHandle,
242 hHandle));
243}
244//******************************************************************************
245//******************************************************************************
246DWORD WIN32API TlsAlloc()
247{
248 dprintf(("KERNEL32: TlsAlloc\n"));
249 return(O32_TlsAlloc());
250}
251//******************************************************************************
252//******************************************************************************
253BOOL WIN32API TlsFree(DWORD index)
254{
255 dprintf(("KERNEL32: TlsFree\n"));
256 return(O32_TlsFree(index));
257}
258//******************************************************************************
259//******************************************************************************
260LPVOID WIN32API TlsGetValue(DWORD index)
261{
262 LPVOID rc;
263
264 rc = O32_TlsGetValue(index);
265// dprintf(("KERNEL32: TlsGetValue %d returned %X\n", index, rc));
266 return(rc);
267}
268//******************************************************************************
269//******************************************************************************
270BOOL WIN32API TlsSetValue(DWORD index, LPVOID val)
271{
272// dprintf(("KERNEL32: TlsSetValue\n"));
273 return(O32_TlsSetValue(index, val));
274}
275//******************************************************************************
276//******************************************************************************
277DWORD WIN32API WaitForSingleObject(HANDLE hObject,
278 DWORD timeout)
279{
280 dprintf(("KERNEL32: WaitForSingleObject (%08xh, %08xh)\n",
281 hObject,
282 timeout));
283
284 return(O32_WaitForSingleObject(hObject,
285 timeout));
286}
287//******************************************************************************
288
289
290/*****************************************************************************
291 * Name : DWORD OS2WaitForSingleObjectEx
292 * Purpose : The WaitForSingleObjectEx function is an extended wait function
293 * that can be used to perform an alertable wait. This enables the
294 * function to return when the system queues an I/O completion
295 * routine to be executed by the calling thread. The function also
296 * returns when the specified object is in the signaled state or
297 * when the time-out interval elapses.
298 * Parameters: HANDLE hObject handle of object to wait for
299 * DWORD dwTimeout time-out interval in milliseconds
300 * BOOL fAlertable alertable wait flag
301 * Variables :
302 * Result : 0xFFFFFFFF in case of error
303 * Remark : only really required for async I/O
304 * Status : UNTESTED STUB
305 *
306 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
307 *****************************************************************************/
308
309DWORD WIN32API WaitForSingleObjectEx(HANDLE hObject,
310 DWORD dwTimeout,
311 BOOL fAlertable)
312{
313 dprintf(("Kernel32: WaitForSingleObjectEx(%08xh,%08xh,%08xh) not implemented correctly.\n",
314 hObject,
315 dwTimeout,
316 fAlertable));
317
318 return(O32_WaitForSingleObject(hObject,
319 dwTimeout));
320}
321
322//******************************************************************************
323//******************************************************************************
324BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
325{
326#ifdef DEBUG
327 BOOL rc;
328
329 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
330 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
331 return(rc);
332#else
333 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
334#endif
335}
336//******************************************************************************
337//******************************************************************************
338BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
339{
340#ifdef DEBUG
341 BOOL rc;
342
343 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
344 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
345 return(rc);
346#else
347 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
348#endif
349}
350//******************************************************************************
351//******************************************************************************
352BOOL WIN32API IsBadCodePtr( FARPROC arg1)
353{
354 dprintf(("KERNEL32: IsBadCodePtr\n"));
355 return O32_IsBadCodePtr(arg1);
356}
357//******************************************************************************
358//******************************************************************************
359BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
360{
361 dprintf(("KERNEL32: IsBadStringPtr"));
362 return O32_IsBadStringPtr(arg1, arg2);
363}
364//******************************************************************************
365//******************************************************************************
366BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
367{
368 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
369 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
370}
371//******************************************************************************
372//******************************************************************************
373DWORD WIN32API GetLastError()
374{
375 DWORD rc;
376
377 rc = O32_GetLastError();
378#ifdef DEBUG_LOCAL
379 dprintf(("KERNEL32: GetLastError returned %d\n", rc));
380#endif
381 return(rc);
382}
383//******************************************************************************
384//******************************************************************************
385VOID WIN32API SetLastError( DWORD arg1)
386{
387// dprintf(("KERNEL32: SetLastError to %d\n", arg1));
388 O32_SetLastError(arg1);
389}
390//******************************************************************************
391//******************************************************************************
392UINT WIN32API GetOEMCP(VOID)
393{
394 dprintf(("KERNEL32: GetOEMCP\n"));
395 return(O32_GetOEMCP());
396}
397//******************************************************************************
398//******************************************************************************
399UINT WIN32API GetACP(VOID)
400{
401 dprintf(("KERNEL32: GetACP\n"));
402 return(O32_GetACP());
403}
404//******************************************************************************
405//******************************************************************************
406BOOL WIN32API FlushFileBuffers(HANDLE hFile)
407{
408 dprintf(("KERNEL32: FlushFileBuffers\n"));
409 return(O32_FlushFileBuffers(hFile));
410}
411//******************************************************************************
412//******************************************************************************
413LONG WIN32API InterlockedDecrement(LPLONG lplVal)
414{
415 dprintf(("KERNEL32: InterlockedDecrement\n"));
416 return(O32_InterlockedDecrement(lplVal));
417}
418//******************************************************************************
419//******************************************************************************
420LONG WIN32API InterlockedIncrement(LPLONG lplVal)
421{
422 dprintf(("KERNEL32: InterlockedIncrement\n"));
423 return(O32_InterlockedIncrement(lplVal));
424}
425//******************************************************************************
426//******************************************************************************
427LONG WIN32API InterlockedExchange( PLONG arg1, LONG arg2)
428{
429 dprintf(("KERNEL32: InterlockedExchange\n"));
430 return O32_InterlockedExchange(arg1, arg2);
431}
432//******************************************************************************
433//******************************************************************************
434UINT WIN32API SetHandleCount(UINT cHandles)
435{
436 dprintf(("KERNEL32: GetHandleCount\n"));
437 return(O32_SetHandleCount(cHandles));
438}
439//******************************************************************************
440//******************************************************************************
441LPWSTR WIN32API GetEnvironmentStringsW(VOID)
442{
443 char *envstrings = (char *)O32_GetEnvironmentStrings();
444 char *tmp;
445 LPWSTR wenvstrings;
446 int len, i;
447
448 dprintf(("KERNEL32: GetEnvironmentStringsW\n"));
449
450 if(envstrings == NULL)
451 return(NULL);
452
453 tmp = envstrings;
454 len = 0;
455 while(*tmp != 0)
456 {
457 len += strlen(tmp)+1;
458 tmp = envstrings + len;
459 }
460 len++; //terminating 0
461 wenvstrings = (LPWSTR)malloc(len*sizeof(WCHAR));
462 for(i=0;
463 i<len;
464 i++)
465 {
466 wenvstrings[i] = envstrings[i];
467 }
468 return(wenvstrings);
469}
470//******************************************************************************
471//******************************************************************************
472BOOL WIN32API FreeEnvironmentStringsA(LPSTR envstrings)
473{
474 dprintf(("KERNEL32: FreeEnvironmentStringsA\n"));
475 return(TRUE);
476}
477//******************************************************************************
478//******************************************************************************
479BOOL WIN32API FreeEnvironmentStringsW(LPWSTR envstrings)
480{
481 dprintf(("KERNEL32: FreeEnvironmentStringsW\n"));
482 free(envstrings);
483 return(TRUE);
484}
485//******************************************************************************
486//******************************************************************************
487BOOL WIN32API GetStringTypeW(DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
488{
489 int i;
490
491 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
492 if((DWORD)lpSrcStr == (DWORD)lpCharType || !lpSrcStr || !lpCharType) {
493 O32_SetLastError(ERROR_INVALID_PARAMETER);
494 return(FALSE);
495 }
496 if(cchSrc == -1)
497 cchSrc = UniStrlen((UniChar*)lpSrcStr);
498
499 memset(lpCharType, 0, cchSrc*sizeof(WORD));
500 switch(fdwInfoType) {
501 case CT_CTYPE1:
502 for(i=0;i<cchSrc;i++) {
503 if(lpSrcStr[i] >= (WCHAR)'a' && lpSrcStr[i] <= (WCHAR)'z')
504 lpCharType[i] |= C1_LOWER | C1_ALPHA;
505 else
506 if(lpSrcStr[i] >= (WCHAR)'A' && lpSrcStr[i] <= (WCHAR)'A')
507 lpCharType[i] |= C1_UPPER | C1_ALPHA;
508 else
509 if(lpSrcStr[i] >= (WCHAR)'0' && lpSrcStr[i] <= (WCHAR)'9')
510 lpCharType[i] |= C1_DIGIT;
511 else
512 if(lpSrcStr[i] >= (WCHAR)' ')
513 lpCharType[i] |= C1_SPACE;
514 }
515 break;
516 case CT_CTYPE2:
517 case CT_CTYPE3: //not supported right now
518 break;
519 }
520 return(TRUE);
521}
522//******************************************************************************
523//NOTE: This has one parameter more than the W version! (@#$@#$)
524//******************************************************************************
525BOOL WIN32API GetStringTypeA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
526{
527 int i;
528
529 dprintf(("KERNEL32: GetStringTypeA, not properly implemented\n"));
530 if(lpSrcStr == (LPCSTR)lpCharType || !lpSrcStr || !lpCharType) {
531 O32_SetLastError(ERROR_INVALID_PARAMETER);
532 return(FALSE);
533 }
534 if(cchSrc == -1)
535 cchSrc = strlen(lpSrcStr);
536
537 memset(lpCharType, 0, cchSrc*sizeof(WORD));
538 switch(fdwInfoType) {
539 case CT_CTYPE1:
540 for(i=0;i<cchSrc;i++) {
541 if(lpSrcStr[i] >= 'a' && lpSrcStr[i] <= 'z')
542 lpCharType[i] |= C1_LOWER | C1_ALPHA;
543 else
544 if(lpSrcStr[i] >= 'A' && lpSrcStr[i] <= 'A')
545 lpCharType[i] |= C1_UPPER | C1_ALPHA;
546 else
547 if(lpSrcStr[i] >= '0' && lpSrcStr[i] <= '9')
548 lpCharType[i] |= C1_DIGIT;
549 else
550 if(lpSrcStr[i] >= ' ')
551 lpCharType[i] |= C1_SPACE;
552 }
553 break;
554 case CT_CTYPE2:
555 case CT_CTYPE3: //not supported right now
556 break;
557 }
558 return(TRUE);
559}
560//******************************************************************************
561//******************************************************************************
562BOOL WIN32API GetStringTypeExW(LCID Locale, DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
563{
564 dprintf(("KERNEL32: GetStringTypeExW, not properly implemented\n"));
565 return(GetStringTypeW(fdwInfoType, lpSrcStr, cchSrc, lpCharType));
566}
567//******************************************************************************
568//******************************************************************************
569BOOL WIN32API GetStringTypeExA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
570{
571 dprintf(("KERNEL32: GetStringTypeExA, not properly implemented\n"));
572 return(GetStringTypeA(Locale, fdwInfoType, lpSrcStr, cchSrc, lpCharType));
573}
574//******************************************************************************
575//******************************************************************************
576VOID WIN32API EnterCriticalSection(CRITICAL_SECTION * lpcsCriticalSection)
577{
578//// dprintf(("KERNEL32: EnterCriticalSection\n"));
579 O32_EnterCriticalSection(lpcsCriticalSection);
580}
581//******************************************************************************
582//******************************************************************************
583VOID WIN32API LeaveCriticalSection(CRITICAL_SECTION * arg1)
584{
585//// dprintf(("KERNEL32: LeaveCriticalSection\n"));
586 O32_LeaveCriticalSection(arg1);
587}
588//******************************************************************************
589//******************************************************************************
590VOID WIN32API InitializeCriticalSection(CRITICAL_SECTION * arg1)
591{
592 dprintf(("KERNEL32: InitializeCriticalSection\n"));
593 O32_InitializeCriticalSection(arg1);
594}
595//******************************************************************************
596//******************************************************************************
597void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *arg1 )
598{
599 dprintf(("KERNEL32: MakeCriticalSectionGlobal not implemented correctly\n"));
600}
601//******************************************************************************
602//******************************************************************************
603BOOL WIN32API SetEnvironmentVariableA(LPCSTR arg1, LPCSTR arg2)
604{
605 dprintf(("KERNEL32: SetEnvironmentVariable %s to %s\n", arg1, arg2));
606 return O32_SetEnvironmentVariable(arg1, arg2);
607}
608//******************************************************************************
609//******************************************************************************
610BOOL WIN32API SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue)
611{
612 char *asciiname, *asciivalue;
613 BOOL rc;
614
615 dprintf(("KERNEL32: OS2SetEnvironmentVariableW\n"));
616 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
617 asciivalue = UnicodeToAsciiString((LPWSTR)lpValue);
618 rc = O32_SetEnvironmentVariable(asciiname, asciivalue);
619 FreeAsciiString(asciivalue);
620 FreeAsciiString(asciiname);
621 return(rc);
622}
623//******************************************************************************
624VOID WIN32API GlobalMemoryStatus( MEMORYSTATUS *arg1)
625{
626 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
627 O32_GlobalMemoryStatus(arg1);
628 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
629 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
630 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
631 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
632 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
633 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
634 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
635}
636//******************************************************************************
637//******************************************************************************
638DWORD WIN32API GetEnvironmentVariableA(LPCSTR arg1, LPSTR arg2, DWORD arg3)
639{
640 dprintf(("KERNEL32: GetEnvironmentVariable %s\n", arg1));
641 return O32_GetEnvironmentVariable(arg1, arg2, arg3);
642}
643//******************************************************************************
644//******************************************************************************
645DWORD WIN32API GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer,
646 DWORD nSize)
647{
648 char *astring, *asciibuffer;
649 DWORD rc;
650
651 dprintf(("KERNEL32: OS2GetEnvironmentVariableW\n"));
652 asciibuffer = (char *)malloc(nSize+1);
653 astring = UnicodeToAsciiString((LPWSTR)lpName);
654
655 rc = O32_GetEnvironmentVariable(astring, asciibuffer, nSize);
656 AsciiToUnicode(asciibuffer, lpBuffer);
657 FreeAsciiString(astring);
658 free(asciibuffer);
659 return(rc);
660}
661//******************************************************************************
662//******************************************************************************
663HINSTANCE WIN32API WinExec(LPCSTR arg1, UINT arg2)
664{
665 dprintf(("KERNEL32: WinExec %s\n", arg1));
666 return (HINSTANCE)O32_WinExec(arg1, arg2);
667}
668//******************************************************************************
669//******************************************************************************
670BOOL WIN32API GetExitCodeProcess(HANDLE arg1, LPDWORD arg2)
671{
672 dprintf(("KERNEL32: GetExitCodeProcess\n"));
673 return O32_GetExitCodeProcess(arg1, arg2);
674}
675//******************************************************************************
676//******************************************************************************
677HANDLE WIN32API GetCurrentProcess(void)
678{
679//// dprintf(("KERNEL32: GetCurrentProcess\n"));
680 return O32_GetCurrentProcess();
681}
682//******************************************************************************
683//******************************************************************************
684DWORD WIN32API GetCurrentProcessId(void)
685{
686 dprintf(("KERNEL32: GetCurrentProcessId\n"));
687 return O32_GetCurrentProcessId();
688}
689//******************************************************************************
690//******************************************************************************
691BOOL WIN32API TerminateProcess( HANDLE arg1, DWORD arg2)
692{
693 dprintf(("KERNEL32: TerminateProcess\n"));
694 return O32_TerminateProcess(arg1, arg2);
695}
696//******************************************************************************
697//******************************************************************************
698VOID WIN32API Sleep(DWORD arg1)
699{
700 dprintf(("KERNEL32: Sleep %d\n", arg1));
701 O32_Sleep(arg1);
702}
703//******************************************************************************
704//******************************************************************************
705DWORD WIN32API GetPriorityClass(HANDLE arg1)
706{
707 dprintf(("KERNEL32: GetPriorityClass\n"));
708 return O32_GetPriorityClass(arg1);
709}
710//******************************************************************************
711//******************************************************************************
712BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
713{
714 dprintf(("KERNEL32: SetPriorityClass\n"));
715 return O32_SetPriorityClass(arg1, arg2);
716}
717//******************************************************************************
718//TODO!
719//******************************************************************************
720int WIN32API LCMapStringW(
721 DWORD /*LCID*/ Locale,
722 DWORD dwMapFlags,
723 LPCWSTR lpSrcStr,
724 int cchSrc,
725 LPWSTR lpDestStr,
726 int cchDest)
727{
728 // quick hack! this code is not done!
729 if(cchSrc == -1)
730 cchSrc = strlen((const char *)lpSrcStr);
731 if(!cchDest)
732 return cchSrc;
733 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
734 return max(cchSrc, cchDest);
735}
736//******************************************************************************
737//TODO!
738//******************************************************************************
739int WIN32API LCMapStringA(
740 DWORD /*LCID*/ Locale,
741 DWORD dwMapFlags,
742 LPCSTR lpSrcStr,
743 int cchSrc,
744 LPSTR lpDestStr,
745 int cchDest)
746{
747 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
748 if(cchSrc == -1)
749 cchSrc = strlen((const char *)lpSrcStr);
750 if(!cchDest)
751 return cchSrc;
752 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
753 return max(cchSrc, cchDest);
754}
755//******************************************************************************
756//SvL: 24-6-'97 - Added
757//******************************************************************************
758VOID WIN32API DeleteCriticalSection( CRITICAL_SECTION * arg1)
759{
760 dprintf(("KERNEL32: OS2DeleteCriticalSection\n"));
761 O32_DeleteCriticalSection(arg1);
762}
763//******************************************************************************
764//SvL: 24-6-'97 - Added
765//SvL: 28-6-'97: Fix for timeSetEvent in Red Alert Map Editor
766//******************************************************************************
767BOOL WIN32API DuplicateHandle(HANDLE srcprocess, HANDLE srchandle, HANDLE destprocess,
768 PHANDLE desthandle, DWORD arg5, BOOL arg6, DWORD arg7)
769{
770 BOOL rc;
771
772#if 0
773 //SvL:
774 //If source & destination process are identical, just copy handle
775 //(if target pointer != NULL)
776 //timeSetEvent's timer handler expects to be called from another process,
777 //but we just create a separate timer thread inside the client process
778 if(srcprocess == destprocess) {
779 if(desthandle != NULL)
780 *desthandle = srchandle;
781 return(TRUE);
782 }
783#endif
784 rc = O32_DuplicateHandle(srcprocess, srchandle, destprocess, desthandle, arg5, arg6, arg7);
785//// dprintf(("KERNEL32: OS2DuplicateHandle returned %d\n", rc));
786 return(rc);
787}
788//******************************************************************************
789//******************************************************************************
790BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
791{
792 dprintf(("KERNEL32: OS2Beep\n"));
793 return O32_Beep(arg1, arg2);
794}
795//******************************************************************************
796//******************************************************************************
797HANDLE WIN32API CreateSemaphoreA(PSECURITY_ATTRIBUTES arg1, LONG arg2, LONG arg3, LPCSTR arg4)
798{
799 dprintf(("KERNEL32: OS2CreateSemaphoreA\n"));
800 return O32_CreateSemaphore(arg1, arg2, arg3, (LPSTR)arg4);
801}
802//******************************************************************************
803//******************************************************************************
804HANDLE WIN32API CreateSemaphoreW(PSECURITY_ATTRIBUTES arg1,
805 LONG arg2, LONG arg3,
806 LPCWSTR arg4)
807{
808 HANDLE rc;
809 char *astring;
810
811 dprintf(("KERNEL32: OS2CreateSemaphoreW"));
812 astring = UnicodeToAsciiString((LPWSTR)arg4);
813 rc = O32_CreateSemaphore(arg1, arg2, arg3, astring);
814 FreeAsciiString(astring);
815 return(rc);
816}
817//******************************************************************************
818//******************************************************************************
819VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
820{
821 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
822 O32_FatalAppExit(arg1, arg2);
823}
824//******************************************************************************
825//******************************************************************************
826VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
827{
828 char *astring;
829
830 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
831 astring = UnicodeToAsciiString((LPWSTR)arg2);
832 O32_FatalAppExit(arg1, astring);
833 //probably won't return, but who cares..
834 FreeAsciiString(astring);
835}
836//******************************************************************************
837//******************************************************************************
838VOID WIN32API FatalExit( UINT arg1)
839{
840 dprintf(("KERNEL32: OS2FatalExit\n"));
841 O32_FatalExit(arg1);
842}
843//******************************************************************************
844//******************************************************************************
845int WIN32API lstrlenA(LPCSTR arg1)
846{
847 dprintf(("KERNEL32: OS2lstrlen %X\n", arg1));
848 return O32_lstrlen(arg1);
849}
850//******************************************************************************
851//******************************************************************************
852int WIN32API lstrlenW(LPCWSTR arg1)
853{
854 int rc;
855
856 rc = UniStrlen( (UniChar*)arg1);
857 dprintf(("KERNEL32: OS2lstrlenW returns %d\n", rc));
858 return rc;
859}
860//******************************************************************************
861//******************************************************************************
862LPSTR WIN32API GetEnvironmentStringsA(void)
863{
864 dprintf(("KERNEL32: OS2GetEnvironmentStringsA\n"));
865 return (LPSTR) O32_GetEnvironmentStrings();
866}
867//******************************************************************************
868//******************************************************************************
869BOOL WIN32API GetOverlappedResult(HANDLE arg1, LPOVERLAPPED arg2, LPDWORD arg3, BOOL arg4)
870{
871 dprintf(("KERNEL32: OS2GetOverlappedResult\n"));
872 return O32_GetOverlappedResult(arg1, arg2, arg3, arg4);
873}
874//******************************************************************************
875//******************************************************************************
876BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
877{
878 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
879 return O32_IsBadHugeReadPtr(arg1, arg2);
880}
881//******************************************************************************
882//******************************************************************************
883BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
884{
885 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
886 return O32_IsBadHugeWritePtr(arg1, arg2);
887}
888//******************************************************************************
889//******************************************************************************
890BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
891{
892 dprintf(("KERNEL32: OS2IsDBCSLeadByte\n"));
893 return O32_IsDBCSLeadByte(arg1);
894}
895//******************************************************************************
896//******************************************************************************
897DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
898{
899 dprintf(("KERNEL32: OS2LoadModule\n"));
900 return O32_LoadModule(arg1, arg2);
901}
902//******************************************************************************
903//******************************************************************************
904int WIN32API MulDiv(int arg1, int arg2, int arg3)
905{
906 dprintf(("KERNEL32: OS2MulDiv %d*%d/%d\n", arg1, arg2, arg3));
907 return O32_MulDiv(arg1, arg2, arg3);
908}
909//******************************************************************************
910//******************************************************************************
911HANDLE WIN32API OpenEventA( DWORD arg1, BOOL arg2, LPCSTR arg3)
912{
913 dprintf(("KERNEL32: OS2OpenEventA\n"));
914 return O32_OpenEvent(arg1, arg2, arg3);
915}
916//******************************************************************************
917//******************************************************************************
918HANDLE WIN32API OpenEventW(DWORD dwDesiredAccess, BOOL bInheritHandle,
919 LPCWSTR lpName)
920{
921 char *asciiname;
922 HANDLE rc;
923
924 dprintf(("KERNEL32: OS2OpenEventW\n"));
925 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
926 rc = O32_OpenEvent(dwDesiredAccess, bInheritHandle, asciiname);
927 FreeAsciiString(asciiname);
928 return(rc);
929}
930//******************************************************************************
931//******************************************************************************
932HANDLE WIN32API OpenMutexA( DWORD arg1, BOOL arg2, LPCSTR arg3)
933{
934 dprintf(("KERNEL32: OS2OpenMutexA\n"));
935 return O32_OpenMutex(arg1, arg2, arg3);
936}
937//******************************************************************************
938//******************************************************************************
939HANDLE WIN32API OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle,
940 LPCWSTR lpName)
941{
942 char *asciiname;
943 HANDLE rc;
944
945 dprintf(("KERNEL32: OS2OpenMutexW\n"));
946 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
947 rc = O32_OpenMutex(dwDesiredAccess, bInheritHandle, asciiname);
948 FreeAsciiString(asciiname);
949 return(rc);
950}
951//******************************************************************************
952//******************************************************************************
953HANDLE WIN32API OpenProcess(DWORD arg1, BOOL arg2, DWORD arg3)
954{
955 dprintf(("KERNEL32: OS2OpenProcess\n"));
956 return O32_OpenProcess(arg1, arg2, arg3);
957}
958//******************************************************************************
959//******************************************************************************
960HANDLE WIN32API OpenSemaphoreA( DWORD arg1, BOOL arg2, LPCSTR arg3)
961{
962 dprintf(("KERNEL32: OS2OpenSemaphoreA"));
963 return O32_OpenSemaphore(arg1, arg2, arg3);
964}
965//******************************************************************************
966//******************************************************************************
967HANDLE WIN32API OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle,
968 LPCWSTR lpName)
969{
970 char *asciiname;
971 HANDLE rc;
972
973 dprintf(("KERNEL32: OS2OpenSemaphoreW"));
974 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
975 rc = O32_OpenSemaphore(dwDesiredAccess, bInheritHandle, asciiname);
976 FreeAsciiString(asciiname);
977 return(rc);
978}
979//******************************************************************************
980//******************************************************************************
981BOOL WIN32API PulseEvent( HANDLE arg1)
982{
983 dprintf(("KERNEL32: OS2PulseEvent\n"));
984 return O32_PulseEvent(arg1);
985}
986//******************************************************************************
987//******************************************************************************
988BOOL WIN32API ReleaseSemaphore( HANDLE arg1, LONG arg2, PLONG arg3)
989{
990 dprintf(("KERNEL32: OS2ReleaseSemaphore"));
991 return O32_ReleaseSemaphore(arg1, arg2, arg3);
992}
993//******************************************************************************
994//******************************************************************************
995BOOL WIN32API ResetEvent(HANDLE arg1)
996{
997 dprintf(("KERNEL32: ResetEvent(%08xh)\n",
998 arg1));
999
1000 return O32_ResetEvent(arg1);
1001}
1002//******************************************************************************
1003//******************************************************************************
1004DWORD WIN32API WaitForMultipleObjects( DWORD arg1, const HANDLE * arg2, BOOL arg3, DWORD arg4)
1005{
1006 dprintf(("KERNEL32: OS2WaitForMultipleObjects"));
1007 return O32_WaitForMultipleObjects(arg1, arg2, arg3, arg4);
1008}
1009
1010
1011/*****************************************************************************
1012 * Name : DWORD OS2WaitForMultipleObjectsEx
1013 * Purpose : The WaitForMultipleObjectsEx function is an extended wait
1014 * function that can be used to perform an alertable wait. This
1015 * enables the function to return when the system queues an I/O
1016 * completion routine to be executed by the calling thread. The
1017 * function also returns either when any one or when all of the
1018 * specified objects are in the signaled state, or when the
1019 * time-out interval elapses.
1020 * Parameters: DWORD cObjects number of handles in handle array
1021 * HANDLE *lphObjects address of object-handle array
1022 * BOOL fWaitAll wait flag
1023 * DWORD dwTimeout time-out interval in milliseconds
1024 * BOOL fAlertable alertable wait flag
1025 * Variables :
1026 * Result : 0xFFFFFFFF in case of error
1027 * Remark : only really required for async I/O
1028 * Status : UNTESTED STUB
1029 *
1030 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1031 *****************************************************************************/
1032
1033DWORD WIN32API WaitForMultipleObjectsEx(DWORD cObjects,
1034 CONST HANDLE *lphObjects,
1035 BOOL fWaitAll,
1036 DWORD dwTimeout,
1037 BOOL fAlertable)
1038{
1039 dprintf(("Kernel32: WaitForMultipleObjectsEx(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented correctly.\n",
1040 cObjects,
1041 lphObjects,
1042 fWaitAll,
1043 dwTimeout,
1044 fAlertable));
1045
1046 return(O32_WaitForMultipleObjects(cObjects,
1047 lphObjects,
1048 fWaitAll,
1049 dwTimeout));
1050}
1051//******************************************************************************
1052//******************************************************************************
1053LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
1054{
1055 dprintf(("KERNEL32: OS2lstrcat\n"));
1056 return O32_lstrcat(arg1, arg2);
1057}
1058//******************************************************************************
1059//******************************************************************************
1060LPWSTR WIN32API lstrcatW(LPWSTR arg1, LPCWSTR arg2)
1061{
1062 dprintf(("KERNEL32: OS2lstrcatW\n"));
1063 UniStrcat( (UniChar*) arg1, (UniChar*) arg2 );
1064 return arg1;
1065}
1066//******************************************************************************
1067//******************************************************************************
1068int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR arg2)
1069{
1070 dprintf(("KERNEL32: OS2lstrcmpA %s %x\n", arg1, arg1));
1071 dprintf(("KERNEL32: OS2lstrcmpA %s\n", arg2));
1072 return O32_lstrcmp(arg1, arg2);
1073}
1074//******************************************************************************
1075//******************************************************************************
1076int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
1077{
1078 dprintf(("KERNEL32: OS2lstrcmpW\n"));
1079 return UniStrcmp( (UniChar*)arg1, (UniChar*)arg2 );
1080}
1081//******************************************************************************
1082//******************************************************************************
1083LPSTR WIN32API lstrcpyA(LPSTR arg1, LPCSTR arg2)
1084{
1085 dprintf(("KERNEL32: OS2lstrcpy %s\n", arg2));
1086 return O32_lstrcpy(arg1, arg2);
1087}
1088//******************************************************************************
1089//******************************************************************************
1090LPWSTR WIN32API lstrcpyW(LPWSTR dest, LPCWSTR src)
1091{
1092 dprintf(("KERNEL32: OS2lstrcpyW"));
1093 UniStrcpy( (UniChar*)dest, (UniChar*)src );
1094 return dest;
1095}
1096//******************************************************************************
1097//******************************************************************************
1098LPSTR WIN32API lstrcpynA(LPSTR arg1, LPCSTR arg2, int arg3)
1099{
1100 dprintf(("KERNEL32: OS2lstrcpy\n"));
1101 return strncpy(arg1, arg2, arg3);
1102}
1103//******************************************************************************
1104//******************************************************************************
1105LPWSTR WIN32API lstrcpynW(LPWSTR dest, LPCWSTR src, int arg3)
1106{
1107 dprintf(("KERNEL32: OS2lstrcpynW"));
1108 UniStrncpy( (UniChar*)dest, (UniChar*)src, arg3 );
1109 return dest;
1110}
1111//******************************************************************************
1112//******************************************************************************
1113int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR arg2)
1114{
1115 dprintf(("KERNEL32: OS2lstrcmpi\n"));
1116 return O32_lstrcmpi(arg1, arg2);
1117}
1118//******************************************************************************
1119//******************************************************************************
1120int WIN32API lstrcmpiW(LPCWSTR arg1, LPCWSTR arg2)
1121{
1122 char *astr1, *astr2;
1123 int rc;
1124
1125 dprintf(("KERNEL32: OS2lstrcmpiW\n"));
1126// NOTE: This function has not equivalent in uunidef.h
1127 astr1 = UnicodeToAsciiString((LPWSTR)arg1);
1128 astr2 = UnicodeToAsciiString((LPWSTR)arg2);
1129 rc = O32_lstrcmpi(astr1, astr2);
1130 FreeAsciiString(astr2);
1131 FreeAsciiString(astr1);
1132 return(rc);
1133}
1134//******************************************************************************
1135//SvL: BUGFIX: C calling convention!
1136//******************************************************************************
1137VOID __cdecl OS2memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
1138{
1139 memmove(Destination, Source, Length);
1140}
1141//******************************************************************************
1142
1143//******************************************************************************
1144UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
1145 DWORD cch1, LPCSTR lpString2, DWORD cch2)
1146{
1147 int i;
1148 int fEqual = TRUE;
1149 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
1150
1151#ifdef DEBUG
1152 if(fdwStyle & SORT_STRINGSORT)
1153 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
1154 if(fdwStyle & NORM_IGNORENONSPACE)
1155 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
1156 if(fdwStyle & NORM_IGNORESYMBOLS)
1157 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
1158#endif
1159
1160 if(cch1 == -1) cch1 = strlen(string1);
1161 if(cch2 == -1) cch2 = strlen(string2);
1162
1163 if(fdwStyle) {
1164 //TODO!
1165 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
1166 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
1167 }
1168 if(fdwStyle & NORM_IGNORECASE)
1169 fEqual = strnicmp(string1, string2, min(cch1, cch2));
1170 else
1171 fEqual = strncmp(string1, string2, min(cch1, cch2));
1172
1173 if (fEqual < 0 ) fEqual = 1;
1174 else if(fEqual == 0) fEqual = 2;
1175 else if(fEqual > 0) fEqual = 3;
1176
1177 //If equal, but different length, largest one is the greatest in lexical value
1178 if(fEqual == 2 && cch1 != cch2){
1179 if(cch1 < cch2)
1180 fEqual = 1;
1181 else
1182 fEqual = 3;
1183 }
1184// dprintf(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
1185 return(fEqual);
1186}
1187
1188//******************************************************************************
1189//TODO: Not complete (fdwStyle flags specify compare method)
1190//******************************************************************************
1191UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
1192 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
1193{
1194 int i;
1195 int fEqual = TRUE;
1196 char *string1 = UnicodeToAsciiString((LPWSTR)lpString1);
1197 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
1198
1199// dprintf(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
1200
1201 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
1202 FreeAsciiString(string1);
1203 FreeAsciiString(string2);
1204
1205 return(fEqual);
1206}
1207//******************************************************************************
1208//TODO:What does this do exactly??
1209// @@@OPH -> see WINE
1210//******************************************************************************
1211BOOL WIN32API DisableThreadLibraryCalls(HMODULE hLibModule)
1212{
1213 dprintf(("KERNEL32: (NI!)OS2DisableThreadLibraryCalls of %X\n", hLibModule));
1214 return(TRUE);
1215}
1216//******************************************************************************
1217//******************************************************************************
1218//TODO: Query processor info to complete this api
1219//******************************************************************************
1220VOID WIN32API GetSystemInfo(LPSYSTEM_INFO lpSystemInfo)
1221{
1222 dprintf(("KERNEL32: GetSystemInfo, not completely accurate\n"));
1223 lpSystemInfo->u.x.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
1224 lpSystemInfo->u.x.wReserved = 0;
1225 lpSystemInfo->dwPageSize = 4096;
1226 lpSystemInfo->lpMinimumApplicationAddress = (LPVOID)0;
1227 lpSystemInfo->lpMaximumApplicationAddress = (LPVOID)(512*1024*1024);
1228 lpSystemInfo->dwActiveProcessorMask = 1;
1229 lpSystemInfo->dwNumberOfProcessors = 1; //assuming non-SMP OS/2
1230 lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
1231 lpSystemInfo->dwAllocationGranularity = 64*1024;
1232 lpSystemInfo->wProcessorLevel = 5; //Pentium
1233 lpSystemInfo->wProcessorRevision = 0x201; //Model 2 stepping 1 (obviously not correct)
1234}
1235//******************************************************************************
1236//Borrowed from Wine
1237//******************************************************************************
1238VOID WIN32API GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo)
1239{
1240 dprintf(("KERNEL32: GetStartupInfo\n"));
1241 lpStartupInfo->cb = sizeof(STARTUPINFOA);
1242 lpStartupInfo->lpReserved = "<Reserved>";
1243 lpStartupInfo->lpDesktop = "Desktop";
1244 lpStartupInfo->lpTitle = "Title";
1245
1246 lpStartupInfo->cbReserved2 = 0;
1247 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
1248
1249 /* @@@PH 98/07/13 Handlemanager support */
1250 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
1251 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
1252 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
1253 return;
1254}
1255//******************************************************************************
1256//Borrowed from Wine
1257//******************************************************************************
1258VOID WIN32API GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo)
1259{
1260 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
1261 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
1262 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
1263
1264 dprintf(("KERNEL32: GetStartupInfoW\n"));
1265 lpStartupInfo->cb = sizeof(STARTUPINFOW);
1266 lpStartupInfo->lpReserved = lpReserved;
1267 lpStartupInfo->lpDesktop = lpDesktop;
1268 lpStartupInfo->lpTitle = lpTitle;
1269
1270 lpStartupInfo->cbReserved2 = 0;
1271 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
1272
1273 /* @@@PH 98/07/13 Handlemanager support */
1274 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
1275 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
1276 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
1277 return;
1278}
1279//******************************************************************************
1280//TODO: Not complete or correct, but sufficient for now
1281//******************************************************************************
1282BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
1283{
1284 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
1285 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
1286 *lpBinaryType = SCS_32BIT_BINARY;
1287 else
1288 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
1289 *lpBinaryType = SCS_DOS_BINARY;
1290 else
1291 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
1292 *lpBinaryType = SCS_PIF_BINARY;
1293 else return(FALSE);
1294 return(TRUE);
1295}
1296//******************************************************************************
1297//******************************************************************************
1298BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
1299{
1300 BOOL rc;
1301 char *astring;
1302
1303 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
1304 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
1305 rc = GetBinaryTypeA(astring, lpBinaryType);
1306 FreeAsciiString(astring);
1307 return(rc);
1308}
1309//******************************************************************************
1310//TODO: SetLastError
1311//******************************************************************************
1312BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
1313{
1314 dprintf(("KERNEL32: OS2GetVersionExA\n"));
1315
1316 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
1317 return(FALSE);
1318
1319 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
1320 lpVersionInformation->dwMinorVersion = 0;
1321 lpVersionInformation->dwBuildNumber = 1564;
1322 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1323 lpVersionInformation->szCSDVersion[0]= 0;
1324 return(TRUE);
1325}
1326//******************************************************************************
1327//******************************************************************************
1328BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
1329{
1330 dprintf(("KERNEL32: OS2GetVersionExW\n"));
1331
1332 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
1333 return(FALSE);
1334
1335 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
1336 lpVersionInformation->dwMinorVersion = 0;
1337 lpVersionInformation->dwBuildNumber = 1564;
1338 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1339 lpVersionInformation->szCSDVersion[0]= 0;
1340 return(TRUE);
1341}
1342//******************************************************************************
1343//Should retrieve this from the exe...
1344//******************************************************************************
1345DWORD WIN32API GetProcessVersion(DWORD Processid)
1346{
1347 dprintf(("KERNEL32: OS2GetProcessVersion not correctly implemented!!\n"));
1348 return(WIN32OS2_VERSION);
1349}
1350//******************************************************************************
1351//******************************************************************************
1352LONG WIN32API GetVersion()
1353{
1354 dprintf(("KERNEL32: GetVersion\n"));
1355 // highword 0 = NT, lowword high byte major ver, low byte minor ver
1356/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
1357/* structures that lead to crashes if we don't identify as NT */
1358
1359// return(WIN32OS2_VERSION);
1360 return (0x0);
1361}
1362//******************************************************************************
1363//SvL: 26-6-'97 - Added
1364//******************************************************************************
1365VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
1366{
1367 char *astring;
1368
1369 astring = UnicodeToAsciiString((LPWSTR)arg1);
1370 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
1371 FreeAsciiString(astring);
1372}
1373//******************************************************************************
1374//******************************************************************************
1375VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
1376{
1377 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
1378 return;
1379}
1380//******************************************************************************
1381//Obsolete
1382//******************************************************************************
1383DWORD WIN32API GetProcessHeaps(DWORD NumberOfHeaps, PHANDLE ProcessHeaps)
1384{
1385 dprintf(("KERNEL32: GetProcessHeaps, Not implemented\n"));
1386 return(0);
1387}
1388//******************************************************************************
1389//WINE
1390//******************************************************************************
1391BOOL WIN32API GetProcessAffinityMask(HANDLE hProcess,
1392 LPDWORD lpProcessAffinityMask,
1393 LPDWORD lpSystemAffinityMask)
1394{
1395 /* It is definitely important for a process to know on what processor
1396 it is running :-) */
1397 if(lpProcessAffinityMask)
1398 *lpProcessAffinityMask=1;
1399 if(lpSystemAffinityMask)
1400 *lpSystemAffinityMask=1;
1401 return TRUE;
1402}
1403//******************************************************************************
1404//******************************************************************************
1405
1406
1407BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
1408 HANDLE hProcess, /* process with cache to flush */
1409 LPCVOID lpvBase, /* address of region to flush */
1410 DWORD cbFlush) /* length of region to flush */
1411
1412{
1413 dprintf(("FlushInstructionCache() - NIY\n"));
1414 return TRUE;
1415}
1416
1417
1418//******************************************************************************
1419VOID WIN32API UninitializeCriticalSection(CRITICAL_SECTION * lpcsCriticalSection)
1420{
1421 dprintf(("KERNEL32: UninitializeCriticalSection\n"));
1422}
1423
1424int WIN32API GetNumberFormatA(LCID Locale,
1425 DWORD dwFlags,
1426 LPCSTR lpValue,
1427 CONST NUMBERFMTA *lpFormat,
1428 LPSTR lpNumberStr,
1429 int cchNumber)
1430{
1431 dprintf(("KERNEL32::OS2GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
1432 Locale,
1433 dwFlags,
1434 lpValue,
1435 lpFormat,
1436 lpNumberStr,
1437 cchNumber));
1438
1439 return 0;
1440}
1441
1442int WIN32API GetNumberFormatW(LCID Locale,
1443 DWORD dwFlags,
1444 LPCWSTR lpValue,
1445 CONST NUMBERFMTW *lpFormat,
1446 LPWSTR lpNumberStr,
1447 int cchNumber)
1448{
1449 dprintf(("KERNEL32::OS2GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
1450 Locale,
1451 dwFlags,
1452 lpValue,
1453 lpFormat,
1454 lpNumberStr,
1455 cchNumber));
1456
1457 return 0;
1458}
1459
1460HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle)
1461//HANDLE WIN32API ConvertToGlobalHandle(HANDLE hHandle,
1462// BOOL fInherit)
1463{
1464 return (hHandle);
1465}
1466
1467BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
1468{
1469 dprintf(("KERNEL32: OS2FindNextChangeNotification, Not implemented\n"));
1470
1471 return(TRUE);
1472}
1473
1474//******************************************************************************
1475//******************************************************************************
1476void WIN32API WrongComctl32()
1477{
1478 O32_MessageBox(NULL,
1479 "KERNEL32.36 not implemented",
1480 "Win32 for OS/2 Error",
1481 MB_OK);
1482 ExitProcess(987);
1483}
1484//******************************************************************************
1485
1486
1487
1488/***********************************************************************
1489* RtlFillMemory (KERNEL32.441)
1490*/
1491VOID WIN32API RtlFillMemory(LPVOID ptr,
1492 UINT len,
1493 UINT fill )
1494{
1495#ifdef DEBUG_LOCAL
1496 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
1497 ptr,
1498 len,
1499 fill));
1500#endif
1501
1502 memset(ptr,
1503 fill,
1504 len );
1505}
1506
1507
1508/***********************************************************************
1509* RtlMoveMemory (KERNEL32.442)
1510*/
1511VOID WIN32API RtlMoveMemory(LPVOID dst,
1512 LPCVOID src,
1513 UINT len )
1514{
1515#ifdef DEBUG_LOCAL
1516 dprintf(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
1517 dst,
1518 src,
1519 len));
1520#endif
1521
1522 memmove(dst,
1523 src,
1524 len );
1525}
1526
1527
1528/***********************************************************************
1529* RtlZeroMemory (KERNEL32.444)
1530*/
1531VOID WIN32API RtlZeroMemory(LPVOID ptr,
1532 UINT len)
1533{
1534#ifdef DEBUG_LOCAL
1535 dprintf(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
1536 ptr,
1537 len));
1538#endif
1539
1540 memset(ptr,
1541 0,
1542 len);
1543}
1544
1545
1546//******************************************************************************
1547/*KSO Thu 21.05.1998*/
1548BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
1549{
1550 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
1551 return O32_IsDBCSLeadByte(TestChar);
1552}
1553//******************************************************************************
1554
1555
1556
1557
1558
1559
1560
Note: See TracBrowser for help on using the repository browser.