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

Last change on this file since 3807 was 3804, checked in by sandervl, 25 years ago

strncpy call changes + language api updates/fixes
File size: 41.0 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.49 2000-07-06 21:18:38 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#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 <versionos2.h>
39
40#define DBG_LOCALLOG DBG_kernel32
41#include "dbglocal.h"
42
43/*****************************************************************************
44 * Defines *
45 *****************************************************************************/
46
47ODINDEBUGCHANNEL(KERNEL32-KERNEL32)
48
49 /* this define enables certain less important debug messages */
50//#define DEBUG_LOCAL 1
51
52
53
54/*****************************************************************************
55 * Name : BOOL WIN32API CloseHandle
56 * Purpose : forward call to Open32
57 * Parameters:
58 * Variables :
59 * Result :
60 * Remark :
61 * Status :
62 *
63 * Author : Patrick Haller [Fri, 1998/06/12 03:44]
64 *****************************************************************************/
65BOOL WIN32API CloseHandle(HANDLE hHandle)
66{
67 dprintf(("KERNEL32: CloseHandle(%08xh)\n",
68 hHandle));
69
70 return HMCloseHandle(hHandle);
71}
72
73
74//******************************************************************************
75HANDLE WIN32API GetStdHandle(DWORD fdwDevice)
76{
77 HANDLE handle;
78
79 /* @@@PH 1998/02/12 Handle Manager Support */
80 handle = HMGetStdHandle(fdwDevice);
81
82 //@@@PH translate handle
83
84 /* handle = GetStdHandle(fdwDevice); */
85 dprintf(("KERNEL32: GetStdHandle for device %X returned %X\n", fdwDevice, handle));
86 return(handle);
87}
88//******************************************************************************
89//******************************************************************************
90BOOL WIN32API SetStdHandle(DWORD IDStdHandle,
91 HANDLE hHandle)
92{
93 dprintf(("KERNEL32: SetStdHandle\n"));
94
95 ///@@@PH translate handle
96
97 return (HMSetStdHandle(IDStdHandle,
98 hHandle));
99}
100//******************************************************************************
101//******************************************************************************
102BOOL WIN32API IsBadWritePtr(LPVOID lpvPtr, UINT cbBytes)
103{
104#ifdef DEBUG
105 BOOL rc;
106
107 rc = O32_IsBadWritePtr(lpvPtr, cbBytes);
108 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
109 return(rc);
110#else
111 return(O32_IsBadWritePtr(lpvPtr, cbBytes));
112#endif
113}
114//******************************************************************************
115//******************************************************************************
116BOOL WIN32API IsBadReadPtr(CONST VOID *lpvPtr, UINT cbBytes)
117{
118#ifdef DEBUG
119 BOOL rc;
120
121 rc = O32_IsBadReadPtr(lpvPtr, cbBytes);
122 dprintf(("KERNEL32: IsBadWritePtr: 0x%X size %d rc = %d\n", (int)lpvPtr, cbBytes, rc));
123 return(rc);
124#else
125 return(O32_IsBadReadPtr(lpvPtr, cbBytes));
126#endif
127}
128//******************************************************************************
129//******************************************************************************
130BOOL WIN32API IsBadCodePtr( FARPROC arg1)
131{
132 dprintf(("KERNEL32: IsBadCodePtr\n"));
133 return O32_IsBadCodePtr(arg1);
134}
135//******************************************************************************
136//******************************************************************************
137BOOL WIN32API IsBadStringPtrA( LPCSTR arg1, UINT arg2)
138{
139 dprintf(("KERNEL32: IsBadStringPtr"));
140 return O32_IsBadStringPtr(arg1, arg2);
141}
142//******************************************************************************
143//******************************************************************************
144BOOL WIN32API IsBadStringPtrW(LPCWSTR arg1, UINT arg2)
145{
146 dprintf(("KERNEL32: OS2IsBadStringPtrW"));
147 return O32_IsBadReadPtr((CONST VOID *)arg1, arg2*2+2);
148}
149//******************************************************************************
150//******************************************************************************
151DWORD WIN32API GetLastError()
152{
153 DWORD rc;
154
155 rc = O32_GetLastError();
156#ifdef DEBUG_LOCAL
157 dprintf(("KERNEL32: GetLastError returned %d\n", rc));
158#endif
159 return(rc);
160}
161//******************************************************************************
162//******************************************************************************
163VOID WIN32API SetLastError( DWORD dwError)
164{
165 if(dwError != 0) {
166 dprintf2(("KERNEL32: SetLastError to %d\n", dwError));
167 }
168 O32_SetLastError(dwError);
169}
170//******************************************************************************
171//******************************************************************************
172UINT WIN32API GetOEMCP(VOID)
173{
174 dprintf(("KERNEL32: GetOEMCP\n"));
175 return(O32_GetOEMCP());
176}
177//******************************************************************************
178//******************************************************************************
179UINT WIN32API GetACP(VOID)
180{
181 dprintf(("KERNEL32: GetACP\n"));
182 return(O32_GetACP());
183}
184//******************************************************************************
185//******************************************************************************
186
187static const unsigned char CT_CType2_LUT[] = {
188 C2_NOTAPPLICABLE, /* - 0 */
189 C2_NOTAPPLICABLE, /* - 1 */
190 C2_NOTAPPLICABLE, /* - 2 */
191 C2_NOTAPPLICABLE, /* - 3 */
192 C2_NOTAPPLICABLE, /* - 4 */
193 C2_NOTAPPLICABLE, /* - 5 */
194 C2_NOTAPPLICABLE, /* - 6 */
195 C2_NOTAPPLICABLE, /* - 7 */
196 C2_NOTAPPLICABLE, /* - 8 */
197 C2_SEGMENTSEPARATOR, /* - 9 */
198 C2_NOTAPPLICABLE, /* - 10 */
199 C2_NOTAPPLICABLE, /* - 11 */
200 C2_NOTAPPLICABLE, /* - 12 */
201 C2_NOTAPPLICABLE, /* - 13 */
202 C2_NOTAPPLICABLE, /* - 14 */
203 C2_NOTAPPLICABLE, /* - 15 */
204 C2_NOTAPPLICABLE, /* - 16 */
205 C2_NOTAPPLICABLE, /* - 17 */
206 C2_NOTAPPLICABLE, /* - 18 */
207 C2_NOTAPPLICABLE, /* - 19 */
208 C2_NOTAPPLICABLE, /* - 20 */
209 C2_NOTAPPLICABLE, /* - 21 */
210 C2_NOTAPPLICABLE, /* - 22 */
211 C2_NOTAPPLICABLE, /* - 23 */
212 C2_NOTAPPLICABLE, /* - 24 */
213 C2_NOTAPPLICABLE, /* - 25 */
214 C2_NOTAPPLICABLE, /* - 26 */
215 C2_NOTAPPLICABLE, /* - 27 */
216 C2_NOTAPPLICABLE, /* - 28 */
217 C2_NOTAPPLICABLE, /* - 29 */
218 C2_NOTAPPLICABLE, /* - 30 */
219 C2_NOTAPPLICABLE, /* - 31 */
220 C2_WHITESPACE, /* - 32 */
221 C2_OTHERNEUTRAL, /* ! - 33 */
222 C2_OTHERNEUTRAL, /* " - 34 */ /* " */
223 C2_EUROPETERMINATOR, /* # - 35 */
224 C2_EUROPETERMINATOR, /* $ - 36 */
225 C2_EUROPETERMINATOR, /* % - 37 */
226 C2_LEFTTORIGHT, /* & - 38 */
227 C2_OTHERNEUTRAL, /* ' - 39 */
228 C2_OTHERNEUTRAL, /* ( - 40 */
229 C2_OTHERNEUTRAL, /* ) - 41 */
230 C2_OTHERNEUTRAL, /* * - 42 */
231 C2_EUROPETERMINATOR, /* + - 43 */
232 C2_COMMONSEPARATOR, /* , - 44 */
233 C2_EUROPETERMINATOR, /* - - 45 */
234 C2_EUROPESEPARATOR, /* . - 46 */
235 C2_EUROPESEPARATOR, /* / - 47 */
236 C2_EUROPENUMBER, /* 0 - 48 */
237 C2_EUROPENUMBER, /* 1 - 49 */
238 C2_EUROPENUMBER, /* 2 - 50 */
239 C2_EUROPENUMBER, /* 3 - 51 */
240 C2_EUROPENUMBER, /* 4 - 52 */
241 C2_EUROPENUMBER, /* 5 - 53 */
242 C2_EUROPENUMBER, /* 6 - 54 */
243 C2_EUROPENUMBER, /* 7 - 55 */
244 C2_EUROPENUMBER, /* 8 - 56 */
245 C2_EUROPENUMBER, /* 9 - 57 */
246 C2_COMMONSEPARATOR, /* : - 58 */
247 C2_OTHERNEUTRAL, /* ; - 59 */
248 C2_OTHERNEUTRAL, /* < - 60 */
249 C2_OTHERNEUTRAL, /* = - 61 */
250 C2_OTHERNEUTRAL, /* > - 62 */
251 C2_OTHERNEUTRAL, /* ? - 63 */
252 C2_LEFTTORIGHT, /* @ - 64 */
253 C2_LEFTTORIGHT, /* A - 65 */
254 C2_LEFTTORIGHT, /* B - 66 */
255 C2_LEFTTORIGHT, /* C - 67 */
256 C2_LEFTTORIGHT, /* D - 68 */
257 C2_LEFTTORIGHT, /* E - 69 */
258 C2_LEFTTORIGHT, /* F - 70 */
259 C2_LEFTTORIGHT, /* G - 71 */
260 C2_LEFTTORIGHT, /* H - 72 */
261 C2_LEFTTORIGHT, /* I - 73 */
262 C2_LEFTTORIGHT, /* J - 74 */
263 C2_LEFTTORIGHT, /* K - 75 */
264 C2_LEFTTORIGHT, /* L - 76 */
265 C2_LEFTTORIGHT, /* M - 77 */
266 C2_LEFTTORIGHT, /* N - 78 */
267 C2_LEFTTORIGHT, /* O - 79 */
268 C2_LEFTTORIGHT, /* P - 80 */
269 C2_LEFTTORIGHT, /* Q - 81 */
270 C2_LEFTTORIGHT, /* R - 82 */
271 C2_LEFTTORIGHT, /* S - 83 */
272 C2_LEFTTORIGHT, /* T - 84 */
273 C2_LEFTTORIGHT, /* U - 85 */
274 C2_LEFTTORIGHT, /* V - 86 */
275 C2_LEFTTORIGHT, /* W - 87 */
276 C2_LEFTTORIGHT, /* X - 88 */
277 C2_LEFTTORIGHT, /* Y - 89 */
278 C2_LEFTTORIGHT, /* Z - 90 */
279 C2_OTHERNEUTRAL, /* [ - 91 */
280 C2_OTHERNEUTRAL, /* \ - 92 */
281 C2_OTHERNEUTRAL, /* ] - 93 */
282 C2_OTHERNEUTRAL, /* ^ - 94 */
283 C2_OTHERNEUTRAL, /* _ - 95 */
284 C2_OTHERNEUTRAL, /* ` - 96 */
285 C2_LEFTTORIGHT, /* a - 97 */
286 C2_LEFTTORIGHT, /* b - 98 */
287 C2_LEFTTORIGHT, /* c - 99 */
288 C2_LEFTTORIGHT, /* d - 100 */
289 C2_LEFTTORIGHT, /* e - 101 */
290 C2_LEFTTORIGHT, /* f - 102 */
291 C2_LEFTTORIGHT, /* g - 103 */
292 C2_LEFTTORIGHT, /* h - 104 */
293 C2_LEFTTORIGHT, /* i - 105 */
294 C2_LEFTTORIGHT, /* j - 106 */
295 C2_LEFTTORIGHT, /* k - 107 */
296 C2_LEFTTORIGHT, /* l - 108 */
297 C2_LEFTTORIGHT, /* m - 109 */
298 C2_LEFTTORIGHT, /* n - 110 */
299 C2_LEFTTORIGHT, /* o - 111 */
300 C2_LEFTTORIGHT, /* p - 112 */
301 C2_LEFTTORIGHT, /* q - 113 */
302 C2_LEFTTORIGHT, /* r - 114 */
303 C2_LEFTTORIGHT, /* s - 115 */
304 C2_LEFTTORIGHT, /* t - 116 */
305 C2_LEFTTORIGHT, /* u - 117 */
306 C2_LEFTTORIGHT, /* v - 118 */
307 C2_LEFTTORIGHT, /* w - 119 */
308 C2_LEFTTORIGHT, /* x - 120 */
309 C2_LEFTTORIGHT, /* y - 121 */
310 C2_LEFTTORIGHT, /* z - 122 */
311 C2_OTHERNEUTRAL, /* { - 123 */
312 C2_OTHERNEUTRAL, /* | - 124 */
313 C2_OTHERNEUTRAL, /* } - 125 */
314 C2_OTHERNEUTRAL, /* ~ - 126 */
315 C2_NOTAPPLICABLE, /*  - 127 */
316 C2_NOTAPPLICABLE, /* € - 128 */
317 C2_NOTAPPLICABLE, /*  - 129 */
318 C2_OTHERNEUTRAL, /* ‚ - 130 */
319 C2_LEFTTORIGHT, /* ƒ - 131 */
320 C2_OTHERNEUTRAL, /* „ - 132 */
321 C2_OTHERNEUTRAL, /* …
322 - 133 */
323 C2_OTHERNEUTRAL, /* † - 134 */
324 C2_OTHERNEUTRAL, /* ‡ - 135 */
325 C2_LEFTTORIGHT, /* ˆ - 136 */
326 C2_EUROPETERMINATOR, /* ‰ - 137 */
327 C2_LEFTTORIGHT, /* Š - 138 */
328 C2_OTHERNEUTRAL, /* ‹ - 139 */
329 C2_LEFTTORIGHT, /* Π- 140 */
330 C2_NOTAPPLICABLE, /*  - 141 */
331 C2_NOTAPPLICABLE, /* Ž - 142 */
332 C2_NOTAPPLICABLE, /*  - 143 */
333 C2_NOTAPPLICABLE, /*  - 144 */
334 C2_OTHERNEUTRAL, /* ‘ - 145 */
335 C2_OTHERNEUTRAL, /* ’ - 146 */
336 C2_OTHERNEUTRAL, /* “ - 147 */
337 C2_OTHERNEUTRAL, /* ” - 148 */
338 C2_OTHERNEUTRAL, /* • - 149 */
339 C2_OTHERNEUTRAL, /* – - 150 */
340 C2_OTHERNEUTRAL, /* — - 151 */
341 C2_LEFTTORIGHT, /* ˜ - 152 */
342 C2_OTHERNEUTRAL, /* ™ - 153 */
343 C2_LEFTTORIGHT, /* š - 154 */
344 C2_OTHERNEUTRAL, /* › - 155 */
345 C2_LEFTTORIGHT, /* œ - 156 */
346 C2_NOTAPPLICABLE, /*  - 157 */
347 C2_NOTAPPLICABLE, /* ž - 158 */
348 C2_LEFTTORIGHT, /* Ÿ - 159 */
349 C2_WHITESPACE, /*   - 160 */
350 C2_OTHERNEUTRAL, /* ¡ - 161 */
351 C2_EUROPETERMINATOR, /* ¢ - 162 */
352 C2_EUROPETERMINATOR, /* £ - 163 */
353 C2_EUROPETERMINATOR, /* € - 164 */
354 C2_EUROPETERMINATOR, /* ¥ - 165 */
355 C2_OTHERNEUTRAL, /* Š - 166 */
356 C2_OTHERNEUTRAL, /* § - 167 */
357 C2_OTHERNEUTRAL, /* š - 168 */
358 C2_OTHERNEUTRAL, /* © - 169 */
359 C2_OTHERNEUTRAL, /* ª - 170 */
360 C2_OTHERNEUTRAL, /* « - 171 */
361 C2_OTHERNEUTRAL, /* ¬ - 172 */
362 C2_OTHERNEUTRAL, /* ­ - 173 */
363 C2_OTHERNEUTRAL, /* ® - 174 */
364 C2_OTHERNEUTRAL, /* ¯ - 175 */
365 C2_EUROPETERMINATOR, /* ° - 176 */
366 C2_EUROPETERMINATOR, /* ± - 177 */
367 C2_EUROPENUMBER, /* ² - 178 */
368 C2_EUROPENUMBER, /* ³ - 179 */
369 C2_OTHERNEUTRAL, /* Ž - 180 */
370 C2_OTHERNEUTRAL, /* µ - 181 */
371 C2_OTHERNEUTRAL, /* ¶ - 182 */
372 C2_OTHERNEUTRAL, /* · - 183 */
373 C2_OTHERNEUTRAL, /* ž - 184 */
374 C2_EUROPENUMBER, /* ¹ - 185 */
375 C2_OTHERNEUTRAL, /* º - 186 */
376 C2_OTHERNEUTRAL, /* » - 187 */
377 C2_OTHERNEUTRAL, /* Π- 188 */
378 C2_OTHERNEUTRAL, /* œ - 189 */
379 C2_OTHERNEUTRAL, /* Ÿ - 190 */
380 C2_OTHERNEUTRAL, /* ¿ - 191 */
381 C2_LEFTTORIGHT, /* À - 192 */
382 C2_LEFTTORIGHT, /* Á - 193 */
383 C2_LEFTTORIGHT, /* Â - 194 */
384 C2_LEFTTORIGHT, /* Ã - 195 */
385 C2_LEFTTORIGHT, /* Ä - 196 */
386 C2_LEFTTORIGHT, /* Å - 197 */
387 C2_LEFTTORIGHT, /* Æ - 198 */
388 C2_LEFTTORIGHT, /* Ç - 199 */
389 C2_LEFTTORIGHT, /* È - 200 */
390 C2_LEFTTORIGHT, /* É - 201 */
391 C2_LEFTTORIGHT, /* Ê - 202 */
392 C2_LEFTTORIGHT, /* Ë - 203 */
393 C2_LEFTTORIGHT, /* Ì - 204 */
394 C2_LEFTTORIGHT, /* Í - 205 */
395 C2_LEFTTORIGHT, /* Î - 206 */
396 C2_LEFTTORIGHT, /* Ï - 207 */
397 C2_LEFTTORIGHT, /* Ð - 208 */
398 C2_LEFTTORIGHT, /* Ñ - 209 */
399 C2_LEFTTORIGHT, /* Ò - 210 */
400 C2_LEFTTORIGHT, /* Ó - 211 */
401 C2_LEFTTORIGHT, /* Ô - 212 */
402 C2_LEFTTORIGHT, /* Õ - 213 */
403 C2_LEFTTORIGHT, /* Ö - 214 */
404 C2_OTHERNEUTRAL, /* × - 215 */
405 C2_LEFTTORIGHT, /* Ø - 216 */
406 C2_LEFTTORIGHT, /* Ù - 217 */
407 C2_LEFTTORIGHT, /* Ú - 218 */
408 C2_LEFTTORIGHT, /* Û - 219 */
409 C2_LEFTTORIGHT, /* Ü - 220 */
410 C2_LEFTTORIGHT, /* Ý - 221 */
411 C2_LEFTTORIGHT, /* Þ - 222 */
412 C2_LEFTTORIGHT, /* ß - 223 */
413 C2_LEFTTORIGHT, /* à - 224 */
414 C2_LEFTTORIGHT, /* á - 225 */
415 C2_LEFTTORIGHT, /* â - 226 */
416 C2_LEFTTORIGHT, /* ã - 227 */
417 C2_LEFTTORIGHT, /* ä - 228 */
418 C2_LEFTTORIGHT, /* å - 229 */
419 C2_LEFTTORIGHT, /* æ - 230 */
420 C2_LEFTTORIGHT, /* ç - 231 */
421 C2_LEFTTORIGHT, /* è - 232 */
422 C2_LEFTTORIGHT, /* é - 233 */
423 C2_LEFTTORIGHT, /* ê - 234 */
424 C2_LEFTTORIGHT, /* ë - 235 */
425 C2_LEFTTORIGHT, /* ì - 236 */
426 C2_LEFTTORIGHT, /* í - 237 */
427 C2_LEFTTORIGHT, /* î - 238 */
428 C2_LEFTTORIGHT, /* ï - 239 */
429 C2_LEFTTORIGHT, /* ð - 240 */
430 C2_LEFTTORIGHT, /* ñ - 241 */
431 C2_LEFTTORIGHT, /* ò - 242 */
432 C2_LEFTTORIGHT, /* ó - 243 */
433 C2_LEFTTORIGHT, /* ô - 244 */
434 C2_LEFTTORIGHT, /* õ - 245 */
435 C2_LEFTTORIGHT, /* ö - 246 */
436 C2_OTHERNEUTRAL, /* ÷ - 247 */
437 C2_LEFTTORIGHT, /* ø - 248 */
438 C2_LEFTTORIGHT, /* ù - 249 */
439 C2_LEFTTORIGHT, /* ú - 250 */
440 C2_LEFTTORIGHT, /* û - 251 */
441 C2_LEFTTORIGHT, /* ü - 252 */
442 C2_LEFTTORIGHT, /* ý - 253 */
443 C2_LEFTTORIGHT, /* þ - 254 */
444 C2_LEFTTORIGHT /* ÿ - 255 */
445};
446
447const WORD OLE2NLS_CT_CType3_LUT[] = {
448 0x0000, /* - 0 */
449 0x0000, /* - 1 */
450 0x0000, /* - 2 */
451 0x0000, /* - 3 */
452 0x0000, /* - 4 */
453 0x0000, /* - 5 */
454 0x0000, /* - 6 */
455 0x0000, /* - 7 */
456 0x0000, /* - 8 */
457 0x0008, /* - 9 */
458 0x0008, /* - 10 */
459 0x0008, /* - 11 */
460 0x0008, /* - 12 */
461 0x0008, /* - 13 */
462 0x0000, /* - 14 */
463 0x0000, /* - 15 */
464 0x0000, /* - 16 */
465 0x0000, /* - 17 */
466 0x0000, /* - 18 */
467 0x0000, /* - 19 */
468 0x0000, /* - 20 */
469 0x0000, /* - 21 */
470 0x0000, /* - 22 */
471 0x0000, /* - 23 */
472 0x0000, /* - 24 */
473 0x0000, /* - 25 */
474 0x0000, /* - 26 */
475 0x0000, /* - 27 */
476 0x0000, /* - 28 */
477 0x0000, /* - 29 */
478 0x0000, /* - 30 */
479 0x0000, /* - 31 */
480 0x0048, /* - 32 */
481 0x0048, /* ! - 33 */
482 0x0448, /* " - 34 */ /* " */
483 0x0048, /* # - 35 */
484 0x0448, /* $ - 36 */
485 0x0048, /* % - 37 */
486 0x0048, /* & - 38 */
487 0x0440, /* ' - 39 */
488 0x0048, /* ( - 40 */
489 0x0048, /* ) - 41 */
490 0x0048, /* * - 42 */
491 0x0048, /* + - 43 */
492 0x0048, /* , - 44 */
493 0x0440, /* - - 45 */
494 0x0048, /* . - 46 */
495 0x0448, /* / - 47 */
496 0x0040, /* 0 - 48 */
497 0x0040, /* 1 - 49 */
498 0x0040, /* 2 - 50 */
499 0x0040, /* 3 - 51 */
500 0x0040, /* 4 - 52 */
501 0x0040, /* 5 - 53 */
502 0x0040, /* 6 - 54 */
503 0x0040, /* 7 - 55 */
504 0x0040, /* 8 - 56 */
505 0x0040, /* 9 - 57 */
506 0x0048, /* : - 58 */
507 0x0048, /* ; - 59 */
508 0x0048, /* < - 60 */
509 0x0448, /* = - 61 */
510 0x0048, /* > - 62 */
511 0x0048, /* ? - 63 */
512 0x0448, /* @ - 64 */
513 0x8040, /* A - 65 */
514 0x8040, /* B - 66 */
515 0x8040, /* C - 67 */
516 0x8040, /* D - 68 */
517 0x8040, /* E - 69 */
518 0x8040, /* F - 70 */
519 0x8040, /* G - 71 */
520 0x8040, /* H - 72 */
521 0x8040, /* I - 73 */
522 0x8040, /* J - 74 */
523 0x8040, /* K - 75 */
524 0x8040, /* L - 76 */
525 0x8040, /* M - 77 */
526 0x8040, /* N - 78 */
527 0x8040, /* O - 79 */
528 0x8040, /* P - 80 */
529 0x8040, /* Q - 81 */
530 0x8040, /* R - 82 */
531 0x8040, /* S - 83 */
532 0x8040, /* T - 84 */
533 0x8040, /* U - 85 */
534 0x8040, /* V - 86 */
535 0x8040, /* W - 87 */
536 0x8040, /* X - 88 */
537 0x8040, /* Y - 89 */
538 0x8040, /* Z - 90 */
539 0x0048, /* [ - 91 */
540 0x0448, /* \ - 92 */
541 0x0048, /* ] - 93 */
542 0x0448, /* ^ - 94 */
543 0x0448, /* _ - 95 */
544 0x0448, /* ` - 96 */
545 0x8040, /* a - 97 */
546 0x8040, /* b - 98 */
547 0x8040, /* c - 99 */
548 0x8040, /* d - 100 */
549 0x8040, /* e - 101 */
550 0x8040, /* f - 102 */
551 0x8040, /* g - 103 */
552 0x8040, /* h - 104 */
553 0x8040, /* i - 105 */
554 0x8040, /* j - 106 */
555 0x8040, /* k - 107 */
556 0x8040, /* l - 108 */
557 0x8040, /* m - 109 */
558 0x8040, /* n - 110 */
559 0x8040, /* o - 111 */
560 0x8040, /* p - 112 */
561 0x8040, /* q - 113 */
562 0x8040, /* r - 114 */
563 0x8040, /* s - 115 */
564 0x8040, /* t - 116 */
565 0x8040, /* u - 117 */
566 0x8040, /* v - 118 */
567 0x8040, /* w - 119 */
568 0x8040, /* x - 120 */
569 0x8040, /* y - 121 */
570 0x8040, /* z - 122 */
571 0x0048, /* { - 123 */
572 0x0048, /* | - 124 */
573 0x0048, /* } - 125 */
574 0x0448, /* ~ - 126 */
575 0x0000, /*  - 127 */
576 0x0000, /* € - 128 */
577 0x0000, /*  - 129 */
578 0x0008, /* ‚ - 130 */
579 0x8000, /* ƒ - 131 */
580 0x0008, /* „ - 132 */
581 0x0008, /* …
582 - 133 */
583 0x0008, /* † - 134 */
584 0x0008, /* ‡ - 135 */
585 0x0001, /* ˆ - 136 */
586 0x0008, /* ‰ - 137 */
587 0x8003, /* Š - 138 */
588 0x0008, /* ‹ - 139 */
589 0x8000, /* Π- 140 */
590 0x0000, /*  - 141 */
591 0x0000, /* Ž - 142 */
592 0x0000, /*  - 143 */
593 0x0000, /*  - 144 */
594 0x0088, /* ‘ - 145 */
595 0x0088, /* ’ - 146 */
596 0x0088, /* “ - 147 */
597 0x0088, /* ” - 148 */
598 0x0008, /* • - 149 */
599 0x0400, /* – - 150 */
600 0x0400, /* — - 151 */
601 0x0408, /* ˜ - 152 */
602 0x0000, /* ™ - 153 */
603 0x8003, /* š - 154 */
604 0x0008, /* › - 155 */
605 0x8000, /* œ - 156 */
606 0x0000, /*  - 157 */
607 0x0000, /* ž - 158 */
608 0x8003, /* Ÿ - 159 */
609 0x0008, /*   - 160 */
610 0x0008, /* ¡ - 161 */
611 0x0048, /* ¢ - 162 */
612 0x0048, /* £ - 163 */
613 0x0008, /* € - 164 */
614 0x0048, /* ¥ - 165 */
615 0x0048, /* Š - 166 */
616 0x0008, /* § - 167 */
617 0x0408, /* š - 168 */
618 0x0008, /* © - 169 */
619 0x0400, /* ª - 170 */
620 0x0008, /* « - 171 */
621 0x0048, /* ¬ - 172 */
622 0x0408, /* ­ - 173 */
623 0x0008, /* ® - 174 */
624 0x0448, /* ¯ - 175 */
625 0x0008, /* ° - 176 */
626 0x0008, /* ± - 177 */
627 0x0000, /* ² - 178 */
628 0x0000, /* ³ - 179 */
629 0x0408, /* Ž - 180 */
630 0x0008, /* µ - 181 */
631 0x0008, /* ¶ - 182 */
632 0x0008, /* · - 183 */
633 0x0408, /* ž - 184 */
634 0x0000, /* ¹ - 185 */
635 0x0400, /* º - 186 */
636 0x0008, /* » - 187 */
637 0x0000, /* Π- 188 */
638 0x0000, /* œ - 189 */
639 0x0000, /* Ÿ - 190 */
640 0x0008, /* ¿ - 191 */
641 0x8003, /* À - 192 */
642 0x8003, /* Á - 193 */
643 0x8003, /* Â - 194 */
644 0x8003, /* Ã - 195 */
645 0x8003, /* Ä - 196 */
646 0x8003, /* Å - 197 */
647 0x8000, /* Æ - 198 */
648 0x8003, /* Ç - 199 */
649 0x8003, /* È - 200 */
650 0x8003, /* É - 201 */
651 0x8003, /* Ê - 202 */
652 0x8003, /* Ë - 203 */
653 0x8003, /* Ì - 204 */
654 0x8003, /* Í - 205 */
655 0x8003, /* Î - 206 */
656 0x8003, /* Ï - 207 */
657 0x8000, /* Ð - 208 */
658 0x8003, /* Ñ - 209 */
659 0x8003, /* Ò - 210 */
660 0x8003, /* Ó - 211 */
661 0x8003, /* Ô - 212 */
662 0x8003, /* Õ - 213 */
663 0x8003, /* Ö - 214 */
664 0x0008, /* × - 215 */
665 0x8003, /* Ø - 216 */
666 0x8003, /* Ù - 217 */
667 0x8003, /* Ú - 218 */
668 0x8003, /* Û - 219 */
669 0x8003, /* Ü - 220 */
670 0x8003, /* Ý - 221 */
671 0x8000, /* Þ - 222 */
672 0x8000, /* ß - 223 */
673 0x8003, /* à - 224 */
674 0x8003, /* á - 225 */
675 0x8003, /* â - 226 */
676 0x8003, /* ã - 227 */
677 0x8003, /* ä - 228 */
678 0x8003, /* å - 229 */
679 0x8000, /* æ - 230 */
680 0x8003, /* ç - 231 */
681 0x8003, /* è - 232 */
682 0x8003, /* é - 233 */
683 0x8003, /* ê - 234 */
684 0x8003, /* ë - 235 */
685 0x8003, /* ì - 236 */
686 0x8003, /* í - 237 */
687 0x8003, /* î - 238 */
688 0x8003, /* ï - 239 */
689 0x8000, /* ð - 240 */
690 0x8003, /* ñ - 241 */
691 0x8003, /* ò - 242 */
692 0x8003, /* ó - 243 */
693 0x8003, /* ô - 244 */
694 0x8003, /* õ - 245 */
695 0x8003, /* ö - 246 */
696 0x0008, /* ÷ - 247 */
697 0x8003, /* ø - 248 */
698 0x8003, /* ù - 249 */
699 0x8003, /* ú - 250 */
700 0x8003, /* û - 251 */
701 0x8003, /* ü - 252 */
702 0x8003, /* ý - 253 */
703 0x8000, /* þ - 254 */
704 0x8003 /* ÿ - 255 */
705};
706
707
708
709ODINFUNCTION4(BOOL, GetStringTypeW,
710 DWORD, dwInfoType,
711 LPCWSTR, lpSrcStr,
712 int, cchSrc,
713 LPWORD, lpCharType)
714{
715 return GetStringTypeExW(0,
716 dwInfoType,
717 lpSrcStr,
718 cchSrc,
719 lpCharType);
720}
721
722
723ODINFUNCTION5(BOOL, GetStringTypeExW,
724 LCID, locale,
725 DWORD, dwInfoType,
726 LPCWSTR, lpSrcStr,
727 int, cchSrc,
728 LPWORD, lpCharType)
729{
730 int i;
731
732 dprintf(("KERNEL32: GetStringTypeW, not properly implemented\n"));
733 if((DWORD)lpSrcStr == (DWORD)lpCharType ||
734 !lpSrcStr ||
735 !lpCharType)
736 {
737 O32_SetLastError(ERROR_INVALID_PARAMETER);
738 return(FALSE);
739 }
740
741 if(cchSrc == -1)
742 cchSrc = UniStrlen((UniChar*)lpSrcStr);
743
744 switch(dwInfoType)
745 {
746 case CT_CTYPE1:
747 for(i=0;i<cchSrc;i++)
748 {
749 lpCharType[i] = 0;
750 if (isdigit(lpSrcStr[i])) lpCharType[i]|=C1_DIGIT;
751 if (isalpha(lpSrcStr[i])) lpCharType[i]|=C1_ALPHA;
752 if (islower(lpSrcStr[i])) lpCharType[i]|=C1_LOWER;
753 if (isupper(lpSrcStr[i])) lpCharType[i]|=C1_UPPER;
754 if (isspace(lpSrcStr[i])) lpCharType[i]|=C1_SPACE;
755 if (ispunct(lpSrcStr[i])) lpCharType[i]|=C1_PUNCT;
756 if (iscntrl(lpSrcStr[i])) lpCharType[i]|=C1_CNTRL;
757 if ( (lpSrcStr[i] == ' ') ||
758 (lpSrcStr[i] == '\t') )
759 lpCharType[i]|=C1_BLANK;
760 }
761 return TRUE;
762 break;
763
764 case CT_CTYPE2:
765 case CT_CTYPE3: //not supported right now
766 return FALSE;
767 break;
768 }
769
770 return FALSE;
771}
772
773//******************************************************************************
774//NOTE: This has one parameter more than the W version! (@#$@#$)
775//******************************************************************************
776ODINFUNCTION5(BOOL, GetStringTypeA,
777 LCID, locale,
778 DWORD, dwInfoType,
779 LPCSTR, lpSrcStr,
780 int, cchSrc,
781 LPWORD, lpCharType)
782{
783 return GetStringTypeExA(locale,
784 dwInfoType,
785 lpSrcStr,
786 cchSrc,
787 lpCharType);
788}
789
790/******************************************************************************
791*GetStringTypeExA[KERNEL32.397]
792*
793* FIXME: Ignores the locale.
794*/
795ODINFUNCTION5(BOOL, GetStringTypeExA,
796 LCID, locale,
797 DWORD, dwInfoType,
798 LPCSTR, src,
799 INT, cchSrc,
800 LPWORD, chartype)
801{
802 int i;
803
804 if ((src==NULL) ||
805 (chartype==NULL) ||
806 (src==(LPSTR)chartype))
807 {
808 SetLastError(ERROR_INVALID_PARAMETER);
809 return FALSE;
810 }
811
812 if (cchSrc==-1)
813 cchSrc=lstrlenA(src)+1;
814
815 switch (dwInfoType)
816 {
817 case CT_CTYPE1:
818 for (i=0;i<cchSrc;i++)
819 {
820 chartype[i] = 0;
821 if (isdigit(src[i])) chartype[i]|=C1_DIGIT;
822 if (isalpha(src[i])) chartype[i]|=C1_ALPHA;
823 if (islower(src[i])) chartype[i]|=C1_LOWER;
824 if (isupper(src[i])) chartype[i]|=C1_UPPER;
825 if (isspace(src[i])) chartype[i]|=C1_SPACE;
826 if (ispunct(src[i])) chartype[i]|=C1_PUNCT;
827 if (iscntrl(src[i])) chartype[i]|=C1_CNTRL;
828 /* FIXME: isblank() is a GNU extension */
829 /*if (isblank(src[i])) chartype[i]|=C1_BLANK; */
830 if ((src[i] == ' ') || (src[i] == '\t')) chartype[i]|=C1_BLANK;
831 /* C1_XDIGIT */
832 }
833 return TRUE;
834
835 case CT_CTYPE2:
836 for (i=0;i<cchSrc;i++)
837 {
838 chartype[i]=(WORD)CT_CType2_LUT[i];
839 }
840 return TRUE;
841
842 case CT_CTYPE3:
843 for (i=0;i<cchSrc;i++)
844 {
845 chartype[i]=OLE2NLS_CT_CType3_LUT[i];
846 }
847 return TRUE;
848
849 default:
850 dprintf(("Unknown dwInfoType:%ld\n",
851 dwInfoType));
852 return FALSE;
853 }
854}
855
856
857//******************************************************************************
858VOID WIN32API GlobalMemoryStatus( MEMORYSTATUS *arg1)
859{
860 dprintf(("KERNEL32: GlobalMemoryStatus\n"));
861 O32_GlobalMemoryStatus(arg1);
862 dprintf(("dwMemoryLoad %X\n", arg1->dwMemoryLoad));
863 dprintf(("dwTotalPhys %X\n", arg1->dwTotalPhys));
864 dprintf(("dwAvailPhys %X\n", arg1->dwAvailPhys));
865 dprintf(("dwTotalPageFile %X\n", arg1->dwTotalPageFile));
866 dprintf(("dwAvailPageFile %X\n", arg1->dwAvailPageFile));
867 dprintf(("dwTotalVirtual %X\n", arg1->dwTotalVirtual));
868 dprintf(("dwAvailVirtual %X\n", arg1->dwAvailVirtual));
869}
870VOID WIN32API Sleep(DWORD arg1)
871{
872 dprintf2(("KERNEL32: Sleep %d\n", arg1));
873 O32_Sleep(arg1);
874}
875//******************************************************************************
876//******************************************************************************
877DWORD WIN32API GetPriorityClass(HANDLE arg1)
878{
879 dprintf(("KERNEL32: GetPriorityClass\n"));
880 return O32_GetPriorityClass(arg1);
881}
882//******************************************************************************
883//******************************************************************************
884BOOL WIN32API SetPriorityClass(HANDLE arg1, DWORD arg2)
885{
886 dprintf(("KERNEL32: SetPriorityClass\n"));
887 return O32_SetPriorityClass(arg1, arg2);
888}
889//******************************************************************************
890//TODO!
891//******************************************************************************
892int WIN32API LCMapStringW(
893 DWORD /*LCID*/ Locale,
894 DWORD dwMapFlags,
895 LPCWSTR lpSrcStr,
896 int cchSrc,
897 LPWSTR lpDestStr,
898 int cchDest)
899{
900 // quick hack! this code is not done!
901 dprintf(("LCMapStringW: NOT IMPLEMENTED!"));
902 if(cchSrc == -1)
903 cchSrc = strlen((const char *)lpSrcStr);
904 if(!cchDest)
905 return cchSrc;
906 lstrcpynW(lpDestStr, lpSrcStr, max(cchSrc, cchDest));
907 return max(cchSrc, cchDest);
908}
909//******************************************************************************
910//TODO!
911//******************************************************************************
912int WIN32API LCMapStringA(
913 DWORD /*LCID*/ Locale,
914 DWORD dwMapFlags,
915 LPCSTR lpSrcStr,
916 int cchSrc,
917 LPSTR lpDestStr,
918 int cchDest)
919{
920 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
921 if(cchSrc == -1)
922 cchSrc = strlen((const char *)lpSrcStr);
923 if(!cchDest)
924 return cchSrc;
925 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
926 return max(cchSrc, cchDest);
927}
928//******************************************************************************
929//SvL: 24-6-'97 - Added
930//******************************************************************************
931BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
932{
933 dprintf(("KERNEL32: OS2Beep\n"));
934 return O32_Beep(arg1, arg2);
935}
936//******************************************************************************
937//******************************************************************************
938VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
939{
940 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
941 O32_FatalAppExit(arg1, arg2);
942}
943//******************************************************************************
944//******************************************************************************
945VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
946{
947 char *astring;
948
949 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
950 astring = UnicodeToAsciiString((LPWSTR)arg2);
951 O32_FatalAppExit(arg1, astring);
952 //probably won't return, but who cares..
953 FreeAsciiString(astring);
954}
955//******************************************************************************
956//******************************************************************************
957VOID WIN32API FatalExit( UINT arg1)
958{
959 dprintf(("KERNEL32: OS2FatalExit\n"));
960 O32_FatalExit(arg1);
961}
962//******************************************************************************
963//******************************************************************************
964BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
965{
966 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
967 return O32_IsBadHugeReadPtr(arg1, arg2);
968}
969//******************************************************************************
970//******************************************************************************
971BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
972{
973 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
974 return O32_IsBadHugeWritePtr(arg1, arg2);
975}
976//******************************************************************************
977//******************************************************************************
978BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
979{
980 dprintf2(("KERNEL32: OS2IsDBCSLeadByte\n"));
981 return O32_IsDBCSLeadByte(arg1);
982}
983//******************************************************************************
984//******************************************************************************
985DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
986{
987 dprintf(("KERNEL32: OS2LoadModule\n"));
988 return O32_LoadModule(arg1, arg2);
989}
990//******************************************************************************
991//******************************************************************************
992int WIN32API MulDiv(int arg1, int arg2, int arg3)
993{
994 dprintf2(("KERNEL32: MulDiv %d*%d/%d\n", arg1, arg2, arg3));
995 if(arg3 == 0)
996 return 0;
997
998 return O32_MulDiv(arg1, arg2, arg3);
999}
1000//******************************************************************************
1001UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
1002 DWORD cch1, LPCSTR lpString2, DWORD cch2)
1003{
1004 int i;
1005 int fEqual = TRUE;
1006 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
1007
1008 SetLastError(0);
1009
1010#ifdef DEBUG
1011 if(fdwStyle & SORT_STRINGSORT)
1012 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
1013 if(fdwStyle & NORM_IGNORENONSPACE)
1014 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
1015 if(fdwStyle & NORM_IGNORESYMBOLS)
1016 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
1017#endif
1018
1019 if(lpString1 == NULL || lpString2 == NULL)
1020 {
1021 dprintf(("CompareStringA: (s1=%s,s2=%s): Invalid NULL string\n", lpString1, lpString2));
1022 SetLastError(ERROR_INVALID_PARAMETER);
1023 return 0;
1024 }
1025
1026 if(cch1 == -1) cch1 = strlen(string1);
1027 if(cch2 == -1) cch2 = strlen(string2);
1028
1029 if(fdwStyle) {
1030 //TODO!
1031 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
1032 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
1033 }
1034 if(fdwStyle & NORM_IGNORECASE)
1035 fEqual = strnicmp(string1, string2, min(cch1, cch2));
1036 else
1037 fEqual = strncmp(string1, string2, min(cch1, cch2));
1038
1039 if (fEqual < 0 ) fEqual = 1;
1040 else if(fEqual == 0) fEqual = 2;
1041 else if(fEqual > 0) fEqual = 3;
1042
1043 //If equal, but different length, largest one is the greatest in lexical value
1044 if(fEqual == 2 && cch1 != cch2){
1045 if(cch1 < cch2)
1046 fEqual = 1;
1047 else
1048 fEqual = 3;
1049 }
1050 dprintf2(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
1051 return(fEqual);
1052}
1053
1054//******************************************************************************
1055//TODO: Not complete (fdwStyle flags specify compare method)
1056//******************************************************************************
1057UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
1058 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
1059{
1060 int i;
1061 int fEqual = TRUE;
1062 char *string1;
1063 char *string2;
1064
1065 dprintf2(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
1066
1067 if(lpString1 == NULL || lpString2 == NULL)
1068 {
1069 dprintf(("CompareStringW: (s1=%s,s2=%s): Invalid NULL string\n", lpString1, lpString2));
1070 SetLastError(ERROR_INVALID_PARAMETER);
1071 return 0;
1072 }
1073
1074 if(cch1 == -1) cch1 = lstrlenW(lpString1);
1075 if(cch2 == -1) cch2 = lstrlenW(lpString2);
1076
1077 string1 = UnicodeToAsciiStringN((LPWSTR)lpString1, cch1);
1078 string2 = UnicodeToAsciiStringN((LPWSTR)lpString2, cch2);
1079
1080 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
1081 FreeAsciiString(string1);
1082 FreeAsciiString(string2);
1083
1084 return(fEqual);
1085}
1086//******************************************************************************
1087//Borrowed from Wine
1088//******************************************************************************
1089ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
1090{
1091 lpStartupInfo->cb = sizeof(STARTUPINFOA);
1092 lpStartupInfo->lpReserved = "<Reserved>";
1093 lpStartupInfo->lpDesktop = "Desktop";
1094 lpStartupInfo->lpTitle = "Title";
1095 lpStartupInfo->dwX = 0;
1096 lpStartupInfo->dwY = 0;
1097 lpStartupInfo->dwXSize = 640;
1098 lpStartupInfo->dwYSize = 480;
1099 lpStartupInfo->dwXCountChars = 80; // for console
1100 lpStartupInfo->dwYCountChars = 25;
1101 lpStartupInfo->dwFillAttribute = 0x0720;
1102 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
1103 STARTF_USEPOSITION |
1104 STARTF_USESIZE |
1105 STARTF_USECOUNTCHARS |
1106 STARTF_USEFILLATTRIBUTE|
1107 STARTF_USESTDHANDLES;
1108 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
1109 lpStartupInfo->cbReserved2 = 0;
1110 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
1111 /* @@@PH 98/07/13 Handlemanager support */
1112 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
1113 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
1114 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
1115 return;
1116}
1117//******************************************************************************
1118//Borrowed from Wine
1119//******************************************************************************
1120ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
1121{
1122 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
1123 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
1124 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
1125
1126 // forward call to ascii variant
1127 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
1128 lpStartupInfo->cb = sizeof(STARTUPINFOW);
1129 lpStartupInfo->lpReserved = lpReserved;
1130 lpStartupInfo->lpDesktop = lpDesktop;
1131 lpStartupInfo->lpTitle = lpTitle;
1132 return;
1133}
1134//******************************************************************************
1135//TODO: Not complete or correct, but sufficient for now
1136//******************************************************************************
1137BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
1138{
1139 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
1140 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
1141 *lpBinaryType = SCS_32BIT_BINARY;
1142 else
1143 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
1144 *lpBinaryType = SCS_DOS_BINARY;
1145 else
1146 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
1147 *lpBinaryType = SCS_PIF_BINARY;
1148 else return(FALSE);
1149 return(TRUE);
1150}
1151//******************************************************************************
1152//******************************************************************************
1153BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
1154{
1155 BOOL rc;
1156 char *astring;
1157
1158 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
1159 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
1160 rc = GetBinaryTypeA(astring, lpBinaryType);
1161 FreeAsciiString(astring);
1162 return(rc);
1163}
1164//******************************************************************************
1165//TODO: SetLastError
1166//******************************************************************************
1167BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
1168{
1169 dprintf(("KERNEL32: OS2GetVersionExA\n"));
1170
1171 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
1172 return(FALSE);
1173
1174 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
1175 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
1176 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
1177 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1178 strcpy(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION);
1179 return(TRUE);
1180}
1181//******************************************************************************
1182//******************************************************************************
1183BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
1184{
1185 dprintf(("KERNEL32: OS2GetVersionExW\n"));
1186
1187 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
1188 return(FALSE);
1189
1190 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
1191 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
1192 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
1193 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1194 lstrcpyW(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION_W);
1195 return(TRUE);
1196}
1197//******************************************************************************
1198//******************************************************************************
1199LONG WIN32API GetVersion()
1200{
1201 dprintf(("KERNEL32: GetVersion\n"));
1202 // highword 0 = NT, lowword high byte major ver, low byte minor ver
1203/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
1204/* structures that lead to crashes if we don't identify as NT */
1205
1206 return ODINNT_VERSION;
1207}
1208//******************************************************************************
1209//******************************************************************************
1210BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
1211 HANDLE hProcess, /* process with cache to flush */
1212 LPCVOID lpvBase, /* address of region to flush */
1213 DWORD cbFlush) /* length of region to flush */
1214
1215{
1216 dprintf(("FlushInstructionCache() - NIY\n"));
1217 return TRUE;
1218}
1219
1220
1221//******************************************************************************
1222
1223/***********************************************************************
1224* RtlFillMemory (KERNEL32.441)
1225*/
1226VOID WIN32API RtlFillMemory(LPVOID ptr,
1227 UINT len,
1228 UINT fill )
1229{
1230#ifdef DEBUG_LOCAL
1231 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
1232 ptr,
1233 len,
1234 fill));
1235#endif
1236
1237 memset(ptr,
1238 fill,
1239 len );
1240}
1241
1242
1243/***********************************************************************
1244* RtlMoveMemory (KERNEL32.442)
1245*/
1246VOID WIN32API RtlMoveMemory(LPVOID dst,
1247 LPCVOID src,
1248 UINT len )
1249{
1250 dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
1251 dst,
1252 src,
1253 len));
1254
1255 memmove(dst,
1256 src,
1257 len );
1258}
1259
1260
1261/***********************************************************************
1262* RtlZeroMemory (KERNEL32.444)
1263*/
1264VOID WIN32API RtlZeroMemory(LPVOID ptr,
1265 UINT len)
1266{
1267 dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
1268 ptr,
1269 len));
1270
1271 memset(ptr,
1272 0,
1273 len);
1274}
1275
1276//******************************************************************************
1277/*KSO Thu 21.05.1998*/
1278BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
1279{
1280 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
1281 return O32_IsDBCSLeadByte(TestChar);
1282}
1283//******************************************************************************
1284
1285
1286
1287
1288
1289
1290
1291
1292/*****************************************************************************
1293 * Name : BOOL GetSystemPowerStatus
1294 * Purpose : The GetSystemPowerStatus function retrieves the power status of
1295 * the system. The status indicates whether the system is running
1296 * on AC or DC power, whether the battery is currently charging,
1297 * and how much battery life currently remains.
1298 * Parameters: LPSYSTEM_POWER_STATUS lpSystemPowerStatus
1299 * Variables :
1300 * Result : TRUE / FALSE
1301 * Remark :
1302 * Status : UNTESTED STUB
1303 *
1304 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1305 *****************************************************************************/
1306
1307BOOL WIN32API GetSystemPowerStatus(LPSYSTEM_POWER_STATUS lpSystemPowerStatus)
1308{
1309 dprintf(("Kernel32: GetSystemPowerStatus(%08xh) not properly implemented.\n",
1310 lpSystemPowerStatus));
1311
1312 if(lpSystemPowerStatus == NULL) {
1313 SetLastError(ERROR_INVALID_PARAMETER);
1314 return FALSE;
1315 }
1316 lpSystemPowerStatus->ACLineStatus = 1; //online
1317 lpSystemPowerStatus->BatteryFlag = 128; //no system battery
1318 lpSystemPowerStatus->BatteryLifePercent = 255; //unknown
1319 lpSystemPowerStatus->reserved = 0;
1320 lpSystemPowerStatus->BatteryLifeTime = -1; //unknown
1321 lpSystemPowerStatus->BatteryFullLifeTime= -1; //unknown
1322
1323 return TRUE;
1324}
Note: See TracBrowser for help on using the repository browser.