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

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

Update by Jens Weissner
File size: 30.3 KB
Line 
1/* $Id: msvcrt.cpp,v 1.4 1999-10-28 15:25:35 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 <wchar.h>
14#include <except.h>
15#include "debugtools.h"
16#include <debugdefs.h>
17
18
19DEFAULT_DEBUG_CHANNEL(msvcrt)
20
21int __app_type;
22int __usermatherr;
23
24typedef struct
25{
26 HANDLE handle;
27 int pad[7];
28} CRTDLL_FILE, *PCRTDLL_FILE;
29
30extern LPSTR _acmdln_dll;
31extern UINT _commode_dll;
32extern UINT _fmode_dll;
33extern INT __mb_cur_max_dll;
34extern USHORT _pctype_dll;
35extern CRTDLL_FILE _iob;
36
37
38
39
40/*********************************************************************
41 * ??1type_info@@UAE@XZ (MSVCRT.14)
42 * FIXME - Could not find anything about it
43 */
44INT CDECL MSVCRT_EXP14(DWORD ret)
45{
46 dprintf(("MSVCRT: ??1type_info@@UAE@XZ not implemented.\n"));
47 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
48 return FALSE;
49}
50
51
52/*********************************************************************
53 * ??2@YAPAXI@Z (MSVCRT.15)
54 * FIXME - Could not find anything about it
55 */
56INT CDECL MSVCRT_EXP15(DWORD ret)
57{
58 dprintf(("MSVCRT: ??2@YAPAXI@Z not implemented.\n"));
59 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
60 return FALSE;
61}
62
63
64/*********************************************************************
65 * ??3@YAXPAX@Z (MSVCRT.16)
66 * FIXME - Could not find anything about it
67 */
68INT CDECL MSVCRT_EXP16(DWORD ret)
69{
70 dprintf(("MSVCRT: ??3@YAXPAX@Z not implemented.\n"));
71 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
72 return FALSE;
73}
74
75
76/*********************************************************************
77 * _CxxThrowException (MSVCRT.66)
78 * FIXME - Could not find anything about it
79 */
80INT CDECL MSVCRT__CxxThrowException(DWORD ret)
81{
82 dprintf(("MSVCRT: _CxxThrowException not implemented.\n"));
83 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
84 return FALSE;
85}
86
87
88/*********************************************************************
89 * _EH_prolog (MSVCRT.67)
90 * FIXME - Could not find anything about it
91 */
92INT CDECL MSVCRT__EH_prolog(DWORD ret)
93{
94 dprintf(("MSVCRT: _EH_prolog not implemented.\n"));
95 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
96 return FALSE;
97}
98
99
100/*********************************************************************
101 * __CxxFrameHandler (MSVCRT.74)
102 * FIXME - Could not find anything about it
103 */
104INT CDECL MSVCRT___CxxFrameHandler(DWORD ret)
105{
106 dprintf(("MSVCRT: __CxxFrameHandler not implemented.\n"));
107 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
108 return FALSE;
109}
110
111
112/*********************************************************************
113 * __p__initenv (MSVCRT.101)
114 */
115char ** CDECL MSVCRT___p__initenv()
116{
117 dprintf(("MSVCRT: __p__initenv not implemented\n"));
118 return &_acmdln_dll;
119}
120
121
122/*********************************************************************
123 * __p___mb_cur_max (MSVCRT.102)
124 */
125int * CDECL MSVCRT___p___mb_cur_max()
126{
127 dprintf(("MSVCRT: __p___mb_cur_max\n"));
128 return &__mb_cur_max_dll;
129}
130
131
132/*********************************************************************
133 * __p__acmdln (MSVCRT.105)
134 */
135char ** CDECL MSVCRT___p__acmdln()
136{
137 dprintf(("MSVCRT: __p__acmdln\n"));
138 return &_acmdln_dll;
139}
140
141/*********************************************************************
142 * __p__fmode (MSVCRT.107)
143 */
144int * CDECL MSVCRT___p__fmode()
145{
146 dprintf(("MSVCRT: __p__fmode\n"));
147 return (int*)&_fmode_dll;
148}
149
150
151/*********************************************************************
152 * __p__commode (MSVCRT.112)
153 */
154int * CDECL MSVCRT___p__commode()
155{
156 dprintf(("MSVCRT: __p__commode\n"));
157 return (int*)&_commode_dll;
158}
159
160
161/*********************************************************************
162 * __p__iob (MSVCRT.113)
163 */
164CRTDLL_FILE * CDECL MSVCRT___p__iob()
165{
166 dprintf(("MSVCRT: __p__iob\n"));
167 return &_iob;
168}
169
170
171/*********************************************************************
172 * __p__pctype (MSVCRT.117)
173 */
174USHORT * CDECL MSVCRT___p__pctype()
175{
176 dprintf(("MSVCRT: __p__pctype\n"));
177 return &_pctype_dll;
178}
179
180
181/*********************************************************************
182 * __set_app_type (MSVCRT.130)
183 */
184int CDECL MSVCRT___set_app_type(int app_type)
185{
186 dprintf(("MSVCRT: __set_app_type\n"));
187 return __app_type = app_type;
188}
189
190
191/*********************************************************************
192 * __setusermatherr (MSVCRT.132)
193 */
194int CDECL MSVCRT___setusermatherr(int matherr)
195{
196 dprintf(("MSVCRT: __setusermatherr\n"));
197 return __usermatherr = matherr;
198}
199
200
201/*********************************************************************
202 * _adjust_fdiv (MSVCRT.158)
203 * FIXME - Could not find anything about it
204 */
205INT CDECL MSVCRT__adjust_fdiv(DWORD ret)
206{
207 dprintf(("MSVCRT: _adjust_fdiv not implemented.\n"));
208 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
209 return FALSE;
210}
211
212
213/*********************************************************************
214 * _except_handler3 (MSVCRT.203)
215 */
216INT CDECL MSVCRT__except_handler3 ( PEXCEPTION_RECORD rec,
217 PEXCEPTION_FRAME frame, PCONTEXT context,
218 PEXCEPTION_FRAME *dispatcher)
219{
220 dprintf(("MSVCRT: _except_handler3\n"));
221 return 1;
222}
223
224
225/*********************************************************************
226 * _get_sbh_threshold (MSVCRT.247)
227 */
228size_t CDECL MSVCRT__get_sbh_threshold( void )
229{
230 dprintf(("MSVCRT: _get_sbh_threshold not implemented.\n"));
231 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
232 return FALSE;
233}
234
235
236/*********************************************************************
237 * _getmbcp (MSVCRT.257)
238 */
239int CDECL MSVCRT__getmbcp( void )
240{
241 dprintf(("MSVCRT: _getmbcp not implemented.\n"));
242 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
243 return FALSE;
244}
245
246
247/*********************************************************************
248 * _getws (MSVCRT.261)
249 */
250wchar_t * CDECL MSVCRT__getws( wchar_t *s )
251{
252 dprintf(("MSVCRT: _getws not implemented.\n"));
253 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
254 return FALSE;
255}
256
257
258/*********************************************************************
259 * _inp (MSVCRT.273)
260 */
261int CDECL MSVCRT__inp( unsigned short port )
262{
263 dprintf(("MSVCRT: _inp not implemented.\n"));
264 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
265 return FALSE;
266}
267
268
269/*********************************************************************
270 * _inpw (MSVCRT.274)
271 */
272unsigned short CDECL MSVCRT__inpw( unsigned short port )
273{
274 dprintf(("MSVCRT: _inpw not implemented.\n"));
275 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
276 return FALSE;
277}
278
279
280/*********************************************************************
281 * _inpd (MSVCRT.275)
282 */
283unsigned long CDECL MSVCRT__inpd( unsigned short port )
284{
285 dprintf(("MSVCRT: _inpd not implemented.\n"));
286 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
287 return FALSE;
288}
289
290
291/*********************************************************************
292 * _ismbbkprint (MSVCRT.284)
293 */
294int CDECL MSVCRT__ismbbkprint( unsigned int ch )
295{
296 dprintf(("MSVCRT: _ismbbkprint not implemented.\n"));
297 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
298 return FALSE;
299}
300
301
302/*********************************************************************
303 * _ismbcalnum (MSVCRT.290)
304 */
305int CDECL MSVCRT__ismbcalnum( unsigned int ch )
306{
307 dprintf(("MSVCRT: _ismbcalnum not implemented.\n"));
308 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
309 return FALSE;
310}
311
312
313/*********************************************************************
314 * _ismbcgraph (MSVCRT.293)
315 */
316int CDECL MSVCRT__ismbcgraph( unsigned int ch )
317{
318 dprintf(("MSVCRT: _ismbcgraph not implemented.\n"));
319 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
320 return FALSE;
321}
322
323
324/*********************************************************************
325 * _ismbcpunct (MSVCRT.302)
326 */
327int CDECL MSVCRT__ismbcpunct( unsigned int ch )
328{
329 dprintf(("MSVCRT: _ismbcpunct not implemented.\n"));
330 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
331 return FALSE;
332}
333
334
335/*********************************************************************
336 * _itow (MSVCRT.310)
337 */
338wchar_t * CDECL MSVCRT__itow( int value, wchar_t *string, int radix )
339{
340 dprintf(("MSVCRT: _itow not implemented.\n"));
341 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
342 return FALSE;
343}
344
345
346/*********************************************************************
347 * _ltow (MSVCRT.328)
348 */
349wchar_t * CDECL MSVCRT__ltow( long value, wchar_t *string, int radix )
350{
351 dprintf(("MSVCRT: _ltow not implemented.\n"));
352 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
353 return FALSE;
354}
355
356
357/*********************************************************************
358 * _outp (MSVCRT.395)
359 */
360int CDECL MSVCRT__outp( unsigned short port, int databyte )
361{
362 dprintf(("MSVCRT: _outp not implemented.\n"));
363 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
364 return FALSE;
365}
366
367
368/*********************************************************************
369 * _outpw (MSVCRT.396)
370 */
371unsigned short CDECL MSVCRT__outpw( unsigned short port, unsigned short dataword )
372{
373 dprintf(("MSVCRT: _outpw not implemented.\n"));
374 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
375 return FALSE;
376}
377
378
379/*********************************************************************
380 * _outpd (MSVCRT.397)
381 */
382unsigned long CDECL MSVCRT__outpd( unsigned short port, unsigned long dataword )
383{
384 dprintf(("MSVCRT: _outpd not implemented.\n"));
385 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
386 return FALSE;
387}
388
389
390/*********************************************************************
391 * _putws (MSVCRT.407)
392 */
393int CDECL MSVCRT__putws( const wchar_t *s )
394{
395 dprintf(("MSVCRT: _putws not implemented.\n"));
396 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
397 return FALSE;
398}
399
400
401/*********************************************************************
402 * _set_error_mode (MSVCRT.421)
403 */
404int CDECL MSVCRT__set_error_mode( int modeval )
405{
406 dprintf(("MSVCRT: _set_error_mode not implemented.\n"));
407 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
408 return FALSE;
409}
410
411
412/*********************************************************************
413 * _set_sbh_threshold (MSVCRT.422)
414 */
415int CDECL MSVCRT__set_sbh_threshold( size_t size )
416{
417 dprintf(("MSVCRT: _set_sbh_threshold not implemented.\n"));
418 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
419 return FALSE;
420}
421
422
423/*********************************************************************
424 * _strncoll (MSVCRT.453)
425 */
426int CDECL MSVCRT__strncoll( const char *s1, const char *s2, size_t n )
427{
428 dprintf(("MSVCRT: _strncoll not implemented.\n"));
429 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
430 return FALSE;
431}
432
433
434/*********************************************************************
435 * _strnicoll (MSVCRT.455)
436 */
437int CDECL MSVCRT__strnicoll( const char *s1, const char *s2, size_t n )
438{
439 dprintf(("MSVCRT: _strnicoll not implemented.\n"));
440 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
441 return FALSE;
442}
443
444
445/*********************************************************************
446 * _ultow (MSVCRT.475)
447 */
448wchar_t * CDECL MSVCRT__ultow( unsigned long value, wchar_t *string, int radix )
449{
450 dprintf(("MSVCRT: _ultow not implemented.\n"));
451 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
452 return FALSE;
453}
454
455
456/*********************************************************************
457 * _umask (MSVCRT.476)
458 */
459int CDECL MSVCRT__umask( int pmode )
460{
461 dprintf(("MSVCRT: _umask not implemented.\n"));
462 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
463 return FALSE;
464}
465
466
467/*********************************************************************
468 * _waccess (MSVCRT.484)
469 */
470int CDECL MSVCRT__waccess( const wchar_t *path, int mode )
471{
472 dprintf(("MSVCRT: _waccess not implemented.\n"));
473 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
474 return FALSE;
475}
476
477
478/*********************************************************************
479 * _wasctime (MSVCRT.485)
480 */
481wchar_t * CDECL MSVCRT__wasctime( const struct tm *timeptr )
482{
483 dprintf(("MSVCRT: _wasctime not implemented.\n"));
484 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
485 return FALSE;
486}
487
488
489/*********************************************************************
490 * _wchdir (MSVCRT.486)
491 */
492int CDECL MSVCRT__wchdir( const wchar_t *dirname )
493{
494 dprintf(("MSVCRT: _wchdir not implemented.\n"));
495 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
496 return FALSE;
497}
498
499
500/*********************************************************************
501 * _wchmod (MSVCRT.487)
502 */
503int CDECL MSVCRT__wchmod( const wchar_t *filename, int pmode )
504{
505 dprintf(("MSVCRT: _wchmod not implemented.\n"));
506 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
507 return FALSE;
508}
509
510
511/*********************************************************************
512 * _wcreat (MSVCRT.489)
513 */
514int CDECL MSVCRT__wcreat( const wchar_t *filename, int pmode )
515{
516 dprintf(("MSVCRT: _wcreat not implemented.\n"));
517 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
518 return FALSE;
519}
520
521
522/*********************************************************************
523 * _wcsncoll (MSVCRT.494)
524 */
525int CDECL MSVCRT__wcsncoll( const wchar_t *string1, const wchar_t *string2, size_t count )
526{
527 dprintf(("MSVCRT: _wcsncoll not implemented.\n"));
528 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
529 return FALSE;
530}
531
532
533/*********************************************************************
534 * _wcsnicoll (MSVCRT.496)
535 */
536int CDECL MSVCRT__wcsnicoll( const wchar_t *string1, const wchar_t *string2 , size_t count )
537{
538 dprintf(("MSVCRT: _wcsnicoll not implemented.\n"));
539 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
540 return FALSE;
541}
542
543
544/*********************************************************************
545 * _wctime (MSVCRT.501)
546 */
547wchar_t * CDECL MSVCRT__wctime( const time_t *timer )
548{
549 dprintf(("MSVCRT: _wctime not implemented.\n"));
550 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
551 return FALSE;
552}
553
554
555/*********************************************************************
556 * _wexecl (MSVCRT.503)
557 */
558int CDECL MSVCRT__wexecl( const wchar_t *path, const wchar_t *arg0, ... )
559{
560 dprintf(("MSVCRT: _wexecl not implemented.\n"));
561 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
562 return FALSE;
563}
564
565
566/*********************************************************************
567 * _wexecle (MSVCRT.504)
568 */
569int CDECL MSVCRT__wexecle( const wchar_t *path, const wchar_t *arg0, ... )
570{
571 dprintf(("MSVCRT: _wexecle not implemented.\n"));
572 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
573 return FALSE;
574}
575
576
577/*********************************************************************
578 * _wexeclp (MSVCRT.505)
579 */
580int CDECL MSVCRT__wexeclp( const wchar_t *file, const wchar_t *arg0, ... )
581{
582 dprintf(("MSVCRT: _wexeclp not implemented.\n"));
583 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
584 return FALSE;
585}
586
587
588/*********************************************************************
589 * _wexeclpe (MSVCRT.506)
590 */
591int CDECL MSVCRT__wexeclpe( const wchar_t *file, const wchar_t *arg0, ... )
592{
593 dprintf(("MSVCRT: _wexeclpe not implemented.\n"));
594 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
595 return FALSE;
596}
597
598
599/*********************************************************************
600 * _wexecv (MSVCRT.507)
601 */
602int CDECL MSVCRT__wexecv( const wchar_t *path, const wchar_t *const argv[] )
603{
604 dprintf(("MSVCRT: _wexecv not implemented.\n"));
605 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
606 return FALSE;
607}
608
609
610/*********************************************************************
611 * _wexecve (MSVCRT.508)
612 */
613int CDECL MSVCRT__wexecve( const wchar_t *path, const wchar_t *const argv[],
614 const wchar_t *const envp[] )
615{
616 dprintf(("MSVCRT: _wexecve not implemented.\n"));
617 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
618 return FALSE;
619}
620
621
622/*********************************************************************
623 * _wexecvp (MSVCRT.509)
624 */
625int CDECL MSVCRT__wexecvp( const wchar_t *file, const wchar_t *const argv[] )
626{
627 dprintf(("MSVCRT: _wexecvp not implemented.\n"));
628 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
629 return FALSE;
630}
631
632
633/*********************************************************************
634 * _wexecvpe (MSVCRT.510)
635 */
636int CDECL MSVCRT__wexecvpe( const wchar_t *file, const wchar_t *const argv[],
637 const wchar_t *const envp[] )
638{
639 dprintf(("MSVCRT: _wexecvpe not implemented.\n"));
640 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
641 return FALSE;
642}
643
644
645/*********************************************************************
646 * _wfdopen (MSVCRT.511)
647 */
648FILE * CDECL MSVCRT__wfdopen( int, const wchar_t *s )
649{
650 dprintf(("MSVCRT: _wfdopen not implemented.\n"));
651 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
652 return FALSE;
653}
654
655
656/*********************************************************************
657 * _wfindfirst (MSVCRT.512)
658 */
659long CDECL MSVCRT__wfindfirst( const wchar_t *filespec, struct _wfinddata_t *fileinfo )
660{
661 dprintf(("MSVCRT: _wfindfirst not implemented.\n"));
662 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
663 return FALSE;
664}
665
666
667/*********************************************************************
668 * _wfindnext (MSVCRT.514)
669 */
670int CDECL MSVCRT__wfindnext( long handle, struct _wfinddata_t *fileinfo )
671{
672 dprintf(("MSVCRT: _wfindnext not implemented.\n"));
673 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
674 return FALSE;
675}
676
677
678/*********************************************************************
679 * _wfopen (MSVCRT.516)
680 */
681FILE * CDECL MSVCRT__wfopen( const wchar_t *s1, const wchar_t *s2 )
682{
683 dprintf(("MSVCRT: _wfopen not implemented.\n"));
684 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
685 return FALSE;
686}
687
688
689/*********************************************************************
690 * _wfreopen (MSVCRT.517)
691 */
692FILE * CDECL MSVCRT__wfreopen( const wchar_t *s1, const wchar_t *s2, FILE * f)
693{
694 dprintf(("MSVCRT: _wfreopen not implemented.\n"));
695 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
696 return FALSE;
697}
698
699
700/*********************************************************************
701 * _wfsopen (MSVCRT.518)
702 */
703FILE * CDECL MSVCRT__wfsopen( const wchar_t *filename, const wchar_t *mode, int shflag )
704{
705 dprintf(("MSVCRT: _wfsopen not implemented.\n"));
706 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
707 return FALSE;
708}
709
710
711/*********************************************************************
712 * _wfullpath (MSVCRT.519)
713 */
714wchar_t * CDECL MSVCRT__wfullpath( wchar_t *s1, const wchar_t *s2, size_t n )
715{
716 dprintf(("MSVCRT: _wfullpath not implemented.\n"));
717 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
718 return FALSE;
719}
720
721
722/*********************************************************************
723 * _wgetcwd (MSVCRT.520)
724 */
725wchar_t * CDECL MSVCRT__wgetcwd( wchar_t *buf, size_t size )
726{
727 dprintf(("MSVCRT: _wgetcwd not implemented.\n"));
728 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
729 return FALSE;
730}
731
732
733/*********************************************************************
734 * _wgetdcwd (MSVCRT.521)
735 */
736wchar_t * CDECL MSVCRT__wgetdcwd( int drive, wchar_t *buffer, size_t maxlen )
737{
738 dprintf(("MSVCRT: _wgetdcwd not implemented.\n"));
739 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
740 return FALSE;
741}
742
743
744/*********************************************************************
745 * _wgetenv (MSVCRT.522)
746 */
747wchar_t * CDECL MSVCRT__wgetenv( const wchar_t *name )
748{
749 dprintf(("MSVCRT: _wgetenv not implemented.\n"));
750 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
751 return FALSE;
752}
753
754
755/*********************************************************************
756 * _wmakepath (MSVCRT.526)
757 */
758void CDECL MSVCRT__wmakepath( wchar_t *path, const wchar_t *drive,
759 const wchar_t *dir, const wchar_t *fname, const wchar_t *ext )
760{
761 dprintf(("MSVCRT: _wmakepath not implemented.\n"));
762 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
763}
764
765
766/*********************************************************************
767 * _wmkdir (MSVCRT.527)
768 */
769int CDECL MSVCRT__wmkdir( const wchar_t *path )
770{
771 dprintf(("MSVCRT: _wmkdir not implemented.\n"));
772 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
773 return FALSE;
774}
775
776
777/*********************************************************************
778 * _wmktemp (MSVCRT.528)
779 */
780wchar_t * CDECL MSVCRT__wmktemp( wchar_t* )
781{
782 dprintf(("MSVCRT: _wmktemp not implemented.\n"));
783 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
784 return FALSE;
785}
786
787
788/*********************************************************************
789 * _wopen (MSVCRT.529)
790 */
791int CDECL MSVCRT__wopen( const wchar_t *s, int n, ... )
792{
793 dprintf(("MSVCRT: _wopen not implemented.\n"));
794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
795 return FALSE;
796}
797
798
799/*********************************************************************
800 * _wperror (MSVCRT.530)
801 */
802void CDECL MSVCRT__wperror( const wchar_t *s )
803{
804 dprintf(("MSVCRT: _wperror not implemented.\n"));
805 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
806}
807
808
809/*********************************************************************
810 * _wpopen (MSVCRT.532)
811 */
812FILE * CDECL MSVCRT__wpopen( const wchar_t *command, const wchar_t *mode )
813{
814 dprintf(("MSVCRT: _wpopen not implemented.\n"));
815 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
816 return FALSE;
817}
818
819
820/*********************************************************************
821 * _wputenv (MSVCRT.533)
822 */
823int CDECL MSVCRT__wputenv( const wchar_t *env_string )
824{
825 dprintf(("MSVCRT: _wputenv not implemented.\n"));
826 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
827 return FALSE;
828}
829
830
831/*********************************************************************
832 * _wremove (MSVCRT.534)
833 */
834int CDECL MSVCRT__wremove( const wchar_t *s )
835{
836 dprintf(("MSVCRT: _wremove not implemented.\n"));
837 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
838 return FALSE;
839}
840
841
842/*********************************************************************
843 * _wrename (MSVCRT.535)
844 */
845int CDECL MSVCRT__wrename( const wchar_t *s1, const wchar_t *s2 )
846{
847 dprintf(("MSVCRT: _wrename not implemented.\n"));
848 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
849 return FALSE;
850}
851
852
853/*********************************************************************
854 * _wrmdir (MSVCRT.537)
855 */
856int CDECL MSVCRT__wrmdir( const wchar_t *path )
857{
858 dprintf(("MSVCRT: _wrmdir not implemented.\n"));
859 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
860 return FALSE;
861}
862
863
864/*********************************************************************
865 * _wsearchenv (MSVCRT.538)
866 */
867void CDECL MSVCRT__wsearchenv( const wchar_t *name, const wchar_t *env_var, wchar_t *buf )
868{
869 dprintf(("MSVCRT: _wsearchenv not implemented.\n"));
870 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
871}
872
873
874/*********************************************************************
875 * _wsetlocale (MSVCRT.539)
876 */
877wchar_t * CDECL MSVCRT__wsetlocale(int category,const wchar_t *locale)
878{
879 dprintf(("MSVCRT: _wsetlocale not implemented.\n"));
880 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
881 return FALSE;
882}
883
884
885/*********************************************************************
886 * _wsopen (MSVCRT.540)
887 */
888int CDECL MSVCRT__wsopen( const wchar_t *s, int n1, int n2, ... )
889{
890 dprintf(("MSVCRT: _wsopen not implemented.\n"));
891 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
892 return FALSE;
893}
894
895
896/*********************************************************************
897 * _wspawnl (MSVCRT.541)
898 */
899int CDECL MSVCRT__wspawnl( int mode, const wchar_t *path, const wchar_t *arg0, ... )
900{
901 dprintf(("MSVCRT: _wspawnl not implemented.\n"));
902 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
903 return FALSE;
904}
905
906
907/*********************************************************************
908 * _wspawnle (MSVCRT.542)
909 */
910int CDECL MSVCRT__wspawnle( int mode, const wchar_t *path, const wchar_t *arg0, ... )
911{
912 dprintf(("MSVCRT: _wspawnle not implemented.\n"));
913 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
914 return FALSE;
915}
916
917
918/*********************************************************************
919 * _wspawnlp (MSVCRT.543)
920 */
921int CDECL MSVCRT__wspawnlp( int mode, const wchar_t *path, const wchar_t *arg0, ... )
922{
923 dprintf(("MSVCRT: _wspawnlp not implemented.\n"));
924 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
925 return FALSE;
926}
927
928
929/*********************************************************************
930 * _wspawnlpe (MSVCRT.544)
931 */
932int CDECL MSVCRT__wspawnlpe( int mode, const wchar_t *path, const wchar_t *arg0, ... )
933{
934 dprintf(("MSVCRT: _wspawnlpe not implemented.\n"));
935 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
936 return FALSE;
937}
938
939
940/*********************************************************************
941 * _wspawnv (MSVCRT.545)
942 */
943int CDECL MSVCRT__wspawnv( int mode, const wchar_t *path, const wchar_t * const *argv )
944{
945 dprintf(("MSVCRT: _wspawnv not implemented.\n"));
946 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
947 return FALSE;
948}
949
950
951/*********************************************************************
952 * _wspawnve (MSVCRT.546)
953 */
954int CDECL MSVCRT__wspawnve( int mode, const wchar_t *path,
955 const wchar_t * const *argv, const wchar_t * const *envp )
956{
957 dprintf(("MSVCRT: _wspawnve not implemented.\n"));
958 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
959 return FALSE;
960}
961
962
963/*********************************************************************
964 * _wspawnvp (MSVCRT.547)
965 */
966int CDECL MSVCRT__wspawnvp( int mode, const wchar_t *path, const wchar_t * const *argv )
967{
968 dprintf(("MSVCRT: _wspawnvp not implemented.\n"));
969 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
970 return FALSE;
971}
972
973
974/*********************************************************************
975 * _wspawnvpe (MSVCRT.548)
976 */
977int CDECL MSVCRT__wspawnvpe( int mode, const wchar_t *path,
978 const wchar_t * const *argv, const wchar_t * const *envp )
979{
980 dprintf(("MSVCRT: _wspawnvpe not implemented.\n"));
981 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
982 return FALSE;
983}
984
985
986/*********************************************************************
987 * _wsplitpath (MSVCRT.549)
988 */
989void CDECL MSVCRT__wsplitpath( const wchar_t *path, wchar_t *drive,
990 wchar_t *dir, wchar_t *fname, wchar_t *ext )
991{
992 dprintf(("MSVCRT: _wsplitpath not implemented.\n"));
993 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
994}
995
996
997/*********************************************************************
998 * _wstat (MSVCRT.550)
999 */
1000int CDECL MSVCRT__wstat( const wchar_t *s, struct _wstat *w )
1001{
1002 dprintf(("MSVCRT: _wstat not implemented.\n"));
1003 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1004 return FALSE;
1005}
1006
1007
1008/*********************************************************************
1009 * _wstrdate (MSVCRT.552)
1010 */
1011wchar_t * CDECL MSVCRT__wstrdate( wchar_t *buf )
1012{
1013 dprintf(("MSVCRT: _wstrdate not implemented.\n"));
1014 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1015 return FALSE;
1016}
1017
1018
1019/*********************************************************************
1020 * _wstrtime (MSVCRT.553)
1021 */
1022wchar_t * CDECL MSVCRT__wstrtime( wchar_t *buf )
1023{
1024 dprintf(("MSVCRT: _wstrtime not implemented.\n"));
1025 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1026 return FALSE;
1027}
1028
1029
1030/*********************************************************************
1031 * _wsystem (MSVCRT.554)
1032 */
1033int CDECL MSVCRT__wsystem( const wchar_t *cmd )
1034{
1035 dprintf(("MSVCRT: _wsystem not implemented.\n"));
1036 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1037 return FALSE;
1038}
1039
1040
1041/*********************************************************************
1042 * _wtempnam (MSVCRT.555)
1043 */
1044wchar_t * CDECL MSVCRT__wtempnam( wchar_t *dir, wchar_t *prefix )
1045{
1046 dprintf(("MSVCRT: _wtempnam not implemented.\n"));
1047 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1048 return FALSE;
1049}
1050
1051
1052/*********************************************************************
1053 * _wtmpnam (MSVCRT.555)
1054 */
1055wchar_t * CDECL MSVCRT__wtmpnam( wchar_t *tn )
1056{
1057 dprintf(("MSVCRT: _wtmpnam not implemented.\n"));
1058 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1059 return FALSE;
1060}
1061
1062
1063/*********************************************************************
1064 * _wunlink (MSVCRT.560)
1065 */
1066int CDECL MSVCRT__wunlink(const wchar_t *path)
1067{
1068 dprintf(("MSVCRT: _wunlink not implemented.\n"));
1069 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1070 return FALSE;
1071}
1072
1073
1074/*********************************************************************
1075 * _wutime (MSVCRT.561)
1076 */
1077int CDECL MSVCRT__wutime( const wchar_t *path, const struct utimbuf * times )
1078{
1079 dprintf(("MSVCRT: _wutime not implemented.\n"));
1080 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1081 return FALSE;
1082}
1083
1084
1085/*********************************************************************
1086 * fgetws (MSVCRT.597)
1087 */
1088wchar_t * CDECL MSVCRT_fgetws( wchar_t *s, int n, FILE *strm )
1089{
1090 dprintf(("MSVCRT: fgetws\n"));
1091 return (fgetws(s, n, strm));
1092}
1093
1094
1095/*********************************************************************
1096 * fputws (MSVCRT.605)
1097 */
1098int CDECL MSVCRT_fputws( const wchar_t *s, FILE *strm )
1099{
1100 dprintf(("MSVCRT: fputws\n"));
1101 return (fputws(s, strm));
1102}
1103
1104
1105/*********************************************************************
1106 * getwc (MSVCRT.621)
1107 */
1108wint_t CDECL MSVCRT_getwc( FILE * strm)
1109{
1110 dprintf(("MSVCRT: getwc\n"));
1111 return (getwc(strm));
1112}
1113
1114
1115/*********************************************************************
1116 * getwchar (MSVCRT.622)
1117 */
1118wint_t CDECL MSVCRT_getwchar( void )
1119{
1120 dprintf(("MSVCRT: getwchar\n"));
1121 return (getwchar());
1122}
1123
1124
1125/*********************************************************************
1126 * putwc (MSVCRT.675)
1127 */
1128wint_t CDECL MSVCRT_putwc( wint_t t, FILE * strm)
1129{
1130 dprintf(("MSVCRT: putwc not implemented.\n"));
1131 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1132 return FALSE;
1133}
1134
1135
1136/*********************************************************************
1137 * putwchar (MSVCRT.676)
1138 */
1139wint_t CDECL MSVCRT_putwchar( wint_t t)
1140{
1141 dprintf(("MSVCRT: putwchar not implemented.\n"));
1142 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1143 return FALSE;
1144}
Note: See TracBrowser for help on using the repository browser.