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

Last change on this file since 4102 was 4069, checked in by phaller, 25 years ago

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