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