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

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

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