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

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

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