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

Last change on this file since 183 was 151, checked in by phaller, 26 years ago

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