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

Last change on this file since 3755 was 3746, checked in by sandervl, 25 years ago

Resource lookup fix (type '#') + misc changes/fixes
File size: 41.7 KB
Line 
1/* $Id: KERNEL32.CPP,v 1.47 2000-06-23 19:02:36 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 if(cchSrc == -1)
902 cchSrc = strlen((const char *)lpSrcStr);
903 if(!cchDest)
904 return cchSrc;
905 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
906 return max(cchSrc, cchDest);
907}
908//******************************************************************************
909//TODO!
910//******************************************************************************
911int WIN32API LCMapStringA(
912 DWORD /*LCID*/ Locale,
913 DWORD dwMapFlags,
914 LPCSTR lpSrcStr,
915 int cchSrc,
916 LPSTR lpDestStr,
917 int cchDest)
918{
919 dprintf(("KERNEL32: LCMapStringA not implemented\n"));
920 if(cchSrc == -1)
921 cchSrc = strlen((const char *)lpSrcStr);
922 if(!cchDest)
923 return cchSrc;
924 strncpy((char *)lpDestStr, (const char *)lpSrcStr, max(cchSrc, cchDest));
925 return max(cchSrc, cchDest);
926}
927//******************************************************************************
928//SvL: 24-6-'97 - Added
929//******************************************************************************
930BOOL WIN32API Beep( DWORD arg1, DWORD arg2)
931{
932 dprintf(("KERNEL32: OS2Beep\n"));
933 return O32_Beep(arg1, arg2);
934}
935//******************************************************************************
936//******************************************************************************
937VOID WIN32API FatalAppExitA( UINT arg1, LPCSTR arg2)
938{
939 dprintf(("KERNEL32: OS2FatalAppExitA\n"));
940 O32_FatalAppExit(arg1, arg2);
941}
942//******************************************************************************
943//******************************************************************************
944VOID WIN32API FatalAppExitW(UINT arg1, LPCWSTR arg2)
945{
946 char *astring;
947
948 dprintf(("KERNEL32: OS2FatalAppExitW\n"));
949 astring = UnicodeToAsciiString((LPWSTR)arg2);
950 O32_FatalAppExit(arg1, astring);
951 //probably won't return, but who cares..
952 FreeAsciiString(astring);
953}
954//******************************************************************************
955//******************************************************************************
956VOID WIN32API FatalExit( UINT arg1)
957{
958 dprintf(("KERNEL32: OS2FatalExit\n"));
959 O32_FatalExit(arg1);
960}
961//******************************************************************************
962//******************************************************************************
963BOOL WIN32API IsBadHugeReadPtr( const void * arg1, UINT arg2)
964{
965 dprintf(("KERNEL32: OS2IsBadHugeReadPtr\n"));
966 return O32_IsBadHugeReadPtr(arg1, arg2);
967}
968//******************************************************************************
969//******************************************************************************
970BOOL WIN32API IsBadHugeWritePtr( PVOID arg1, UINT arg2)
971{
972 dprintf(("KERNEL32: OS2IsBadHugeWritePtr\n"));
973 return O32_IsBadHugeWritePtr(arg1, arg2);
974}
975//******************************************************************************
976//******************************************************************************
977BOOL WIN32API IsDBCSLeadByte(BYTE arg1)
978{
979 dprintf2(("KERNEL32: OS2IsDBCSLeadByte\n"));
980 return O32_IsDBCSLeadByte(arg1);
981}
982//******************************************************************************
983//******************************************************************************
984DWORD WIN32API LoadModule( LPCSTR arg1, PVOID arg2)
985{
986 dprintf(("KERNEL32: OS2LoadModule\n"));
987 return O32_LoadModule(arg1, arg2);
988}
989//******************************************************************************
990//******************************************************************************
991int WIN32API MulDiv(int arg1, int arg2, int arg3)
992{
993 dprintf2(("KERNEL32: MulDiv %d*%d/%d\n", arg1, arg2, arg3));
994 if(arg3 == 0)
995 return 0;
996
997 return O32_MulDiv(arg1, arg2, arg3);
998}
999//******************************************************************************
1000UINT WIN32API CompareStringA(LCID lcid, DWORD fdwStyle, LPCSTR lpString1,
1001 DWORD cch1, LPCSTR lpString2, DWORD cch2)
1002{
1003 int i;
1004 int fEqual = TRUE;
1005 char *string1 = (char *)lpString1, *string2 = (char *)lpString2;
1006
1007 SetLastError(0);
1008
1009#ifdef DEBUG
1010 if(fdwStyle & SORT_STRINGSORT)
1011 dprintf(("KERNEL32: SORT_STRINGSORT not supported!\n"));
1012 if(fdwStyle & NORM_IGNORENONSPACE)
1013 dprintf(("KERNEL32: NORM_IGNORENONSPACE not supported!\n"));
1014 if(fdwStyle & NORM_IGNORESYMBOLS)
1015 dprintf(("KERNEL32: NORM_IGNORESYMBOLS not supported!\n"));
1016#endif
1017
1018 if(lpString1 == NULL || lpString2 == NULL)
1019 {
1020 dprintf(("CompareStringA: (s1=%s,s2=%s): Invalid NULL string\n", lpString1, lpString2));
1021 SetLastError(ERROR_INVALID_PARAMETER);
1022 return 0;
1023 }
1024
1025 if(cch1 == -1) cch1 = strlen(string1);
1026 if(cch2 == -1) cch2 = strlen(string2);
1027
1028 if(fdwStyle) {
1029 //TODO!
1030 if(fdwStyle != 0 && fdwStyle != NORM_IGNORECASE)
1031 return(0); /*PLF Fri 98-03-13 04:09:32 was return 1 */
1032 }
1033 if(fdwStyle & NORM_IGNORECASE)
1034 fEqual = strnicmp(string1, string2, min(cch1, cch2));
1035 else
1036 fEqual = strncmp(string1, string2, min(cch1, cch2));
1037
1038 if (fEqual < 0 ) fEqual = 1;
1039 else if(fEqual == 0) fEqual = 2;
1040 else if(fEqual > 0) fEqual = 3;
1041
1042 //If equal, but different length, largest one is the greatest in lexical value
1043 if(fEqual == 2 && cch1 != cch2){
1044 if(cch1 < cch2)
1045 fEqual = 1;
1046 else
1047 fEqual = 3;
1048 }
1049 dprintf2(("KERNEL32: OS2CompareStringA '%s' - '%s' returned %d\n", lpString1, lpString2, fEqual));
1050 return(fEqual);
1051}
1052
1053//******************************************************************************
1054//TODO: Not complete (fdwStyle flags specify compare method)
1055//******************************************************************************
1056UINT WIN32API CompareStringW(LCID lcid, DWORD fdwStyle, LPCWSTR lpString1,
1057 DWORD cch1, LPCWSTR lpString2, DWORD cch2)
1058{
1059 int i;
1060 int fEqual = TRUE;
1061 char *string1;
1062 char *string2;
1063
1064 dprintf2(("KERNEL32: OS2CompareStringW '%s' - '%s'\n", string1, string2));
1065
1066 if(lpString1 == NULL || lpString2 == NULL)
1067 {
1068 dprintf(("CompareStringW: (s1=%s,s2=%s): Invalid NULL string\n", lpString1, lpString2));
1069 SetLastError(ERROR_INVALID_PARAMETER);
1070 return 0;
1071 }
1072
1073 if(cch1 == -1) cch1 = lstrlenW(lpString1);
1074 if(cch2 == -1) cch2 = lstrlenW(lpString2);
1075
1076 string1 = UnicodeToAsciiStringN((LPWSTR)lpString1, cch1);
1077 string2 = UnicodeToAsciiStringN((LPWSTR)lpString2, cch2);
1078
1079 fEqual = CompareStringA(lcid, fdwStyle, string1, cch1, string2, cch2);
1080 FreeAsciiString(string1);
1081 FreeAsciiString(string2);
1082
1083 return(fEqual);
1084}
1085//******************************************************************************
1086//Borrowed from Wine
1087//******************************************************************************
1088ODINPROCEDURE1(GetStartupInfoA,LPSTARTUPINFOA,lpStartupInfo)
1089{
1090 lpStartupInfo->cb = sizeof(STARTUPINFOA);
1091 lpStartupInfo->lpReserved = "<Reserved>";
1092 lpStartupInfo->lpDesktop = "Desktop";
1093 lpStartupInfo->lpTitle = "Title";
1094 lpStartupInfo->dwX = 0;
1095 lpStartupInfo->dwY = 0;
1096 lpStartupInfo->dwXSize = 640;
1097 lpStartupInfo->dwYSize = 480;
1098 lpStartupInfo->dwXCountChars = 80; // for console
1099 lpStartupInfo->dwYCountChars = 25;
1100 lpStartupInfo->dwFillAttribute = 0x0720;
1101 lpStartupInfo->dwFlags = STARTF_USESHOWWINDOW |
1102 STARTF_USEPOSITION |
1103 STARTF_USESIZE |
1104 STARTF_USECOUNTCHARS |
1105 STARTF_USEFILLATTRIBUTE|
1106 STARTF_USESTDHANDLES;
1107 lpStartupInfo->wShowWindow = SW_SHOWDEFAULT;
1108 lpStartupInfo->cbReserved2 = 0;
1109 lpStartupInfo->lpReserved2 = NULL; /* must be NULL for VC runtime */
1110 /* @@@PH 98/07/13 Handlemanager support */
1111 lpStartupInfo->hStdInput = GetStdHandle(STD_INPUT_HANDLE);
1112 lpStartupInfo->hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
1113 lpStartupInfo->hStdError = GetStdHandle(STD_ERROR_HANDLE);
1114 return;
1115}
1116//******************************************************************************
1117//Borrowed from Wine
1118//******************************************************************************
1119ODINPROCEDURE1(GetStartupInfoW,LPSTARTUPINFOW,lpStartupInfo)
1120{
1121 static WCHAR lpReserved[] = {'<', 'R','e','s','e','r','v','e','d','>', 0};
1122 static WCHAR lpDesktop[] = {'D', 'e','s','k','t','o','p', 0};
1123 static WCHAR lpTitle[] = {'T', 'i','t','l','e', 0};
1124
1125 // forward call to ascii variant
1126 GetStartupInfoA((LPSTARTUPINFOA)lpStartupInfo);
1127 lpStartupInfo->cb = sizeof(STARTUPINFOW);
1128 lpStartupInfo->lpReserved = lpReserved;
1129 lpStartupInfo->lpDesktop = lpDesktop;
1130 lpStartupInfo->lpTitle = lpTitle;
1131 return;
1132}
1133//******************************************************************************
1134//TODO: Not complete or correct, but sufficient for now
1135//******************************************************************************
1136BOOL WIN32API GetBinaryTypeA(LPCTSTR lpApplicationName, LPDWORD lpBinaryType)
1137{
1138 dprintf(("KERNEL32: OS2GetBinaryTypeA %s\n", lpApplicationName));
1139 if(strstr(lpApplicationName, ".EXE") || strstr(lpApplicationName, ".exe"))
1140 *lpBinaryType = SCS_32BIT_BINARY;
1141 else
1142 if(strstr(lpApplicationName, ".COM") || strstr(lpApplicationName, ".com"))
1143 *lpBinaryType = SCS_DOS_BINARY;
1144 else
1145 if(strstr(lpApplicationName, ".PIF") || strstr(lpApplicationName, ".pif"))
1146 *lpBinaryType = SCS_PIF_BINARY;
1147 else return(FALSE);
1148 return(TRUE);
1149}
1150//******************************************************************************
1151//******************************************************************************
1152BOOL WIN32API GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
1153{
1154 BOOL rc;
1155 char *astring;
1156
1157 dprintf(("KERNEL32: OS2GetBinaryTypeW\n"));
1158 astring = UnicodeToAsciiString((LPWSTR)lpApplicationName);
1159 rc = GetBinaryTypeA(astring, lpBinaryType);
1160 FreeAsciiString(astring);
1161 return(rc);
1162}
1163//******************************************************************************
1164//TODO: SetLastError
1165//******************************************************************************
1166BOOL WIN32API GetVersionExA(OSVERSIONINFOA *lpVersionInformation)
1167{
1168 dprintf(("KERNEL32: OS2GetVersionExA\n"));
1169
1170 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOA))
1171 return(FALSE);
1172
1173 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
1174 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
1175 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
1176 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1177 strcpy(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION);
1178 return(TRUE);
1179}
1180//******************************************************************************
1181//******************************************************************************
1182BOOL WIN32API GetVersionExW(OSVERSIONINFOW *lpVersionInformation)
1183{
1184 dprintf(("KERNEL32: OS2GetVersionExW\n"));
1185
1186 if(lpVersionInformation == NULL || lpVersionInformation->dwOSVersionInfoSize != sizeof(OSVERSIONINFOW))
1187 return(FALSE);
1188
1189 lpVersionInformation->dwMajorVersion = ODINNT_MAJOR_VERSION; //pretend we're NT 4.0
1190 lpVersionInformation->dwMinorVersion = ODINNT_MINOR_VERSION;
1191 lpVersionInformation->dwBuildNumber = ODINNT_BUILD_NR;
1192 lpVersionInformation->dwPlatformId = VER_PLATFORM_WIN32_NT;
1193 lstrcpyW(lpVersionInformation->szCSDVersion, ODINNT_CSDVERSION_W);
1194 return(TRUE);
1195}
1196//******************************************************************************
1197//******************************************************************************
1198LONG WIN32API GetVersion()
1199{
1200 dprintf(("KERNEL32: GetVersion\n"));
1201 // highword 0 = NT, lowword high byte major ver, low byte minor ver
1202/* @@@PH 98/04/04 MFC30 makes assumptions about process control block */
1203/* structures that lead to crashes if we don't identify as NT */
1204
1205 return ODINNT_VERSION;
1206}
1207//******************************************************************************
1208//SvL: 26-6-'97 - Added
1209//******************************************************************************
1210VOID WIN32API OutputDebugStringW(LPCWSTR arg1)
1211{
1212 char *astring;
1213
1214 astring = UnicodeToAsciiString((LPWSTR)arg1);
1215 dprintf(("KERNEL32: OS2OutputDebugStringW %s\n", astring));
1216 FreeAsciiString(astring);
1217}
1218//******************************************************************************
1219//******************************************************************************
1220VOID WIN32API OutputDebugStringA(LPCSTR lpszOutputString)
1221{
1222 dprintf(("KERNEL32: OutputDebugStringA: %s\n", lpszOutputString));
1223 return;
1224}
1225//******************************************************************************
1226//******************************************************************************
1227BOOL WIN32API FlushInstructionCache( /*PLF Mon 98-02-09 23:56:49 : STUB STUB STUB STUB STUB */
1228 HANDLE hProcess, /* process with cache to flush */
1229 LPCVOID lpvBase, /* address of region to flush */
1230 DWORD cbFlush) /* length of region to flush */
1231
1232{
1233 dprintf(("FlushInstructionCache() - NIY\n"));
1234 return TRUE;
1235}
1236
1237
1238//******************************************************************************
1239
1240/***********************************************************************
1241* RtlFillMemory (KERNEL32.441)
1242*/
1243VOID WIN32API RtlFillMemory(LPVOID ptr,
1244 UINT len,
1245 UINT fill )
1246{
1247#ifdef DEBUG_LOCAL
1248 dprintf(("KERNEL32: RtlFillMemory(%08x,%08x,%08x)\n",
1249 ptr,
1250 len,
1251 fill));
1252#endif
1253
1254 memset(ptr,
1255 fill,
1256 len );
1257}
1258
1259
1260/***********************************************************************
1261* RtlMoveMemory (KERNEL32.442)
1262*/
1263VOID WIN32API RtlMoveMemory(LPVOID dst,
1264 LPCVOID src,
1265 UINT len )
1266{
1267 dprintf2(("KERNEL32: RtlMoveMemory(%08x,%08x,%08x)\n",
1268 dst,
1269 src,
1270 len));
1271
1272 memmove(dst,
1273 src,
1274 len );
1275}
1276
1277
1278/***********************************************************************
1279* RtlZeroMemory (KERNEL32.444)
1280*/
1281VOID WIN32API RtlZeroMemory(LPVOID ptr,
1282 UINT len)
1283{
1284 dprintf2(("KERNEL32: RtlZeroMemory(%08x,%08x)\n",
1285 ptr,
1286 len));
1287
1288 memset(ptr,
1289 0,
1290 len);
1291}
1292
1293//******************************************************************************
1294/*KSO Thu 21.05.1998*/
1295BOOL WIN32API IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar)
1296{
1297 dprintf(("KERNEL32: OS2IsDBCSLeadByteEx - not correctly implemented\n"));
1298 return O32_IsDBCSLeadByte(TestChar);
1299}
1300//******************************************************************************
1301
1302
1303
1304
1305
1306
1307
1308
1309/*****************************************************************************
1310 * Name : BOOL GetSystemPowerStatus
1311 * Purpose : The GetSystemPowerStatus function retrieves the power status of
1312 * the system. The status indicates whether the system is running
1313 * on AC or DC power, whether the battery is currently charging,
1314 * and how much battery life currently remains.
1315 * Parameters: LPSYSTEM_POWER_STATUS lpSystemPowerStatus
1316 * Variables :
1317 * Result : TRUE / FALSE
1318 * Remark :
1319 * Status : UNTESTED STUB
1320 *
1321 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1322 *****************************************************************************/
1323
1324BOOL WIN32API GetSystemPowerStatus(LPSYSTEM_POWER_STATUS lpSystemPowerStatus)
1325{
1326 dprintf(("Kernel32: GetSystemPowerStatus(%08xh) not properly implemented.\n",
1327 lpSystemPowerStatus));
1328
1329 if(lpSystemPowerStatus == NULL) {
1330 SetLastError(ERROR_INVALID_PARAMETER);
1331 return FALSE;
1332 }
1333 lpSystemPowerStatus->ACLineStatus = 1; //online
1334 lpSystemPowerStatus->BatteryFlag = 128; //no system battery
1335 lpSystemPowerStatus->BatteryLifePercent = 255; //unknown
1336 lpSystemPowerStatus->reserved = 0;
1337 lpSystemPowerStatus->BatteryLifeTime = -1; //unknown
1338 lpSystemPowerStatus->BatteryFullLifeTime= -1; //unknown
1339
1340 return TRUE;
1341}
Note: See TracBrowser for help on using the repository browser.