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

Last change on this file since 2153 was 2153, checked in by sandervl, 26 years ago

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