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

Last change on this file since 106 was 105, checked in by hugh, 26 years ago

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