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

Last change on this file since 557 was 550, checked in by sandervl, 26 years ago

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