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

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

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