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

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

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