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

Last change on this file since 2016 was 1898, checked in by sandervl, 26 years ago

compilation fixes
File size: 30.8 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.37 1999-11-30 20:19:34 sandervl Exp $ */
2
3/*
4 * Win32 compatibility file functions for OS/2
5 *
6 * Copyright 1998 Sander van Leeuwen
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 <builtin.h>
34#include "heap.h"
35#include "handlemanager.h"
36#include "wprocess.h"
37
38
39/*****************************************************************************
40 * Defines *
41 *****************************************************************************/
42
43ODINDEBUGCHANNEL(KERNEL32-KERNEL32)
44
45 /* this define enables certain less important debug messages */
46//#define DEBUG_LOCAL 1
47
48
49
50/*****************************************************************************
51 * Name : BOOL WIN32API CloseHandle
52 * Purpose : forward call to Open32
53 * Parameters:
54 * Variables :
55 * Result :
56 * Remark :
57 * Status :
58 *
59 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
60 *****************************************************************************/
61BOOL WIN32API CloseHandle(HANDLE hHandle)
62{
63 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
64 hHandle));
65
66 return HMCloseHandle(hHandle);
67}
68
69
70//******************************************************************************
71HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
72{
73 HANDLE handle;
74
75 /* @@@PH 1998/02/12 Handle Manager Support */
76 handle = HMGetStdHandle(fdwDevice);
77
78 //@@@PH translate handle
79
80 /* handle = GetStdHandle(fdwDevice); */
81 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
82 return(handle);
83}
84//******************************************************************************
85//******************************************************************************
86BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
87 HANDLE hHandle)
88{
89 dprintf(("KERNEL32: SetStdHandle\n"));
90
91 ///@@@PH translate handle
92
93 return (HMSetStdHandle(IDStdHandle,
94 hHandle));
95}
96//******************************************************************************
97//******************************************************************************
98BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
99{
100#ifdef DEBUG
101 BOOL rc;
102
103 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
104 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
105 return(rc);
106#else
107 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
108#endif
109}
110//******************************************************************************
111//******************************************************************************
112BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
113{
114#ifdef DEBUG
115 BOOL rc;
116
117 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
118 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
119 return(rc);
120#else
121 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
122#endif
123}
124//******************************************************************************
125//******************************************************************************
126BOOL WIN32API IsBadCodePtr( FARPROC arg1)
127{
128 dprintf(("KERNEL32: IsBadCodePtr\n"));
129 return O32_IsBadCodePtr(arg1);
130}
131//******************************************************************************
132//******************************************************************************
133BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
134{
135 dprintf(("KERNEL32: IsBadStringPtr"));
136 return O32_IsBadStringPtr(arg1, arg2);
137}
138//******************************************************************************
139//******************************************************************************
140BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
141{
142 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
143 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
144}
145//******************************************************************************
146//******************************************************************************
147DWORD WIN32API GetLastError()
148{
149 DWORD rc;
150
151 rc = O32_GetLastError();
152#ifdef DEBUG_LOCAL
153 dprintf(("KERNEL32: GetLastError returned %d\n", rc));
154#endif
155 return(rc);
156}
157//******************************************************************************
158//******************************************************************************
159VOID WIN32API SetLastError( DWORD arg1)
160{
161 dprintf2(("KERNEL32: SetLastError to %d\n", arg1));
162 O32_SetLastError(arg1);
163}
164//******************************************************************************
165//******************************************************************************
166UINT WIN32API GetOEMCP(VOID)
167{
168 dprintf(("KERNEL32: GetOEMCP\n"));
169 return(O32_GetOEMCP());
170}
171//******************************************************************************
172//******************************************************************************
173UINT WIN32API GetACP(VOID)
174{
175 dprintf(("KERNEL32: GetACP\n"));
176 return(O32_GetACP());
177}
178//******************************************************************************
179//******************************************************************************
180//******************************************************************************
181//******************************************************************************
182LPWSTR WIN32API GetEnvironmentStringsW(VOID)
183{
184 char *envstrings = (char *)O32_GetEnvironmentStrings();
185 char *tmp;
186 LPWSTR wenvstrings;
187 int len, i;
188
189 dprintf(("KERNEL32: GetEnvironmentStringsW\n"));
190
191 if(envstrings == NULL)
192 return(NULL);
193
194 tmp = envstrings;
195 len = 0;
196 while(*tmp != 0)
197 {
198 len += strlen(tmp)+1;
199 tmp = envstrings + len;
200 }
201 len++; //terminating 0
202 wenvstrings = (LPWSTR)malloc(len*sizeof(WCHAR));
203 for(i=0;
204 i<len;
205 i++)
206 {
207 wenvstrings[i] = envstrings[i];
208 }
209 return(wenvstrings);
210}
211//******************************************************************************
212//******************************************************************************
213BOOL WIN32API FreeEnvironmentStringsA(LPSTR envstrings)
214{
215 dprintf(("KERNEL32: FreeEnvironmentStringsA\n"));
216 return(TRUE);
217}
218//******************************************************************************
219//******************************************************************************
220BOOL WIN32API FreeEnvironmentStringsW(LPWSTR envstrings)
221{
222 dprintf(("KERNEL32: FreeEnvironmentStringsW\n"));
223 free(envstrings);
224 return(TRUE);
225}
226//******************************************************************************
227//******************************************************************************
228BOOL WIN32API GetStringTypeW(DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
229{
230 int i;
231
232 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
233 if((DWORD)lpSrcStr == (DWORD)lpCharType || !lpSrcStr || !lpCharType) {
234 O32_SetLastError(ERROR_INVALID_PARAMETER);
235 return(FALSE);
236 }
237 if(cchSrc == -1)
238 cchSrc = UniStrlen((UniChar*)lpSrcStr);
239
240 memset(lpCharType, 0, cchSrc*sizeof(WORD));
241 switch(fdwInfoType) {
242 case CT_CTYPE1:
243 for(i=0;i<cchSrc;i++) {
244 if(lpSrcStr[i] >= (WCHAR)'a' && lpSrcStr[i] <= (WCHAR)'z')
245 lpCharType[i] |= C1_LOWER | C1_ALPHA;
246 else
247 if(lpSrcStr[i] >= (WCHAR)'A' && lpSrcStr[i] <= (WCHAR)'A')
248 lpCharType[i] |= C1_UPPER | C1_ALPHA;
249 else
250 if(lpSrcStr[i] >= (WCHAR)'0' && lpSrcStr[i] <= (WCHAR)'9')
251 lpCharType[i] |= C1_DIGIT;
252 else
253 if(lpSrcStr[i] >= (WCHAR)' ')
254 lpCharType[i] |= C1_SPACE;
255 }
256 break;
257 case CT_CTYPE2:
258 case CT_CTYPE3: //not supported right now
259 break;
260 }
261 return(TRUE);
262}
263//******************************************************************************
264//NOTE: This has one parameter more than the W version! (@#$@#$)
265//******************************************************************************
266BOOL WIN32API GetStringTypeA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
267{
268 int i;
269
270 dprintf(("KERNEL32: GetStringTypeA, not properly implemented\n"));
271 if(lpSrcStr == (LPCSTR)lpCharType || !lpSrcStr || !lpCharType) {
272 O32_SetLastError(ERROR_INVALID_PARAMETER);
273 return(FALSE);
274 }
275 if(cchSrc == -1)
276 cchSrc = strlen(lpSrcStr);
277
278 memset(lpCharType, 0, cchSrc*sizeof(WORD));
279 switch(fdwInfoType) {
280 case CT_CTYPE1:
281 for(i=0;i<cchSrc;i++) {
282 if(lpSrcStr[i] >= 'a' && lpSrcStr[i] <= 'z')
283 lpCharType[i] |= C1_LOWER | C1_ALPHA;
284 else
285 if(lpSrcStr[i] >= 'A' && lpSrcStr[i] <= 'A')
286 lpCharType[i] |= C1_UPPER | C1_ALPHA;
287 else
288 if(lpSrcStr[i] >= '0' && lpSrcStr[i] <= '9')
289 lpCharType[i] |= C1_DIGIT;
290 else
291 if(lpSrcStr[i] >= ' ')
292 lpCharType[i] |= C1_SPACE;
293 }
294 break;
295 case CT_CTYPE2:
296 case CT_CTYPE3: //not supported right now
297 break;
298 }
299 return(TRUE);
300}
301//******************************************************************************
302//******************************************************************************
303BOOL WIN32API GetStringTypeExW(LCID Locale, DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
304{
305 dprintf(("KERNEL32: GetStringTypeExW, not properly implemented\n"));
306 return(GetStringTypeW(fdwInfoType, lpSrcStr, cchSrc, lpCharType));
307}
308//******************************************************************************
309//******************************************************************************
310BOOL WIN32API GetStringTypeExA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
311{
312 dprintf(("KERNEL32: GetStringTypeExA, not properly implemented\n"));
313 return(GetStringTypeA(Locale, fdwInfoType, lpSrcStr, cchSrc, lpCharType));
314}
315//******************************************************************************
316//******************************************************************************
317BOOL WIN32API SetEnvironmentVariableA(LPCSTR arg1, LPCSTR arg2)
318{
319 dprintf(("KERNEL32: SetEnvironmentVariable %s to %s\n", arg1, arg2));
320 return O32_SetEnvironmentVariable(arg1, arg2);
321}
322//******************************************************************************
323//******************************************************************************
324BOOL WIN32API SetEnvironmentVariableW(LPCWSTR lpName, LPCWSTR lpValue)
325{
326 char *asciiname, *asciivalue;
327 BOOL rc;
328
329 dprintf(("KERNEL32: OS2SetEnvironmentVariableW\n"));
330 asciiname = UnicodeToAsciiString((LPWSTR)lpName);
331 asciivalue = UnicodeToAsciiString((LPWSTR)lpValue);
332 rc = O32_SetEnvironmentVariable(asciiname, asciivalue);
333 FreeAsciiString(asciivalue);
334 FreeAsciiString(asciiname);
335 return(rc);
336}
337//******************************************************************************
338VOID WIN32API GlobalMemoryStatus( MEMORYSTATUS *arg1)
339{
340 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
341 O32_GlobalMemoryStatus(arg1);
342 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
343 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
344 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
345 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
346 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
347 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
348 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
349}
350//******************************************************************************
351//******************************************************************************
352DWORD WIN32API GetEnvironmentVariableA(LPCSTR arg1, LPSTR arg2, DWORD arg3)
353{
354 dprintf(("KERNEL32: GetEnvironmentVariable %s\n", arg1));
355 return O32_GetEnvironmentVariable(arg1, arg2, arg3);
356}
357//******************************************************************************
358//******************************************************************************
359DWORD WIN32API GetEnvironmentVariableW(LPCWSTR lpName, LPWSTR lpBuffer,
360 DWORD nSize)
361{
362 char *astring, *asciibuffer;
363 DWORD rc;
364
365 dprintf(("KERNEL32: OS2GetEnvironmentVariableW\n"));
366 asciibuffer = (char *)malloc(nSize+1);
367 *asciibuffer = 0;
368 astring = UnicodeToAsciiString((LPWSTR)lpName);
369
370 rc = O32_GetEnvironmentVariable(astring, asciibuffer, nSize);
371 AsciiToUnicode(asciibuffer, lpBuffer);
372 FreeAsciiString(astring);
373 free(asciibuffer);
374 return(rc);
375}
376VOID WIN32API Sleep(DWORD arg1)
377{
378 dprintf2(("KERNEL32: Sleep %d\n", arg1));
379 O32_Sleep(arg1);
380}
381//******************************************************************************
382//******************************************************************************
383DWORD WIN32API GetPriorityClass(HANDLE arg1)
384{
385 dprintf(("KERNEL32: GetPriorityClass\n"));
386 return O32_GetPriorityClass(arg1);
387}
388//******************************************************************************
389//******************************************************************************
390BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
391{
392 dprintf(("KERNEL32: SetPriorityClass\n"));
393 return O32_SetPriorityClass(arg1, arg2);
394}
395//******************************************************************************
396//TODO!
397//******************************************************************************
398int WIN32API LCMapStringW(
399 DWORD /*LCID*/ Locale,
400 DWORD dwMapFlags,
401 LPCWSTR lpSrcStr,
402 int cchSrc,
403 LPWSTR lpDestStr,
404 int cchDest)
405{
406 // quick hack! this code is not done!
407 if(cchSrc == -1)
408 cchSrc = strlen((const char *)lpSrcStr);
409 if(!cchDest)
410 return cchSrc;
411 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
412 return max(cchSrc, cchDest);
413}
414//******************************************************************************
415//TODO!
416//******************************************************************************
417int WIN32API LCMapStringA(
418 DWORD /*LCID*/ Locale,
419 DWORD dwMapFlags,
420 LPCSTR lpSrcStr,
421 int cchSrc,
422 LPSTR lpDestStr,
423 int cchDest)
424{
425 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
426 if(cchSrc == -1)
427 cchSrc = strlen((const char *)lpSrcStr);
428 if(!cchDest)
429 return cchSrc;
430 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
431 return max(cchSrc, cchDest);
432}
433//******************************************************************************
434//SvL: 24-6-'97 - Added
435//******************************************************************************
436BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
437{
438 dprintf(("KERNEL32: OS2Beep\n"));
439 return O32_Beep(arg1, arg2);
440}
441//******************************************************************************
442//******************************************************************************
443VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
444{
445 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
446 O32_FatalAppExit(arg1, arg2);
447}
448//******************************************************************************
449//******************************************************************************
450VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
451{
452 char *astring;
453
454 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
455 astring = UnicodeToAsciiString((LPWSTR)arg2);
456 O32_FatalAppExit(arg1, astring);
457 //probably won't return, but who cares..
458 FreeAsciiString(astring);
459}
460//******************************************************************************
461//******************************************************************************
462VOID WIN32API FatalExit( UINT arg1)
463{
464 dprintf(("KERNEL32: OS2FatalExit\n"));
465 O32_FatalExit(arg1);
466}
467//******************************************************************************
468//******************************************************************************
469LPSTR WIN32API GetEnvironmentStringsA(void)
470{
471 dprintf(("KERNEL32: OS2GetEnvironmentStringsA\n"));
472 return (LPSTR) O32_GetEnvironmentStrings();
473}
474//******************************************************************************
475//******************************************************************************
476BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
477{
478 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
479 return O32_IsBadHugeReadPtr(arg1, arg2);
480}
481//******************************************************************************
482//******************************************************************************
483BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
484{
485 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
486 return O32_IsBadHugeWritePtr(arg1, arg2);
487}
488//******************************************************************************
489//******************************************************************************
490BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
491{
492 dprintf2(("KERNEL32: OS2IsDBCSLeadByte\n"));
493 return O32_IsDBCSLeadByte(arg1);
494}
495//******************************************************************************
496//******************************************************************************
497DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
498{
499 dprintf(("KERNEL32: OS2LoadModule\n"));
500 return O32_LoadModule(arg1, arg2);
501}
502//******************************************************************************
503//******************************************************************************
504int WIN32API MulDiv(int arg1, int arg2, int arg3)
505{
506 dprintf(("KERNEL32: OS2MulDiv %d*%d/%d\n", arg1, arg2, arg3));
507 if(arg3 == 0)
508 return 0;
509
510 return O32_MulDiv(arg1, arg2, arg3);
511}
512//******************************************************************************
513//******************************************************************************
514//SvL: BUGFIX: C calling convention!
515//******************************************************************************
516VOID __cdecl OS2memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
517{
518 memmove(Destination, Source, Length);
519}
520//******************************************************************************
521
522//******************************************************************************
523UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
524 DWORD cch1, LPCSTR lpString2, DWORD cch2)
525{
526 int i;
527 int fEqual = TRUE;
528 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
529
530#ifdef DEBUG
531 if(fdwStyle & SORT_STRINGSORT)
532 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
533 if(fdwStyle & NORM_IGNORENONSPACE)
534 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
535 if(fdwStyle & NORM_IGNORESYMBOLS)
536 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
537#endif
538
539 if(cch1 == -1) cch1 = strlen(string1);
540 if(cch2 == -1) cch2 = strlen(string2);
541
542 if(fdwStyle) {
543 //TODO!
544 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
545 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
546 }
547 if(fdwStyle & NORM_IGNORECASE)
548 fEqual = strnicmp(string1, string2, min(cch1, cch2));
549 else
550 fEqual = strncmp(string1, string2, min(cch1, cch2));
551
552 if (fEqual < 0 ) fEqual = 1;
553 else if(fEqual == 0) fEqual = 2;
554 else if(fEqual > 0) fEqual = 3;
555
556 //If equal, but different length, largest one is the greatest in lexical value
557 if(fEqual == 2 && cch1 != cch2){
558 if(cch1 < cch2)
559 fEqual = 1;
560 else
561 fEqual = 3;
562 }
563 dprintf2(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
564 return(fEqual);
565}
566
567//******************************************************************************
568//TODO: Not complete (fdwStyle flags specify compare method)
569//******************************************************************************
570UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
571 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
572{
573 int i;
574 int fEqual = TRUE;
575 char *string1 = UnicodeToAsciiString((LPWSTR)lpString1);
576 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
577
578 dprintf2(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
579
580 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
581 FreeAsciiString(string1);
582 FreeAsciiString(string2);
583
584 return(fEqual);
585}
586//******************************************************************************
587//Borrowed from Wine
588//******************************************************************************
589ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
590{
591 lpStartupInfo->cb = sizeof(STARTUPINFOA);
592 lpStartupInfo->lpReserved = "<Reserved>";
593 lpStartupInfo->lpDesktop = "Desktop";
594 lpStartupInfo->lpTitle = "Title";
595 lpStartupInfo->dwX = 0;
596 lpStartupInfo->dwY = 0;
597 lpStartupInfo->dwXSize = 640;
598 lpStartupInfo->dwYSize = 480;
599 lpStartupInfo->dwXCountChars = 80; // for console
600 lpStartupInfo->dwYCountChars = 25;
601 lpStartupInfo->dwFillAttribute = 0x0720;
602 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
603 STARTF_USEPOSITION |
604 STARTF_USESIZE |
605 STARTF_USECOUNTCHARS |
606 STARTF_USEFILLATTRIBUTE|
607 STARTF_USESTDHANDLES;
608 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
609 lpStartupInfo->cbReserved2 = 0;
610 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
611 /* @@@PH 98/07/13 Handlemanager support */
612 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
613 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
614 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
615 return;
616}
617//******************************************************************************
618//Borrowed from Wine
619//******************************************************************************
620ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
621{
622 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
623 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
624 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
625
626 // forward call to ascii variant
627 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
628 lpStartupInfo->cb = sizeof(STARTUPINFOW);
629 lpStartupInfo->lpReserved = lpReserved;
630 lpStartupInfo->lpDesktop = lpDesktop;
631 lpStartupInfo->lpTitle = lpTitle;
632 return;
633}
634//******************************************************************************
635//TODO: Not complete or correct, but sufficient for now
636//******************************************************************************
637BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
638{
639 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
640 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
641 *lpBinaryType = SCS_32BIT_BINARY;
642 else
643 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
644 *lpBinaryType = SCS_DOS_BINARY;
645 else
646 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
647 *lpBinaryType = SCS_PIF_BINARY;
648 else return(FALSE);
649 return(TRUE);
650}
651//******************************************************************************
652//******************************************************************************
653BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
654{
655 BOOL rc;
656 char *astring;
657
658 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
659 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
660 rc = GetBinaryTypeA(astring, lpBinaryType);
661 FreeAsciiString(astring);
662 return(rc);
663}
664//******************************************************************************
665//TODO: SetLastError
666//******************************************************************************
667BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
668{
669 dprintf(("KERNEL32: OS2GetVersionExA\n"));
670
671 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
672 return(FALSE);
673
674 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
675 lpVersionInformation->dwMinorVersion = 0;
676 lpVersionInformation->dwBuildNumber = 0x565;
677 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
678 strcpy(lpVersionInformation->szCSDVersion, "Service Pack 3");
679 return(TRUE);
680}
681//******************************************************************************
682//******************************************************************************
683BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
684{
685 dprintf(("KERNEL32: OS2GetVersionExW\n"));
686
687 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
688 return(FALSE);
689
690 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
691 lpVersionInformation->dwMinorVersion = 0;
692 lpVersionInformation->dwBuildNumber = 0x565;
693 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
694 lstrcpyW(lpVersionInformation->szCSDVersion, (LPWSTR)L"Service Pack 3");
695 return(TRUE);
696}
697//******************************************************************************
698//******************************************************************************
699LONG WIN32API GetVersion()
700{
701 dprintf(("KERNEL32: GetVersion\n"));
702 // highword 0 = NT, lowword high byte major ver, low byte minor ver
703/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
704/* structures that lead to crashes if we don't identify as NT */
705
706// return(WIN32OS2_VERSION);
707 return (0x0000004);
708}
709//******************************************************************************
710//SvL: 26-6-'97 - Added
711//******************************************************************************
712VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
713{
714 char *astring;
715
716 astring = UnicodeToAsciiString((LPWSTR)arg1);
717 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
718 FreeAsciiString(astring);
719}
720//******************************************************************************
721//******************************************************************************
722VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
723{
724 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
725 return;
726}
727//******************************************************************************
728//******************************************************************************
729BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
730 HANDLE hProcess, /* process with cache to flush */
731 LPCVOID lpvBase, /* address of region to flush */
732 DWORD cbFlush) /* length of region to flush */
733
734{
735 dprintf(("FlushInstructionCache() - NIY\n"));
736 return TRUE;
737}
738
739
740int WIN32API GetNumberFormatA(LCID Locale,
741 DWORD dwFlags,
742 LPCSTR lpValue,
743 CONST NUMBERFMTA *lpFormat,
744 LPSTR lpNumberStr,
745 int cchNumber)
746{
747 dprintf(("KERNEL32::OS2GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
748 Locale,
749 dwFlags,
750 lpValue,
751 lpFormat,
752 lpNumberStr,
753 cchNumber));
754
755 return 0;
756}
757
758int WIN32API GetNumberFormatW(LCID Locale,
759 DWORD dwFlags,
760 LPCWSTR lpValue,
761 CONST NUMBERFMTW *lpFormat,
762 LPWSTR lpNumberStr,
763 int cchNumber)
764{
765 dprintf(("KERNEL32::OS2GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
766 Locale,
767 dwFlags,
768 lpValue,
769 lpFormat,
770 lpNumberStr,
771 cchNumber));
772
773 return 0;
774}
775
776BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
777{
778 dprintf(("KERNEL32: OS2FindNextChangeNotification, Not implemented\n"));
779
780 return(TRUE);
781}
782
783//******************************************************************************
784//******************************************************************************
785void WIN32API WrongComctl32()
786{
787 O32_MessageBox(NULL,
788 "KERNEL32.36 not implemented",
789 "Win32 for OS/2 Error",
790 MB_OK);
791 ExitProcess(987);
792}
793//******************************************************************************
794
795/***********************************************************************
796* RtlFillMemory (KERNEL32.441)
797*/
798VOID WIN32API RtlFillMemory(LPVOID ptr,
799 UINT len,
800 UINT fill )
801{
802#ifdef DEBUG_LOCAL
803 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
804 ptr,
805 len,
806 fill));
807#endif
808
809 memset(ptr,
810 fill,
811 len );
812}
813
814
815/***********************************************************************
816* RtlMoveMemory (KERNEL32.442)
817*/
818VOID WIN32API RtlMoveMemory(LPVOID dst,
819 LPCVOID src,
820 UINT len )
821{
822 dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
823 dst,
824 src,
825 len));
826
827 memmove(dst,
828 src,
829 len );
830}
831
832
833/***********************************************************************
834* RtlZeroMemory (KERNEL32.444)
835*/
836VOID WIN32API RtlZeroMemory(LPVOID ptr,
837 UINT len)
838{
839 dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
840 ptr,
841 len));
842
843 memset(ptr,
844 0,
845 len);
846}
847
848//******************************************************************************
849/*KSO Thu 21.05.1998*/
850BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
851{
852 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
853 return O32_IsDBCSLeadByte(TestChar);
854}
855//******************************************************************************
856
857
858
859
860
861
862
863
Note: See TracBrowser for help on using the repository browser.