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

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

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