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

Last change on this file since 710 was 705, checked in by sandervl, 26 years ago

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