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

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

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