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

Last change on this file since 536 was 532, checked in by sandervl, 26 years ago

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