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

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

Added stub for CxxLongjmpUnwind
File size: 57.0 KB
Line 
1/* $Id: msvcrt.cpp,v 1.12 2000-06-21 17:33:37 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 <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 * __CxxFrameHandler (MSVCRT.74)
622 * FIXME - Could not find anything about it
623 */
624INT CDECL MSVCRT___CxxFrameHandler(DWORD ret)
625{
626 dprintf(("MSVCRT: __CxxFrameHandler not implemented.\n"));
627 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
628 return FALSE;
629}
630
631
632/*********************************************************************
633 * __CxxLongjmpUnwind (MSVCRT.75) ?
634 * FIXME - Could not find anything about it
635 */
636INT CDECL MSVCRT___CxxLongjmpUnwind(DWORD ret)
637{
638 dprintf(("MSVCRT: __CxxLongjmpUnwind not implemented.\n"));
639 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
640 return FALSE;
641}
642
643
644/*********************************************************************
645 * __GetMainArgs (MSVCRT.89)
646 */
647DWORD CDECL MSVCRT___GetMainArgs(LPDWORD argc,LPSTR **argv,
648 LPSTR *environ,DWORD flag)
649{
650 char *cmdline;
651 char **xargv;
652 int xargc,i,afterlastspace;
653 DWORD version;
654
655 dprintf(("MSVCRT: GetMainArgs\n"));
656
657 MSVCRT__acmdln = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
658 GetCommandLineA() );
659
660 version = GetVersion();
661 MSVCRT__osver = version >> 16;
662 MSVCRT__winminor = version & 0xFF;
663 MSVCRT__winmajor = (version>>8) & 0xFF;
664 MSVCRT__baseversion = version >> 16;
665 MSVCRT__winver = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
666 MSVCRT__baseminor = (version >> 16) & 0xFF;
667 MSVCRT__basemajor = (version >> 24) & 0xFF;
668 MSVCRT__osversion = version & 0xFFFF;
669 MSVCRT__osminor = version & 0xFF;
670 MSVCRT__osmajor = (version>>8) & 0xFF;
671
672 /* missing threading init */
673
674 i=0;xargv=NULL;xargc=0;afterlastspace=0;
675/*
676 while (cmdline[i]) {
677 if (cmdline[i]==' ') {
678 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
679 sizeof(char*)*(++xargc));
680 cmdline[i]='\0';
681 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
682 cmdline+afterlastspace);
683 i++;
684 while (cmdline[i]==' ')
685 i++;
686 if (cmdline[i])
687 afterlastspace=i;
688
689 } else
690 i++;
691
692 }
693
694 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
695 sizeof(char*)*(++xargc));
696 cmdline[i]='\0';
697 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
698 cmdline+afterlastspace);
699*/
700 MSVCRT___argc = xargc;
701 *argc = xargc;
702 MSVCRT___argv = xargv;
703 *argv = xargv;
704 MSVCRT__environ = *environ = GetEnvironmentStringsA();
705 dprintf(("MSVCRT: GetMainArgs end\n"));
706 return 0;
707}
708
709
710/*********************************************************************
711 * __initenv (MSVCRT.90)
712 * FIXME - Could not find anything about it
713 */
714INT CDECL MSVCRT___initenv(DWORD ret)
715{
716 dprintf(("MSVCRT: __initenv not implemented.\n"));
717 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
718 return FALSE;
719}
720
721
722/*********************************************************************
723 * __p___argc (MSVCRT.99)
724 */
725int * CDECL MSVCRT___p___argc()
726{
727 dprintf(("MSVCRT: __p___argc\n"));
728 return (int*)&MSVCRT___argc;
729}
730
731
732/*********************************************************************
733 * __p___argv (MSVCRT.100)
734 */
735char ** CDECL MSVCRT___p___argv()
736{
737 dprintf(("MSVCRT: __p___argv\n"));
738 return (char**)&MSVCRT___argv;
739}
740
741
742/*********************************************************************
743 * __p__initenv (MSVCRT.101)
744 */
745char ** CDECL MSVCRT___p__initenv()
746{
747 dprintf(("MSVCRT: __p__initenv not implemented\n"));
748 return &MSVCRT__acmdln;
749}
750
751
752/*********************************************************************
753 * __p___mb_cur_max (MSVCRT.102)
754 */
755int * CDECL MSVCRT___p___mb_cur_max()
756{
757 dprintf(("MSVCRT: __p___mb_cur_max\n"));
758 return &MSVCRT___mb_cur_max;
759}
760
761
762/*********************************************************************
763 * __p__acmdln (MSVCRT.105)
764 */
765char ** CDECL MSVCRT___p__acmdln()
766{
767 dprintf(("MSVCRT: __p__acmdln\n"));
768 return &MSVCRT__acmdln;
769}
770
771
772/*********************************************************************
773 * __p__fmode (MSVCRT.107)
774 */
775int * CDECL MSVCRT___p__fmode()
776{
777 dprintf(("MSVCRT: __p__fmode\n"));
778 return (int*)&MSVCRT__fmode;
779}
780
781
782/*********************************************************************
783 * __p__daylight (MSVCRT.108)
784 */
785int * CDECL MSVCRT___p__daylight()
786{
787 dprintf(("MSVCRT: __p__daylight\n"));
788 return (int*)&MSVCRT__daylight;
789}
790
791
792/*********************************************************************
793 * __p__environ (MSVCRT.110)
794 */
795char ** CDECL MSVCRT___p__environ()
796{
797 dprintf(("MSVCRT: __p__environ\n"));
798 return &MSVCRT__environ;
799}
800
801
802/*********************************************************************
803 * __p__fileinfo (MSVCRT.111)
804 */
805char ** CDECL MSVCRT___p__fileinfo()
806{
807 dprintf(("MSVCRT: __p__fileinfo\n"));
808 return &MSVCRT__fileinfo;
809}
810
811
812/*********************************************************************
813 * __p__commode (MSVCRT.112)
814 */
815int * CDECL MSVCRT___p__commode()
816{
817 dprintf(("MSVCRT: __p__commode\n"));
818 return (int*)&MSVCRT__commode;
819}
820
821
822/*********************************************************************
823 * __p__iob (MSVCRT.113)
824 */
825CRTDLL_FILE * CDECL MSVCRT___p__iob()
826{
827 dprintf(("MSVCRT: __p__iob\n"));
828 return &_iob;
829}
830
831
832/*********************************************************************
833 * __p__osver (MSVCRT.116)
834 */
835int * CDECL MSVCRT___p__osver()
836{
837 dprintf(("MSVCRT: __p__osver\n"));
838 return (int*)&MSVCRT__osver;
839}
840
841
842/*********************************************************************
843 * __p__pctype (MSVCRT.117)
844 */
845USHORT * CDECL MSVCRT___p__pctype()
846{
847 dprintf(("MSVCRT: __p__pctype\n"));
848 return (USHORT*)&MSVCRT__pctype;
849}
850
851
852/*********************************************************************
853 * __p__pgmptr (MSVCRT.118)
854 */
855char ** CDECL MSVCRT___p__pgmptr()
856{
857 dprintf(("MSVCRT: __p__pgmptr\n"));
858 return (char**)&MSVCRT__pgmptr;
859}
860
861
862/*********************************************************************
863 * __p__pwctype (MSVCRT.119)
864 */
865USHORT * CDECL MSVCRT___p__pwctype()
866{
867 dprintf(("MSVCRT: __p__pwctype\n"));
868 return (USHORT*)&MSVCRT__pwctype;
869}
870
871
872/*********************************************************************
873 * __p__timezone (MSVCRT.120)
874 */
875int * CDECL MSVCRT___p__timezone()
876{
877 dprintf(("MSVCRT: __p__timezone\n"));
878 return (int*)&MSVCRT__timezone;
879}
880
881
882/*********************************************************************
883 * __p__tzname (MSVCRT.121)
884 */
885char ** CDECL MSVCRT___p__tzname()
886{
887 dprintf(("MSVCRT: __p__tzname\n"));
888 return (char**)&MSVCRT__tzname;
889}
890
891
892/*********************************************************************
893 * __p__winmajor (MSVCRT.124)
894 */
895int * CDECL MSVCRT___p__winmajor()
896{
897 dprintf(("MSVCRT: __p__winmajor\n"));
898 return (int*)&MSVCRT__winmajor;
899}
900
901
902/*********************************************************************
903 * __p__winminor (MSVCRT.125)
904 */
905int * CDECL MSVCRT___p__winminor()
906{
907 dprintf(("MSVCRT: __p__winminor\n"));
908 return (int*)&MSVCRT__winminor;
909}
910
911
912/*********************************************************************
913 * __p__winver (MSVCRT.126)
914 */
915int * CDECL MSVCRT___p__winver()
916{
917 dprintf(("MSVCRT: __p__winver\n"));
918 return (int*)&MSVCRT__winver;
919}
920
921
922/*********************************************************************
923 * __set_app_type (MSVCRT.130)
924 */
925int CDECL MSVCRT___set_app_type(int app_type)
926{
927 dprintf(("MSVCRT: __set_app_type\n"));
928 return __app_type = app_type;
929}
930
931
932/*********************************************************************
933 * __setusermatherr (MSVCRT.132)
934 */
935int CDECL MSVCRT___setusermatherr(int matherr)
936{
937 dprintf(("MSVCRT: __setusermatherr\n"));
938 return __usermatherr = matherr;
939}
940
941
942/*********************************************************************
943 * _adjust_fdiv (MSVCRT.158)
944 * FIXME - Could not find anything about it
945 */
946INT CDECL MSVCRT__adjust_fdiv(DWORD ret)
947{
948 dprintf(("MSVCRT: _adjust_fdiv not implemented.\n"));
949 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
950 return FALSE;
951}
952
953
954/*********************************************************************
955 * _aexit_rtn (MSVCRT.159)
956 */
957VOID CDECL MSVCRT__aexit_rtn(int exitcode)
958{
959 dprintf(("MSVCRT: _aexit_rtn\n"));
960 ExitProcess(exitcode);
961}
962
963
964/*********************************************************************
965 * _atoi64 (MSVCRT.163)
966 */
967__int64 CDECL MSVCRT__atoi64(const char *s)
968{
969 dprintf(("MSVCRT: _atoi64 not implemented.\n"));
970 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
971 return FALSE;
972}
973
974
975/*********************************************************************
976 * _beginthreadex (MSVCRT.167)
977 */
978unsigned long CDECL MSVCRT__beginthreadex( void *security, unsigned stack_size,
979 unsigned ( __stdcall *start_address )( void * ), void *arglist,
980 unsigned initflag, unsigned *thrdaddr )
981{
982 dprintf(("MSVCRT: _beginthreadex not implemented.\n"));
983 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
984 return FALSE;
985}
986
987
988/*********************************************************************
989 * _endthreadex (MSVCRT.198)
990 */
991void CDECL MSVCRT__endthreadex(unsigned retval)
992{
993 dprintf(("MSVCRT: _endthreadex not implemented.\n"));
994 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
995}
996
997
998/*********************************************************************
999 * _except_handler3 (MSVCRT.203)
1000 */
1001INT CDECL MSVCRT__except_handler3 ( PEXCEPTION_RECORD rec,
1002 PEXCEPTION_FRAME frame, PCONTEXT context,
1003 PEXCEPTION_FRAME *dispatcher)
1004{
1005 dprintf(("MSVCRT: _except_handler3\n"));
1006 return 1;
1007}
1008
1009
1010/*********************************************************************
1011 * _filelengthi64 (MSVCRT.222)
1012 */
1013__int64 CDECL MSVCRT__filelengthi64(int handle)
1014{
1015 dprintf(("MSVCRT: _filelengthi64 not implemented.\n"));
1016 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1017 return FALSE;
1018}
1019
1020
1021/*********************************************************************
1022 * _findfirsti64 (MSVCRT.226)
1023 */
1024__int64 CDECL MSVCRT__findfirsti64( char *filespec, struct _finddata_t *fileinfo)
1025{
1026 dprintf(("MSVCRT: _findfirsti64 not implemented.\n"));
1027 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1028 return FALSE;
1029}
1030
1031
1032/*********************************************************************
1033 * _findnexti64 (MSVCRT.228)
1034 */
1035__int64 CDECL MSVCRT__findnexti64(long handle, struct _finddata_t *fileinfo)
1036{
1037 dprintf(("MSVCRT: _findnexti64 not implemented.\n"));
1038 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1039 return FALSE;
1040}
1041
1042
1043/*********************************************************************
1044 * _fstati64 (MSVCRT.240)
1045 */
1046__int64 CDECL MSVCRT__fstati64(int handle)
1047{
1048 dprintf(("MSVCRT: _fstati64 not implemented.\n"));
1049 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1050 return FALSE;
1051}
1052
1053
1054/*********************************************************************
1055 * _get_sbh_threshold (MSVCRT.247)
1056 */
1057size_t CDECL MSVCRT__get_sbh_threshold( void )
1058{
1059 dprintf(("MSVCRT: _get_sbh_threshold not implemented.\n"));
1060 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1061 return FALSE;
1062}
1063
1064
1065/*********************************************************************
1066 * _getmaxstdio (MSVCRT.256)
1067 */
1068int CDECL MSVCRT__getmaxstdio( void )
1069{
1070 dprintf(("MSVCRT: _getmaxstdio not implemented.\n"));
1071 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1072 return FALSE;
1073}
1074
1075
1076/*********************************************************************
1077 * _getmbcp (MSVCRT.257)
1078 */
1079int CDECL MSVCRT__getmbcp( void )
1080{
1081 dprintf(("MSVCRT: _getmbcp not implemented.\n"));
1082 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1083 return FALSE;
1084}
1085
1086
1087/*********************************************************************
1088 * _getws (MSVCRT.261)
1089 */
1090wchar_t * CDECL MSVCRT__getws( wchar_t *s )
1091{
1092 dprintf(("MSVCRT: _getws not implemented.\n"));
1093 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1094 return FALSE;
1095}
1096
1097
1098/*********************************************************************
1099 * _heapadd (MSVCRT.263)
1100 */
1101int CDECL MSVCRT__heapadd(void *v, size_t s)
1102{
1103 dprintf(("MSVCRT: _heapadd not implemented.\n"));
1104 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1105 return FALSE;
1106}
1107
1108
1109/*********************************************************************
1110 * _i64toa (MSVCRT.270)
1111 */
1112char * CDECL MSVCRT__i64toa(__int64 i1, char *s, int i2)
1113{
1114 dprintf(("MSVCRT: _i64toa not implemented.\n"));
1115 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1116 return FALSE;
1117}
1118
1119
1120/*********************************************************************
1121 * _i64tow (MSVCRT.271)
1122 */
1123wchar_t * CDECL MSVCRT__i64tow(__int64 i1, wchar_t *s, int i2)
1124{
1125 dprintf(("MSVCRT: _i64tow not implemented.\n"));
1126 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1127 return FALSE;
1128}
1129
1130
1131/*********************************************************************
1132 * _inp (MSVCRT.273)
1133 */
1134int CDECL MSVCRT__inp( unsigned short port )
1135{
1136 dprintf(("MSVCRT: _inp not implemented.\n"));
1137 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1138 return FALSE;
1139}
1140
1141
1142/*********************************************************************
1143 * _inpw (MSVCRT.274)
1144 */
1145unsigned short CDECL MSVCRT__inpw( unsigned short port )
1146{
1147 dprintf(("MSVCRT: _inpw not implemented.\n"));
1148 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1149 return FALSE;
1150}
1151
1152
1153/*********************************************************************
1154 * _inpd (MSVCRT.275)
1155 */
1156unsigned long CDECL MSVCRT__inpd( unsigned short port )
1157{
1158 dprintf(("MSVCRT: _inpd not implemented.\n"));
1159 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1160 return FALSE;
1161}
1162
1163
1164/*********************************************************************
1165 * _ismbbkprint (MSVCRT.284)
1166 */
1167int CDECL MSVCRT__ismbbkprint( unsigned int ch )
1168{
1169 dprintf(("MSVCRT: _ismbbkprint not implemented.\n"));
1170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1171 return FALSE;
1172}
1173
1174
1175/*********************************************************************
1176 * _ismbcalnum (MSVCRT.290)
1177 */
1178int CDECL MSVCRT__ismbcalnum( unsigned int ch )
1179{
1180 dprintf(("MSVCRT: _ismbcalnum not implemented.\n"));
1181 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1182 return FALSE;
1183}
1184
1185
1186/*********************************************************************
1187 * _ismbcgraph (MSVCRT.293)
1188 */
1189int CDECL MSVCRT__ismbcgraph( unsigned int ch )
1190{
1191 dprintf(("MSVCRT: _ismbcgraph not implemented.\n"));
1192 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1193 return FALSE;
1194}
1195
1196
1197/*********************************************************************
1198 * _ismbcpunct (MSVCRT.302)
1199 */
1200int CDECL MSVCRT__ismbcpunct( unsigned int ch )
1201{
1202 dprintf(("MSVCRT: _ismbcpunct not implemented.\n"));
1203 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1204 return FALSE;
1205}
1206
1207
1208/*********************************************************************
1209 * _itow (MSVCRT.310)
1210 */
1211wchar_t * CDECL MSVCRT__itow( int value, wchar_t *string, int radix )
1212{
1213 dprintf(("MSVCRT: _itow not implemented.\n"));
1214 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1215 return FALSE;
1216}
1217
1218
1219/*********************************************************************
1220 * _lseeki64 (MSVCRT.326)
1221 */
1222__int64 CDECL MSVCRT__lseeki64( int handle, __int64 offset, int origin )
1223{
1224 dprintf(("MSVCRT: _lseeki64 not implemented.\n"));
1225 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1226 return FALSE;
1227}
1228
1229
1230/*********************************************************************
1231 * _ltow (MSVCRT.328)
1232 */
1233wchar_t * CDECL MSVCRT__ltow( long value, wchar_t *string, int radix )
1234{
1235 dprintf(("MSVCRT: _ltow not implemented.\n"));
1236 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1237 return FALSE;
1238}
1239
1240
1241/*********************************************************************
1242 * _outp (MSVCRT.395)
1243 */
1244int CDECL MSVCRT__outp( unsigned short port, int databyte )
1245{
1246 dprintf(("MSVCRT: _outp not implemented.\n"));
1247 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1248 return FALSE;
1249}
1250
1251
1252/*********************************************************************
1253 * _outpw (MSVCRT.396)
1254 */
1255unsigned short CDECL MSVCRT__outpw( unsigned short port, unsigned short dataword )
1256{
1257 dprintf(("MSVCRT: _outpw not implemented.\n"));
1258 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1259 return FALSE;
1260}
1261
1262
1263/*********************************************************************
1264 * _outpd (MSVCRT.397)
1265 */
1266unsigned long CDECL MSVCRT__outpd( unsigned short port, unsigned long dataword )
1267{
1268 dprintf(("MSVCRT: _outpd not implemented.\n"));
1269 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1270 return FALSE;
1271}
1272
1273
1274/*********************************************************************
1275 * _putws (MSVCRT.407)
1276 */
1277int CDECL MSVCRT__putws( const wchar_t *s )
1278{
1279 dprintf(("MSVCRT: _putws not implemented.\n"));
1280 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1281 return FALSE;
1282}
1283
1284
1285/*********************************************************************
1286 * _set_error_mode (MSVCRT.421)
1287 */
1288int CDECL MSVCRT__set_error_mode( int modeval )
1289{
1290 dprintf(("MSVCRT: _set_error_mode not implemented.\n"));
1291 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1292 return FALSE;
1293}
1294
1295
1296/*********************************************************************
1297 * _set_sbh_threshold (MSVCRT.422)
1298 */
1299int CDECL MSVCRT__set_sbh_threshold( size_t size )
1300{
1301 dprintf(("MSVCRT: _set_sbh_threshold not implemented.\n"));
1302 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1303 return FALSE;
1304}
1305
1306
1307/*********************************************************************
1308 * _setmaxstdio (MSVCRT.426)
1309 */
1310int CDECL MSVCRT__setmaxstdio(int i)
1311{
1312 dprintf(("MSVCRT: _setmaxstdio not implemented.\n"));
1313 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1314 return FALSE;
1315}
1316
1317
1318/*********************************************************************
1319 * _setmbcp (MSVCRT.427)
1320 */
1321int CDECL MSVCRT__setmbcp( int codepage )
1322{
1323 dprintf(("MSVCRT: _setmbcp not implemented.\n"));
1324 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1325 return FALSE;
1326}
1327
1328
1329/*********************************************************************
1330 * _stati64 (MSVCRT.444)
1331 */
1332__int64 CDECL MSVCRT__stati64( const char *path, struct _stat *buffer )
1333{
1334 dprintf(("MSVCRT: _stati64 not implemented.\n"));
1335 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1336 return FALSE;
1337}
1338
1339
1340/*********************************************************************
1341 * _strncoll (MSVCRT.453)
1342 */
1343int CDECL MSVCRT__strncoll( const char *s1, const char *s2, size_t n )
1344{
1345 dprintf(("MSVCRT: _strncoll not implemented.\n"));
1346 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1347 return FALSE;
1348}
1349
1350
1351/*********************************************************************
1352 * _strnicoll (MSVCRT.455)
1353 */
1354int CDECL MSVCRT__strnicoll( const char *s1, const char *s2, size_t n )
1355{
1356 dprintf(("MSVCRT: _strnicoll not implemented.\n"));
1357 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1358 return FALSE;
1359}
1360
1361
1362/*********************************************************************
1363 * _telli64 (MSVCRT.465)
1364 */
1365__int64 CDECL MSVCRT__telli64( int handle )
1366{
1367 dprintf(("MSVCRT: _telli64 not implemented.\n"));
1368 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1369 return FALSE;
1370}
1371
1372
1373/*********************************************************************
1374 * _ui64toa (MSVCRT.472)
1375 */
1376/*
1377char * CDECL MSVCRT__ui64toa(unsigned __int64 value, char *s, int i)
1378{
1379 dprintf(("MSVCRT: _ui64toa not implemented.\n"));
1380 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1381 return FALSE;
1382}
1383*/
1384
1385/*********************************************************************
1386 * _ui64tow (MSVCRT.473)
1387 */
1388/*
1389wchar_t * CDECL MSVCRT__ui64tow(unsigned __int64 value, wchar_t *s, int i)
1390{
1391 dprintf(("MSVCRT: _ui64tow not implemented.\n"));
1392 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1393 return FALSE;
1394}
1395*/
1396
1397/*********************************************************************
1398 * _ultow (MSVCRT.475)
1399 */
1400wchar_t * CDECL MSVCRT__ultow( unsigned long value, wchar_t *string, int radix )
1401{
1402 dprintf(("MSVCRT: _ultow not implemented.\n"));
1403 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1404 return FALSE;
1405}
1406
1407
1408/*********************************************************************
1409 * _umask (MSVCRT.476)
1410 */
1411int CDECL MSVCRT__umask( int pmode )
1412{
1413 dprintf(("MSVCRT: _umask not implemented.\n"));
1414 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1415 return FALSE;
1416}
1417
1418
1419/*********************************************************************
1420 * _waccess (MSVCRT.484)
1421 */
1422int CDECL MSVCRT__waccess( const wchar_t *path, int mode )
1423{
1424 dprintf(("MSVCRT: _waccess not implemented.\n"));
1425 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1426 return FALSE;
1427}
1428
1429
1430/*********************************************************************
1431 * _wasctime (MSVCRT.485)
1432 */
1433wchar_t * CDECL MSVCRT__wasctime( const struct tm *timeptr )
1434{
1435 dprintf(("MSVCRT: _wasctime not implemented.\n"));
1436 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1437 return FALSE;
1438}
1439
1440
1441/*********************************************************************
1442 * _wchdir (MSVCRT.486)
1443 */
1444int CDECL MSVCRT__wchdir( const wchar_t *dirname )
1445{
1446 dprintf(("MSVCRT: _wchdir not implemented.\n"));
1447 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1448 return FALSE;
1449}
1450
1451
1452/*********************************************************************
1453 * _wchmod (MSVCRT.487)
1454 */
1455int CDECL MSVCRT__wchmod( const wchar_t *filename, int pmode )
1456{
1457 dprintf(("MSVCRT: _wchmod not implemented.\n"));
1458 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1459 return FALSE;
1460}
1461
1462
1463/*********************************************************************
1464 * _wcreat (MSVCRT.489)
1465 */
1466int CDECL MSVCRT__wcreat( const wchar_t *filename, int pmode )
1467{
1468 dprintf(("MSVCRT: _wcreat not implemented.\n"));
1469 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1470 return FALSE;
1471}
1472
1473
1474/*********************************************************************
1475 * _wcsncoll (MSVCRT.494)
1476 */
1477int CDECL MSVCRT__wcsncoll( const wchar_t *string1, const wchar_t *string2, size_t count )
1478{
1479 dprintf(("MSVCRT: _wcsncoll not implemented.\n"));
1480 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1481 return FALSE;
1482}
1483
1484
1485/*********************************************************************
1486 * _wcsnicoll (MSVCRT.496)
1487 */
1488int CDECL MSVCRT__wcsnicoll( const wchar_t *string1, const wchar_t *string2 , size_t count )
1489{
1490 dprintf(("MSVCRT: _wcsnicoll not implemented.\n"));
1491 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1492 return FALSE;
1493}
1494
1495
1496/*********************************************************************
1497 * _wctime (MSVCRT.501)
1498 */
1499wchar_t * CDECL MSVCRT__wctime( const time_t *timer )
1500{
1501 dprintf(("MSVCRT: _wctime not implemented.\n"));
1502 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1503 return FALSE;
1504}
1505
1506
1507/*********************************************************************
1508 * _wexecl (MSVCRT.503)
1509 */
1510int CDECL MSVCRT__wexecl( const wchar_t *path, const wchar_t *arg0, ... )
1511{
1512 dprintf(("MSVCRT: _wexecl not implemented.\n"));
1513 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1514 return FALSE;
1515}
1516
1517
1518/*********************************************************************
1519 * _wexecle (MSVCRT.504)
1520 */
1521int CDECL MSVCRT__wexecle( const wchar_t *path, const wchar_t *arg0, ... )
1522{
1523 dprintf(("MSVCRT: _wexecle not implemented.\n"));
1524 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1525 return FALSE;
1526}
1527
1528
1529/*********************************************************************
1530 * _wexeclp (MSVCRT.505)
1531 */
1532int CDECL MSVCRT__wexeclp( const wchar_t *file, const wchar_t *arg0, ... )
1533{
1534 dprintf(("MSVCRT: _wexeclp not implemented.\n"));
1535 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1536 return FALSE;
1537}
1538
1539
1540/*********************************************************************
1541 * _wexeclpe (MSVCRT.506)
1542 */
1543int CDECL MSVCRT__wexeclpe( const wchar_t *file, const wchar_t *arg0, ... )
1544{
1545 dprintf(("MSVCRT: _wexeclpe not implemented.\n"));
1546 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1547 return FALSE;
1548}
1549
1550
1551/*********************************************************************
1552 * _wexecv (MSVCRT.507)
1553 */
1554int CDECL MSVCRT__wexecv( const wchar_t *path, const wchar_t *const argv[] )
1555{
1556 dprintf(("MSVCRT: _wexecv not implemented.\n"));
1557 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1558 return FALSE;
1559}
1560
1561
1562/*********************************************************************
1563 * _wexecve (MSVCRT.508)
1564 */
1565int CDECL MSVCRT__wexecve( const wchar_t *path, const wchar_t *const argv[],
1566 const wchar_t *const envp[] )
1567{
1568 dprintf(("MSVCRT: _wexecve not implemented.\n"));
1569 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1570 return FALSE;
1571}
1572
1573
1574/*********************************************************************
1575 * _wexecvp (MSVCRT.509)
1576 */
1577int CDECL MSVCRT__wexecvp( const wchar_t *file, const wchar_t *const argv[] )
1578{
1579 dprintf(("MSVCRT: _wexecvp not implemented.\n"));
1580 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1581 return FALSE;
1582}
1583
1584
1585/*********************************************************************
1586 * _wexecvpe (MSVCRT.510)
1587 */
1588int CDECL MSVCRT__wexecvpe( const wchar_t *file, const wchar_t *const argv[],
1589 const wchar_t *const envp[] )
1590{
1591 dprintf(("MSVCRT: _wexecvpe not implemented.\n"));
1592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1593 return FALSE;
1594}
1595
1596
1597/*********************************************************************
1598 * _wfdopen (MSVCRT.511)
1599 */
1600FILE * CDECL MSVCRT__wfdopen( int, const wchar_t *s )
1601{
1602 dprintf(("MSVCRT: _wfdopen not implemented.\n"));
1603 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1604 return FALSE;
1605}
1606
1607
1608/*********************************************************************
1609 * _wfindfirst (MSVCRT.512)
1610 */
1611long CDECL MSVCRT__wfindfirst( const wchar_t *filespec, struct _wfinddata_t *fileinfo )
1612{
1613 dprintf(("MSVCRT: _wfindfirst not implemented.\n"));
1614 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1615 return FALSE;
1616}
1617
1618
1619/*********************************************************************
1620 * _wfindfirsti64 (MSVCRT.513)
1621 */
1622__int64 CDECL MSVCRT__wfindfirsti64( wchar_t *filespec, struct _wfinddata_t *fileinfo )
1623{
1624 dprintf(("MSVCRT: _wfindfirsti64 not implemented.\n"));
1625 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1626 return FALSE;
1627}
1628
1629
1630/*********************************************************************
1631 * _wfindnext (MSVCRT.514)
1632 */
1633int CDECL MSVCRT__wfindnext( long handle, struct _wfinddata_t *fileinfo )
1634{
1635 dprintf(("MSVCRT: _wfindnext not implemented.\n"));
1636 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1637 return FALSE;
1638}
1639
1640
1641/*********************************************************************
1642 * _wfindnexti64 (MSVCRT.515)
1643 */
1644/*
1645int CDECL MSVCRT__wfindnexti64(intptr_t x, struct _wfinddatai64_t *s)
1646{
1647 dprintf(("MSVCRT: _wfindnexti64 not implemented.\n"));
1648 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1649 return FALSE;
1650}
1651*/
1652
1653
1654/*********************************************************************
1655 * _wfopen (MSVCRT.516)
1656 */
1657FILE * CDECL MSVCRT__wfopen( const wchar_t *s1, const wchar_t *s2 )
1658{
1659 dprintf(("MSVCRT: _wfopen not implemented.\n"));
1660 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1661 return FALSE;
1662}
1663
1664
1665/*********************************************************************
1666 * _wfreopen (MSVCRT.517)
1667 */
1668FILE * CDECL MSVCRT__wfreopen( const wchar_t *s1, const wchar_t *s2, FILE * f)
1669{
1670 dprintf(("MSVCRT: _wfreopen not implemented.\n"));
1671 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1672 return FALSE;
1673}
1674
1675
1676/*********************************************************************
1677 * _wfsopen (MSVCRT.518)
1678 */
1679FILE * CDECL MSVCRT__wfsopen( const wchar_t *filename, const wchar_t *mode, int shflag )
1680{
1681 dprintf(("MSVCRT: _wfsopen not implemented.\n"));
1682 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1683 return FALSE;
1684}
1685
1686
1687/*********************************************************************
1688 * _wfullpath (MSVCRT.519)
1689 */
1690wchar_t * CDECL MSVCRT__wfullpath( wchar_t *s1, const wchar_t *s2, size_t n )
1691{
1692 dprintf(("MSVCRT: _wfullpath not implemented.\n"));
1693 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1694 return FALSE;
1695}
1696
1697
1698/*********************************************************************
1699 * _wgetcwd (MSVCRT.520)
1700 */
1701wchar_t * CDECL MSVCRT__wgetcwd( wchar_t *buf, size_t size )
1702{
1703 dprintf(("MSVCRT: _wgetcwd not implemented.\n"));
1704 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1705 return FALSE;
1706}
1707
1708
1709/*********************************************************************
1710 * _wgetdcwd (MSVCRT.521)
1711 */
1712wchar_t * CDECL MSVCRT__wgetdcwd( int drive, wchar_t *buffer, size_t maxlen )
1713{
1714 dprintf(("MSVCRT: _wgetdcwd not implemented.\n"));
1715 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1716 return FALSE;
1717}
1718
1719
1720/*********************************************************************
1721 * _wgetenv (MSVCRT.522)
1722 */
1723wchar_t * CDECL MSVCRT__wgetenv( const wchar_t *name )
1724{
1725 dprintf(("MSVCRT: _wgetenv not implemented.\n"));
1726 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727 return FALSE;
1728}
1729
1730
1731/*********************************************************************
1732 * _wmakepath (MSVCRT.526)
1733 */
1734void CDECL MSVCRT__wmakepath( wchar_t *path, const wchar_t *drive,
1735 const wchar_t *dir, const wchar_t *fname, const wchar_t *ext )
1736{
1737 dprintf(("MSVCRT: _wmakepath not implemented.\n"));
1738 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1739}
1740
1741
1742/*********************************************************************
1743 * _wmkdir (MSVCRT.527)
1744 */
1745int CDECL MSVCRT__wmkdir( const wchar_t *path )
1746{
1747 dprintf(("MSVCRT: _wmkdir not implemented.\n"));
1748 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1749 return FALSE;
1750}
1751
1752
1753/*********************************************************************
1754 * _wmktemp (MSVCRT.528)
1755 */
1756wchar_t * CDECL MSVCRT__wmktemp( wchar_t* )
1757{
1758 dprintf(("MSVCRT: _wmktemp not implemented.\n"));
1759 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1760 return FALSE;
1761}
1762
1763
1764/*********************************************************************
1765 * _wopen (MSVCRT.529)
1766 */
1767int CDECL MSVCRT__wopen( const wchar_t *s, int n, ... )
1768{
1769 dprintf(("MSVCRT: _wopen not implemented.\n"));
1770 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1771 return FALSE;
1772}
1773
1774
1775/*********************************************************************
1776 * _wperror (MSVCRT.530)
1777 */
1778void CDECL MSVCRT__wperror( const wchar_t *s )
1779{
1780 dprintf(("MSVCRT: _wperror not implemented.\n"));
1781 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1782}
1783
1784
1785/*********************************************************************
1786 * _wpopen (MSVCRT.532)
1787 */
1788FILE * CDECL MSVCRT__wpopen( const wchar_t *command, const wchar_t *mode )
1789{
1790 dprintf(("MSVCRT: _wpopen not implemented.\n"));
1791 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1792 return FALSE;
1793}
1794
1795
1796/*********************************************************************
1797 * _wputenv (MSVCRT.533)
1798 */
1799int CDECL MSVCRT__wputenv( const wchar_t *env_string )
1800{
1801 dprintf(("MSVCRT: _wputenv not implemented.\n"));
1802 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1803 return FALSE;
1804}
1805
1806
1807/*********************************************************************
1808 * _wremove (MSVCRT.534)
1809 */
1810int CDECL MSVCRT__wremove( const wchar_t *s )
1811{
1812 dprintf(("MSVCRT: _wremove not implemented.\n"));
1813 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1814 return FALSE;
1815}
1816
1817
1818/*********************************************************************
1819 * _wrename (MSVCRT.535)
1820 */
1821int CDECL MSVCRT__wrename( const wchar_t *s1, const wchar_t *s2 )
1822{
1823 dprintf(("MSVCRT: _wrename not implemented.\n"));
1824 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1825 return FALSE;
1826}
1827
1828
1829/*********************************************************************
1830 * _wrmdir (MSVCRT.537)
1831 */
1832int CDECL MSVCRT__wrmdir( const wchar_t *path )
1833{
1834 dprintf(("MSVCRT: _wrmdir not implemented.\n"));
1835 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1836 return FALSE;
1837}
1838
1839
1840/*********************************************************************
1841 * _wsearchenv (MSVCRT.538)
1842 */
1843void CDECL MSVCRT__wsearchenv( const wchar_t *name, const wchar_t *env_var, wchar_t *buf )
1844{
1845 dprintf(("MSVCRT: _wsearchenv not implemented.\n"));
1846 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1847}
1848
1849
1850/*********************************************************************
1851 * _wsetlocale (MSVCRT.539)
1852 */
1853wchar_t * CDECL MSVCRT__wsetlocale(int category,const wchar_t *locale)
1854{
1855 dprintf(("MSVCRT: _wsetlocale not implemented.\n"));
1856 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1857 return FALSE;
1858}
1859
1860
1861/*********************************************************************
1862 * _wsopen (MSVCRT.540)
1863 */
1864int CDECL MSVCRT__wsopen( const wchar_t *s, int n1, int n2, ... )
1865{
1866 dprintf(("MSVCRT: _wsopen not implemented.\n"));
1867 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1868 return FALSE;
1869}
1870
1871
1872/*********************************************************************
1873 * _wspawnl (MSVCRT.541)
1874 */
1875int CDECL MSVCRT__wspawnl( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1876{
1877 dprintf(("MSVCRT: _wspawnl not implemented.\n"));
1878 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1879 return FALSE;
1880}
1881
1882
1883/*********************************************************************
1884 * _wspawnle (MSVCRT.542)
1885 */
1886int CDECL MSVCRT__wspawnle( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1887{
1888 dprintf(("MSVCRT: _wspawnle not implemented.\n"));
1889 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1890 return FALSE;
1891}
1892
1893
1894/*********************************************************************
1895 * _wspawnlp (MSVCRT.543)
1896 */
1897int CDECL MSVCRT__wspawnlp( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1898{
1899 dprintf(("MSVCRT: _wspawnlp not implemented.\n"));
1900 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1901 return FALSE;
1902}
1903
1904
1905/*********************************************************************
1906 * _wspawnlpe (MSVCRT.544)
1907 */
1908int CDECL MSVCRT__wspawnlpe( int mode, const wchar_t *path, const wchar_t *arg0, ... )
1909{
1910 dprintf(("MSVCRT: _wspawnlpe not implemented.\n"));
1911 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1912 return FALSE;
1913}
1914
1915
1916/*********************************************************************
1917 * _wspawnv (MSVCRT.545)
1918 */
1919int CDECL MSVCRT__wspawnv( int mode, const wchar_t *path, const wchar_t * const *argv )
1920{
1921 dprintf(("MSVCRT: _wspawnv not implemented.\n"));
1922 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1923 return FALSE;
1924}
1925
1926
1927/*********************************************************************
1928 * _wspawnve (MSVCRT.546)
1929 */
1930int CDECL MSVCRT__wspawnve( int mode, const wchar_t *path,
1931 const wchar_t * const *argv, const wchar_t * const *envp )
1932{
1933 dprintf(("MSVCRT: _wspawnve not implemented.\n"));
1934 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1935 return FALSE;
1936}
1937
1938
1939/*********************************************************************
1940 * _wspawnvp (MSVCRT.547)
1941 */
1942int CDECL MSVCRT__wspawnvp( int mode, const wchar_t *path, const wchar_t * const *argv )
1943{
1944 dprintf(("MSVCRT: _wspawnvp not implemented.\n"));
1945 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1946 return FALSE;
1947}
1948
1949
1950/*********************************************************************
1951 * _wspawnvpe (MSVCRT.548)
1952 */
1953int CDECL MSVCRT__wspawnvpe( int mode, const wchar_t *path,
1954 const wchar_t * const *argv, const wchar_t * const *envp )
1955{
1956 dprintf(("MSVCRT: _wspawnvpe not implemented.\n"));
1957 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1958 return FALSE;
1959}
1960
1961
1962/*********************************************************************
1963 * _wsplitpath (MSVCRT.549)
1964 */
1965void CDECL MSVCRT__wsplitpath( const wchar_t *path, wchar_t *drive,
1966 wchar_t *dir, wchar_t *fname, wchar_t *ext )
1967{
1968 dprintf(("MSVCRT: _wsplitpath not implemented.\n"));
1969 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1970}
1971
1972
1973/*********************************************************************
1974 * _wstat (MSVCRT.550)
1975 */
1976int CDECL MSVCRT__wstat( const wchar_t *s, struct _wstat *w )
1977{
1978 dprintf(("MSVCRT: _wstat not implemented.\n"));
1979 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1980 return FALSE;
1981}
1982
1983
1984/*********************************************************************
1985 * _wstati64 (MSVCRT.551)
1986 */
1987int CDECL MSVCRT__wstati64(const wchar_t *s, struct _stati64 *w)
1988{
1989 dprintf(("MSVCRT: _wstati64 not implemented.\n"));
1990 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1991 return FALSE;
1992}
1993
1994
1995/*********************************************************************
1996 * _wstrdate (MSVCRT.552)
1997 */
1998wchar_t * CDECL MSVCRT__wstrdate( wchar_t *buf )
1999{
2000 dprintf(("MSVCRT: _wstrdate not implemented.\n"));
2001 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2002 return FALSE;
2003}
2004
2005
2006/*********************************************************************
2007 * _wstrtime (MSVCRT.553)
2008 */
2009wchar_t * CDECL MSVCRT__wstrtime( wchar_t *buf )
2010{
2011 dprintf(("MSVCRT: _wstrtime not implemented.\n"));
2012 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2013 return FALSE;
2014}
2015
2016
2017/*********************************************************************
2018 * _wsystem (MSVCRT.554)
2019 */
2020int CDECL MSVCRT__wsystem( const wchar_t *cmd )
2021{
2022 dprintf(("MSVCRT: _wsystem not implemented.\n"));
2023 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2024 return FALSE;
2025}
2026
2027
2028/*********************************************************************
2029 * _wtempnam (MSVCRT.555)
2030 */
2031wchar_t * CDECL MSVCRT__wtempnam( wchar_t *dir, wchar_t *prefix )
2032{
2033 dprintf(("MSVCRT: _wtempnam not implemented.\n"));
2034 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2035 return FALSE;
2036}
2037
2038
2039/*********************************************************************
2040 * _wtmpnam (MSVCRT.558)
2041 */
2042wchar_t * CDECL MSVCRT__wtmpnam( wchar_t *tn )
2043{
2044 dprintf(("MSVCRT: _wtmpnam not implemented.\n"));
2045 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2046 return FALSE;
2047}
2048
2049
2050/*********************************************************************
2051 * _wtoi64 (MSVCRT.556)
2052 */
2053__int64 CDECL MSVCRT__wtoi64(const wchar_t *wt)
2054{
2055 dprintf(("MSVCRT: _wtoi64 not implemented.\n"));
2056 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2057 return FALSE;
2058}
2059
2060
2061/*********************************************************************
2062 * _wunlink (MSVCRT.560)
2063 */
2064int CDECL MSVCRT__wunlink(const wchar_t *path)
2065{
2066 dprintf(("MSVCRT: _wunlink not implemented.\n"));
2067 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2068 return FALSE;
2069}
2070
2071
2072/*********************************************************************
2073 * _wutime (MSVCRT.561)
2074 */
2075int CDECL MSVCRT__wutime( const wchar_t *path, const struct utimbuf * times )
2076{
2077 dprintf(("MSVCRT: _wutime not implemented.\n"));
2078 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2079 return FALSE;
2080}
2081
2082
2083/*********************************************************************
2084 * fgetws (MSVCRT.597)
2085 */
2086wchar_t * CDECL MSVCRT_fgetws( wchar_t *s, int n, FILE *strm )
2087{
2088 dprintf(("MSVCRT: fgetws\n"));
2089 return (fgetws(s, n, strm));
2090}
2091
2092
2093/*********************************************************************
2094 * fputws (MSVCRT.605)
2095 */
2096int CDECL MSVCRT_fputws( const wchar_t *s, FILE *strm )
2097{
2098 dprintf(("MSVCRT: fputws\n"));
2099 return (fputws(s, strm));
2100}
2101
2102
2103/*********************************************************************
2104 * getwc (MSVCRT.621)
2105 */
2106wint_t CDECL MSVCRT_getwc( FILE * strm)
2107{
2108 dprintf(("MSVCRT: getwc\n"));
2109 return (getwc(strm));
2110}
2111
2112
2113/*********************************************************************
2114 * getwchar (MSVCRT.622)
2115 */
2116wint_t CDECL MSVCRT_getwchar( void )
2117{
2118 dprintf(("MSVCRT: getwchar\n"));
2119 return (getwchar());
2120}
2121
2122
2123/*********************************************************************
2124 * putwc (MSVCRT.675)
2125 */
2126wint_t CDECL MSVCRT_putwc( wint_t t, FILE * strm)
2127{
2128 dprintf(("MSVCRT: putwc not implemented.\n"));
2129 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2130 return FALSE;
2131}
2132
2133
2134/*********************************************************************
2135 * putwchar (MSVCRT.676)
2136 */
2137wint_t CDECL MSVCRT_putwchar( wint_t t)
2138{
2139 dprintf(("MSVCRT: putwchar not implemented.\n"));
2140 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2141 return FALSE;
2142}
2143
2144/**************************************************************************/
2145/* MSVCRT20 & MSVCRT40 only functions */
2146/**************************************************************************/
2147
2148
2149/*********************************************************************
2150 * _matherr (MSVCRT20.677)
2151 */
2152int CDECL MSVCRT__matherr( struct exception *except )
2153{
2154 dprintf(("MSVCRT20: _matherr\n"));
2155 return _matherr(except);
2156}
Note: See TracBrowser for help on using the repository browser.