source: trunk/src/msvcrt/msvcrt.cpp@ 4067

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

implemented _lock, _unlock, CxxThrowException
File size: 59.2 KB
Line 
1/* $Id: msvcrt.cpp,v 1.13 2000-08-22 02:45:40 phaller Exp $ */
2
3/*
4 * The Visual C RunTime DLL (MSVCRT/MSVCRT20/MSVCRT40)
5 *
6 * Implements Visual C run-time functionality
7 *
8 * Copyright 1999 Jens Wiessner
9 */
10
11
12#include <os2win.h>
13#include <odinwrap.h>
14#include <wchar.h>
15#include <math.h>
16#include <string.h>
17
18#include <heapstring.h>
19#include <crtdll.h>
20
21#include <win/winbase.h>
22#include <win/winnt.h>
23#include "msvcrt.h"
24
25ODINDEBUGCHANNEL(msvcrt)
26
27/*********************************************************************
28 * ??3@YAXPAX@Z (MSVCRT.1)
29 * FIXME - Could not find anything about it
30 */
31INT CDECL MSVCRT_EXP1(DWORD ret)
32{
33 dprintf(("MSVCRT: MSVCRT_EXP1 not implemented.\n"));
34 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
35 return FALSE;
36}
37
38
39/*********************************************************************
40 * ??3@YAXPAX@Z (MSVCRT.2)
41 * FIXME - Could not find anything about it
42 */
43INT CDECL MSVCRT_EXP2(DWORD ret)
44{
45 dprintf(("MSVCRT: MSVCRT_EXP2 not implemented.\n"));
46 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
47 return FALSE;
48}
49
50
51/*********************************************************************
52 * ??3@YAXPAX@Z (MSVCRT.3)
53 * FIXME - Could not find anything about it
54 */
55INT CDECL MSVCRT_EXP3(DWORD ret)
56{
57 dprintf(("MSVCRT: MSVCRT_EXP3 not implemented.\n"));
58 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
59 return FALSE;
60}
61
62
63/*********************************************************************
64 * ??3@YAXPAX@Z (MSVCRT.4)
65 * FIXME - Could not find anything about it
66 */
67INT CDECL MSVCRT_EXP4(DWORD ret)
68{
69 dprintf(("MSVCRT: MSVCRT_EXP4 not implemented.\n"));
70 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
71 return FALSE;
72}
73
74
75/*********************************************************************
76 * ??3@YAXPAX@Z (MSVCRT.5)
77 * FIXME - Could not find anything about it
78 */
79INT CDECL MSVCRT_EXP5(DWORD ret)
80{
81 dprintf(("MSVCRT: MSVCRT_EXP5 not implemented.\n"));
82 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
83 return FALSE;
84}
85
86
87/*********************************************************************
88 * ??3@YAXPAX@Z (MSVCRT.6)
89 * FIXME - Could not find anything about it
90 */
91INT CDECL MSVCRT_EXP6(DWORD ret)
92{
93 dprintf(("MSVCRT: MSVCRT_EXP6 not implemented.\n"));
94 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
95 return FALSE;
96}
97
98
99/*********************************************************************
100 * ??3@YAXPAX@Z (MSVCRT.7)
101 * FIXME - Could not find anything about it
102 */
103INT CDECL MSVCRT_EXP7(DWORD ret)
104{
105 dprintf(("MSVCRT: MSVCRT_EXP7 not implemented.\n"));
106 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
107 return FALSE;
108}
109
110
111/*********************************************************************
112 * ??3@YAXPAX@Z (MSVCRT.8)
113 * FIXME - Could not find anything about it
114 */
115INT CDECL MSVCRT_EXP8(DWORD ret)
116{
117 dprintf(("MSVCRT: MSVCRT_EXP8 not implemented.\n"));
118 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
119 return FALSE;
120}
121
122
123/*********************************************************************
124 * ??3@YAXPAX@Z (MSVCRT.9)
125 * FIXME - Could not find anything about it
126 */
127INT CDECL MSVCRT_EXP9(DWORD ret)
128{
129 dprintf(("MSVCRT: MSVCRT_EXP9 not implemented.\n"));
130 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
131 return FALSE;
132}
133
134
135/*********************************************************************
136 * ??3@YAXPAX@Z (MSVCRT.10)
137 * FIXME - Could not find anything about it
138 */
139INT CDECL MSVCRT_EXP10(DWORD ret)
140{
141 dprintf(("MSVCRT: MSVCRT_EXP10 not implemented.\n"));
142 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
143 return FALSE;
144}
145
146
147/*********************************************************************
148 * ??3@YAXPAX@Z (MSVCRT.11)
149 * FIXME - Could not find anything about it
150 */
151INT CDECL MSVCRT_EXP11(DWORD ret)
152{
153 dprintf(("MSVCRT: MSVCRT_EXP11 not implemented.\n"));
154 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
155 return FALSE;
156}
157
158
159/*********************************************************************
160 * ??3@YAXPAX@Z (MSVCRT.12)
161 * FIXME - Could not find anything about it
162 */
163INT CDECL MSVCRT_EXP12(DWORD ret)
164{
165 dprintf(("MSVCRT: MSVCRT_EXP12 not implemented.\n"));
166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
167 return FALSE;
168}
169
170
171/*********************************************************************
172 * ??3@YAXPAX@Z (MSVCRT.13)
173 * FIXME - Could not find anything about it
174 */
175INT CDECL MSVCRT_EXP13(DWORD ret)
176{
177 dprintf(("MSVCRT: MSVCRT_EXP13 not implemented.\n"));
178 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
179 return FALSE;
180}
181
182
183/*********************************************************************
184 * ??1type_info@@UAE@XZ (MSVCRT.14)
185 * FIXME - Could not find anything about it
186 */
187INT CDECL MSVCRT_EXP14(DWORD ret)
188{
189 dprintf(("MSVCRT: MSVCRT_EXP14 not implemented.\n"));
190 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
191 return FALSE;
192}
193
194
195/*********************************************************************
196 * ??2@YAPAXI@Z (MSVCRT.15)
197 */
198VOID* CDECL MSVCRT_new(DWORD size)
199{
200 dprintf(("MSVCRT: ??2@YAPAXI@Z\n"));
201 VOID* result;
202 if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
203 (*new_handler)();
204 return result;
205}
206
207
208/*********************************************************************
209 * ??3@YAXPAX@Z (MSVCRT.16)
210 */
211VOID CDECL MSVCRT_delete(VOID* ptr)
212{
213 dprintf(("MSVCRT: ??3@YAXPAX@Z\n"));
214 HeapFree(GetProcessHeap(),0,ptr);
215}
216
217
218/*********************************************************************
219 * ??3@YAXPAX@Z (MSVCRT.17)
220 * FIXME - Could not find anything about it
221 */
222INT CDECL MSVCRT_EXP17(DWORD ret)
223{
224 dprintf(("MSVCRT: MSVCRT_EXP17 not implemented.\n"));
225 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
226 return FALSE;
227}
228
229
230/*********************************************************************
231 * ??3@YAXPAX@Z (MSVCRT.18)
232 * FIXME - Could not find anything about it
233 */
234INT CDECL MSVCRT_EXP18(DWORD ret)
235{
236 dprintf(("MSVCRT: MSVCRT_EXP18 not implemented.\n"));
237 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
238 return FALSE;
239}
240
241
242/*********************************************************************
243 * ??3@YAXPAX@Z (MSVCRT.19)
244 * FIXME - Could not find anything about it
245 */
246INT CDECL MSVCRT_EXP19(DWORD ret)
247{
248 dprintf(("MSVCRT: MSVCRT_EXP19 not implemented.\n"));
249 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
250 return FALSE;
251}
252
253
254/*********************************************************************
255 * ??3@YAXPAX@Z (MSVCRT.20)
256 * FIXME - Could not find anything about it
257 */
258INT CDECL MSVCRT_EXP20(DWORD ret)
259{
260 dprintf(("MSVCRT: MSVCRT_EXP20 not implemented.\n"));
261 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
262 return FALSE;
263}
264
265
266/*********************************************************************
267 * ??3@YAXPAX@Z (MSVCRT.21)
268 * FIXME - Could not find anything about it
269 */
270INT CDECL MSVCRT_EXP21(DWORD ret)
271{
272 dprintf(("MSVCRT: MSVCRT_EXP21 not implemented.\n"));
273 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
274 return FALSE;
275}
276
277
278/*********************************************************************
279 * ??3@YAXPAX@Z (MSVCRT.22)
280 * FIXME - Could not find anything about it
281 */
282INT CDECL MSVCRT_EXP22(DWORD ret)
283{
284 dprintf(("MSVCRT: MSVCRT_EXP22 not implemented.\n"));
285 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
286 return FALSE;
287}
288
289
290/*********************************************************************
291 * ??3@YAXPAX@Z (MSVCRT.23)
292 * FIXME - Could not find anything about it
293 */
294INT CDECL MSVCRT_EXP23(DWORD ret)
295{
296 dprintf(("MSVCRT: MSVCRT_EXP23 not implemented.\n"));
297 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
298 return FALSE;
299}
300
301
302/*********************************************************************
303 * ??3@YAXPAX@Z (MSVCRT.24)
304 * FIXME - Could not find anything about it
305 */
306INT CDECL MSVCRT_EXP24(DWORD ret)
307{
308 dprintf(("MSVCRT: MSVCRT_EXP24 not implemented.\n"));
309 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
310 return FALSE;
311}
312
313
314/*********************************************************************
315 * ??3@YAXPAX@Z (MSVCRT.25)
316 * FIXME - Could not find anything about it
317 */
318INT CDECL MSVCRT_EXP25(DWORD ret)
319{
320 dprintf(("MSVCRT: MSVCRT_EXP25 not implemented.\n"));
321 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
322 return FALSE;
323}
324
325
326/*********************************************************************
327 * ??3@YAXPAX@Z (MSVCRT.26)
328 * FIXME - Could not find anything about it
329 */
330INT CDECL MSVCRT_EXP26(DWORD ret)
331{
332 dprintf(("MSVCRT: MSVCRT_EXP26 not implemented.\n"));
333 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
334 return FALSE;
335}
336
337
338/*********************************************************************
339 * ??3@YAXPAX@Z (MSVCRT.27)
340 * FIXME - Could not find anything about it
341 */
342INT CDECL MSVCRT_EXP27(DWORD ret)
343{
344 dprintf(("MSVCRT: MSVCRT_EXP27 not implemented.\n"));
345 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
346 return FALSE;
347}
348
349
350/*********************************************************************
351 * ??3@YAXPAX@Z (MSVCRT.28)
352 * FIXME - Could not find anything about it
353 */
354INT CDECL MSVCRT_EXP28(DWORD ret)
355{
356 dprintf(("MSVCRT: MSVCRT_EXP28 not implemented.\n"));
357 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
358 return FALSE;
359}
360
361
362/*********************************************************************
363 * ??3@YAXPAX@Z (MSVCRT.29)
364 * FIXME - Could not find anything about it
365 */
366INT CDECL MSVCRT_EXP29(DWORD ret)
367{
368 dprintf(("MSVCRT: MSVCRT_EXP29 not implemented.\n"));
369 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
370 return FALSE;
371}
372
373
374/*********************************************************************
375 * ??3@YAXPAX@Z (MSVCRT.30)
376 * FIXME - Could not find anything about it
377 */
378INT CDECL MSVCRT_EXP30(DWORD ret)
379{
380 dprintf(("MSVCRT: MSVCRT_EXP30 not implemented.\n"));
381 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
382 return FALSE;
383}
384
385
386/*********************************************************************
387 * ??3@YAXPAX@Z (MSVCRT.31)
388 * FIXME - Could not find anything about it
389 */
390INT CDECL MSVCRT_EXP31(DWORD ret)
391{
392 dprintf(("MSVCRT: MSVCRT_EXP31 not implemented.\n"));
393 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
394 return FALSE;
395}
396
397
398/*********************************************************************
399 * ??3@YAXPAX@Z (MSVCRT.32)
400 * FIXME - Could not find anything about it
401 */
402INT CDECL MSVCRT_EXP32(DWORD ret)
403{
404 dprintf(("MSVCRT: MSVCRT_EXP32 not implemented.\n"));
405 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
406 return FALSE;
407}
408
409
410/*********************************************************************
411 * ??3@YAXPAX@Z (MSVCRT.33)
412 * FIXME - Could not find anything about it
413 */
414INT CDECL MSVCRT_EXP33(DWORD ret)
415{
416 dprintf(("MSVCRT: MSVCRT_EXP33 not implemented.\n"));
417 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
418 return FALSE;
419}
420
421
422/*********************************************************************
423 * ??3@YAXPAX@Z (MSVCRT.34)
424 * FIXME - Could not find anything about it
425 */
426INT CDECL MSVCRT_EXP34(DWORD ret)
427{
428 dprintf(("MSVCRT: MSVCRT_EXP34 not implemented.\n"));
429 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
430 return FALSE;
431}
432
433
434/*********************************************************************
435 * ??3@YAXPAX@Z (MSVCRT.35)
436 * FIXME - Could not find anything about it
437 */
438INT CDECL MSVCRT_EXP35(DWORD ret)
439{
440 dprintf(("MSVCRT: MSVCRT_EXP35 not implemented.\n"));
441 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
442 return FALSE;
443}
444
445
446/*********************************************************************
447 * ??3@YAXPAX@Z (MSVCRT.36)
448 * FIXME - Could not find anything about it
449 */
450INT CDECL MSVCRT_EXP36(DWORD ret)
451{
452 dprintf(("MSVCRT: MSVCRT_EXP36 not implemented.\n"));
453 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
454 return FALSE;
455}
456
457
458/*********************************************************************
459 * ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z (MSVCRT.37)
460 */
461new_handler_type CDECL MSVCRT_set_new_handler(new_handler_type func)
462{
463 dprintf(("MSVCRT: ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z\n"));
464 new_handler_type old_handler = new_handler;
465 new_handler = func;
466 return old_handler;
467}
468
469
470/*********************************************************************
471 * ??3@YAXPAX@Z (MSVCRT.38)
472 * FIXME - Could not find anything about it
473 */
474INT CDECL MSVCRT_EXP38(DWORD ret)
475{
476 dprintf(("MSVCRT: MSVCRT_EXP38 not implemented.\n"));
477 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
478 return FALSE;
479}
480
481
482/*********************************************************************
483 * ??3@YAXPAX@Z (MSVCRT.39)
484 * FIXME - Could not find anything about it
485 */
486INT CDECL MSVCRT_EXP39(DWORD ret)
487{
488 dprintf(("MSVCRT: MSVCRT_EXP39 not implemented.\n"));
489 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
490 return FALSE;
491}
492
493
494/*********************************************************************
495 * ??3@YAXPAX@Z (MSVCRT.40)
496 * FIXME - Could not find anything about it
497 */
498INT CDECL MSVCRT_EXP40(DWORD ret)
499{
500 dprintf(("MSVCRT: MSVCRT_EXP40 not implemented.\n"));
501 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
502 return FALSE;
503}
504
505
506/*********************************************************************
507 * ??3@YAXPAX@Z (MSVCRT.41)
508 * FIXME - Could not find anything about it
509 */
510INT CDECL MSVCRT_EXP41(DWORD ret)
511{
512 dprintf(("MSVCRT: MSVCRT_EXP41 not implemented.\n"));
513 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
514 return FALSE;
515}
516
517
518/*********************************************************************
519 * ??3@YAXPAX@Z (MSVCRT.42)
520 * FIXME - Could not find anything about it
521 */
522INT CDECL MSVCRT_EXP42(DWORD ret)
523{
524 dprintf(("MSVCRT: MSVCRT_EXP42 not implemented.\n"));
525 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
526 return FALSE;
527}
528
529
530/*********************************************************************
531 * ??3@YAXPAX@Z (MSVCRT.43)
532 * FIXME - Could not find anything about it
533 */
534INT CDECL MSVCRT_EXP43(DWORD ret)
535{
536 dprintf(("MSVCRT: MSVCRT_EXP43 not implemented.\n"));
537 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
538 return FALSE;
539}
540
541
542/*********************************************************************
543 * ??3@YAXPAX@Z (MSVCRT.44)
544 * FIXME - Could not find anything about it
545 */
546INT CDECL MSVCRT_EXP44(DWORD ret)
547{
548 dprintf(("MSVCRT: MSVCRT_EXP44 not implemented.\n"));
549 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
550 return FALSE;
551}
552
553
554/*********************************************************************
555 * ??3@YAXPAX@Z (MSVCRT.45)
556 * FIXME - Could not find anything about it
557 */
558INT CDECL MSVCRT_EXP45(DWORD ret)
559{
560 dprintf(("MSVCRT: MSVCRT_EXP45 not implemented.\n"));
561 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
562 return FALSE;
563}
564
565
566/*********************************************************************
567 * ??3@YAXPAX@Z (MSVCRT.46)
568 * FIXME - Could not find anything about it
569 */
570INT CDECL MSVCRT_EXP46(DWORD ret)
571{
572 dprintf(("MSVCRT: MSVCRT_EXP46 not implemented.\n"));
573 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
574 return FALSE;
575}
576
577
578/*********************************************************************
579 * ??3@YAXPAX@Z (MSVCRT.47)
580 * FIXME - Could not find anything about it
581 */
582INT CDECL MSVCRT_EXP47(DWORD ret)
583{
584 dprintf(("MSVCRT: MSVCRT_EXP47 not implemented.\n"));
585 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
586 return FALSE;
587}
588
589
590/*********************************************************************
591 * ??3@YAXPAX@Z (MSVCRT.48)
592 * FIXME - Could not find anything about it
593 */
594INT CDECL MSVCRT_EXP48(DWORD ret)
595{
596 dprintf(("MSVCRT: MSVCRT_EXP48 not implemented.\n"));
597 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
598 return FALSE;
599}
600
601
602/*********************************************************************
603 * ??3@YAXPAX@Z (MSVCRT.49)
604 * FIXME - Could not find anything about it
605 */
606INT CDECL MSVCRT_EXP49(DWORD ret)
607{
608 dprintf(("MSVCRT: MSVCRT_EXP49 not implemented.\n"));
609 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
610 return FALSE;
611}
612
613
614/*********************************************************************
615 * _CxxThrowException (MSVCRT.66)
616 * FIXME - Could not find anything about it
617 */
618
619static EXCEPTION_RECORD cxxExceptionFrame =
620{ 0x0e06d763, // Exception Code
621 0x00000001, // Exception Flags
622 0x00000000, // Exception Record Pointer
623 0x00000000, // Exception Address
624 0x00000003, // Number Of Parameters
625 0x19930520, // Parameter #1
626 0x00000000, // Parameter #2
627 0x00000000 // Parameter #3
628};
629
630VOID CDECL MSVCRT__CxxThrowException(DWORD arg1,
631 DWORD arg2)
632{
633 EXCEPTION_RECORD er;
634
635 dprintf(("MSVCRT: _CxxThrowException %08xh %08xh\n",
636 arg1,
637 arg2));
638
639 //memcpy(er, cxxExceptionFrame, sizeof(er));
640 // PH: optimization - why copying values when they're overwritten anyway...
641 memcpy(&er, &cxxExceptionFrame, 6);
642
643 // Note: er.ExceptionInformation[0] is already set!
644 er.ExceptionInformation[1] = arg1;
645 er.ExceptionInformation[2] = arg2;
646
647 RaiseException(er.ExceptionCode,
648 er.ExceptionFlags,
649 er.NumberParameters,
650 &er.ExceptionInformation[0]);
651}
652
653/*********************************************************************
654 * __CxxFrameHandler (MSVCRT.74)
655 * FIXME - Could not find anything about it
656 */
657INT CDECL MSVCRT___CxxFrameHandler(DWORD ret)
658{
659 dprintf(("MSVCRT: __CxxFrameHandler not implemented.\n"));
660 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
661 return FALSE;
662}
663
664
665/*********************************************************************
666 * __CxxLongjmpUnwind (MSVCRT.75) ?
667 * FIXME - Could not find anything about it
668 */
669INT CDECL MSVCRT___CxxLongjmpUnwind(DWORD ret)
670{
671 dprintf(("MSVCRT: __CxxLongjmpUnwind not implemented.\n"));
672 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
673 return FALSE;
674}
675
676
677/*********************************************************************
678 * __GetMainArgs (MSVCRT.89)
679 */
680DWORD CDECL MSVCRT___GetMainArgs(LPDWORD argc,LPSTR **argv,
681 LPSTR *environ,DWORD flag)
682{
683 char *cmdline;
684 char **xargv;
685 int xargc,i,afterlastspace;
686 DWORD version;
687
688 dprintf(("MSVCRT: GetMainArgs\n"));
689
690 MSVCRT__acmdln = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
691 GetCommandLineA() );
692
693 version = GetVersion();
694 MSVCRT__osver = version >> 16;
695 MSVCRT__winminor = version & 0xFF;
696 MSVCRT__winmajor = (version>>8) & 0xFF;
697 MSVCRT__baseversion = version >> 16;
698 MSVCRT__winver = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
699 MSVCRT__baseminor = (version >> 16) & 0xFF;
700 MSVCRT__basemajor = (version >> 24) & 0xFF;
701 MSVCRT__osversion = version & 0xFFFF;
702 MSVCRT__osminor = version & 0xFF;
703 MSVCRT__osmajor = (version>>8) & 0xFF;
704
705 /* missing threading init */
706
707 i=0;xargv=NULL;xargc=0;afterlastspace=0;
708/*
709 while (cmdline[i]) {
710 if (cmdline[i]==' ') {
711 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
712 sizeof(char*)*(++xargc));
713 cmdline[i]='\0';
714 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
715 cmdline+afterlastspace);
716 i++;
717 while (cmdline[i]==' ')
718 i++;
719 if (cmdline[i])
720 afterlastspace=i;
721
722 } else
723 i++;
724
725 }
726
727 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
728 sizeof(char*)*(++xargc));
729 cmdline[i]='\0';
730 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
731 cmdline+afterlastspace);
732*/
733 MSVCRT___argc = xargc;
734 *argc = xargc;
735 MSVCRT___argv = xargv;
736 *argv = xargv;
737 MSVCRT__environ = *environ = GetEnvironmentStringsA();
738 dprintf(("MSVCRT: GetMainArgs end\n"));
739 return 0;
740}
741
742
743/*********************************************************************
744 * __initenv (MSVCRT.90)
745 * FIXME - Could not find anything about it
746 */
747INT CDECL MSVCRT___initenv(DWORD ret)
748{
749 dprintf(("MSVCRT: __initenv not implemented.\n"));
750 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
751 return FALSE;
752}
753
754
755/*********************************************************************
756 * __p___argc (MSVCRT.99)
757 */
758int * CDECL MSVCRT___p___argc()
759{
760 dprintf(("MSVCRT: __p___argc\n"));
761 return (int*)&MSVCRT___argc;
762}
763
764
765/*********************************************************************
766 * __p___argv (MSVCRT.100)
767 */
768char ** CDECL MSVCRT___p___argv()
769{
770 dprintf(("MSVCRT: __p___argv\n"));
771 return (char**)&MSVCRT___argv;
772}
773
774
775/*********************************************************************
776 * __p__initenv (MSVCRT.101)
777 */
778char ** CDECL MSVCRT___p__initenv()
779{
780 dprintf(("MSVCRT: __p__initenv not implemented\n"));
781 return &MSVCRT__acmdln;
782}
783
784
785/*********************************************************************
786 * __p___mb_cur_max (MSVCRT.102)
787 */
788int * CDECL MSVCRT___p___mb_cur_max()
789{
790 dprintf(("MSVCRT: __p___mb_cur_max\n"));
791 return &MSVCRT___mb_cur_max;
792}
793
794
795/*********************************************************************
796 * __p__acmdln (MSVCRT.105)
797 */
798char ** CDECL MSVCRT___p__acmdln()
799{
800 dprintf(("MSVCRT: __p__acmdln\n"));
801 return &MSVCRT__acmdln;
802}
803
804
805/*********************************************************************
806 * __p__fmode (MSVCRT.107)
807 */
808int * CDECL MSVCRT___p__fmode()
809{
810 dprintf(("MSVCRT: __p__fmode\n"));
811 return (int*)&MSVCRT__fmode;
812}
813
814
815/*********************************************************************
816 * __p__daylight (MSVCRT.108)
817 */
818int * CDECL MSVCRT___p__daylight()
819{
820 dprintf(("MSVCRT: __p__daylight\n"));
821 return (int*)&MSVCRT__daylight;
822}
823
824
825/*********************************************************************
826 * __p__environ (MSVCRT.110)
827 */
828char ** CDECL MSVCRT___p__environ()
829{
830 dprintf(("MSVCRT: __p__environ\n"));
831 return &MSVCRT__environ;
832}
833
834
835/*********************************************************************
836 * __p__fileinfo (MSVCRT.111)
837 */
838char ** CDECL MSVCRT___p__fileinfo()
839{
840 dprintf(("MSVCRT: __p__fileinfo\n"));
841 return &MSVCRT__fileinfo;
842}
843
844
845/*********************************************************************
846 * __p__commode (MSVCRT.112)
847 */
848int * CDECL MSVCRT___p__commode()
849{
850 dprintf(("MSVCRT: __p__commode\n"));
851 return (int*)&MSVCRT__commode;
852}
853
854
855/*********************************************************************
856 * __p__iob (MSVCRT.113)
857 */
858CRTDLL_FILE * CDECL MSVCRT___p__iob()
859{
860 dprintf(("MSVCRT: __p__iob\n"));
861 return &_iob;
862}
863
864
865/*********************************************************************
866 * __p__osver (MSVCRT.116)
867 */
868int * CDECL MSVCRT___p__osver()
869{
870 dprintf(("MSVCRT: __p__osver\n"));
871 return (int*)&MSVCRT__osver;
872}
873
874
875/*********************************************************************
876 * __p__pctype (MSVCRT.117)
877 */
878USHORT * CDECL MSVCRT___p__pctype()
879{
880 dprintf(("MSVCRT: __p__pctype\n"));
881 return (USHORT*)&MSVCRT__pctype;
882}
883
884
885/*********************************************************************
886 * __p__pgmptr (MSVCRT.118)
887 */
888char ** CDECL MSVCRT___p__pgmptr()
889{
890 dprintf(("MSVCRT: __p__pgmptr\n"));
891 return (char**)&MSVCRT__pgmptr;
892}
893
894
895/*********************************************************************
896 * __p__pwctype (MSVCRT.119)
897 */
898USHORT * CDECL MSVCRT___p__pwctype()
899{
900 dprintf(("MSVCRT: __p__pwctype\n"));
901 return (USHORT*)&MSVCRT__pwctype;
902}
903
904
905/*********************************************************************
906 * __p__timezone (MSVCRT.120)
907 */
908int * CDECL MSVCRT___p__timezone()
909{
910 dprintf(("MSVCRT: __p__timezone\n"));
911 return (int*)&MSVCRT__timezone;
912}
913
914
915/*********************************************************************
916 * __p__tzname (MSVCRT.121)
917 */
918char ** CDECL MSVCRT___p__tzname()
919{
920 dprintf(("MSVCRT: __p__tzname\n"));
921 return (char**)&MSVCRT__tzname;
922}
923
924
925/*********************************************************************
926 * __p__winmajor (MSVCRT.124)
927 */
928int * CDECL MSVCRT___p__winmajor()
929{
930 dprintf(("MSVCRT: __p__winmajor\n"));
931 return (int*)&MSVCRT__winmajor;
932}
933
934
935/*********************************************************************
936 * __p__winminor (MSVCRT.125)
937 */
938int * CDECL MSVCRT___p__winminor()
939{
940 dprintf(("MSVCRT: __p__winminor\n"));
941 return (int*)&MSVCRT__winminor;
942}
943
944
945/*********************************************************************
946 * __p__winver (MSVCRT.126)
947 */
948int * CDECL MSVCRT___p__winver()
949{
950 dprintf(("MSVCRT: __p__winver\n"));
951 return (int*)&MSVCRT__winver;
952}
953
954
955/*********************************************************************
956 * __set_app_type (MSVCRT.130)
957 */
958int CDECL MSVCRT___set_app_type(int app_type)
959{
960 dprintf(("MSVCRT: __set_app_type\n"));
961 return __app_type = app_type;
962}
963
964
965/*********************************************************************
966 * __setusermatherr (MSVCRT.132)
967 */
968int CDECL MSVCRT___setusermatherr(int matherr)
969{
970 dprintf(("MSVCRT: __setusermatherr\n"));
971 return __usermatherr = matherr;
972}
973
974
975/*********************************************************************
976 * _adjust_fdiv (MSVCRT.158)
977 * FIXME - Could not find anything about it
978 */
979INT CDECL MSVCRT__adjust_fdiv(DWORD ret)
980{
981 dprintf(("MSVCRT: _adjust_fdiv not implemented.\n"));
982 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
983 return FALSE;
984}
985
986
987/*********************************************************************
988 * _aexit_rtn (MSVCRT.159)
989 */
990VOID CDECL MSVCRT__aexit_rtn(int exitcode)
991{
992 dprintf(("MSVCRT: _aexit_rtn\n"));
993 ExitProcess(exitcode);
994}
995
996
997/*********************************************************************
998 * _atoi64 (MSVCRT.163)
999 */
1000__int64 CDECL MSVCRT__atoi64(const char *s)
1001{
1002 dprintf(("MSVCRT: _atoi64 not implemented.\n"));
1003 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1004 return FALSE;
1005}
1006
1007
1008/*********************************************************************
1009 * _beginthreadex (MSVCRT.167)
1010 */
1011unsigned long CDECL MSVCRT__beginthreadex( void *security, unsigned stack_size,
1012 unsigned ( __stdcall *start_address )( void * ), void *arglist,
1013 unsigned initflag, unsigned *thrdaddr )
1014{
1015 dprintf(("MSVCRT: _beginthreadex not implemented.\n"));
1016 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1017 return FALSE;
1018}
1019
1020
1021/*********************************************************************
1022 * _endthreadex (MSVCRT.198)
1023 */
1024void CDECL MSVCRT__endthreadex(unsigned retval)
1025{
1026 dprintf(("MSVCRT: _endthreadex not implemented.\n"));
1027 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1028}
1029
1030
1031/*********************************************************************
1032 * _except_handler3 (MSVCRT.203)
1033 */
1034INT CDECL MSVCRT__except_handler3 ( PEXCEPTION_RECORD rec,
1035 PEXCEPTION_FRAME frame, PCONTEXT context,
1036 PEXCEPTION_FRAME *dispatcher)
1037{
1038 dprintf(("MSVCRT: _except_handler3\n"));
1039 return 1;
1040}
1041
1042
1043/*********************************************************************
1044 * _filelengthi64 (MSVCRT.222)
1045 */
1046__int64 CDECL MSVCRT__filelengthi64(int handle)
1047{
1048 dprintf(("MSVCRT: _filelengthi64 not implemented.\n"));
1049 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1050 return FALSE;
1051}
1052
1053
1054/*********************************************************************
1055 * _findfirsti64 (MSVCRT.226)
1056 */
1057__int64 CDECL MSVCRT__findfirsti64( char *filespec, struct _finddata_t *fileinfo)
1058{
1059 dprintf(("MSVCRT: _findfirsti64 not implemented.\n"));
1060 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1061 return FALSE;
1062}
1063
1064
1065/*********************************************************************
1066 * _findnexti64 (MSVCRT.228)
1067 */
1068__int64 CDECL MSVCRT__findnexti64(long handle, struct _finddata_t *fileinfo)
1069{
1070 dprintf(("MSVCRT: _findnexti64 not implemented.\n"));
1071 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1072 return FALSE;
1073}
1074
1075
1076/*********************************************************************
1077 * _fstati64 (MSVCRT.240)
1078 */
1079__int64 CDECL MSVCRT__fstati64(int handle)
1080{
1081 dprintf(("MSVCRT: _fstati64 not implemented.\n"));
1082 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1083 return FALSE;
1084}
1085
1086
1087/*********************************************************************
1088 * _get_sbh_threshold (MSVCRT.247)
1089 */
1090size_t CDECL MSVCRT__get_sbh_threshold( void )
1091{
1092 dprintf(("MSVCRT: _get_sbh_threshold not implemented.\n"));
1093 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1094 return FALSE;
1095}
1096
1097
1098/*********************************************************************
1099 * _getmaxstdio (MSVCRT.256)
1100 */
1101int CDECL MSVCRT__getmaxstdio( void )
1102{
1103 dprintf(("MSVCRT: _getmaxstdio not implemented.\n"));
1104 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1105 return FALSE;
1106}
1107
1108
1109/*********************************************************************
1110 * _getmbcp (MSVCRT.257)
1111 */
1112int CDECL MSVCRT__getmbcp( void )
1113{
1114 dprintf(("MSVCRT: _getmbcp not implemented.\n"));
1115 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1116 return FALSE;
1117}
1118
1119
1120/*********************************************************************
1121 * _getws (MSVCRT.261)
1122 */
1123wchar_t * CDECL MSVCRT__getws( wchar_t *s )
1124{
1125 dprintf(("MSVCRT: _getws not implemented.\n"));
1126 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1127 return FALSE;
1128}
1129
1130
1131/*********************************************************************
1132 * _heapadd (MSVCRT.263)
1133 */
1134int CDECL MSVCRT__heapadd(void *v, size_t s)
1135{
1136 dprintf(("MSVCRT: _heapadd not implemented.\n"));
1137 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1138 return FALSE;
1139}
1140
1141
1142/*********************************************************************
1143 * _i64toa (MSVCRT.270)
1144 */
1145char * CDECL MSVCRT__i64toa(__int64 i1, char *s, int i2)
1146{
1147 dprintf(("MSVCRT: _i64toa not implemented.\n"));
1148 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1149 return FALSE;
1150}
1151
1152
1153/*********************************************************************
1154 * _i64tow (MSVCRT.271)
1155 */
1156wchar_t * CDECL MSVCRT__i64tow(__int64 i1, wchar_t *s, int i2)
1157{
1158 dprintf(("MSVCRT: _i64tow not implemented.\n"));
1159 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1160 return FALSE;
1161}
1162
1163
1164/*********************************************************************
1165 * _inp (MSVCRT.273)
1166 */
1167int CDECL MSVCRT__inp( unsigned short port )
1168{
1169 dprintf(("MSVCRT: _inp not implemented.\n"));
1170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1171 return FALSE;
1172}
1173
1174
1175/*********************************************************************
1176 * _inpw (MSVCRT.274)
1177 */
1178unsigned short CDECL MSVCRT__inpw( unsigned short port )
1179{
1180 dprintf(("MSVCRT: _inpw not implemented.\n"));
1181 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1182 return FALSE;
1183}
1184
1185
1186/*********************************************************************
1187 * _inpd (MSVCRT.275)
1188 */
1189unsigned long CDECL MSVCRT__inpd( unsigned short port )
1190{
1191 dprintf(("MSVCRT: _inpd not implemented.\n"));
1192 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1193 return FALSE;
1194}
1195
1196
1197/*********************************************************************
1198 * _ismbbkprint (MSVCRT.284)
1199 */
1200int CDECL MSVCRT__ismbbkprint( unsigned int ch )
1201{
1202 dprintf(("MSVCRT: _ismbbkprint not implemented.\n"));
1203 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1204 return FALSE;
1205}
1206
1207
1208/*********************************************************************
1209 * _ismbcalnum (MSVCRT.290)
1210 */
1211int CDECL MSVCRT__ismbcalnum( unsigned int ch )
1212{
1213 dprintf(("MSVCRT: _ismbcalnum not implemented.\n"));
1214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1215 return FALSE;
1216}
1217
1218
1219/*********************************************************************
1220 * _ismbcgraph (MSVCRT.293)
1221 */
1222int CDECL MSVCRT__ismbcgraph( unsigned int ch )
1223{
1224 dprintf(("MSVCRT: _ismbcgraph not implemented.\n"));
1225 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1226 return FALSE;
1227}
1228
1229
1230/*********************************************************************
1231 * _ismbcpunct (MSVCRT.302)
1232 */
1233int CDECL MSVCRT__ismbcpunct( unsigned int ch )
1234{
1235 dprintf(("MSVCRT: _ismbcpunct not implemented.\n"));
1236 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1237 return FALSE;
1238}
1239
1240
1241/*********************************************************************
1242 * _itow (MSVCRT.310)
1243 */
1244wchar_t * CDECL MSVCRT__itow( int value, wchar_t *string, int radix )
1245{
1246 dprintf(("MSVCRT: _itow not implemented.\n"));
1247 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1248 return FALSE;
1249}
1250
1251
1252/*********************************************************************
1253 * _unlock (MSVCRT.480)
1254 */
1255// Note: PH 2000/08/22 array size is probably larger than 0x12!
1256static CRITICAL_SECTION* arrpCriticalSections[0x12] = {0};
1257
1258#define CRITSEC_TABLE_LOCK 0x11
1259
1260VOID CDECL MSVCRT__unlock(unsigned long ulIndex)
1261{
1262 dprintf(("MSVCRT: _unlock\n"));
1263
1264 CRITICAL_SECTION *pCS = arrpCriticalSections[ulIndex];
1265 LeaveCriticalSection(pCS);
1266}
1267
1268
1269/*********************************************************************
1270 * _lock (MSVCRT.318)
1271 */
1272// Prototype from CRTDLL.CPP
1273VOID CDECL amsg_exit(int errnum);
1274
1275VOID CDECL MSVCRT__lock(unsigned long ulIndex)
1276{
1277 dprintf(("MSVCRT: _lock\n"));
1278
1279 CRITICAL_SECTION *pCS = arrpCriticalSections[ulIndex];
1280 if (pCS == NULL)
1281 {
1282 CRITICAL_SECTION *pCSNew;
1283
1284 pCSNew = (CRITICAL_SECTION*)malloc( sizeof(CRITICAL_SECTION) );
1285 if (pCSNew == NULL)
1286 amsg_exit(0x11); // yield error message
1287
1288 MSVCRT__lock(CRITSEC_TABLE_LOCK); // lock table
1289 if (pCS != NULL) // has been modified meanwhile by other thread ?
1290 free(pCSNew);
1291 else
1292 {
1293 InitializeCriticalSection(pCSNew);
1294 arrpCriticalSections[ulIndex] = pCSNew;
1295 }
1296
1297 MSVCRT__unlock(CRITSEC_TABLE_LOCK); // unlock table
1298 }
1299
1300 EnterCriticalSection(pCS);
1301}
1302
1303
1304/*********************************************************************
1305 * _lseeki64 (MSVCRT.326)
1306 */
1307__int64 CDECL MSVCRT__lseeki64( int handle, __int64 offset, int origin )
1308{
1309 dprintf(("MSVCRT: _lseeki64 not implemented.\n"));
1310 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1311 return FALSE;
1312}
1313
1314
1315/*********************************************************************
1316 * _ltow (MSVCRT.328)
1317 */
1318wchar_t * CDECL MSVCRT__ltow( long value, wchar_t *string, int radix )
1319{
1320 dprintf(("MSVCRT: _ltow not implemented.\n"));
1321 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1322 return FALSE;
1323}
1324
1325
1326/*********************************************************************
1327 * _outp (MSVCRT.395)
1328 */
1329int CDECL MSVCRT__outp( unsigned short port, int databyte )
1330{
1331 dprintf(("MSVCRT: _outp not implemented.\n"));
1332 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1333 return FALSE;
1334}
1335
1336
1337/*********************************************************************
1338 * _outpw (MSVCRT.396)
1339 */
1340unsigned short CDECL MSVCRT__outpw( unsigned short port, unsigned short dataword )
1341{
1342 dprintf(("MSVCRT: _outpw not implemented.\n"));
1343 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1344 return FALSE;
1345}
1346
1347
1348/*********************************************************************
1349 * _outpd (MSVCRT.397)
1350 */
1351unsigned long CDECL MSVCRT__outpd( unsigned short port, unsigned long dataword )
1352{
1353 dprintf(("MSVCRT: _outpd not implemented.\n"));
1354 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1355 return FALSE;
1356}
1357
1358
1359/*********************************************************************
1360 * _putws (MSVCRT.407)
1361 */
1362int CDECL MSVCRT__putws( const wchar_t *s )
1363{
1364 dprintf(("MSVCRT: _putws not implemented.\n"));
1365 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1366 return FALSE;
1367}
1368
1369
1370/*********************************************************************
1371 * _set_error_mode (MSVCRT.421)
1372 */
1373int CDECL MSVCRT__set_error_mode( int modeval )
1374{
1375 dprintf(("MSVCRT: _set_error_mode not implemented.\n"));
1376 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1377 return FALSE;
1378}
1379
1380
1381/*********************************************************************
1382 * _set_sbh_threshold (MSVCRT.422)
1383 */
1384int CDECL MSVCRT__set_sbh_threshold( size_t size )
1385{
1386 dprintf(("MSVCRT: _set_sbh_threshold not implemented.\n"));
1387 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1388 return FALSE;
1389}
1390
1391
1392/*********************************************************************
1393 * _setmaxstdio (MSVCRT.426)
1394 */
1395int CDECL MSVCRT__setmaxstdio(int i)
1396{
1397 dprintf(("MSVCRT: _setmaxstdio not implemented.\n"));
1398 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1399 return FALSE;
1400}
1401
1402
1403/*********************************************************************
1404 * _setmbcp (MSVCRT.427)
1405 */
1406int CDECL MSVCRT__setmbcp( int codepage )
1407{
1408 dprintf(("MSVCRT: _setmbcp not implemented.\n"));
1409 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410 return FALSE;
1411}
1412
1413
1414/*********************************************************************
1415 * _stati64 (MSVCRT.444)
1416 */
1417__int64 CDECL MSVCRT__stati64( const char *path, struct _stat *buffer )
1418{
1419 dprintf(("MSVCRT: _stati64 not implemented.\n"));
1420 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421 return FALSE;
1422}
1423
1424
1425/*********************************************************************
1426 * _strncoll (MSVCRT.453)
1427 */
1428int CDECL MSVCRT__strncoll( const char *s1, const char *s2, size_t n )
1429{
1430 dprintf(("MSVCRT: _strncoll not implemented.\n"));
1431 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1432 return FALSE;
1433}
1434
1435
1436/*********************************************************************
1437 * _strnicoll (MSVCRT.455)
1438 */
1439int CDECL MSVCRT__strnicoll( const char *s1, const char *s2, size_t n )
1440{
1441 dprintf(("MSVCRT: _strnicoll not implemented.\n"));
1442 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1443 return FALSE;
1444}
1445
1446
1447/*********************************************************************
1448 * _telli64 (MSVCRT.465)
1449 */
1450__int64 CDECL MSVCRT__telli64( int handle )
1451{
1452 dprintf(("MSVCRT: _telli64 not implemented.\n"));
1453 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1454 return FALSE;
1455}
1456
1457
1458/*********************************************************************
1459 * _ui64toa (MSVCRT.472)
1460 */
1461/*
1462char * CDECL MSVCRT__ui64toa(unsigned __int64 value, char *s, int i)
1463{
1464 dprintf(("MSVCRT: _ui64toa not implemented.\n"));
1465 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1466 return FALSE;
1467}
1468*/
1469
1470/*********************************************************************
1471 * _ui64tow (MSVCRT.473)
1472 */
1473/*
1474wchar_t * CDECL MSVCRT__ui64tow(unsigned __int64 value, wchar_t *s, int i)
1475{
1476 dprintf(("MSVCRT: _ui64tow not implemented.\n"));
1477 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1478 return FALSE;
1479}
1480*/
1481
1482/*********************************************************************
1483 * _ultow (MSVCRT.475)
1484 */
1485wchar_t * CDECL MSVCRT__ultow( unsigned long value, wchar_t *string, int radix )
1486{
1487 dprintf(("MSVCRT: _ultow not implemented.\n"));
1488 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1489 return FALSE;
1490}
1491
1492
1493/*********************************************************************
1494 * _umask (MSVCRT.476)
1495 */
1496int CDECL MSVCRT__umask( int pmode )
1497{
1498 dprintf(("MSVCRT: _umask not implemented.\n"));
1499 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1500 return FALSE;
1501}
1502
1503
1504/*********************************************************************
1505 * _waccess (MSVCRT.484)
1506 */
1507int CDECL MSVCRT__waccess( const wchar_t *path, int mode )
1508{
1509 dprintf(("MSVCRT: _waccess not implemented.\n"));
1510 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1511 return FALSE;
1512}
1513
1514
1515/*********************************************************************
1516 * _wasctime (MSVCRT.485)
1517 */
1518wchar_t * CDECL MSVCRT__wasctime( const struct tm *timeptr )
1519{
1520 dprintf(("MSVCRT: _wasctime not implemented.\n"));
1521 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1522 return FALSE;
1523}
1524
1525
1526/*********************************************************************
1527 * _wchdir (MSVCRT.486)
1528 */
1529int CDECL MSVCRT__wchdir( const wchar_t *dirname )
1530{
1531 dprintf(("MSVCRT: _wchdir not implemented.\n"));
1532 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1533 return FALSE;
1534}
1535
1536
1537/*********************************************************************
1538 * _wchmod (MSVCRT.487)
1539 */
1540int CDECL MSVCRT__wchmod( const wchar_t *filename, int pmode )
1541{
1542 dprintf(("MSVCRT: _wchmod not implemented.\n"));
1543 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1544 return FALSE;
1545}
1546
1547
1548/*********************************************************************
1549 * _wcreat (MSVCRT.489)
1550 */
1551int CDECL MSVCRT__wcreat( const wchar_t *filename, int pmode )
1552{
1553 dprintf(("MSVCRT: _wcreat not implemented.\n"));
1554 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1555 return FALSE;
1556}
1557
1558
1559/*********************************************************************
1560 * _wcsncoll (MSVCRT.494)
1561 */
1562int CDECL MSVCRT__wcsncoll( const wchar_t *string1, const wchar_t *string2, size_t count )
1563{
1564 dprintf(("MSVCRT: _wcsncoll not implemented.\n"));
1565 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1566 return FALSE;
1567}
1568
1569
1570/*********************************************************************
1571 * _wcsnicoll (MSVCRT.496)
1572 */
1573int CDECL MSVCRT__wcsnicoll( const wchar_t *string1, const wchar_t *string2 , size_t count )
1574{
1575 dprintf(("MSVCRT: _wcsnicoll not implemented.\n"));
1576 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1577 return FALSE;
1578}
1579
1580
1581/*********************************************************************
1582 * _wctime (MSVCRT.501)
1583 */
1584wchar_t * CDECL MSVCRT__wctime( const time_t *timer )
1585{
1586 dprintf(("MSVCRT: _wctime not implemented.\n"));
1587 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1588 return FALSE;
1589}
1590
1591
1592/*********************************************************************
1593 * _wexecl (MSVCRT.503)
1594 */
1595int CDECL MSVCRT__wexecl( const wchar_t *path, const wchar_t *arg0, ... )
1596{
1597 dprintf(("MSVCRT: _wexecl not implemented.\n"));
1598 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1599 return FALSE;
1600}
1601
1602
1603/*********************************************************************
1604 * _wexecle (MSVCRT.504)
1605 */
1606int CDECL MSVCRT__wexecle( const wchar_t *path, const wchar_t *arg0, ... )
1607{
1608 dprintf(("MSVCRT: _wexecle not implemented.\n"));
1609 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1610 return FALSE;
1611}
1612
1613
1614/*********************************************************************
1615 * _wexeclp (MSVCRT.505)
1616 */
1617int CDECL MSVCRT__wexeclp( const wchar_t *file, const wchar_t *arg0, ... )
1618{
1619 dprintf(("MSVCRT: _wexeclp not implemented.\n"));
1620 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1621 return FALSE;
1622}
1623
1624
1625/*********************************************************************
1626 * _wexeclpe (MSVCRT.506)
1627 */
1628int CDECL MSVCRT__wexeclpe( const wchar_t *file, const wchar_t *arg0, ... )
1629{
1630 dprintf(("MSVCRT: _wexeclpe not implemented.\n"));
1631 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1632 return FALSE;
1633}
1634
1635
1636/*********************************************************************
1637 * _wexecv (MSVCRT.507)
1638 */
1639int CDECL MSVCRT__wexecv( const wchar_t *path, const wchar_t *const argv[] )
1640{
1641 dprintf(("MSVCRT: _wexecv not implemented.\n"));
1642 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1643 return FALSE;
1644}
1645
1646
1647/*********************************************************************
1648 * _wexecve (MSVCRT.508)
1649 */
1650int CDECL MSVCRT__wexecve( const wchar_t *path, const wchar_t *const argv[],
1651 const wchar_t *const envp[] )
1652{
1653 dprintf(("MSVCRT: _wexecve not implemented.\n"));
1654 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1655 return FALSE;
1656}
1657
1658
1659/*********************************************************************
1660 * _wexecvp (MSVCRT.509)
1661 */
1662int CDECL MSVCRT__wexecvp( const wchar_t *file, const wchar_t *const argv[] )
1663{
1664 dprintf(("MSVCRT: _wexecvp not implemented.\n"));
1665 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1666 return FALSE;
1667}
1668
1669
1670/*********************************************************************
1671 * _wexecvpe (MSVCRT.510)
1672 */
1673int CDECL MSVCRT__wexecvpe( const wchar_t *file, const wchar_t *const argv[],
1674 const wchar_t *const envp[] )
1675{
1676 dprintf(("MSVCRT: _wexecvpe not implemented.\n"));
1677 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1678 return FALSE;
1679}
1680
1681
1682/*********************************************************************
1683 * _wfdopen (MSVCRT.511)
1684 */
1685FILE * CDECL MSVCRT__wfdopen( int, const wchar_t *s )
1686{
1687 dprintf(("MSVCRT: _wfdopen not implemented.\n"));
1688 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1689 return FALSE;
1690}
1691
1692
1693/*********************************************************************
1694 * _wfindfirst (MSVCRT.512)
1695 */
1696long CDECL MSVCRT__wfindfirst( const wchar_t *filespec, struct _wfinddata_t *fileinfo )
1697{
1698 dprintf(("MSVCRT: _wfindfirst not implemented.\n"));
1699 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1700 return FALSE;
1701}
1702
1703
1704/*********************************************************************
1705 * _wfindfirsti64 (MSVCRT.513)
1706 */
1707__int64 CDECL MSVCRT__wfindfirsti64( wchar_t *filespec, struct _wfinddata_t *fileinfo )
1708{
1709 dprintf(("MSVCRT: _wfindfirsti64 not implemented.\n"));
1710 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1711 return FALSE;
1712}
1713
1714
1715/*********************************************************************
1716 * _wfindnext (MSVCRT.514)
1717 */
1718int CDECL MSVCRT__wfindnext( long handle, struct _wfinddata_t *fileinfo )
1719{
1720 dprintf(("MSVCRT: _wfindnext not implemented.\n"));
1721 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1722 return FALSE;
1723}
1724
1725
1726/*********************************************************************
1727 * _wfindnexti64 (MSVCRT.515)
1728 */
1729/*
1730int CDECL MSVCRT__wfindnexti64(intptr_t x, struct _wfinddatai64_t *s)
1731{
1732 dprintf(("MSVCRT: _wfindnexti64 not implemented.\n"));
1733 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1734 return FALSE;
1735}
1736*/
1737
1738
1739/*********************************************************************
1740 * _wfopen (MSVCRT.516)
1741 */
1742FILE * CDECL MSVCRT__wfopen( const wchar_t *s1, const wchar_t *s2 )
1743{
1744 dprintf(("MSVCRT: _wfopen not implemented.\n"));
1745 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1746 return FALSE;
1747}
1748
1749
1750/*********************************************************************
1751 * _wfreopen (MSVCRT.517)
1752 */
1753FILE * CDECL MSVCRT__wfreopen( const wchar_t *s1, const wchar_t *s2, FILE * f)
1754{
1755 dprintf(("MSVCRT: _wfreopen not implemented.\n"));
1756 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1757 return FALSE;
1758}
1759
1760
1761/*********************************************************************
1762 * _wfsopen (MSVCRT.518)
1763 */
1764FILE * CDECL MSVCRT__wfsopen( const wchar_t *filename, const wchar_t *mode, int shflag )
1765{
1766 dprintf(("MSVCRT: _wfsopen not implemented.\n"));
1767 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1768 return FALSE;
1769}
1770
1771
1772/*********************************************************************
1773 * _wfullpath (MSVCRT.519)
1774 */
1775wchar_t * CDECL MSVCRT__wfullpath( wchar_t *s1, const wchar_t *s2, size_t n )
1776{
1777 dprintf(("MSVCRT: _wfullpath not implemented.\n"));
1778 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1779 return FALSE;
1780}
1781
1782
1783/*********************************************************************
1784 * _wgetcwd (MSVCRT.520)
1785 */
1786wchar_t * CDECL MSVCRT__wgetcwd( wchar_t *buf, size_t size )
1787{
1788 dprintf(("MSVCRT: _wgetcwd not implemented.\n"));
1789 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1790 return FALSE;
1791}
1792
1793
1794/*********************************************************************
1795 * _wgetdcwd (MSVCRT.521)
1796 */
1797wchar_t * CDECL MSVCRT__wgetdcwd( int drive, wchar_t *buffer, size_t maxlen )
1798{
1799 dprintf(("MSVCRT: _wgetdcwd not implemented.\n"));
1800 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1801 return FALSE;
1802}
1803
1804
1805/*********************************************************************
1806 * _wgetenv (MSVCRT.522)
1807 */
1808wchar_t * CDECL MSVCRT__wgetenv( const wchar_t *name )
1809{
1810 dprintf(("MSVCRT: _wgetenv not implemented.\n"));
1811 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1812 return FALSE;
1813}
1814
1815
1816/*********************************************************************
1817 * _wmakepath (MSVCRT.526)
1818 */
1819void CDECL MSVCRT__wmakepath( wchar_t *path, const wchar_t *drive,
1820 const wchar_t *dir, const wchar_t *fname, const wchar_t *ext )
1821{
1822 dprintf(("MSVCRT: _wmakepath not implemented.\n"));
1823 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1824}
1825
1826
1827/*********************************************************************
1828 * _wmkdir (MSVCRT.527)
1829 */
1830int CDECL MSVCRT__wmkdir( const wchar_t *path )
1831{
1832 dprintf(("MSVCRT: _wmkdir not implemented.\n"));
1833 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1834 return FALSE;
1835}
1836
1837
1838/*********************************************************************
1839 * _wmktemp (MSVCRT.528)
1840 */
1841wchar_t * CDECL MSVCRT__wmktemp( wchar_t* )
1842{
1843 dprintf(("MSVCRT: _wmktemp not implemented.\n"));
1844 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1845 return FALSE;
1846}
1847
1848
1849/*********************************************************************
1850 * _wopen (MSVCRT.529)
1851 */
1852int CDECL MSVCRT__wopen( const wchar_t *s, int n, ... )
1853{
1854 dprintf(("MSVCRT: _wopen not implemented.\n"));
1855 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1856 return FALSE;
1857}
1858
1859
1860/*********************************************************************
1861 * _wperror (MSVCRT.530)
1862 */
1863void CDECL MSVCRT__wperror( const wchar_t *s )
1864{
1865 dprintf(("MSVCRT: _wperror not implemented.\n"));
1866 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1867}
1868
1869
1870/*********************************************************************
1871 * _wpopen (MSVCRT.532)
1872 */
1873FILE * CDECL MSVCRT__wpopen( const wchar_t *command, const wchar_t *mode )
1874{
1875 dprintf(("MSVCRT: _wpopen not implemented.\n"));
1876 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1877 return FALSE;
1878}
1879
1880
1881/*********************************************************************
1882 * _wputenv (MSVCRT.533)
1883 */
1884int CDECL MSVCRT__wputenv( const wchar_t *env_string )
1885{
1886 dprintf(("MSVCRT: _wputenv not implemented.\n"));
1887 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1888 return FALSE;
1889}
1890
1891
1892/*********************************************************************
1893 * _wremove (MSVCRT.534)
1894 */
1895int CDECL MSVCRT__wremove( const wchar_t *s )
1896{
1897 dprintf(("MSVCRT: _wremove not implemented.\n"));
1898 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1899 return FALSE;
1900}
1901
1902
1903/*********************************************************************
1904 * _wrename (MSVCRT.535)
1905 */
1906int CDECL MSVCRT__wrename( const wchar_t *s1, const wchar_t *s2 )
1907{
1908 dprintf(("MSVCRT: _wrename not implemented.\n"));
1909 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1910 return FALSE;
1911}
1912
1913
1914/*********************************************************************
1915 * _wrmdir (MSVCRT.537)
1916 */
1917int CDECL MSVCRT__wrmdir( const wchar_t *path )
1918{
1919 dprintf(("MSVCRT: _wrmdir not implemented.\n"));
1920 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1921 return FALSE;
1922}
1923
1924
1925/*********************************************************************
1926 * _wsearchenv (MSVCRT.538)
1927 */
1928void CDECL MSVCRT__wsearchenv( const wchar_t *name, const wchar_t *env_var, wchar_t *buf )
1929{
1930 dprintf(("MSVCRT: _wsearchenv not implemented.\n"));
1931 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1932}
1933
1934
1935/*********************************************************************
1936 * _wsetlocale (MSVCRT.539)
1937 */
1938wchar_t * CDECL MSVCRT__wsetlocale(int category,const wchar_t *locale)
1939{
1940 dprintf(("MSVCRT: _wsetlocale not implemented.\n"));
1941 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942 return FALSE;
1943}
1944
1945
1946/*********************************************************************
1947 * _wsopen (MSVCRT.540)
1948 */
1949int CDECL MSVCRT__wsopen( const wchar_t *s, int n1, int n2, ... )
1950{
1951 dprintf(("MSVCRT: _wsopen not implemented.\n"));
1952 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1953 return FALSE;
1954}
1955
1956
1957/*********************************************************************
1958 * _wspawnl (MSVCRT.541)
1959 */
1960int CDECL MSVCRT__wspawnl( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1961{
1962 dprintf(("MSVCRT: _wspawnl not implemented.\n"));
1963 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1964 return FALSE;
1965}
1966
1967
1968/*********************************************************************
1969 * _wspawnle (MSVCRT.542)
1970 */
1971int CDECL MSVCRT__wspawnle( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1972{
1973 dprintf(("MSVCRT: _wspawnle not implemented.\n"));
1974 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1975 return FALSE;
1976}
1977
1978
1979/*********************************************************************
1980 * _wspawnlp (MSVCRT.543)
1981 */
1982int CDECL MSVCRT__wspawnlp( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1983{
1984 dprintf(("MSVCRT: _wspawnlp not implemented.\n"));
1985 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1986 return FALSE;
1987}
1988
1989
1990/*********************************************************************
1991 * _wspawnlpe (MSVCRT.544)
1992 */
1993int CDECL MSVCRT__wspawnlpe( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1994{
1995 dprintf(("MSVCRT: _wspawnlpe not implemented.\n"));
1996 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1997 return FALSE;
1998}
1999
2000
2001/*********************************************************************
2002 * _wspawnv (MSVCRT.545)
2003 */
2004int CDECL MSVCRT__wspawnv( int mode, const wchar_t *path, const wchar_t * const *argv )
2005{
2006 dprintf(("MSVCRT: _wspawnv not implemented.\n"));
2007 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2008 return FALSE;
2009}
2010
2011
2012/*********************************************************************
2013 * _wspawnve (MSVCRT.546)
2014 */
2015int CDECL MSVCRT__wspawnve( int mode, const wchar_t *path,
2016 const wchar_t * const *argv, const wchar_t * const *envp )
2017{
2018 dprintf(("MSVCRT: _wspawnve not implemented.\n"));
2019 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2020 return FALSE;
2021}
2022
2023
2024/*********************************************************************
2025 * _wspawnvp (MSVCRT.547)
2026 */
2027int CDECL MSVCRT__wspawnvp( int mode, const wchar_t *path, const wchar_t * const *argv )
2028{
2029 dprintf(("MSVCRT: _wspawnvp not implemented.\n"));
2030 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2031 return FALSE;
2032}
2033
2034
2035/*********************************************************************
2036 * _wspawnvpe (MSVCRT.548)
2037 */
2038int CDECL MSVCRT__wspawnvpe( int mode, const wchar_t *path,
2039 const wchar_t * const *argv, const wchar_t * const *envp )
2040{
2041 dprintf(("MSVCRT: _wspawnvpe not implemented.\n"));
2042 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2043 return FALSE;
2044}
2045
2046
2047/*********************************************************************
2048 * _wsplitpath (MSVCRT.549)
2049 */
2050void CDECL MSVCRT__wsplitpath( const wchar_t *path, wchar_t *drive,
2051 wchar_t *dir, wchar_t *fname, wchar_t *ext )
2052{
2053 dprintf(("MSVCRT: _wsplitpath not implemented.\n"));
2054 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2055}
2056
2057
2058/*********************************************************************
2059 * _wstat (MSVCRT.550)
2060 */
2061int CDECL MSVCRT__wstat( const wchar_t *s, struct _wstat *w )
2062{
2063 dprintf(("MSVCRT: _wstat not implemented.\n"));
2064 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2065 return FALSE;
2066}
2067
2068
2069/*********************************************************************
2070 * _wstati64 (MSVCRT.551)
2071 */
2072int CDECL MSVCRT__wstati64(const wchar_t *s, struct _stati64 *w)
2073{
2074 dprintf(("MSVCRT: _wstati64 not implemented.\n"));
2075 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2076 return FALSE;
2077}
2078
2079
2080/*********************************************************************
2081 * _wstrdate (MSVCRT.552)
2082 */
2083wchar_t * CDECL MSVCRT__wstrdate( wchar_t *buf )
2084{
2085 dprintf(("MSVCRT: _wstrdate not implemented.\n"));
2086 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2087 return FALSE;
2088}
2089
2090
2091/*********************************************************************
2092 * _wstrtime (MSVCRT.553)
2093 */
2094wchar_t * CDECL MSVCRT__wstrtime( wchar_t *buf )
2095{
2096 dprintf(("MSVCRT: _wstrtime not implemented.\n"));
2097 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2098 return FALSE;
2099}
2100
2101
2102/*********************************************************************
2103 * _wsystem (MSVCRT.554)
2104 */
2105int CDECL MSVCRT__wsystem( const wchar_t *cmd )
2106{
2107 dprintf(("MSVCRT: _wsystem not implemented.\n"));
2108 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2109 return FALSE;
2110}
2111
2112
2113/*********************************************************************
2114 * _wtempnam (MSVCRT.555)
2115 */
2116wchar_t * CDECL MSVCRT__wtempnam( wchar_t *dir, wchar_t *prefix )
2117{
2118 dprintf(("MSVCRT: _wtempnam not implemented.\n"));
2119 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2120 return FALSE;
2121}
2122
2123
2124/*********************************************************************
2125 * _wtmpnam (MSVCRT.558)
2126 */
2127wchar_t * CDECL MSVCRT__wtmpnam( wchar_t *tn )
2128{
2129 dprintf(("MSVCRT: _wtmpnam not implemented.\n"));
2130 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2131 return FALSE;
2132}
2133
2134
2135/*********************************************************************
2136 * _wtoi64 (MSVCRT.556)
2137 */
2138__int64 CDECL MSVCRT__wtoi64(const wchar_t *wt)
2139{
2140 dprintf(("MSVCRT: _wtoi64 not implemented.\n"));
2141 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2142 return FALSE;
2143}
2144
2145
2146/*********************************************************************
2147 * _wunlink (MSVCRT.560)
2148 */
2149int CDECL MSVCRT__wunlink(const wchar_t *path)
2150{
2151 dprintf(("MSVCRT: _wunlink not implemented.\n"));
2152 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2153 return FALSE;
2154}
2155
2156
2157/*********************************************************************
2158 * _wutime (MSVCRT.561)
2159 */
2160int CDECL MSVCRT__wutime( const wchar_t *path, const struct utimbuf * times )
2161{
2162 dprintf(("MSVCRT: _wutime not implemented.\n"));
2163 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2164 return FALSE;
2165}
2166
2167
2168/*********************************************************************
2169 * fgetws (MSVCRT.597)
2170 */
2171wchar_t * CDECL MSVCRT_fgetws( wchar_t *s, int n, FILE *strm )
2172{
2173 dprintf(("MSVCRT: fgetws\n"));
2174 return (fgetws(s, n, strm));
2175}
2176
2177
2178/*********************************************************************
2179 * fputws (MSVCRT.605)
2180 */
2181int CDECL MSVCRT_fputws( const wchar_t *s, FILE *strm )
2182{
2183 dprintf(("MSVCRT: fputws\n"));
2184 return (fputws(s, strm));
2185}
2186
2187
2188/*********************************************************************
2189 * getwc (MSVCRT.621)
2190 */
2191wint_t CDECL MSVCRT_getwc( FILE * strm)
2192{
2193 dprintf(("MSVCRT: getwc\n"));
2194 return (getwc(strm));
2195}
2196
2197
2198/*********************************************************************
2199 * getwchar (MSVCRT.622)
2200 */
2201wint_t CDECL MSVCRT_getwchar( void )
2202{
2203 dprintf(("MSVCRT: getwchar\n"));
2204 return (getwchar());
2205}
2206
2207
2208/*********************************************************************
2209 * putwc (MSVCRT.675)
2210 */
2211wint_t CDECL MSVCRT_putwc( wint_t t, FILE * strm)
2212{
2213 dprintf(("MSVCRT: putwc not implemented.\n"));
2214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2215 return FALSE;
2216}
2217
2218
2219/*********************************************************************
2220 * putwchar (MSVCRT.676)
2221 */
2222wint_t CDECL MSVCRT_putwchar( wint_t t)
2223{
2224 dprintf(("MSVCRT: putwchar not implemented.\n"));
2225 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2226 return FALSE;
2227}
2228
2229/**************************************************************************/
2230/* MSVCRT20 & MSVCRT40 only functions */
2231/**************************************************************************/
2232
2233
2234/*********************************************************************
2235 * _matherr (MSVCRT20.677)
2236 */
2237int CDECL MSVCRT__matherr( struct exception *except )
2238{
2239 dprintf(("MSVCRT20: _matherr\n"));
2240 return _matherr(except);
2241}
Note: See TracBrowser for help on using the repository browser.