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

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

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