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

Last change on this file since 4346 was 4325, checked in by phaller, 25 years ago

Fixed memory calculation
File size: 19.9 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.54 2000-09-25 19:57:17 phaller 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#include <ctype.h>
32
33#include "misc.h"
34#include <builtin.h>
35#include "heap.h"
36#include "handlemanager.h"
37#include "wprocess.h"
38#include "oslibdos.h"
39#include <versionos2.h>
40
41#define DBG_LOCALLOG DBG_kernel32
42#include "dbglocal.h"
43
44/*****************************************************************************
45 * Defines *
46 *****************************************************************************/
47
48ODINDEBUGCHANNEL(KERNEL32-KERNEL32)
49
50 /* this define enables certain less important debug messages */
51//#define DEBUG_LOCAL 1
52
53
54
55/*****************************************************************************
56 * Name : BOOL WIN32API CloseHandle
57 * Purpose : forward call to Open32
58 * Parameters:
59 * Variables :
60 * Result :
61 * Remark :
62 * Status :
63 *
64 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
65 *****************************************************************************/
66BOOL WIN32API CloseHandle(HANDLE hHandle)
67{
68 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
69 hHandle));
70
71 return HMCloseHandle(hHandle);
72}
73
74
75//******************************************************************************
76HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
77{
78 HANDLE handle;
79
80 /* @@@PH 1998/02/12 Handle Manager Support */
81 handle = HMGetStdHandle(fdwDevice);
82
83 //@@@PH translate handle
84
85 /* handle = GetStdHandle(fdwDevice); */
86 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
87 return(handle);
88}
89//******************************************************************************
90//******************************************************************************
91BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
92 HANDLE hHandle)
93{
94 dprintf(("KERNEL32: SetStdHandle\n"));
95
96 ///@@@PH translate handle
97
98 return (HMSetStdHandle(IDStdHandle,
99 hHandle));
100}
101//******************************************************************************
102//******************************************************************************
103BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
104{
105#ifdef DEBUG
106 BOOL rc;
107
108 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
109 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
110 return(rc);
111#else
112 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
113#endif
114}
115//******************************************************************************
116//******************************************************************************
117BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
118{
119#ifdef DEBUG
120 BOOL rc;
121
122 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
123 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
124 return(rc);
125#else
126 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
127#endif
128}
129//******************************************************************************
130//******************************************************************************
131BOOL WIN32API IsBadCodePtr( FARPROC arg1)
132{
133 dprintf(("KERNEL32: IsBadCodePtr\n"));
134 return O32_IsBadCodePtr(arg1);
135}
136//******************************************************************************
137//******************************************************************************
138BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
139{
140 dprintf(("KERNEL32: IsBadStringPtr"));
141 return O32_IsBadStringPtr(arg1, arg2);
142}
143//******************************************************************************
144//******************************************************************************
145BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
146{
147 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
148 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
149}
150//******************************************************************************
151//******************************************************************************
152DWORD WIN32API GetLastError()
153{
154 DWORD rc;
155
156 rc = O32_GetLastError();
157 if(rc) {
158 dprintf2(("KERNEL32: GetLastError returned %d\n", rc));
159 }
160 return(rc);
161}
162//******************************************************************************
163//******************************************************************************
164VOID WIN32API SetLastError( DWORD dwError)
165{
166 if(dwError != 0) {
167 dprintf2(("KERNEL32: SetLastError to %d\n", dwError));
168 }
169 O32_SetLastError(dwError);
170}
171//******************************************************************************
172//******************************************************************************
173UINT WIN32API GetOEMCP(VOID)
174{
175 dprintf(("KERNEL32: GetOEMCP\n"));
176 return(O32_GetOEMCP());
177}
178//******************************************************************************
179//******************************************************************************
180UINT WIN32API GetACP(VOID)
181{
182 dprintf(("KERNEL32: GetACP\n"));
183 return(O32_GetACP());
184}
185//******************************************************************************
186//******************************************************************************
187
188/*
189 * PH 2000/09/25 This is an experiment to overcome some problems
190 * with Open32's GMS variant.
191 */
192void _GlobalMemoryStatus(MEMORYSTATUS *lpMemStat)
193{
194 ULONG sys[5];
195 // Note: QSV_TOTPHYSMEM = 17, QSV_MAXSHMEM = 21
196 lpMemStat->dwLength = sizeof(MEMORYSTATUS);
197
198 if(!OSLibDosQuerySysInfo( 17, 21, (PVOID)sys, sizeof(sys)))
199 {
200 // Specified a number between 0 and 100 that gives a general idea of
201 // current memory utilization, in which 0 indicates no memory use and
202 // 100 indicates full memory use
203
204 //#define MB512 0x1c000000
205 //lpMemStat->dwMemoryLoad = (MB512-sys[20]) * 100 / MB512;
206 lpMemStat->dwMemoryLoad = (sys[1] * 100) / sys[0];
207
208 // bytes of physical memory
209 lpMemStat->dwTotalPhys = sys[0];
210
211 // free physical memory bytes
212 lpMemStat->dwAvailPhys = sys[0] - sys[1];
213
214 // bytes of paging file
215 // @@@PH add swapper.dat size?
216 lpMemStat->dwTotalPageFile = sys[2];
217
218 // free bytes of paging file
219 lpMemStat->dwAvailPageFile = sys[2];
220
221 // user bytes of address space
222 lpMemStat->dwTotalVirtual = max(sys[2], sys[3]);
223 lpMemStat->dwAvailVirtual = min(sys[2], sys[3]);
224 }
225}
226
227
228
229VOID WIN32API GlobalMemoryStatus(MEMORYSTATUS *arg1)
230{
231 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
232 //O32_GlobalMemoryStatus(arg1);
233 _GlobalMemoryStatus(arg1);
234 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
235 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
236 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
237 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
238 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
239 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
240 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
241}
242VOID WIN32API Sleep(DWORD arg1)
243{
244 dprintf2(("KERNEL32: Sleep %d\n", arg1));
245 O32_Sleep(arg1);
246}
247//******************************************************************************
248//******************************************************************************
249DWORD WIN32API GetPriorityClass(HANDLE arg1)
250{
251 dprintf(("KERNEL32: GetPriorityClass\n"));
252 return O32_GetPriorityClass(arg1);
253}
254//******************************************************************************
255//******************************************************************************
256BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
257{
258 dprintf(("KERNEL32: SetPriorityClass\n"));
259 return O32_SetPriorityClass(arg1, arg2);
260}
261//******************************************************************************
262//******************************************************************************
263BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
264{
265 dprintf(("KERNEL32: OS2Beep\n"));
266 return O32_Beep(arg1, arg2);
267}
268//******************************************************************************
269//******************************************************************************
270VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
271{
272 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
273 O32_FatalAppExit(arg1, arg2);
274}
275//******************************************************************************
276//******************************************************************************
277VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
278{
279 char *astring;
280
281 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
282 astring = UnicodeToAsciiString((LPWSTR)arg2);
283 O32_FatalAppExit(arg1, astring);
284 //probably won't return, but who cares..
285 FreeAsciiString(astring);
286}
287//******************************************************************************
288//******************************************************************************
289VOID WIN32API FatalExit( UINT arg1)
290{
291 dprintf(("KERNEL32: OS2FatalExit\n"));
292 O32_FatalExit(arg1);
293}
294//******************************************************************************
295//******************************************************************************
296BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
297{
298 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
299 return O32_IsBadHugeReadPtr(arg1, arg2);
300}
301//******************************************************************************
302//******************************************************************************
303BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
304{
305 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
306 return O32_IsBadHugeWritePtr(arg1, arg2);
307}
308//******************************************************************************
309//******************************************************************************
310BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
311{
312 dprintf2(("KERNEL32: OS2IsDBCSLeadByte\n"));
313 return O32_IsDBCSLeadByte(arg1);
314}
315//******************************************************************************
316//******************************************************************************
317DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
318{
319 dprintf(("KERNEL32: OS2LoadModule\n"));
320 return O32_LoadModule(arg1, arg2);
321}
322//******************************************************************************
323//******************************************************************************
324int WIN32API MulDiv(int arg1, int arg2, int arg3)
325{
326 dprintf2(("KERNEL32: MulDiv %d*%d/%d\n", arg1, arg2, arg3));
327 if(arg3 == 0)
328 return 0;
329
330 return O32_MulDiv(arg1, arg2, arg3);
331}
332//******************************************************************************
333//Borrowed from Wine
334//******************************************************************************
335ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
336{
337 lpStartupInfo->cb = sizeof(STARTUPINFOA);
338 lpStartupInfo->lpReserved = "<Reserved>";
339 lpStartupInfo->lpDesktop = "Desktop";
340 lpStartupInfo->lpTitle = "Title";
341 lpStartupInfo->dwX = 0;
342 lpStartupInfo->dwY = 0;
343 lpStartupInfo->dwXSize = 640;
344 lpStartupInfo->dwYSize = 480;
345 lpStartupInfo->dwXCountChars = 80; // for console
346 lpStartupInfo->dwYCountChars = 25;
347 lpStartupInfo->dwFillAttribute = 0x0720;
348 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
349 STARTF_USEPOSITION |
350 STARTF_USESIZE |
351 STARTF_USECOUNTCHARS |
352 STARTF_USEFILLATTRIBUTE|
353 STARTF_USESTDHANDLES;
354 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
355 lpStartupInfo->cbReserved2 = 0;
356 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
357 /* @@@PH 98/07/13 Handlemanager support */
358 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
359 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
360 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
361 return;
362}
363//******************************************************************************
364//Borrowed from Wine
365//******************************************************************************
366ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
367{
368 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
369 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
370 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
371
372 // forward call to ascii variant
373 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
374 lpStartupInfo->cb = sizeof(STARTUPINFOW);
375 lpStartupInfo->lpReserved = lpReserved;
376 lpStartupInfo->lpDesktop = lpDesktop;
377 lpStartupInfo->lpTitle = lpTitle;
378 return;
379}
380//******************************************************************************
381//TODO: Not complete or correct, but sufficient for now
382//******************************************************************************
383BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
384{
385 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
386 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
387 *lpBinaryType = SCS_32BIT_BINARY;
388 else
389 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
390 *lpBinaryType = SCS_DOS_BINARY;
391 else
392 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
393 *lpBinaryType = SCS_PIF_BINARY;
394 else return(FALSE);
395 return(TRUE);
396}
397//******************************************************************************
398//******************************************************************************
399BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
400{
401 BOOL rc;
402 char *astring;
403
404 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
405 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
406 rc = GetBinaryTypeA(astring, lpBinaryType);
407 FreeAsciiString(astring);
408 return(rc);
409}
410//******************************************************************************
411//TODO: SetLastError
412//******************************************************************************
413BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
414{
415 dprintf(("KERNEL32: OS2GetVersionExA\n"));
416
417 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
418 return(FALSE);
419
420 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
421 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
422 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
423 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
424 strcpy(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION);
425 return(TRUE);
426}
427//******************************************************************************
428//******************************************************************************
429BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
430{
431 dprintf(("KERNEL32: OS2GetVersionExW\n"));
432
433 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
434 return(FALSE);
435
436 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
437 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
438 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
439 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
440 lstrcpyW(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION_W);
441 return(TRUE);
442}
443//******************************************************************************
444//******************************************************************************
445LONG WIN32API GetVersion()
446{
447 dprintf(("KERNEL32: GetVersion\n"));
448 // highword 0 = NT, lowword high byte major ver, low byte minor ver
449/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
450/* structures that lead to crashes if we don't identify as NT */
451
452 return ODINNT_VERSION;
453}
454//******************************************************************************
455//******************************************************************************
456BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
457 HANDLE hProcess, /* process with cache to flush */
458 LPCVOID lpvBase, /* address of region to flush */
459 DWORD cbFlush) /* length of region to flush */
460
461{
462 dprintf(("FlushInstructionCache() - NIY\n"));
463 return TRUE;
464}
465
466
467//******************************************************************************
468
469/***********************************************************************
470* RtlFillMemory (KERNEL32.441)
471*/
472VOID WIN32API RtlFillMemory(LPVOID ptr,
473 UINT len,
474 UINT fill )
475{
476#ifdef DEBUG_LOCAL
477 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
478 ptr,
479 len,
480 fill));
481#endif
482
483 memset(ptr,
484 fill,
485 len );
486}
487
488
489/***********************************************************************
490* RtlMoveMemory (KERNEL32.442)
491*/
492VOID WIN32API RtlMoveMemory(LPVOID dst,
493 LPCVOID src,
494 UINT len )
495{
496 dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
497 dst,
498 src,
499 len));
500
501 memmove(dst,
502 src,
503 len );
504}
505
506
507/***********************************************************************
508* RtlZeroMemory (KERNEL32.444)
509*/
510VOID WIN32API RtlZeroMemory(LPVOID ptr,
511 UINT len)
512{
513 dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
514 ptr,
515 len));
516
517 memset(ptr,
518 0,
519 len);
520}
521
522//******************************************************************************
523/*KSO Thu 21.05.1998*/
524BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
525{
526 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
527 return O32_IsDBCSLeadByte(TestChar);
528}
529//******************************************************************************
530
531
532
533
534
535
536
537
538/*****************************************************************************
539 * Name : BOOL GetSystemPowerStatus
540 * Purpose : The GetSystemPowerStatus function retrieves the power status of
541 * the system. The status indicates whether the system is running
542 * on AC or DC power, whether the battery is currently charging,
543 * and how much battery life currently remains.
544 * Parameters: LPSYSTEM_POWER_STATUS lpSystemPowerStatus
545 * Variables :
546 * Result : TRUE / FALSE
547 * Remark :
548 * Status : UNTESTED STUB
549 *
550 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
551 *****************************************************************************/
552
553BOOL WIN32API GetSystemPowerStatus(LPSYSTEM_POWER_STATUS lpSystemPowerStatus)
554{
555 dprintf(("Kernel32: GetSystemPowerStatus(%08xh) not properly implemented.\n",
556 lpSystemPowerStatus));
557
558 if(lpSystemPowerStatus == NULL) {
559 SetLastError(ERROR_INVALID_PARAMETER);
560 return FALSE;
561 }
562 lpSystemPowerStatus->ACLineStatus = 1; //online
563 lpSystemPowerStatus->BatteryFlag = 128; //no system battery
564 lpSystemPowerStatus->BatteryLifePercent = 255; //unknown
565 lpSystemPowerStatus->reserved = 0;
566 lpSystemPowerStatus->BatteryLifeTime = -1; //unknown
567 lpSystemPowerStatus->BatteryFullLifeTime= -1; //unknown
568
569 return TRUE;
570}
Note: See TracBrowser for help on using the repository browser.