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

Last change on this file since 1451 was 1440, checked in by achimha, 26 years ago

ported Re/UninitializeCriticalSection from WINE
File size: 38.3 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.24 1999-10-25 18:20:52 achimha 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
22#include <odin.h>
23#include <odinwrap.h>
24#include <os2sel.h>
25
26#include <os2win.h>
27#include <winnt.h>
28#include <winnls.h>
29#include <stdlib.h>
30#include <string.h>
31
32#include "misc.h"
33#include "devio.h"
34#include "except.h"
35#include <builtin.h>
36#include "heap.h"
37#include "handlemanager.h"
38#include "wprocess.h"
39
40
41/*****************************************************************************
42 * Defines *
43 *****************************************************************************/
44
45ODINDEBUGCHANNEL(KERNEL32-KERNEL32)
46
47 /* this define enables certain less important debug messages */
48//#define DEBUG_LOCAL 1
49
50
51
52/*****************************************************************************
53 * Name : BOOL WIN32API CloseHandle
54 * Purpose : forward call to Open32
55 * Parameters:
56 * Variables :
57 * Result :
58 * Remark :
59 * Status :
60 *
61 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
62 *****************************************************************************/
63BOOL WIN32API CloseHandle(HANDLE hHandle)
64{
65 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
66 hHandle));
67
68 return HMCloseHandle(hHandle);
69}
70
71
72//******************************************************************************
73HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
74{
75 HANDLE handle;
76
77 /* @@@PH 1998/02/12 Handle Manager Support */
78 handle = HMGetStdHandle(fdwDevice);
79
80 //@@@PH translate handle
81
82 /* handle = GetStdHandle(fdwDevice); */
83 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
84 return(handle);
85}
86//******************************************************************************
87//******************************************************************************
88BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
89 HANDLE hHandle)
90{
91 dprintf(("KERNEL32: SetStdHandle\n"));
92
93 ///@@@PH translate handle
94
95 return (HMSetStdHandle(IDStdHandle,
96 hHandle));
97}
98//******************************************************************************
99//******************************************************************************
100BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
101{
102#ifdef DEBUG
103 BOOL rc;
104
105 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
106 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
107 return(rc);
108#else
109 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
110#endif
111}
112//******************************************************************************
113//******************************************************************************
114BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
115{
116#ifdef DEBUG
117 BOOL rc;
118
119 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
120 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
121 return(rc);
122#else
123 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
124#endif
125}
126//******************************************************************************
127//******************************************************************************
128BOOL WIN32API IsBadCodePtr( FARPROC arg1)
129{
130 dprintf(("KERNEL32: IsBadCodePtr\n"));
131 return O32_IsBadCodePtr(arg1);
132}
133//******************************************************************************
134//******************************************************************************
135BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
136{
137 dprintf(("KERNEL32: IsBadStringPtr"));
138 return O32_IsBadStringPtr(arg1, arg2);
139}
140//******************************************************************************
141//******************************************************************************
142BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
143{
144 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
145 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
146}
147//******************************************************************************
148//******************************************************************************
149DWORD WIN32API GetLastError()
150{
151 DWORD rc;
152
153 rc = O32_GetLastError();
154#ifdef DEBUG_LOCAL
155 dprintf(("KERNEL32: GetLastError returned %d\n", rc));
156#endif
157 return(rc);
158}
159//******************************************************************************
160//******************************************************************************
161VOID WIN32API SetLastError( DWORD arg1)
162{
163// dprintf(("KERNEL32: SetLastError to %d\n", arg1));
164 O32_SetLastError(arg1);
165}
166//******************************************************************************
167//******************************************************************************
168UINT WIN32API GetOEMCP(VOID)
169{
170 dprintf(("KERNEL32: GetOEMCP\n"));
171 return(O32_GetOEMCP());
172}
173//******************************************************************************
174//******************************************************************************
175UINT WIN32API GetACP(VOID)
176{
177 dprintf(("KERNEL32: GetACP\n"));
178 return(O32_GetACP());
179}
180//******************************************************************************
181//******************************************************************************
182//******************************************************************************
183//******************************************************************************
184LPWSTR WIN32API GetEnvironmentStringsW(VOID)
185{
186 char *envstrings = (char *)O32_GetEnvironmentStrings();
187 char *tmp;
188 LPWSTR wenvstrings;
189 int len, i;
190
191 dprintf(("KERNEL32: GetEnvironmentStringsW\n"));
192
193 if(envstrings == NULL)
194 return(NULL);
195
196 tmp = envstrings;
197 len = 0;
198 while(*tmp != 0)
199 {
200 len += strlen(tmp)+1;
201 tmp = envstrings + len;
202 }
203 len++; //terminating 0
204 wenvstrings = (LPWSTR)malloc(len*sizeof(WCHAR));
205 for(i=0;
206 i<len;
207 i++)
208 {
209 wenvstrings[i] = envstrings[i];
210 }
211 return(wenvstrings);
212}
213//******************************************************************************
214//******************************************************************************
215BOOL WIN32API FreeEnvironmentStringsA(LPSTR envstrings)
216{
217 dprintf(("KERNEL32: FreeEnvironmentStringsA\n"));
218 return(TRUE);
219}
220//******************************************************************************
221//******************************************************************************
222BOOL WIN32API FreeEnvironmentStringsW(LPWSTR envstrings)
223{
224 dprintf(("KERNEL32: FreeEnvironmentStringsW\n"));
225 free(envstrings);
226 return(TRUE);
227}
228//******************************************************************************
229//******************************************************************************
230BOOL WIN32API GetStringTypeW(DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
231{
232 int i;
233
234 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
235 if((DWORD)lpSrcStr == (DWORD)lpCharType || !lpSrcStr || !lpCharType) {
236 O32_SetLastError(ERROR_INVALID_PARAMETER);
237 return(FALSE);
238 }
239 if(cchSrc == -1)
240 cchSrc = UniStrlen((UniChar*)lpSrcStr);
241
242 memset(lpCharType, 0, cchSrc*sizeof(WORD));
243 switch(fdwInfoType) {
244 case CT_CTYPE1:
245 for(i=0;i<cchSrc;i++) {
246 if(lpSrcStr[i] >= (WCHAR)'a' && lpSrcStr[i] <= (WCHAR)'z')
247 lpCharType[i] |= C1_LOWER | C1_ALPHA;
248 else
249 if(lpSrcStr[i] >= (WCHAR)'A' && lpSrcStr[i] <= (WCHAR)'A')
250 lpCharType[i] |= C1_UPPER | C1_ALPHA;
251 else
252 if(lpSrcStr[i] >= (WCHAR)'0' && lpSrcStr[i] <= (WCHAR)'9')
253 lpCharType[i] |= C1_DIGIT;
254 else
255 if(lpSrcStr[i] >= (WCHAR)' ')
256 lpCharType[i] |= C1_SPACE;
257 }
258 break;
259 case CT_CTYPE2:
260 case CT_CTYPE3: //not supported right now
261 break;
262 }
263 return(TRUE);
264}
265//******************************************************************************
266//NOTE: This has one parameter more than the W version! (@#$@#$)
267//******************************************************************************
268BOOL WIN32API GetStringTypeA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
269{
270 int i;
271
272 dprintf(("KERNEL32: GetStringTypeA, not properly implemented\n"));
273 if(lpSrcStr == (LPCSTR)lpCharType || !lpSrcStr || !lpCharType) {
274 O32_SetLastError(ERROR_INVALID_PARAMETER);
275 return(FALSE);
276 }
277 if(cchSrc == -1)
278 cchSrc = strlen(lpSrcStr);
279
280 memset(lpCharType, 0, cchSrc*sizeof(WORD));
281 switch(fdwInfoType) {
282 case CT_CTYPE1:
283 for(i=0;i<cchSrc;i++) {
284 if(lpSrcStr[i] >= 'a' && lpSrcStr[i] <= 'z')
285 lpCharType[i] |= C1_LOWER | C1_ALPHA;
286 else
287 if(lpSrcStr[i] >= 'A' && lpSrcStr[i] <= 'A')
288 lpCharType[i] |= C1_UPPER | C1_ALPHA;
289 else
290 if(lpSrcStr[i] >= '0' && lpSrcStr[i] <= '9')
291 lpCharType[i] |= C1_DIGIT;
292 else
293 if(lpSrcStr[i] >= ' ')
294 lpCharType[i] |= C1_SPACE;
295 }
296 break;
297 case CT_CTYPE2:
298 case CT_CTYPE3: //not supported right now
299 break;
300 }
301 return(TRUE);
302}
303//******************************************************************************
304//******************************************************************************
305BOOL WIN32API GetStringTypeExW(LCID Locale, DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
306{
307 dprintf(("KERNEL32: GetStringTypeExW, not properly implemented\n"));
308 return(GetStringTypeW(fdwInfoType, lpSrcStr, cchSrc, lpCharType));
309}
310//******************************************************************************
311//******************************************************************************
312BOOL WIN32API GetStringTypeExA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
313{
314 dprintf(("KERNEL32: GetStringTypeExA, not properly implemented\n"));
315 return(GetStringTypeA(Locale, fdwInfoType, lpSrcStr, cchSrc, lpCharType));
316}
317//******************************************************************************
318//******************************************************************************
319VOID WIN32API EnterCriticalSection(CRITICAL_SECTION * lpcsCriticalSection)
320{
321//// dprintf(("KERNEL32: EnterCriticalSection\n"));
322 O32_EnterCriticalSection(lpcsCriticalSection);
323}
324//******************************************************************************
325//******************************************************************************
326VOID WIN32API LeaveCriticalSection(CRITICAL_SECTION * arg1)
327{
328//// dprintf(("KERNEL32: LeaveCriticalSection\n"));
329 O32_LeaveCriticalSection(arg1);
330}
331//******************************************************************************
332//******************************************************************************
333VOID WIN32API InitializeCriticalSection(CRITICAL_SECTION * arg1)
334{
335 dprintf(("KERNEL32: InitializeCriticalSection\n"));
336 O32_InitializeCriticalSection(arg1);
337}
338//******************************************************************************
339//******************************************************************************
340void WIN32API MakeCriticalSectionGlobal( CRITICAL_SECTION *arg1 )
341{
342 dprintf(("KERNEL32: MakeCriticalSectionGlobal not implemented correctly\n"));
343}
344//******************************************************************************
345//******************************************************************************
346/***********************************************************************
347 * ReinitializeCriticalSection (KERNEL32.581)
348 */
349void WIN32API ReinitializeCriticalSection( CRITICAL_SECTION *crit )
350{
351 dprintf(("KERNEL32: ReinitializeCriticalSection\n"));
352 if ( !crit->LockSemaphore )
353 InitializeCriticalSection( crit );
354
355 else if ( crit->Reserved && crit->Reserved != GetCurrentProcessId() )
356 {
357// FIXME_(win32)("(%p) called for %08lx first, %08lx now: making global\n",
358// crit, crit->Reserved, GetCurrentProcessId() );
359
360 MakeCriticalSectionGlobal( crit );
361 }
362}
363//******************************************************************************
364//******************************************************************************
365/***********************************************************************
366 * UninitializeCriticalSection (KERNEL32.703)
367 */
368void WIN32API UninitializeCriticalSection( CRITICAL_SECTION *crit )
369{
370 dprintf(("KERNEL32: UninitializeCriticalSection\n"));
371 if ( crit->LockSemaphore )
372 {
373 if ( crit->Reserved ) /* not global */
374 DeleteCriticalSection( crit );
375// else
376// FIXME_(win32)("(%p) for %08lx: Crst is global, don't know whether to delete\n",
377// crit, GetCurrentProcessId() );
378 }
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 if(arg3 == 0)
616 return 0;
617
618 return O32_MulDiv(arg1, arg2, arg3);
619}
620//******************************************************************************
621//******************************************************************************
622HANDLE WIN32API OpenProcess(DWORD arg1, BOOL arg2, DWORD arg3)
623{
624 dprintf(("KERNEL32: OS2OpenProcess\n"));
625 return O32_OpenProcess(arg1, arg2, arg3);
626}
627//******************************************************************************
628//******************************************************************************
629//SvL: BUGFIX: C calling convention!
630//******************************************************************************
631VOID __cdecl OS2memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
632{
633 memmove(Destination, Source, Length);
634}
635//******************************************************************************
636
637//******************************************************************************
638UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
639 DWORD cch1, LPCSTR lpString2, DWORD cch2)
640{
641 int i;
642 int fEqual = TRUE;
643 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
644
645#ifdef DEBUG
646 if(fdwStyle & SORT_STRINGSORT)
647 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
648 if(fdwStyle & NORM_IGNORENONSPACE)
649 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
650 if(fdwStyle & NORM_IGNORESYMBOLS)
651 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
652#endif
653
654 if(cch1 == -1) cch1 = strlen(string1);
655 if(cch2 == -1) cch2 = strlen(string2);
656
657 if(fdwStyle) {
658 //TODO!
659 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
660 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
661 }
662 if(fdwStyle & NORM_IGNORECASE)
663 fEqual = strnicmp(string1, string2, min(cch1, cch2));
664 else
665 fEqual = strncmp(string1, string2, min(cch1, cch2));
666
667 if (fEqual < 0 ) fEqual = 1;
668 else if(fEqual == 0) fEqual = 2;
669 else if(fEqual > 0) fEqual = 3;
670
671 //If equal, but different length, largest one is the greatest in lexical value
672 if(fEqual == 2 && cch1 != cch2){
673 if(cch1 < cch2)
674 fEqual = 1;
675 else
676 fEqual = 3;
677 }
678// dprintf(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
679 return(fEqual);
680}
681
682//******************************************************************************
683//TODO: Not complete (fdwStyle flags specify compare method)
684//******************************************************************************
685UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
686 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
687{
688 int i;
689 int fEqual = TRUE;
690 char *string1 = UnicodeToAsciiString((LPWSTR)lpString1);
691 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
692
693// dprintf(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
694
695 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
696 FreeAsciiString(string1);
697 FreeAsciiString(string2);
698
699 return(fEqual);
700}
701//******************************************************************************
702//******************************************************************************
703//TODO: Query processor info to complete this api
704//******************************************************************************
705VOID WIN32API GetSystemInfo(LPSYSTEM_INFO lpSystemInfo)
706{
707 dprintf(("KERNEL32: GetSystemInfo, not completely accurate\n"));
708 lpSystemInfo->u.x.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
709 lpSystemInfo->u.x.wReserved = 0;
710 lpSystemInfo->dwPageSize = 4096;
711 lpSystemInfo->lpMinimumApplicationAddress = (LPVOID)0;
712 lpSystemInfo->lpMaximumApplicationAddress = (LPVOID)(512*1024*1024);
713 lpSystemInfo->dwActiveProcessorMask = 1;
714 lpSystemInfo->dwNumberOfProcessors = 1; //assuming non-SMP OS/2
715 lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_PENTIUM;
716 lpSystemInfo->dwAllocationGranularity = 64*1024;
717 lpSystemInfo->wProcessorLevel = 5; //Pentium
718 lpSystemInfo->wProcessorRevision = 0x201; //Model 2 stepping 1 (obviously not correct)
719}
720//******************************************************************************
721//Borrowed from Wine
722//******************************************************************************
723ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
724{
725 lpStartupInfo->cb = sizeof(STARTUPINFOA);
726 lpStartupInfo->lpReserved = "<Reserved>";
727 lpStartupInfo->lpDesktop = "Desktop";
728 lpStartupInfo->lpTitle = "Title";
729 lpStartupInfo->dwX = 0;
730 lpStartupInfo->dwY = 0;
731 lpStartupInfo->dwXSize = 640;
732 lpStartupInfo->dwYSize = 480;
733 lpStartupInfo->dwXCountChars = 80; // for console
734 lpStartupInfo->dwYCountChars = 25;
735 lpStartupInfo->dwFillAttribute = 0x0720;
736 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
737 STARTF_USEPOSITION |
738 STARTF_USESIZE |
739 STARTF_USECOUNTCHARS |
740 STARTF_USEFILLATTRIBUTE|
741 STARTF_USESTDHANDLES;
742 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
743 lpStartupInfo->cbReserved2 = 0;
744 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
745 /* @@@PH 98/07/13 Handlemanager support */
746 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
747 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
748 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
749 return;
750}
751//******************************************************************************
752//Borrowed from Wine
753//******************************************************************************
754ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
755{
756 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
757 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
758 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
759
760 // forward call to ascii variant
761 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
762 lpStartupInfo->cb = sizeof(STARTUPINFOW);
763 lpStartupInfo->lpReserved = lpReserved;
764 lpStartupInfo->lpDesktop = lpDesktop;
765 lpStartupInfo->lpTitle = lpTitle;
766 return;
767}
768//******************************************************************************
769//TODO: Not complete or correct, but sufficient for now
770//******************************************************************************
771BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
772{
773 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
774 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
775 *lpBinaryType = SCS_32BIT_BINARY;
776 else
777 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
778 *lpBinaryType = SCS_DOS_BINARY;
779 else
780 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
781 *lpBinaryType = SCS_PIF_BINARY;
782 else return(FALSE);
783 return(TRUE);
784}
785//******************************************************************************
786//******************************************************************************
787BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
788{
789 BOOL rc;
790 char *astring;
791
792 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
793 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
794 rc = GetBinaryTypeA(astring, lpBinaryType);
795 FreeAsciiString(astring);
796 return(rc);
797}
798//******************************************************************************
799//TODO: SetLastError
800//******************************************************************************
801BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
802{
803 dprintf(("KERNEL32: OS2GetVersionExA\n"));
804
805 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
806 return(FALSE);
807
808 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
809 lpVersionInformation->dwMinorVersion = 0;
810 lpVersionInformation->dwBuildNumber = 0x565;
811 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
812 strcpy(lpVersionInformation->szCSDVersion, "Service Pack 3");
813 return(TRUE);
814}
815//******************************************************************************
816//******************************************************************************
817BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
818{
819 dprintf(("KERNEL32: OS2GetVersionExW\n"));
820
821 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
822 return(FALSE);
823
824 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
825 lpVersionInformation->dwMinorVersion = 0;
826 lpVersionInformation->dwBuildNumber = 0x565;
827 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
828 lstrcpyW(lpVersionInformation->szCSDVersion, (LPWSTR)L"Service Pack 3");
829 return(TRUE);
830}
831//******************************************************************************
832//Should retrieve this from the exe...
833//******************************************************************************
834DWORD WIN32API GetProcessVersion(DWORD Processid)
835{
836 dprintf(("KERNEL32: OS2GetProcessVersion not correctly implemented!!\n"));
837 return(WIN32OS2_VERSION);
838}
839//******************************************************************************
840//******************************************************************************
841LONG WIN32API GetVersion()
842{
843 dprintf(("KERNEL32: GetVersion\n"));
844 // highword 0 = NT, lowword high byte major ver, low byte minor ver
845/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
846/* structures that lead to crashes if we don't identify as NT */
847
848// return(WIN32OS2_VERSION);
849 return (0x00000400);
850}
851//******************************************************************************
852//SvL: 26-6-'97 - Added
853//******************************************************************************
854VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
855{
856 char *astring;
857
858 astring = UnicodeToAsciiString((LPWSTR)arg1);
859 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
860 FreeAsciiString(astring);
861}
862//******************************************************************************
863//******************************************************************************
864VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
865{
866 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
867 return;
868}
869//******************************************************************************
870//Obsolete
871//******************************************************************************
872DWORD WIN32API GetProcessHeaps(DWORD NumberOfHeaps, PHANDLE ProcessHeaps)
873{
874 dprintf(("KERNEL32: GetProcessHeaps, Not implemented\n"));
875 return(0);
876}
877//******************************************************************************
878//WINE
879//******************************************************************************
880BOOL WIN32API GetProcessAffinityMask(HANDLE hProcess,
881 LPDWORD lpProcessAffinityMask,
882 LPDWORD lpSystemAffinityMask)
883{
884 /* It is definitely important for a process to know on what processor
885 it is running :-) */
886 if(lpProcessAffinityMask)
887 *lpProcessAffinityMask=1;
888 if(lpSystemAffinityMask)
889 *lpSystemAffinityMask=1;
890 return TRUE;
891}
892//******************************************************************************
893//******************************************************************************
894
895
896BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
897 HANDLE hProcess, /* process with cache to flush */
898 LPCVOID lpvBase, /* address of region to flush */
899 DWORD cbFlush) /* length of region to flush */
900
901{
902 dprintf(("FlushInstructionCache() - NIY\n"));
903 return TRUE;
904}
905
906
907int WIN32API GetNumberFormatA(LCID Locale,
908 DWORD dwFlags,
909 LPCSTR lpValue,
910 CONST NUMBERFMTA *lpFormat,
911 LPSTR lpNumberStr,
912 int cchNumber)
913{
914 dprintf(("KERNEL32::OS2GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
915 Locale,
916 dwFlags,
917 lpValue,
918 lpFormat,
919 lpNumberStr,
920 cchNumber));
921
922 return 0;
923}
924
925int WIN32API GetNumberFormatW(LCID Locale,
926 DWORD dwFlags,
927 LPCWSTR lpValue,
928 CONST NUMBERFMTW *lpFormat,
929 LPWSTR lpNumberStr,
930 int cchNumber)
931{
932 dprintf(("KERNEL32::OS2GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
933 Locale,
934 dwFlags,
935 lpValue,
936 lpFormat,
937 lpNumberStr,
938 cchNumber));
939
940 return 0;
941}
942
943BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
944{
945 dprintf(("KERNEL32: OS2FindNextChangeNotification, Not implemented\n"));
946
947 return(TRUE);
948}
949
950//******************************************************************************
951//******************************************************************************
952void WIN32API WrongComctl32()
953{
954 O32_MessageBox(NULL,
955 "KERNEL32.36 not implemented",
956 "Win32 for OS/2 Error",
957 MB_OK);
958 ExitProcess(987);
959}
960//******************************************************************************
961
962
963
964/***********************************************************************
965* RtlFillMemory (KERNEL32.441)
966*/
967VOID WIN32API RtlFillMemory(LPVOID ptr,
968 UINT len,
969 UINT fill )
970{
971#ifdef DEBUG_LOCAL
972 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
973 ptr,
974 len,
975 fill));
976#endif
977
978 memset(ptr,
979 fill,
980 len );
981}
982
983
984/***********************************************************************
985* RtlMoveMemory (KERNEL32.442)
986*/
987VOID WIN32API RtlMoveMemory(LPVOID dst,
988 LPCVOID src,
989 UINT len )
990{
991#ifdef DEBUG_LOCAL
992 dprintf(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
993 dst,
994 src,
995 len));
996#endif
997
998 memmove(dst,
999 src,
1000 len );
1001}
1002
1003
1004/***********************************************************************
1005* RtlZeroMemory (KERNEL32.444)
1006*/
1007VOID WIN32API RtlZeroMemory(LPVOID ptr,
1008 UINT len)
1009{
1010#ifdef DEBUG_LOCAL
1011 dprintf(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
1012 ptr,
1013 len));
1014#endif
1015
1016 memset(ptr,
1017 0,
1018 len);
1019}
1020
1021
1022//******************************************************************************
1023/*KSO Thu 21.05.1998*/
1024BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
1025{
1026 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
1027 return O32_IsDBCSLeadByte(TestChar);
1028}
1029//******************************************************************************
1030
1031
1032
1033
1034
1035
1036
1037
Note: See TracBrowser for help on using the repository browser.