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

Last change on this file since 2182 was 2042, checked in by sandervl, 26 years ago

Ported ExpandEnvironmentStringsA/W (Wine: 991114)
File size: 27.1 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.38 1999-12-09 11:00:40 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//******************************************************************************
180BOOL WIN32API GetStringTypeW(DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
181{
182 int i;
183
184 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
185 if((DWORD)lpSrcStr == (DWORD)lpCharType || !lpSrcStr || !lpCharType) {
186 O32_SetLastError(ERROR_INVALID_PARAMETER);
187 return(FALSE);
188 }
189 if(cchSrc == -1)
190 cchSrc = UniStrlen((UniChar*)lpSrcStr);
191
192 memset(lpCharType, 0, cchSrc*sizeof(WORD));
193 switch(fdwInfoType) {
194 case CT_CTYPE1:
195 for(i=0;i<cchSrc;i++) {
196 if(lpSrcStr[i] >= (WCHAR)'a' && lpSrcStr[i] <= (WCHAR)'z')
197 lpCharType[i] |= C1_LOWER | C1_ALPHA;
198 else
199 if(lpSrcStr[i] >= (WCHAR)'A' && lpSrcStr[i] <= (WCHAR)'A')
200 lpCharType[i] |= C1_UPPER | C1_ALPHA;
201 else
202 if(lpSrcStr[i] >= (WCHAR)'0' && lpSrcStr[i] <= (WCHAR)'9')
203 lpCharType[i] |= C1_DIGIT;
204 else
205 if(lpSrcStr[i] >= (WCHAR)' ')
206 lpCharType[i] |= C1_SPACE;
207 }
208 break;
209 case CT_CTYPE2:
210 case CT_CTYPE3: //not supported right now
211 break;
212 }
213 return(TRUE);
214}
215//******************************************************************************
216//NOTE: This has one parameter more than the W version! (@#$@#$)
217//******************************************************************************
218BOOL WIN32API GetStringTypeA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
219{
220 int i;
221
222 dprintf(("KERNEL32: GetStringTypeA, not properly implemented\n"));
223 if(lpSrcStr == (LPCSTR)lpCharType || !lpSrcStr || !lpCharType) {
224 O32_SetLastError(ERROR_INVALID_PARAMETER);
225 return(FALSE);
226 }
227 if(cchSrc == -1)
228 cchSrc = strlen(lpSrcStr);
229
230 memset(lpCharType, 0, cchSrc*sizeof(WORD));
231 switch(fdwInfoType) {
232 case CT_CTYPE1:
233 for(i=0;i<cchSrc;i++) {
234 if(lpSrcStr[i] >= 'a' && lpSrcStr[i] <= 'z')
235 lpCharType[i] |= C1_LOWER | C1_ALPHA;
236 else
237 if(lpSrcStr[i] >= 'A' && lpSrcStr[i] <= 'A')
238 lpCharType[i] |= C1_UPPER | C1_ALPHA;
239 else
240 if(lpSrcStr[i] >= '0' && lpSrcStr[i] <= '9')
241 lpCharType[i] |= C1_DIGIT;
242 else
243 if(lpSrcStr[i] >= ' ')
244 lpCharType[i] |= C1_SPACE;
245 }
246 break;
247 case CT_CTYPE2:
248 case CT_CTYPE3: //not supported right now
249 break;
250 }
251 return(TRUE);
252}
253//******************************************************************************
254//******************************************************************************
255BOOL WIN32API GetStringTypeExW(LCID Locale, DWORD fdwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
256{
257 dprintf(("KERNEL32: GetStringTypeExW, not properly implemented\n"));
258 return(GetStringTypeW(fdwInfoType, lpSrcStr, cchSrc, lpCharType));
259}
260//******************************************************************************
261//******************************************************************************
262BOOL WIN32API GetStringTypeExA(LCID Locale, DWORD fdwInfoType, LPCSTR lpSrcStr, int cchSrc, LPWORD lpCharType)
263{
264 dprintf(("KERNEL32: GetStringTypeExA, not properly implemented\n"));
265 return(GetStringTypeA(Locale, fdwInfoType, lpSrcStr, cchSrc, lpCharType));
266}
267//******************************************************************************
268VOID WIN32API GlobalMemoryStatus( MEMORYSTATUS *arg1)
269{
270 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
271 O32_GlobalMemoryStatus(arg1);
272 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
273 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
274 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
275 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
276 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
277 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
278 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
279}
280VOID WIN32API Sleep(DWORD arg1)
281{
282 dprintf2(("KERNEL32: Sleep %d\n", arg1));
283 O32_Sleep(arg1);
284}
285//******************************************************************************
286//******************************************************************************
287DWORD WIN32API GetPriorityClass(HANDLE arg1)
288{
289 dprintf(("KERNEL32: GetPriorityClass\n"));
290 return O32_GetPriorityClass(arg1);
291}
292//******************************************************************************
293//******************************************************************************
294BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
295{
296 dprintf(("KERNEL32: SetPriorityClass\n"));
297 return O32_SetPriorityClass(arg1, arg2);
298}
299//******************************************************************************
300//TODO!
301//******************************************************************************
302int WIN32API LCMapStringW(
303 DWORD /*LCID*/ Locale,
304 DWORD dwMapFlags,
305 LPCWSTR lpSrcStr,
306 int cchSrc,
307 LPWSTR lpDestStr,
308 int cchDest)
309{
310 // quick hack! this code is not done!
311 if(cchSrc == -1)
312 cchSrc = strlen((const char *)lpSrcStr);
313 if(!cchDest)
314 return cchSrc;
315 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
316 return max(cchSrc, cchDest);
317}
318//******************************************************************************
319//TODO!
320//******************************************************************************
321int WIN32API LCMapStringA(
322 DWORD /*LCID*/ Locale,
323 DWORD dwMapFlags,
324 LPCSTR lpSrcStr,
325 int cchSrc,
326 LPSTR lpDestStr,
327 int cchDest)
328{
329 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
330 if(cchSrc == -1)
331 cchSrc = strlen((const char *)lpSrcStr);
332 if(!cchDest)
333 return cchSrc;
334 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
335 return max(cchSrc, cchDest);
336}
337//******************************************************************************
338//SvL: 24-6-'97 - Added
339//******************************************************************************
340BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
341{
342 dprintf(("KERNEL32: OS2Beep\n"));
343 return O32_Beep(arg1, arg2);
344}
345//******************************************************************************
346//******************************************************************************
347VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
348{
349 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
350 O32_FatalAppExit(arg1, arg2);
351}
352//******************************************************************************
353//******************************************************************************
354VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
355{
356 char *astring;
357
358 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
359 astring = UnicodeToAsciiString((LPWSTR)arg2);
360 O32_FatalAppExit(arg1, astring);
361 //probably won't return, but who cares..
362 FreeAsciiString(astring);
363}
364//******************************************************************************
365//******************************************************************************
366VOID WIN32API FatalExit( UINT arg1)
367{
368 dprintf(("KERNEL32: OS2FatalExit\n"));
369 O32_FatalExit(arg1);
370}
371//******************************************************************************
372//******************************************************************************
373BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
374{
375 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
376 return O32_IsBadHugeReadPtr(arg1, arg2);
377}
378//******************************************************************************
379//******************************************************************************
380BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
381{
382 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
383 return O32_IsBadHugeWritePtr(arg1, arg2);
384}
385//******************************************************************************
386//******************************************************************************
387BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
388{
389 dprintf2(("KERNEL32: OS2IsDBCSLeadByte\n"));
390 return O32_IsDBCSLeadByte(arg1);
391}
392//******************************************************************************
393//******************************************************************************
394DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
395{
396 dprintf(("KERNEL32: OS2LoadModule\n"));
397 return O32_LoadModule(arg1, arg2);
398}
399//******************************************************************************
400//******************************************************************************
401int WIN32API MulDiv(int arg1, int arg2, int arg3)
402{
403 dprintf(("KERNEL32: OS2MulDiv %d*%d/%d\n", arg1, arg2, arg3));
404 if(arg3 == 0)
405 return 0;
406
407 return O32_MulDiv(arg1, arg2, arg3);
408}
409//******************************************************************************
410//******************************************************************************
411//SvL: BUGFIX: C calling convention!
412//******************************************************************************
413VOID __cdecl OS2memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
414{
415 memmove(Destination, Source, Length);
416}
417//******************************************************************************
418
419//******************************************************************************
420UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
421 DWORD cch1, LPCSTR lpString2, DWORD cch2)
422{
423 int i;
424 int fEqual = TRUE;
425 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
426
427#ifdef DEBUG
428 if(fdwStyle & SORT_STRINGSORT)
429 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
430 if(fdwStyle & NORM_IGNORENONSPACE)
431 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
432 if(fdwStyle & NORM_IGNORESYMBOLS)
433 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
434#endif
435
436 if(cch1 == -1) cch1 = strlen(string1);
437 if(cch2 == -1) cch2 = strlen(string2);
438
439 if(fdwStyle) {
440 //TODO!
441 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
442 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
443 }
444 if(fdwStyle & NORM_IGNORECASE)
445 fEqual = strnicmp(string1, string2, min(cch1, cch2));
446 else
447 fEqual = strncmp(string1, string2, min(cch1, cch2));
448
449 if (fEqual < 0 ) fEqual = 1;
450 else if(fEqual == 0) fEqual = 2;
451 else if(fEqual > 0) fEqual = 3;
452
453 //If equal, but different length, largest one is the greatest in lexical value
454 if(fEqual == 2 && cch1 != cch2){
455 if(cch1 < cch2)
456 fEqual = 1;
457 else
458 fEqual = 3;
459 }
460 dprintf2(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
461 return(fEqual);
462}
463
464//******************************************************************************
465//TODO: Not complete (fdwStyle flags specify compare method)
466//******************************************************************************
467UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
468 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
469{
470 int i;
471 int fEqual = TRUE;
472 char *string1 = UnicodeToAsciiString((LPWSTR)lpString1);
473 char *string2 = UnicodeToAsciiString((LPWSTR)lpString2);
474
475 dprintf2(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
476
477 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
478 FreeAsciiString(string1);
479 FreeAsciiString(string2);
480
481 return(fEqual);
482}
483//******************************************************************************
484//Borrowed from Wine
485//******************************************************************************
486ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
487{
488 lpStartupInfo->cb = sizeof(STARTUPINFOA);
489 lpStartupInfo->lpReserved = "<Reserved>";
490 lpStartupInfo->lpDesktop = "Desktop";
491 lpStartupInfo->lpTitle = "Title";
492 lpStartupInfo->dwX = 0;
493 lpStartupInfo->dwY = 0;
494 lpStartupInfo->dwXSize = 640;
495 lpStartupInfo->dwYSize = 480;
496 lpStartupInfo->dwXCountChars = 80; // for console
497 lpStartupInfo->dwYCountChars = 25;
498 lpStartupInfo->dwFillAttribute = 0x0720;
499 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
500 STARTF_USEPOSITION |
501 STARTF_USESIZE |
502 STARTF_USECOUNTCHARS |
503 STARTF_USEFILLATTRIBUTE|
504 STARTF_USESTDHANDLES;
505 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
506 lpStartupInfo->cbReserved2 = 0;
507 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
508 /* @@@PH 98/07/13 Handlemanager support */
509 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
510 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
511 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
512 return;
513}
514//******************************************************************************
515//Borrowed from Wine
516//******************************************************************************
517ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
518{
519 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
520 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
521 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
522
523 // forward call to ascii variant
524 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
525 lpStartupInfo->cb = sizeof(STARTUPINFOW);
526 lpStartupInfo->lpReserved = lpReserved;
527 lpStartupInfo->lpDesktop = lpDesktop;
528 lpStartupInfo->lpTitle = lpTitle;
529 return;
530}
531//******************************************************************************
532//TODO: Not complete or correct, but sufficient for now
533//******************************************************************************
534BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
535{
536 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
537 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
538 *lpBinaryType = SCS_32BIT_BINARY;
539 else
540 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
541 *lpBinaryType = SCS_DOS_BINARY;
542 else
543 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
544 *lpBinaryType = SCS_PIF_BINARY;
545 else return(FALSE);
546 return(TRUE);
547}
548//******************************************************************************
549//******************************************************************************
550BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
551{
552 BOOL rc;
553 char *astring;
554
555 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
556 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
557 rc = GetBinaryTypeA(astring, lpBinaryType);
558 FreeAsciiString(astring);
559 return(rc);
560}
561//******************************************************************************
562//TODO: SetLastError
563//******************************************************************************
564BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
565{
566 dprintf(("KERNEL32: OS2GetVersionExA\n"));
567
568 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
569 return(FALSE);
570
571 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
572 lpVersionInformation->dwMinorVersion = 0;
573 lpVersionInformation->dwBuildNumber = 0x565;
574 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
575 strcpy(lpVersionInformation->szCSDVersion, "Service Pack 3");
576 return(TRUE);
577}
578//******************************************************************************
579//******************************************************************************
580BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
581{
582 dprintf(("KERNEL32: OS2GetVersionExW\n"));
583
584 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
585 return(FALSE);
586
587 lpVersionInformation->dwMajorVersion = 4; //pretend we're NT 4.0
588 lpVersionInformation->dwMinorVersion = 0;
589 lpVersionInformation->dwBuildNumber = 0x565;
590 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
591 lstrcpyW(lpVersionInformation->szCSDVersion, (LPWSTR)L"Service Pack 3");
592 return(TRUE);
593}
594//******************************************************************************
595//******************************************************************************
596LONG WIN32API GetVersion()
597{
598 dprintf(("KERNEL32: GetVersion\n"));
599 // highword 0 = NT, lowword high byte major ver, low byte minor ver
600/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
601/* structures that lead to crashes if we don't identify as NT */
602
603// return(WIN32OS2_VERSION);
604 return (0x0000004);
605}
606//******************************************************************************
607//SvL: 26-6-'97 - Added
608//******************************************************************************
609VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
610{
611 char *astring;
612
613 astring = UnicodeToAsciiString((LPWSTR)arg1);
614 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
615 FreeAsciiString(astring);
616}
617//******************************************************************************
618//******************************************************************************
619VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
620{
621 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
622 return;
623}
624//******************************************************************************
625//******************************************************************************
626BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
627 HANDLE hProcess, /* process with cache to flush */
628 LPCVOID lpvBase, /* address of region to flush */
629 DWORD cbFlush) /* length of region to flush */
630
631{
632 dprintf(("FlushInstructionCache() - NIY\n"));
633 return TRUE;
634}
635
636
637int WIN32API GetNumberFormatA(LCID Locale,
638 DWORD dwFlags,
639 LPCSTR lpValue,
640 CONST NUMBERFMTA *lpFormat,
641 LPSTR lpNumberStr,
642 int cchNumber)
643{
644 dprintf(("KERNEL32::OS2GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
645 Locale,
646 dwFlags,
647 lpValue,
648 lpFormat,
649 lpNumberStr,
650 cchNumber));
651
652 return 0;
653}
654
655int WIN32API GetNumberFormatW(LCID Locale,
656 DWORD dwFlags,
657 LPCWSTR lpValue,
658 CONST NUMBERFMTW *lpFormat,
659 LPWSTR lpNumberStr,
660 int cchNumber)
661{
662 dprintf(("KERNEL32::OS2GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not implemented.\n",
663 Locale,
664 dwFlags,
665 lpValue,
666 lpFormat,
667 lpNumberStr,
668 cchNumber));
669
670 return 0;
671}
672
673BOOL WIN32API FindCloseChangeNotification(HANDLE hChange)
674{
675 dprintf(("KERNEL32: OS2FindNextChangeNotification, Not implemented\n"));
676
677 return(TRUE);
678}
679
680//******************************************************************************
681//******************************************************************************
682void WIN32API WrongComctl32()
683{
684 O32_MessageBox(NULL,
685 "KERNEL32.36 not implemented",
686 "Win32 for OS/2 Error",
687 MB_OK);
688 ExitProcess(987);
689}
690//******************************************************************************
691
692/***********************************************************************
693* RtlFillMemory (KERNEL32.441)
694*/
695VOID WIN32API RtlFillMemory(LPVOID ptr,
696 UINT len,
697 UINT fill )
698{
699#ifdef DEBUG_LOCAL
700 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
701 ptr,
702 len,
703 fill));
704#endif
705
706 memset(ptr,
707 fill,
708 len );
709}
710
711
712/***********************************************************************
713* RtlMoveMemory (KERNEL32.442)
714*/
715VOID WIN32API RtlMoveMemory(LPVOID dst,
716 LPCVOID src,
717 UINT len )
718{
719 dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
720 dst,
721 src,
722 len));
723
724 memmove(dst,
725 src,
726 len );
727}
728
729
730/***********************************************************************
731* RtlZeroMemory (KERNEL32.444)
732*/
733VOID WIN32API RtlZeroMemory(LPVOID ptr,
734 UINT len)
735{
736 dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
737 ptr,
738 len));
739
740 memset(ptr,
741 0,
742 len);
743}
744
745//******************************************************************************
746/*KSO Thu 21.05.1998*/
747BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
748{
749 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
750 return O32_IsDBCSLeadByte(TestChar);
751}
752//******************************************************************************
753
754
755
756
757
758
759
760
Note: See TracBrowser for help on using the repository browser.