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

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

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