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

Last change on this file since 433 was 426, checked in by phaller, 26 years ago

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