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

Last change on this file since 130 was 114, checked in by phaller, 26 years ago

Fix: preparing support for HandleManager on kernel objects
File size: 43.4 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.6 1999-06-17 21:52:00 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 CloseHandle
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 *****************************************************************************/
58BOOL WIN32API CloseHandle(HANDLE hHandle)
59{
60 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
61 hHandle));
62
63 return HMCloseHandle(hHandle);
64}
65
66
67//******************************************************************************
68HANDLE WIN32API GetModuleHandleA(LPCTSTR lpszModule)
69{
70 HANDLE hMod;
71
72 hMod = OS2iGetModuleHandleA( (PSZ) lpszModule);
73 eprintf(("KERNEL32: GetModuleHandle %s returned %X\n", lpszModule, hMod));
74 return(hMod);
75}
76//******************************************************************************
77//******************************************************************************
78HMODULE WIN32API GetModuleHandleW(LPCWSTR arg1)
79{
80 HMODULE rc;
81 char *astring;
82
83 astring = UnicodeToAsciiString((LPWSTR)arg1);
84 rc = O32_GetModuleHandle(astring);
85 dprintf(("KERNEL32: OS2GetModuleHandleW %s returned %X\n", astring, rc));
86 FreeAsciiString(astring);
87 return(rc);
88}
89//******************************************************************************
90//******************************************************************************
91HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
92{
93 HANDLE handle;
94
95 /* @@@PH 1998/02/12 Handle Manager Support */
96 handle = HMGetStdHandle(fdwDevice);
97
98 //@@@PH translate handle
99
100 /* handle = GetStdHandle(fdwDevice); */
101 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
102 return(handle);
103}
104//******************************************************************************
105//******************************************************************************
106BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
107 HANDLE hHandle)
108{
109 dprintf(("KERNEL32: SetStdHandle\n"));
110
111 ///@@@PH translate handle
112
113 return (HMSetStdHandle(IDStdHandle,
114 hHandle));
115}
116//******************************************************************************
117//******************************************************************************
118DWORD WIN32API TlsAlloc()
119{
120 dprintf(("KERNEL32: TlsAlloc\n"));
121 return(O32_TlsAlloc());
122}
123//******************************************************************************
124//******************************************************************************
125BOOL WIN32API TlsFree(DWORD index)
126{
127 dprintf(("KERNEL32: TlsFree\n"));
128 return(O32_TlsFree(index));
129}
130//******************************************************************************
131//******************************************************************************
132LPVOID WIN32API TlsGetValue(DWORD index)
133{
134 LPVOID rc;
135
136 rc = O32_TlsGetValue(index);
137// dprintf(("KERNEL32: TlsGetValue %d returned %X\n", index, rc));
138 return(rc);
139}
140//******************************************************************************
141//******************************************************************************
142BOOL WIN32API TlsSetValue(DWORD index, LPVOID val)
143{
144// dprintf(("KERNEL32: TlsSetValue\n"));
145 return(O32_TlsSetValue(index, val));
146}
147//******************************************************************************
148//******************************************************************************
149BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
150{
151#ifdef DEBUG
152 BOOL rc;
153
154 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
155 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
156 return(rc);
157#else
158 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
159#endif
160}
161//******************************************************************************
162//******************************************************************************
163BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
164{
165#ifdef DEBUG
166 BOOL rc;
167
168 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
169 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
170 return(rc);
171#else
172 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
173#endif
174}
175//******************************************************************************
176//******************************************************************************
177BOOL WIN32API IsBadCodePtr( FARPROC arg1)
178{
179 dprintf(("KERNEL32: IsBadCodePtr\n"));
180 return O32_IsBadCodePtr(arg1);
181}
182//******************************************************************************
183//******************************************************************************
184BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
185{
186 dprintf(("KERNEL32: IsBadStringPtr"));
187 return O32_IsBadStringPtr(arg1, arg2);
188}
189//******************************************************************************
190//******************************************************************************
191BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
192{
193 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
194 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
195}
196//******************************************************************************
197//******************************************************************************
198DWORD WIN32API GetLastError()
199{
200 DWORD rc;
201
202 rc = O32_GetLastError();
203#ifdef DEBUG_LOCAL
204 dprintf(("KERNEL32: GetLastError returned %d\n", rc));
205#endif
206 return(rc);
207}
208//******************************************************************************
209//******************************************************************************
210VOID WIN32API SetLastError( DWORD arg1)
211{
212// dprintf(("KERNEL32: SetLastError to %d\n", arg1));
213 O32_SetLastError(arg1);
214}
215//******************************************************************************
216//******************************************************************************
217UINT WIN32API GetOEMCP(VOID)
218{
219 dprintf(("KERNEL32: GetOEMCP\n"));
220 return(O32_GetOEMCP());
221}
222//******************************************************************************
223//******************************************************************************
224UINT WIN32API GetACP(VOID)
225{
226 dprintf(("KERNEL32: GetACP\n"));
227 return(O32_GetACP());
228}
229//******************************************************************************
230//******************************************************************************
231LONG WIN32API InterlockedDecrement(LPLONG lplVal)
232{
233 dprintf(("KERNEL32: InterlockedDecrement\n"));
234 return(O32_InterlockedDecrement(lplVal));
235}
236//******************************************************************************
237//******************************************************************************
238LONG WIN32API InterlockedIncrement(LPLONG lplVal)
239{
240 dprintf(("KERNEL32: InterlockedIncrement\n"));
241 return(O32_InterlockedIncrement(lplVal));
242}
243//******************************************************************************
244//******************************************************************************
245LONG WIN32API InterlockedExchange( PLONG arg1, LONG arg2)
246{
247 dprintf(("KERNEL32: InterlockedExchange\n"));
248 return O32_InterlockedExchange(arg1, arg2);
249}
250//******************************************************************************
251//******************************************************************************
252LPWSTR WIN32API GetEnvironmentStringsW(VOID)
253{
254 char *envstrings = (char *)O32_GetEnvironmentStrings();
255 char *tmp;
256 LPWSTR wenvstrings;
257 int len, i;
258
259 dprintf(("KERNEL32: GetEnvironmentStringsW\n"));
260
261 if(envstrings == NULL)
262 return(NULL);
263
264 tmp = envstrings;
265 len = 0;
266 while(*tmp != 0)
267 {
268 len += strlen(tmp)+1;
269 tmp = envstrings + len;
270 }
271 len++; //terminating 0
272 wenvstrings = (LPWSTR)malloc(len*sizeof(WCHAR));
273 for(i=0;
274 i<len;
275 i++)
276 {
277 wenvstrings[i] = envstrings[i];
278 }
279 return(wenvstrings);
280}
281//******************************************************************************
282//******************************************************************************
283BOOL WIN32API FreeEnvironmentStringsA(LPSTR envstrings)
284{
285 dprintf(("KERNEL32: FreeEnvironmentStringsA\n"));
286 return(TRUE);
287}
288//******************************************************************************
289//******************************************************************************
290BOOL WIN32API FreeEnvironmentStringsW(LPWSTR envstrings)
291{
292 dprintf(("KERNEL32: FreeEnvironmentStringsW\n"));
293 free(envstrings);
294 return(TRUE);
295}
296//******************************************************************************
297//******************************************************************************
298BOOL WIN32API GetStringTypeW(DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
299{
300 int i;
301
302 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
303 if((DWORD)lpSrcStr == (DWORD)lpCharType || !lpSrcStr || !lpCharType) {
304 O32_SetLastError(ERROR_INVALID_PARAMETER);
305 return(FALSE);
306 }
307 if(cchSrc == -1)
308 cchSrc = UniStrlen((UniChar*)lpSrcStr);
309
310 memset(lpCharType, 0, cchSrc*sizeof(WORD));
311 switch(fdwInfoType) {
312 case CT_CTYPE1:
313 for(i=0;i<cchSrc;i++) {
314 if(lpSrcStr[i] >= (WCHAR)'a' && lpSrcStr[i] <= (WCHAR)'z')
315 lpCharType[i] |= C1_LOWER | C1_ALPHA;
316 else
317 if(lpSrcStr[i] >= (WCHAR)'A' && lpSrcStr[i] <= (WCHAR)'A')
318 lpCharType[i] |= C1_UPPER | C1_ALPHA;
319 else
320 if(lpSrcStr[i] >= (WCHAR)'0' && lpSrcStr[i] <= (WCHAR)'9')
321 lpCharType[i] |= C1_DIGIT;
322 else
323 if(lpSrcStr[i] >= (WCHAR)' ')
324 lpCharType[i] |= C1_SPACE;
325 }
326 break;
327 case CT_CTYPE2:
328 case CT_CTYPE3: //not supported right now
329 break;
330 }
331 return(TRUE);
332}
333//******************************************************************************
334//NOTE: This has one parameter more than the W version! (@#$@#$)
335//******************************************************************************
336BOOL WIN32API GetStringTypeA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
337{
338 int i;
339
340 dprintf(("KERNEL32: GetStringTypeA, not properly implemented\n"));
341 if(lpSrcStr == (LPCSTR)lpCharType || !lpSrcStr || !lpCharType) {
342 O32_SetLastError(ERROR_INVALID_PARAMETER);
343 return(FALSE);
344 }
345 if(cchSrc == -1)
346 cchSrc = strlen(lpSrcStr);
347
348 memset(lpCharType, 0, cchSrc*sizeof(WORD));
349 switch(fdwInfoType) {
350 case CT_CTYPE1:
351 for(i=0;i<cchSrc;i++) {
352 if(lpSrcStr[i] >= 'a' && lpSrcStr[i] <= 'z')
353 lpCharType[i] |= C1_LOWER | C1_ALPHA;
354 else
355 if(lpSrcStr[i] >= 'A' && lpSrcStr[i] <= 'A')
356 lpCharType[i] |= C1_UPPER | C1_ALPHA;
357 else
358 if(lpSrcStr[i] >= '0' && lpSrcStr[i] <= '9')
359 lpCharType[i] |= C1_DIGIT;
360 else
361 if(lpSrcStr[i] >= ' ')
362 lpCharType[i] |= C1_SPACE;
363 }
364 break;
365 case CT_CTYPE2:
366 case CT_CTYPE3: //not supported right now
367 break;
368 }
369 return(TRUE);
370}
371//******************************************************************************
372//******************************************************************************
373BOOL WIN32API GetStringTypeExW(LCID Locale, DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
374{
375 dprintf(("KERNEL32: GetStringTypeExW, not properly implemented\n"));
376 return(GetStringTypeW(fdwInfoType, lpSrcStr, cchSrc, lpCharType));
377}
378//******************************************************************************
379//******************************************************************************
380BOOL WIN32API GetStringTypeExA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
381{
382 dprintf(("KERNEL32: GetStringTypeExA, not properly implemented\n"));
383 return(GetStringTypeA(Locale, fdwInfoType, lpSrcStr, cchSrc, lpCharType));
384}
385//******************************************************************************
386//******************************************************************************
387VOID WIN32API EnterCriticalSection(CRITICAL_SECTION * lpcsCriticalSection)
388{
389//// dprintf(("KERNEL32: EnterCriticalSection\n"));
390 O32_EnterCriticalSection(lpcsCriticalSection);
391}
392//******************************************************************************
393//******************************************************************************
394VOID WIN32API LeaveCriticalSection(CRITICAL_SECTION * arg1)
395{
396//// dprintf(("KERNEL32: LeaveCriticalSection\n"));
397 O32_LeaveCriticalSection(arg1);
398}
399//******************************************************************************
400//******************************************************************************
401VOID WIN32API InitializeCriticalSection(CRITICAL_SECTION * arg1)
402{
403 dprintf(("KERNEL32: InitializeCriticalSection\n"));
404 O32_InitializeCriticalSection(arg1);
405}
406//******************************************************************************
407//******************************************************************************
408void WINAPI MakeCriticalSectionGlobal( CRITICAL_SECTION *arg1 )
409{
410 dprintf(("KERNEL32: MakeCriticalSectionGlobal not implemented correctly\n"));
411}
412//******************************************************************************
413//******************************************************************************
414BOOL WIN32API SetEnvironmentVariableA(LPCSTR arg1, LPCSTR arg2)
415{
416 dprintf(("KERNEL32: SetEnvironmentVariable %s to %s\n", arg1, arg2));
417 return O32_SetEnvironmentVariable(arg1, arg2);
418}
419//******************************************************************************
420//******************************************************************************
421BOOL WIN32API SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue)
422{
423 char *asciiname, *asciivalue;
424 BOOL rc;
425
426 dprintf(("KERNEL32: OS2SetEnvironmentVariableW\n"));
427 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
428 asciivalue = UnicodeToAsciiString((LPWSTR)lpValue);
429 rc = O32_SetEnvironmentVariable(asciiname, asciivalue);
430 FreeAsciiString(asciivalue);
431 FreeAsciiString(asciiname);
432 return(rc);
433}
434//******************************************************************************
435VOID WIN32API GlobalMemoryStatus( MEMORYSTATUS *arg1)
436{
437 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
438 O32_GlobalMemoryStatus(arg1);
439 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
440 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
441 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
442 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
443 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
444 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
445 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
446}
447//******************************************************************************
448//******************************************************************************
449DWORD WIN32API GetEnvironmentVariableA(LPCSTR arg1, LPSTR arg2, DWORD arg3)
450{
451 dprintf(("KERNEL32: GetEnvironmentVariable %s\n", arg1));
452 return O32_GetEnvironmentVariable(arg1, arg2, arg3);
453}
454//******************************************************************************
455//******************************************************************************
456DWORD WIN32API GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer,
457 DWORD nSize)
458{
459 char *astring, *asciibuffer;
460 DWORD rc;
461
462 dprintf(("KERNEL32: OS2GetEnvironmentVariableW\n"));
463 asciibuffer = (char *)malloc(nSize+1);
464 astring = UnicodeToAsciiString((LPWSTR)lpName);
465
466 rc = O32_GetEnvironmentVariable(astring, asciibuffer, nSize);
467 AsciiToUnicode(asciibuffer, lpBuffer);
468 FreeAsciiString(astring);
469 free(asciibuffer);
470 return(rc);
471}
472//******************************************************************************
473//******************************************************************************
474HINSTANCE WIN32API WinExec(LPCSTR arg1, UINT arg2)
475{
476 dprintf(("KERNEL32: WinExec %s\n", arg1));
477 return (HINSTANCE)O32_WinExec(arg1, arg2);
478}
479//******************************************************************************
480//******************************************************************************
481BOOL WIN32API GetExitCodeProcess(HANDLE arg1, LPDWORD arg2)
482{
483 dprintf(("KERNEL32: GetExitCodeProcess\n"));
484 return O32_GetExitCodeProcess(arg1, arg2);
485}
486//******************************************************************************
487//******************************************************************************
488HANDLE WIN32API GetCurrentProcess(void)
489{
490//// dprintf(("KERNEL32: GetCurrentProcess\n"));
491 return O32_GetCurrentProcess();
492}
493//******************************************************************************
494//******************************************************************************
495DWORD WIN32API GetCurrentProcessId(void)
496{
497 dprintf(("KERNEL32: GetCurrentProcessId\n"));
498 return O32_GetCurrentProcessId();
499}
500//******************************************************************************
501//******************************************************************************
502BOOL WIN32API TerminateProcess( HANDLE arg1, DWORD arg2)
503{
504 dprintf(("KERNEL32: TerminateProcess\n"));
505 return O32_TerminateProcess(arg1, arg2);
506}
507//******************************************************************************
508//******************************************************************************
509VOID WIN32API Sleep(DWORD arg1)
510{
511 dprintf(("KERNEL32: Sleep %d\n", arg1));
512 O32_Sleep(arg1);
513}
514//******************************************************************************
515//******************************************************************************
516DWORD WIN32API GetPriorityClass(HANDLE arg1)
517{
518 dprintf(("KERNEL32: GetPriorityClass\n"));
519 return O32_GetPriorityClass(arg1);
520}
521//******************************************************************************
522//******************************************************************************
523BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
524{
525 dprintf(("KERNEL32: SetPriorityClass\n"));
526 return O32_SetPriorityClass(arg1, arg2);
527}
528//******************************************************************************
529//TODO!
530//******************************************************************************
531int WIN32API LCMapStringW(
532 DWORD /*LCID*/ Locale,
533 DWORD dwMapFlags,
534 LPCWSTR lpSrcStr,
535 int cchSrc,
536 LPWSTR lpDestStr,
537 int cchDest)
538{
539 // quick hack! this code is not done!
540 if(cchSrc == -1)
541 cchSrc = strlen((const char *)lpSrcStr);
542 if(!cchDest)
543 return cchSrc;
544 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
545 return max(cchSrc, cchDest);
546}
547//******************************************************************************
548//TODO!
549//******************************************************************************
550int WIN32API LCMapStringA(
551 DWORD /*LCID*/ Locale,
552 DWORD dwMapFlags,
553 LPCSTR lpSrcStr,
554 int cchSrc,
555 LPSTR lpDestStr,
556 int cchDest)
557{
558 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
559 if(cchSrc == -1)
560 cchSrc = strlen((const char *)lpSrcStr);
561 if(!cchDest)
562 return cchSrc;
563 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
564 return max(cchSrc, cchDest);
565}
566//******************************************************************************
567//SvL: 24-6-'97 - Added
568//******************************************************************************
569VOID WIN32API DeleteCriticalSection( CRITICAL_SECTION * arg1)
570{
571 dprintf(("KERNEL32: OS2DeleteCriticalSection\n"));
572 O32_DeleteCriticalSection(arg1);
573}
574//******************************************************************************
575//******************************************************************************
576BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
577{
578 dprintf(("KERNEL32: OS2Beep\n"));
579 return O32_Beep(arg1, arg2);
580}
581//******************************************************************************
582//******************************************************************************
583VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
584{
585 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
586 O32_FatalAppExit(arg1, arg2);
587}
588//******************************************************************************
589//******************************************************************************
590VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
591{
592 char *astring;
593
594 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
595 astring = UnicodeToAsciiString((LPWSTR)arg2);
596 O32_FatalAppExit(arg1, astring);
597 //probably won't return, but who cares..
598 FreeAsciiString(astring);
599}
600//******************************************************************************
601//******************************************************************************
602VOID WIN32API FatalExit( UINT arg1)
603{
604 dprintf(("KERNEL32: OS2FatalExit\n"));
605 O32_FatalExit(arg1);
606}
607//******************************************************************************
608//******************************************************************************
609int WIN32API lstrlenA(LPCSTR arg1)
610{
611 dprintf(("KERNEL32: OS2lstrlen %X\n", arg1));
612 return O32_lstrlen(arg1);
613}
614//******************************************************************************
615//******************************************************************************
616int WIN32API lstrlenW(LPCWSTR arg1)
617{
618 int rc;
619
620 rc = UniStrlen( (UniChar*)arg1);
621 dprintf(("KERNEL32: OS2lstrlenW returns %d\n", rc));
622 return rc;
623}
624//******************************************************************************
625//******************************************************************************
626LPSTR WIN32API GetEnvironmentStringsA(void)
627{
628 dprintf(("KERNEL32: OS2GetEnvironmentStringsA\n"));
629 return (LPSTR) O32_GetEnvironmentStrings();
630}
631//******************************************************************************
632//******************************************************************************
633BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
634{
635 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
636 return O32_IsBadHugeReadPtr(arg1, arg2);
637}
638//******************************************************************************
639//******************************************************************************
640BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
641{
642 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
643 return O32_IsBadHugeWritePtr(arg1, arg2);
644}
645//******************************************************************************
646//******************************************************************************
647BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
648{
649 dprintf(("KERNEL32: OS2IsDBCSLeadByte\n"));
650 return O32_IsDBCSLeadByte(arg1);
651}
652//******************************************************************************
653//******************************************************************************
654DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
655{
656 dprintf(("KERNEL32: OS2LoadModule\n"));
657 return O32_LoadModule(arg1, arg2);
658}
659//******************************************************************************
660//******************************************************************************
661int WIN32API MulDiv(int arg1, int arg2, int arg3)
662{
663 dprintf(("KERNEL32: OS2MulDiv %d*%d/%d\n", arg1, arg2, arg3));
664 return O32_MulDiv(arg1, arg2, arg3);
665}
666//******************************************************************************
667//******************************************************************************
668HANDLE WIN32API OpenProcess(DWORD arg1, BOOL arg2, DWORD arg3)
669{
670 dprintf(("KERNEL32: OS2OpenProcess\n"));
671 return O32_OpenProcess(arg1, arg2, arg3);
672}
673//******************************************************************************
674//******************************************************************************
675LPSTR WIN32API lstrcatA(LPSTR arg1, LPCSTR arg2)
676{
677 dprintf(("KERNEL32: OS2lstrcat\n"));
678 return O32_lstrcat(arg1, arg2);
679}
680//******************************************************************************
681//******************************************************************************
682LPWSTR WIN32API lstrcatW(LPWSTR arg1, LPCWSTR arg2)
683{
684 dprintf(("KERNEL32: OS2lstrcatW\n"));
685 UniStrcat( (UniChar*) arg1, (UniChar*) arg2 );
686 return arg1;
687}
688//******************************************************************************
689//******************************************************************************
690int WIN32API lstrcmpA(LPCSTR arg1, LPCSTR arg2)
691{
692 dprintf(("KERNEL32: OS2lstrcmpA %s %x\n", arg1, arg1));
693 dprintf(("KERNEL32: OS2lstrcmpA %s\n", arg2));
694 return O32_lstrcmp(arg1, arg2);
695}
696//******************************************************************************
697//******************************************************************************
698int WIN32API lstrcmpW(LPCWSTR arg1, LPCWSTR arg2)
699{
700 dprintf(("KERNEL32: OS2lstrcmpW\n"));
701 return UniStrcmp( (UniChar*)arg1, (UniChar*)arg2 );
702}
703//******************************************************************************
704//******************************************************************************
705LPSTR WIN32API lstrcpyA(LPSTR arg1, LPCSTR arg2)
706{
707 dprintf(("KERNEL32: OS2lstrcpy %s\n", arg2));
708 return O32_lstrcpy(arg1, arg2);
709}
710//******************************************************************************
711//******************************************************************************
712LPWSTR WIN32API lstrcpyW(LPWSTR dest, LPCWSTR src)
713{
714 dprintf(("KERNEL32: OS2lstrcpyW"));
715 UniStrcpy( (UniChar*)dest, (UniChar*)src );
716 return dest;
717}
718//******************************************************************************
719//******************************************************************************
720LPSTR WIN32API lstrcpynA(LPSTR arg1, LPCSTR arg2, int arg3)
721{
722 dprintf(("KERNEL32: OS2lstrcpy\n"));
723 return strncpy(arg1, arg2, arg3);
724}
725//******************************************************************************
726//******************************************************************************
727LPWSTR WIN32API lstrcpynW(LPWSTR dest, LPCWSTR src, int arg3)
728{
729 dprintf(("KERNEL32: OS2lstrcpynW"));
730 UniStrncpy( (UniChar*)dest, (UniChar*)src, arg3 );
731 return dest;
732}
733//******************************************************************************
734//******************************************************************************
735int WIN32API lstrcmpiA(LPCSTR arg1, LPCSTR arg2)
736{
737 dprintf(("KERNEL32: OS2lstrcmpi\n"));
738 return O32_lstrcmpi(arg1, arg2);
739}
740//******************************************************************************
741//******************************************************************************
742int WIN32API lstrcmpiW(LPCWSTR arg1, LPCWSTR arg2)
743{
744 char *astr1, *astr2;
745 int rc;
746
747 dprintf(("KERNEL32: OS2lstrcmpiW\n"));
748// NOTE: This function has not equivalent in uunidef.h
749 astr1 = UnicodeToAsciiString((LPWSTR)arg1);
750 astr2 = UnicodeToAsciiString((LPWSTR)arg2);
751 rc = O32_lstrcmpi(astr1, astr2);
752 FreeAsciiString(astr2);
753 FreeAsciiString(astr1);
754 return(rc);
755}
756//******************************************************************************
757//SvL: BUGFIX: C calling convention!
758//******************************************************************************
759VOID __cdecl OS2memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
760{
761 memmove(Destination, Source, Length);
762}
763//******************************************************************************
764
765//******************************************************************************
766UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
767 DWORD cch1, LPCSTR lpString2, DWORD cch2)
768{
769 int i;
770 int fEqual = TRUE;
771 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
772
773#ifdef DEBUG
774 if(fdwStyle & SORT_STRINGSORT)
775 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
776 if(fdwStyle & NORM_IGNORENONSPACE)
777 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
778 if(fdwStyle & NORM_IGNORESYMBOLS)
779 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
780#endif
781
782 if(cch1 == -1) cch1 = strlen(string1);
783 if(cch2 == -1) cch2 = strlen(string2);
784
785 if(fdwStyle) {
786 //TODO!
787 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
788 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
789 }
790 if(fdwStyle & NORM_IGNORECASE)
791 fEqual = strnicmp(string1, string2, min(cch1, cch2));
792 else
793 fEqual = strncmp(string1, string2, min(cch1, cch2));
794
795 if (fEqual < 0 ) fEqual = 1;
796 else if(fEqual == 0) fEqual = 2;
797 else if(fEqual > 0) fEqual = 3;
798
799 //If equal, but different length, largest one is the greatest in lexical value
800 if(fEqual == 2 && cch1 != cch2){
801 if(cch1 < cch2)
802 fEqual = 1;
803 else
804 fEqual = 3;
805 }
806// dprintf(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
807 return(fEqual);
808}
809
810//******************************************************************************
811//TODO: Not complete (fdwStyle flags specify compare method)
812//******************************************************************************
813UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
814 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
815{
816 int i;
817 int fEqual = TRUE;
818 char *string1 = UnicodeToAsciiString((LPWSTR)lpString1);
819 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
820
821// dprintf(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
822
823 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
824 FreeAsciiString(string1);
825 FreeAsciiString(string2);
826
827 return(fEqual);
828}
829//******************************************************************************
830//TODO:What does this do exactly??
831// @@@OPH -> see WINE
832//******************************************************************************
833BOOL WIN32API DisableThreadLibraryCalls(HMODULE hLibModule)
834{
835 dprintf(("KERNEL32: (NI!)OS2DisableThreadLibraryCalls of %X\n", hLibModule));
836 return(TRUE);
837}
838//******************************************************************************
839//******************************************************************************
840//TODO: Query processor info to complete this api
841//******************************************************************************
842VOID WIN32API GetSystemInfo(LPSYSTEM_INFO lpSystemInfo)
843{
844 dprintf(("KERNEL32: GetSystemInfo, not completely accurate\n"));
845 lpSystemInfo->u.x.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
846 lpSystemInfo->u.x.wReserved = 0;
847 lpSystemInfo->dwPageSize = 4096;
848 lpSystemInfo->lpMinimumApplicationAddress = (LPVOID)0;
849 lpSystemInfo->lpMaximumApplicationAddress = (LPVOID)(512*1024*1024);
850 lpSystemInfo->dwActiveProcessorMask = 1;
851 lpSystemInfo->dwNumberOfProcessors = 1; //assuming non-SMP OS/2
852 lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
853 lpSystemInfo->dwAllocationGranularity = 64*1024;
854 lpSystemInfo->wProcessorLevel = 5; //Pentium
855 lpSystemInfo->wProcessorRevision = 0x201; //Model 2 stepping 1 (obviously not correct)
856}
857//******************************************************************************
858//Borrowed from Wine
859//******************************************************************************
860VOID WIN32API GetStartupInfoA(LPSTARTUPINFOA lpStartupInfo)
861{
862 dprintf(("KERNEL32: GetStartupInfo\n"));
863 lpStartupInfo->cb = sizeof(STARTUPINFOA);
864 lpStartupInfo->lpReserved = "<Reserved>";
865 lpStartupInfo->lpDesktop = "Desktop";
866 lpStartupInfo->lpTitle = "Title";
867
868 lpStartupInfo->cbReserved2 = 0;
869 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
870
871 /* @@@PH 98/07/13 Handlemanager support */
872 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
873 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
874 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
875 return;
876}
877//******************************************************************************
878//Borrowed from Wine
879//******************************************************************************
880VOID WIN32API GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo)
881{
882 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
883 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
884 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
885
886 dprintf(("KERNEL32: GetStartupInfoW\n"));
887 lpStartupInfo->cb = sizeof(STARTUPINFOW);
888 lpStartupInfo->lpReserved = lpReserved;
889 lpStartupInfo->lpDesktop = lpDesktop;
890 lpStartupInfo->lpTitle = lpTitle;
891
892 lpStartupInfo->cbReserved2 = 0;
893 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
894
895 /* @@@PH 98/07/13 Handlemanager support */
896 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
897 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
898 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
899 return;
900}
901//******************************************************************************
902//TODO: Not complete or correct, but sufficient for now
903//******************************************************************************
904BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
905{
906 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
907 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
908 *lpBinaryType = SCS_32BIT_BINARY;
909 else
910 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
911 *lpBinaryType = SCS_DOS_BINARY;
912 else
913 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
914 *lpBinaryType = SCS_PIF_BINARY;
915 else return(FALSE);
916 return(TRUE);
917}
918//******************************************************************************
919//******************************************************************************
920BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
921{
922 BOOL rc;
923 char *astring;
924
925 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
926 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
927 rc = GetBinaryTypeA(astring, lpBinaryType);
928 FreeAsciiString(astring);
929 return(rc);
930}
931//******************************************************************************
932//TODO: SetLastError
933//******************************************************************************
934BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
935{
936 dprintf(("KERNEL32: OS2GetVersionExA\n"));
937
938 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
939 return(FALSE);
940
941 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
942 lpVersionInformation->dwMinorVersion = 0;
943 lpVersionInformation->dwBuildNumber = 1564;
944 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
945 lpVersionInformation->szCSDVersion[0]= 0;
946 return(TRUE);
947}
948//******************************************************************************
949//******************************************************************************
950BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
951{
952 dprintf(("KERNEL32: OS2GetVersionExW\n"));
953
954 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
955 return(FALSE);
956
957 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
958 lpVersionInformation->dwMinorVersion = 0;
959 lpVersionInformation->dwBuildNumber = 1564;
960 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
961 lpVersionInformation->szCSDVersion[0]= 0;
962 return(TRUE);
963}
964//******************************************************************************
965//Should retrieve this from the exe...
966//******************************************************************************
967DWORD WIN32API GetProcessVersion(DWORD Processid)
968{
969 dprintf(("KERNEL32: OS2GetProcessVersion not correctly implemented!!\n"));
970 return(WIN32OS2_VERSION);
971}
972//******************************************************************************
973//******************************************************************************
974LONG WIN32API GetVersion()
975{
976 dprintf(("KERNEL32: GetVersion\n"));
977 // highword 0 = NT, lowword high byte major ver, low byte minor ver
978/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
979/* structures that lead to crashes if we don't identify as NT */
980
981// return(WIN32OS2_VERSION);
982 return (0x0);
983}
984//******************************************************************************
985//SvL: 26-6-'97 - Added
986//******************************************************************************
987VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
988{
989 char *astring;
990
991 astring = UnicodeToAsciiString((LPWSTR)arg1);
992 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
993 FreeAsciiString(astring);
994}
995//******************************************************************************
996//******************************************************************************
997VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
998{
999 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
1000 return;
1001}
1002//******************************************************************************
1003//Obsolete
1004//******************************************************************************
1005DWORD WIN32API GetProcessHeaps(DWORD NumberOfHeaps, PHANDLE ProcessHeaps)
1006{
1007 dprintf(("KERNEL32: GetProcessHeaps, Not implemented\n"));
1008 return(0);
1009}
1010//******************************************************************************
1011//WINE
1012//******************************************************************************
1013BOOL WIN32API GetProcessAffinityMask(HANDLE hProcess,
1014 LPDWORD lpProcessAffinityMask,
1015 LPDWORD lpSystemAffinityMask)
1016{
1017 /* It is definitely important for a process to know on what processor
1018 it is running :-) */
1019 if(lpProcessAffinityMask)
1020 *lpProcessAffinityMask=1;
1021 if(lpSystemAffinityMask)
1022 *lpSystemAffinityMask=1;
1023 return TRUE;
1024}
1025//******************************************************************************
1026//******************************************************************************
1027
1028
1029BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
1030 HANDLE hProcess, /* process with cache to flush */
1031 LPCVOID lpvBase, /* address of region to flush */
1032 DWORD cbFlush) /* length of region to flush */
1033
1034{
1035 dprintf(("FlushInstructionCache() - NIY\n"));
1036 return TRUE;
1037}
1038
1039
1040//******************************************************************************
1041VOID WIN32API UninitializeCriticalSection(CRITICAL_SECTION * lpcsCriticalSection)
1042{
1043 dprintf(("KERNEL32: UninitializeCriticalSection\n"));
1044}
1045
1046int WIN32API GetNumberFormatA(LCID Locale,
1047 DWORD dwFlags,
1048 LPCSTR lpValue,
1049 CONST NUMBERFMTA *lpFormat,
1050 LPSTR lpNumberStr,
1051 int cchNumber)
1052{
1053 dprintf(("KERNEL32::OS2GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
1054 Locale,
1055 dwFlags,
1056 lpValue,
1057 lpFormat,
1058 lpNumberStr,
1059 cchNumber));
1060
1061 return 0;
1062}
1063
1064int WIN32API GetNumberFormatW(LCID Locale,
1065 DWORD dwFlags,
1066 LPCWSTR lpValue,
1067 CONST NUMBERFMTW *lpFormat,
1068 LPWSTR lpNumberStr,
1069 int cchNumber)
1070{
1071 dprintf(("KERNEL32::OS2GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
1072 Locale,
1073 dwFlags,
1074 lpValue,
1075 lpFormat,
1076 lpNumberStr,
1077 cchNumber));
1078
1079 return 0;
1080}
1081
1082BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
1083{
1084 dprintf(("KERNEL32: OS2FindNextChangeNotification, Not implemented\n"));
1085
1086 return(TRUE);
1087}
1088
1089//******************************************************************************
1090//******************************************************************************
1091void WIN32API WrongComctl32()
1092{
1093 O32_MessageBox(NULL,
1094 "KERNEL32.36 not implemented",
1095 "Win32 for OS/2 Error",
1096 MB_OK);
1097 ExitProcess(987);
1098}
1099//******************************************************************************
1100
1101
1102
1103/***********************************************************************
1104* RtlFillMemory (KERNEL32.441)
1105*/
1106VOID WIN32API RtlFillMemory(LPVOID ptr,
1107 UINT len,
1108 UINT fill )
1109{
1110#ifdef DEBUG_LOCAL
1111 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
1112 ptr,
1113 len,
1114 fill));
1115#endif
1116
1117 memset(ptr,
1118 fill,
1119 len );
1120}
1121
1122
1123/***********************************************************************
1124* RtlMoveMemory (KERNEL32.442)
1125*/
1126VOID WIN32API RtlMoveMemory(LPVOID dst,
1127 LPCVOID src,
1128 UINT len )
1129{
1130#ifdef DEBUG_LOCAL
1131 dprintf(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
1132 dst,
1133 src,
1134 len));
1135#endif
1136
1137 memmove(dst,
1138 src,
1139 len );
1140}
1141
1142
1143/***********************************************************************
1144* RtlZeroMemory (KERNEL32.444)
1145*/
1146VOID WIN32API RtlZeroMemory(LPVOID ptr,
1147 UINT len)
1148{
1149#ifdef DEBUG_LOCAL
1150 dprintf(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
1151 ptr,
1152 len));
1153#endif
1154
1155 memset(ptr,
1156 0,
1157 len);
1158}
1159
1160
1161//******************************************************************************
1162/*KSO Thu 21.05.1998*/
1163BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
1164{
1165 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
1166 return O32_IsDBCSLeadByte(TestChar);
1167}
1168//******************************************************************************
1169
1170
1171
1172
1173
1174
1175
Note: See TracBrowser for help on using the repository browser.