source: trunk/src/crtdll/crtdll.cpp@ 971

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

Jens Weissner's update (extra stubs)
File size: 78.8 KB
Line 
1/* $Id: crtdll.cpp,v 1.3 1999-09-18 10:36:34 sandervl Exp $ */
2
3/*
4 * The C RunTime DLL
5 *
6 * Implements C run-time functionality as known from UNIX.
7 *
8 * Copyright 1996,1998 Marcus Meissner
9 * Copyright 1996 Jukka Iivonen
10 * Copyright 1997 Uwe Bonnes
11 * Copyright 1999 Jens Wiessner
12 */
13
14
15#include <os2win.h>
16#include <stdio.h>
17#include <stdlib.h>
18#include <string.h>
19#include <odinwrap.h>
20#include <misc.h>
21#include <unicode.h>
22#include <heapstring.h>
23#include <ctype.h>
24#include <setjmp.h>
25#include <except.h>
26#include <debugtools.h>
27
28#include <wchar.h>
29#include <wctype.h>
30#include <math.h>
31#include <locale.h>
32#include <signal.h>
33#include <io.h>
34#include <assert.h>
35#include <process.h>
36#include <float.h>
37#include <conio.h>
38#include <direct.h>
39#include <malloc.h>
40#include <sys\utime.h>
41#include <sys\stat.h>
42
43#include <crtdll.h>
44#include "crtinc.h"
45
46
47// DEFAULT_DEBUG_CHANNEL(crtdll)
48
49INT CDECL CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args );
50
51
52/*********************************************************************
53 * CRTDLL_MainInit (CRTDLL.init)
54 */
55BOOL WINAPI CRTDLL_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
56{
57 if (fdwReason == DLL_PROCESS_ATTACH) {
58 CRTDLL__fdopen(0,"r");
59 CRTDLL__fdopen(1,"w");
60 CRTDLL__fdopen(2,"w");
61 }
62 return TRUE;
63}
64
65/*********************************************************************
66 * _XcptFilter (CRTDLL.21)
67 * FIXME - Could not find anything about it
68 */
69INT CDECL CRTDLL__XcptFilter(DWORD ret)
70{
71 dprintf(("CRTDLL: XcptFilter\n"));
72
73 return 0;
74}
75
76/*********************************************************************
77 * _GetMainArgs (CRTDLL.22)
78 */
79DWORD CDECL CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,
80 LPSTR *environ,DWORD flag)
81{
82 char *cmdline;
83 char **xargv;
84 int xargc,i,afterlastspace;
85 DWORD version;
86
87 dprintf(("CRTDLL: GetMainArgs\n"));
88
89 CRTDLL_acmdln_dll = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
90 GetCommandLineA() );
91
92 version = GetVersion();
93 CRTDLL_osver_dll = version >> 16;
94 CRTDLL_winminor_dll = version & 0xFF;
95 CRTDLL_winmajor_dll = (version>>8) & 0xFF;
96 CRTDLL_baseversion_dll = version >> 16;
97 CRTDLL_winver_dll = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
98 CRTDLL_baseminor_dll = (version >> 16) & 0xFF;
99 CRTDLL_basemajor_dll = (version >> 24) & 0xFF;
100 CRTDLL_osversion_dll = version & 0xFFFF;
101 CRTDLL_osminor_dll = version & 0xFF;
102 CRTDLL_osmajor_dll = (version>>8) & 0xFF;
103
104 /* missing threading init */
105/*
106 i=0;xargv=NULL;xargc=0;afterlastspace=0;
107 dprintf(("CRTDLL: GetMainArgs i loop\n"));
108 while (cmdline[i]) {
109 if (cmdline[i]==' ') {
110 dprintf(("CRTDLL: GetMainArgs *1\n"));
111 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
112 sizeof(char*)*(++xargc));
113 cmdline[i]='\0';
114 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
115 cmdline+afterlastspace);
116 i++;
117 dprintf(("CRTDLL: GetMainArgs *2\n"));
118 while (cmdline[i]==' ')
119 i++;
120 if (cmdline[i])
121 afterlastspace=i;
122 dprintf(("CRTDLL: GetMainArgs *3\n"));
123 } else
124 i++;
125
126 }
127 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
128 sizeof(char*)*(++xargc));
129 dprintf(("CRTDLL: GetMainArgs *4\n"));
130 cmdline[i]='\0';
131 dprintf(("CRTDLL: GetMainArgs *5\n"));
132 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
133 cmdline+afterlastspace);
134 dprintf(("CRTDLL: GetMainArgs *6\n"));
135 dprintf(("CRTDLL: GetMainArgs *7\n"));
136 CRTDLL_argc_dll = xargc;
137 dprintf(("CRTDLL: GetMainArgs *8\n"));
138 *argc = xargc;
139 dprintf(("CRTDLL: GetMainArgs *9\n"));
140 CRTDLL_argv_dll = xargv;
141 dprintf(("CRTDLL: GetMainArgs *11\n"));
142 *argv = xargv;
143*/
144 dprintf(("CRTDLL: GetMainArgs end\n"));
145 CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
146 return 0;
147}
148
149
150/*********************************************************************
151 * CRTDLL___isascii (CRTDLL.28)
152 */
153int CDECL CRTDLL___isascii(int i)
154{
155 dprintf(("CRTDLL: __isascii\n"));
156 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
157 return FALSE;
158}
159
160
161/*********************************************************************
162 * CRTDLL___iscsym (CRTDLL.29)
163 */
164int CDECL CRTDLL___iscsym(int i)
165{
166 dprintf(("CRTDLL: __iscsym\n"));
167 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
168 return FALSE;
169}
170
171
172/*********************************************************************
173 * CRTDLL___iscsymf (CRTDLL.30)
174 */
175int CDECL CRTDLL___iscsymf(int i)
176{
177 dprintf(("CRTDLL: __iscsymf\n"));
178 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
179 return FALSE;
180}
181
182
183/*********************************************************************
184 * __mb_cur_max_dll (CRTDLL.31)
185 * FIXME - Could not find anything about it
186 */
187INT CDECL CRTDLL___mb_cur_max_dll(DWORD ret)
188{
189 dprintf(("CRTDLL: __mb_cur_max_dll\n"));
190
191 return 0;
192}
193
194
195/*********************************************************************
196 * CRTDLL___threadhandle (CRTDLL.32)
197 */
198unsigned long CDECL CRTDLL___threadhandle( void )
199{
200 dprintf(("CRTDLL: __threadhandle\n"));
201 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
202 return FALSE;
203}
204
205
206/*********************************************************************
207 * CRTDLL___threadid (CRTDLL.33)
208 */
209int * CDECL CRTDLL___threadid(void)
210{
211 dprintf(("CRTDLL: __threadid\n"));
212 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
213 return FALSE;
214}
215
216
217/*********************************************************************
218 * CRTDLL__abnormal_termination (CRTDLL.36)
219 */
220int CDECL CRTDLL__abnormal_termination(void)
221{
222 dprintf(("CRTDLL: _abnormal_termination\n"));
223 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
224 return FALSE;
225}
226
227
228/*********************************************************************
229 * CRTDLL__access (CRTDLL.37)
230 */
231int CDECL CRTDLL__access(const char *path,int mode)
232{
233 dprintf(("CRTDLL: _access\n"));
234 return (_access(path, mode));
235}
236
237
238/*********************************************************************
239 * _aexit_rtn_dll (CRTDLL.39)
240 * FIXME - Could not find anything about it
241 */
242INT CDECL CRTDLL__aexit_rtn_dll(DWORD ret)
243{
244 dprintf(("CRTDLL: _aexit_rtn_dll\n"));
245
246 return 0;
247}
248
249
250/*********************************************************************
251 * _amsg_exit (CRTDLL.40)
252 * FIXME - Could not find anything about it
253 */
254INT CDECL CRTDLL__amsg_exit(DWORD ret)
255{
256 dprintf(("CRTDLL: _amsg_exit\n"));
257
258 return 0;
259}
260
261
262/*********************************************************************
263 * CRTDLL__assert (CRTDLL.41)
264 */
265void CDECL CRTDLL__assert( char *s1, char *s2, int i)
266{
267 dprintf(("CRTDLL: _assert\n"));
268 _assert(s1, s2, i);
269}
270
271
272/*********************************************************************
273 * CRTDLL__beginthread (CRTDLL.46)
274 */
275unsigned long CDECL CRTDLL__beginthread( register void (*start_address)(void *),
276 unsigned stack_size, void *arglist )
277{
278 dprintf(("CRTDLL: _beginthread\n"));
279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
280 return FALSE;
281}
282
283
284/*********************************************************************
285 * _chdir (CRTDLL.51)
286 */
287INT CDECL CRTDLL__chdir(LPCSTR newdir)
288{
289 dprintf(("CRTDLL: chdir\n"));
290 if (!SetCurrentDirectoryA(newdir))
291 return 1;
292 return 0;
293}
294
295
296/*********************************************************************
297 * CRTDLL__close (CRTDLL.57)
298 */
299int CDECL CRTDLL__close(int handle)
300{
301 dprintf(("CRTDLL: _close\n"));
302 return (_close(handle));
303}
304
305
306/*********************************************************************
307 * CRTDLL__control87 (CRTDLL.60)
308 */
309unsigned CDECL CRTDLL__control87(unsigned i1,unsigned i2)
310{
311 dprintf(("CRTDLL: _control87\n"));
312 return (_control87(i1, i2));
313}
314
315
316/*********************************************************************
317 * CRTDLL__cwait (CRTDLL.69)
318 */
319int CDECL CRTDLL__cwait( int *status, int process_id, int action_code )
320{
321 dprintf(("CRTDLL: _cwait\n"));
322 return (_cwait(status, process_id, action_code));
323}
324
325
326/*********************************************************************
327 * CRTDLL__dup (CRTDLL.71)
328 */
329int CDECL CRTDLL__dup(int handle)
330{
331 dprintf(("CRTDLL: _dup\n"));
332 return (_dup(handle));
333}
334
335
336/*********************************************************************
337 * CRTDLL__dup2 (CRTDLL.72)
338 */
339int CDECL CRTDLL__dup2(int handle1,int handle2)
340{
341 dprintf(("CRTDLL: _dup2\n"));
342 return (_dup2(handle1, handle2));
343}
344
345
346/*********************************************************************
347 * CRTDLL__ecvt (CRTDLL.73)
348 */
349char * CDECL CRTDLL__ecvt( double val, int ndig, int *dec, int *sign )
350{
351 dprintf(("CRTDLL: _ecvt\n"));
352 return (_ecvt(val, ndig, dec, sign));
353}
354
355
356/*********************************************************************
357 * CRTDLL__endthread (CRTDLL.74)
358 */
359void CDECL CRTDLL__endthread(void)
360{
361 dprintf(("CRTDLL: _endthread\n"));
362 _endthread ();
363}
364
365
366/*********************************************************************
367 * CRTDLL__errno (CRTDLL.77)
368 */
369int * CDECL CRTDLL__errno(void)
370{
371 dprintf(("CRTDLL: _errno\n"));
372 return (_errno());
373}
374
375
376/*********************************************************************
377 * _except_handler2 (CRTDLL.78)
378 * FIXME - Could not find anything about it
379 */
380INT CDECL CRTDLL__except_handler2(DWORD ret)
381{
382 dprintf(("CRTDLL: _except_handler2\n"));
383
384 return 0;
385}
386
387
388/*********************************************************************
389 * _exit (CRTDLL.87)
390 */
391VOID CDECL CRTDLL__exit(DWORD ret)
392{
393 dprintf(("CRTDLL: exit\n"));
394 ExitProcess(ret);
395}
396
397
398/*********************************************************************
399 * CRTDLL__expand (CRTDLL.88)
400 */
401void * CDECL CRTDLL__expand( void *ptr, size_t size )
402{
403 dprintf(("CRTDLL: _expand\n"));
404 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
405 return FALSE;
406}
407
408
409/*********************************************************************
410 * CRTDLL__fcvt (CRTDLL.90)
411 */
412char * CDECL CRTDLL__fcvt( double val, int ndig, int *dec, int *sign )
413{
414 dprintf(("CRTDLL: _fcvt\n"));
415 return (_fcvt(val, ndig, dec, sign));
416}
417
418
419/*********************************************************************
420 * _fdopen (CRTDLL.91)
421 */
422CRTDLL_FILE * CDECL CRTDLL__fdopen(INT handle, LPCSTR mode)
423{
424 dprintf(("CRTDLL: fdopen\n"));
425 CRTDLL_FILE *file;
426
427 switch (handle)
428 {
429 case 0:
430 file = CRTDLL_stdin;
431 if (!file->handle) file->handle = GetStdHandle( STD_INPUT_HANDLE );
432 break;
433 case 1:
434 file = CRTDLL_stdout;
435 if (!file->handle) file->handle = GetStdHandle( STD_OUTPUT_HANDLE );
436 break;
437 case 2:
438 file=CRTDLL_stderr;
439 if (!file->handle) file->handle = GetStdHandle( STD_ERROR_HANDLE );
440 break;
441 default:
442 file = (PCRTDLL_FILE)HeapAlloc( GetProcessHeap(), 0, sizeof(*file) );
443 file->handle = handle;
444 break;
445 }
446 return file;
447}
448
449
450/*********************************************************************
451 * CRTDLL__fgetchar (CRTDLL.92)
452 */
453int CDECL CRTDLL__fgetchar( void )
454{
455 dprintf(("CRTDLL: _fgetchar\n"));
456 return (_fgetchar());
457}
458
459
460/*********************************************************************
461 * CRTDLL__fgetwchar (CRTDLL.93)
462 */
463wint_t CDECL CRTDLL__fgetwchar( void *i )
464{
465 dprintf(("CRTDLL: _fgetwchar\n"));
466 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
467 return FALSE;
468}
469
470
471 /*********************************************************************
472 * _findclose (CRTDLL.098)
473 */
474int CDECL CRTDLL__findclose( long handle )
475{
476 dprintf(("CRTDLL: _findclose\n"));
477 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
478 return FALSE;
479}
480
481
482 /*********************************************************************
483 * _findfirst (CRTDLL.099)
484 */
485DWORD CDECL CRTDLL__findfirst(LPCSTR fname, struct find_t * x2)
486{
487 dprintf(("CRTDLL: _findfirst\n"));
488 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
489 return FALSE;
490}
491
492
493/*********************************************************************
494 * _findnext (CRTDLL.100)
495 */
496INT CDECL CRTDLL__findnext(DWORD hand, struct find_t * x2)
497{
498 dprintf(("CRTDLL: _findnext\n"));
499 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
500 return FALSE;
501}
502
503
504/*********************************************************************
505 * _finite (CRTDLL.101)
506 */
507INT CDECL CRTDLL__finite(double x)
508{
509 dprintf(("CRTDLL: _finite\n"));
510 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
511 return FALSE;
512}
513
514
515/*********************************************************************
516 * _fpreset (CRTDLL.107)
517 */
518INT CDECL CRTDLL__fpreset(void)
519{
520 dprintf(("CRTDLL: _fpreset\n"));
521 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
522 return FALSE;
523}
524
525
526/*********************************************************************
527 * _fputchar (CRTDLL.108)
528 */
529INT CDECL CRTDLL__fputchar( int c )
530{
531 dprintf(("CRTDLL: _fputchar\n"));
532 return(_fputchar(c));
533}
534
535
536/*********************************************************************
537 * _fputwchar (CRTDLL.109)
538 */
539wint_t CDECL CRTDLL__fputwchar( wint_t )
540{
541 dprintf(("CRTDLL: _fputwchar\n"));
542 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
543 return FALSE;
544}
545
546
547/*********************************************************************
548 * _fsopen (CRTDLL.110)
549 */
550FILE * CDECL CRTDLL__fsopen( const char *filename, const char *mode, int shflag )
551{
552 dprintf(("CRTDLL: _fsopen\n"));
553 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
554 return FALSE;
555}
556
557
558/*********************************************************************
559 * _fstat (CRTDLL.111)
560 */
561int CDECL CRTDLL__fstat(int file, struct stat* buf)
562{
563 dprintf(("CRTDLL: _fstat\n"));
564 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
565 return FALSE;
566}
567
568
569/*********************************************************************
570 * _ftime (CRTDLL.112)
571 */
572int CDECL CRTDLL__ftime( struct timeb *timeptr )
573{
574 dprintf(("CRTDLL: _ftime\n"));
575 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
576 return FALSE;
577}
578
579
580/*********************************************************************
581 * _fullpath (CRTDLL.114)
582 */
583char * CDECL CRTDLL__fullpath( char *buf, char *path, size_t size )
584{
585 dprintf(("CRTDLL: _fullpath\n"));
586 return (_fullpath(buf, path, size));
587}
588
589
590/*********************************************************************
591 * _gcvt (CRTDLL.116)
592 */
593char * CDECL CRTDLL__gcvt( double val, int ndig, char *buf )
594{
595 dprintf(("CRTDLL: _gcvt\n"));
596 return (_gcvt(val, ndig, buf));
597}
598
599
600/*********************************************************************
601 * _get_osfhandle (CRTDLL.117)
602 */
603long CDECL CRTDLL__get_osfhandle( int posixhandle )
604{
605 dprintf(("CRTDLL: _gcvt\n"));
606 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
607 return FALSE;
608}
609
610
611/*********************************************************************
612 * _getch (CRTDLL.118)
613 */
614int CDECL CRTDLL__getch(void)
615{
616 dprintf(("CRTDLL: _getch\n"));
617 return (_getch());
618}
619
620
621/*********************************************************************
622 * _getche (CRTDLL.119)
623 */
624int CDECL CRTDLL__getche(void)
625{
626 dprintf(("CRTDLL: _getche\n"));
627 return (_getche());
628}
629
630
631/*********************************************************************
632 * _getcwd (CRTDLL.120)
633 */
634char * CDECL CRTDLL__getcwd( char *buf, size_t size )
635{
636 dprintf(("CRTDLL: _getcwd\n"));
637 return (_getcwd(buf, size));
638}
639
640
641/*********************************************************************
642 * _getdcwd (CRTDLL.121)
643 */
644char * CDECL CRTDLL__getdcwd( int drive, char *buffer, size_t maxlen )
645{
646 dprintf(("CRTDLL: _getdcwd\n"));
647 return (_getdcwd(drive, buffer, maxlen));
648}
649
650
651/*********************************************************************
652 * _getdiskfree (CRTDLL.122)
653 */
654unsigned CDECL CRTDLL__getdiskfree( unsigned drive, struct _diskfree_t *diskspace)
655{
656 dprintf(("CRTDLL: _getdiskfree\n"));
657 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
658 return FALSE;
659}
660
661
662/*********************************************************************
663 * _getdrive (CRTDLL.124)
664 */
665unsigned CDECL CRTDLL__getdrive( void )
666{
667 dprintf(("CRTDLL: _getdrive\n"));
668 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
669 return FALSE;
670}
671
672
673/*********************************************************************
674 * _getw (CRTDLL.128)
675 */
676int CDECL CRTDLL__getw( FILE *fp )
677{
678 dprintf(("CRTDLL: _getw\n"));
679 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
680 return FALSE;
681}
682
683
684/*******************************************************************
685 * _global_unwind2 (CRTDLL.129)
686 */
687void CDECL CRTDLL__global_unwind2( PEXCEPTION_FRAME frame )
688{
689 dprintf(("CRTDLL: global_undwind2\n"));
690 RtlUnwind( frame, 0, NULL, 0 );
691}
692
693
694/*********************************************************************
695 * _heapchk (CRTDLL.130)
696 */
697int CDECL CRTDLL__heapchk( void )
698{
699 dprintf(("CRTDLL: _heapchk\n"));
700 return (_heapchk());
701}
702
703
704/*********************************************************************
705 * _heapmin (CRTDLL.131)
706 */
707int CDECL CRTDLL__heapmin( void )
708{
709 dprintf(("CRTDLL: _heapmin\n"));
710 return (_heapmin());
711}
712
713
714/*********************************************************************
715 * _heapset (CRTDLL.132)
716 */
717int CDECL CRTDLL__heapset( unsigned int fill )
718{
719 dprintf(("CRTDLL: _heapset\n"));
720 return (_heapset(fill));
721}
722
723
724/*********************************************************************
725 * _heapwalk (CRTDLL.133)
726 */
727int CDECL CRTDLL__heapwalk( struct _heapinfo *entry )
728{
729 dprintf(("CRTDLL: _heapwalk\n"));
730 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
731 return FALSE;
732}
733
734
735/*********************************************************************
736 * _initterm (CRTDLL.135)
737 */
738DWORD CDECL CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
739{
740 dprintf(("CRTDLL: initterm\n"));
741 _INITTERMFUN *current;
742
743 current=start;
744 while (current<end) {
745 if (*current) (*current)();
746 current++;
747 }
748 return 0;
749}
750
751
752/*********************************************************************
753 * _isctype (CRTDLL.138)
754 */
755BOOL CDECL CRTDLL__isctype(CHAR x,CHAR type)
756{
757 dprintf(("CRTDLL: isctype\n"));
758 if ((type & CRTDLL_SPACE) && isspace(x))
759 return TRUE;
760 if ((type & CRTDLL_PUNCT) && ispunct(x))
761 return TRUE;
762 if ((type & CRTDLL_LOWER) && islower(x))
763 return TRUE;
764 if ((type & CRTDLL_UPPER) && isupper(x))
765 return TRUE;
766 if ((type & CRTDLL_ALPHA) && isalpha(x))
767 return TRUE;
768 if ((type & CRTDLL_DIGIT) && isdigit(x))
769 return TRUE;
770 if ((type & CRTDLL_CONTROL) && iscntrl(x))
771 return TRUE;
772 /* check CRTDLL_LEADBYTE */
773 return FALSE;
774}
775
776
777/*********************************************************************
778 * _ismbbalnum (CRTDLL.139)
779 */
780int CDECL CRTDLL__ismbbalnum( unsigned int ch )
781{
782 dprintf(("CRTDLL: _ismbbalnum\n"));
783 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
784 return FALSE;
785}
786
787
788/*********************************************************************
789 * _ismbbalpha (CRTDLL.140)
790 */
791int CDECL CRTDLL__ismbbalpha( unsigned int ch )
792{
793 dprintf(("CRTDLL: _ismbbalpha\n"));
794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
795 return FALSE;
796}
797
798
799/*********************************************************************
800 * _ismbbgraph (CRTDLL.141)
801 */
802int CDECL CRTDLL__ismbbgraph( unsigned int ch )
803{
804 dprintf(("CRTDLL: _ismbbgraph\n"));
805 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
806 return FALSE;
807}
808
809
810/*********************************************************************
811 * _ismbbkalnum (CRTDLL.142)
812 */
813int CDECL CRTDLL__ismbbkalnum( unsigned int ch )
814{
815 dprintf(("CRTDLL: _ismbbkalnum\n"));
816 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
817 return FALSE;
818}
819
820
821/*********************************************************************
822 * _ismbbkana (CRTDLL.143)
823 */
824int CDECL CRTDLL__ismbbkana( unsigned int ch )
825{
826 dprintf(("CRTDLL: _ismbbkana\n"));
827 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
828 return FALSE;
829}
830
831
832/*********************************************************************
833 * _ismbbkpunct (CRTDLL.144)
834 */
835int CDECL CRTDLL__ismbbkpunct( unsigned int ch )
836{
837 dprintf(("CRTDLL: _ismbbkpunct\n"));
838 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
839 return FALSE;
840}
841
842
843/*********************************************************************
844 * _ismbblead (CRTDLL.145)
845 */
846int CDECL CRTDLL__ismbblead( unsigned int ch )
847{
848 dprintf(("CRTDLL: _ismbblead\n"));
849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
850 return FALSE;
851}
852
853
854/*********************************************************************
855 * _ismbbprint (CRTDLL.146)
856 */
857int CDECL CRTDLL__ismbbprint( unsigned int ch )
858{
859 dprintf(("CRTDLL: _ismbbprint\n"));
860 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
861 return FALSE;
862}
863
864
865/*********************************************************************
866 * _ismbbpunct (CRTDLL.147)
867 */
868int CDECL CRTDLL__ismbbpunct( unsigned int ch )
869{
870 dprintf(("CRTDLL: _ismbbpunct\n"));
871 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
872 return FALSE;
873}
874
875
876/*********************************************************************
877 * _ismbbtrail (CRTDLL.148)
878 */
879int CDECL CRTDLL__ismbbtrail( unsigned int ch )
880{
881 dprintf(("CRTDLL: _ismbbtrail\n"));
882 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
883 return FALSE;
884}
885
886
887/*********************************************************************
888 * _ismbcalpha (CRTDLL.149)
889 */
890int CDECL CRTDLL__ismbcalpha( unsigned int ch )
891{
892 dprintf(("CRTDLL: _ismbcalpha\n"));
893 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
894 return FALSE;
895}
896
897
898/*********************************************************************
899 * _ismbcdigit (CRTDLL.150)
900 */
901int CDECL CRTDLL__ismbcdigit( unsigned int ch )
902{
903 dprintf(("CRTDLL: _ismbcdigit\n"));
904 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
905 return FALSE;
906}
907
908
909/*********************************************************************
910 * _ismbchira (CRTDLL.151)
911 */
912int CDECL CRTDLL__ismbchira( unsigned int ch )
913{
914 dprintf(("CRTDLL: _ismbchira\n"));
915 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
916 return FALSE;
917}
918
919
920/*********************************************************************
921 * _ismbckata (CRTDLL.152)
922 */
923int CDECL CRTDLL__ismbckata( unsigned int ch )
924{
925 dprintf(("CRTDLL: _ismbckata\n"));
926 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
927 return FALSE;
928}
929
930/*********************************************************************
931 * _ismbcl0 (CRTDLL.153)
932 */
933int CDECL CRTDLL__ismbcl0( unsigned int ch )
934{
935 dprintf(("CRTDLL: _ismbcl0\n"));
936 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
937 return FALSE;
938}
939
940
941/*********************************************************************
942 * _ismbcl1 (CRTDLL.154)
943 */
944int CDECL CRTDLL__ismbcl1( unsigned int ch )
945{
946 dprintf(("CRTDLL: _ismbcl1\n"));
947 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
948 return FALSE;
949}
950
951
952/*********************************************************************
953 * _ismbcl2 (CRTDLL.155)
954 */
955int CDECL CRTDLL__ismbcl2( unsigned int ch )
956{
957 dprintf(("CRTDLL: _ismbcl2\n"));
958 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
959 return FALSE;
960}
961
962
963/*********************************************************************
964 * _ismbclegal (CRTDLL.156)
965 */
966int CDECL CRTDLL__ismbclegal( unsigned int ch )
967{
968 dprintf(("CRTDLL: _ismbclegal\n"));
969 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
970 return FALSE;
971}
972
973
974/*********************************************************************
975 * _ismbclower (CRTDLL.157)
976 */
977int CDECL CRTDLL__ismbclower( unsigned int ch )
978{
979 dprintf(("CRTDLL: _ismbclower\n"));
980 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
981 return FALSE;
982}
983
984
985/*********************************************************************
986 * _ismbcprint (CRTDLL.158)
987 */
988int CDECL CRTDLL__ismbcprint( unsigned int ch )
989{
990 dprintf(("CRTDLL: _ismbcprint\n"));
991 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
992 return FALSE;
993}
994
995
996/*********************************************************************
997 * _ismbcspace (CRTDLL.159)
998 */
999int CDECL CRTDLL__ismbcspace( unsigned int ch )
1000{
1001 dprintf(("CRTDLL: _ismbcspace\n"));
1002 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1003 return FALSE;
1004}
1005
1006
1007/*********************************************************************
1008 * _ismbcsymbol (CRTDLL.160)
1009 */
1010int CDECL CRTDLL__ismbcsymbol( unsigned int ch )
1011{
1012 dprintf(("CRTDLL: _ismbcsymbol\n"));
1013 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1014 return FALSE;
1015}
1016
1017
1018/*********************************************************************
1019 * _ismbcupper (CRTDLL.161)
1020 */
1021int CDECL CRTDLL__ismbcupper( unsigned int ch )
1022{
1023 dprintf(("CRTDLL: _ismbcupper\n"));
1024 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1025 return FALSE;
1026}
1027
1028
1029/*******************************************************************
1030 * _local_unwind2 (CRTDLL.172)
1031 */
1032void CDECL CRTDLL__local_unwind2( PEXCEPTION_FRAME endframe, DWORD nr )
1033{
1034 dprintf(("CRTDLL: local_undwind2\n"));
1035}
1036
1037
1038/*********************************************************************
1039 * _locking (CRTDLL.173)
1040 */
1041int CDECL CRTDLL__locking(int handle,int mode,unsigned long nbyte)
1042{
1043 dprintf(("CRTDLL: _locking\n"));
1044 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1045 return FALSE;
1046}
1047
1048
1049/*********************************************************************
1050 * _lrotl (CRTDLL.175)
1051 */
1052unsigned long CDECL CRTDLL__lrotl( unsigned long value, unsigned int shift )
1053{
1054 dprintf(("CRTDLL: _lrotl\n"));
1055 return (_lrotl(value, shift));
1056}
1057
1058
1059/*********************************************************************
1060 * _lrotr (CRTDLL.176)
1061 */
1062unsigned long CDECL CRTDLL__lrotr( unsigned long value, unsigned int shift )
1063{
1064 dprintf(("CRTDLL: _lrotr\n"));
1065 return (_lrotr(value, shift));
1066}
1067
1068
1069/*********************************************************************
1070 * _lseek (CRTDLL.178)
1071 */
1072long CDECL CRTDLL__lseek(int handle,long offset,int origin)
1073{
1074 dprintf(("CRTDLL: _lssek\n"));
1075 return (_lseek(handle, offset, origin));
1076}
1077
1078
1079/*********************************************************************
1080 * _makepath (CRTDLL.180)
1081 */
1082void CDECL CRTDLL__makepath( char *path, char *drive,
1083 char *dir, char *fname, char *ext )
1084{
1085 dprintf(("CRTDLL: _makepath\n"));
1086 _makepath(path, drive, dir, fname, ext);
1087}
1088
1089
1090/*********************************************************************
1091 * _matherr (CRTDLL.181)
1092 */
1093double CDECL CRTDLL__matherr( struct exception * excep )
1094{
1095 dprintf(("CRTDLL: _matherr\n"));
1096 return (_matherr(excep));
1097}
1098
1099
1100/*********************************************************************
1101 * _mbbtombc (CRTDLL.182)
1102 */
1103unsigned int CDECL CRTDLL__mbbtombc( unsigned int ch )
1104{
1105 dprintf(("CRTDLL: _mbbtombc\n"));
1106 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1107 return FALSE;
1108}
1109
1110
1111/*********************************************************************
1112 * _mbbtype (CRTDLL.183)
1113 */
1114int CDECL CRTDLL__mbbtype( unsigned char s, int i )
1115{
1116 dprintf(("CRTDLL: _mbbtype\n"));
1117 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1118 return FALSE;
1119}
1120
1121
1122/*********************************************************************
1123 * _mbccpy (CRTDLL.184)
1124 */
1125void CDECL CRTDLL__mbccpy( unsigned char *dest, const unsigned char *ch )
1126{
1127 dprintf(("CRTDLL: _mbccpy\n"));
1128 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1129}
1130
1131
1132/*********************************************************************
1133 * _mbcjistojms (CRTDLL.185)
1134 */
1135int CDECL CRTDLL__mbcjistojms( unsigned int ch )
1136{
1137 dprintf(("CRTDLL: _mbcjistojms\n"));
1138 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1139 return FALSE;
1140}
1141
1142
1143/*********************************************************************
1144 * _mbcjmstojis (CRTDLL.186)
1145 */
1146int CDECL CRTDLL__mbcjmstojis( unsigned int ch )
1147{
1148 dprintf(("CRTDLL: _mbcjmstojis\n"));
1149 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1150 return FALSE;
1151}
1152
1153
1154/*********************************************************************
1155 * _mbclen (CRTDLL.187)
1156 */
1157size_t CDECL CRTDLL__mbclen( const unsigned char *ch )
1158{
1159 dprintf(("CRTDLL: _mbclen\n"));
1160 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1161 return FALSE;
1162}
1163
1164
1165/*********************************************************************
1166 * _mbctohira (CRTDLL.188)
1167 */
1168int CDECL CRTDLL__mbctohira( unsigned int ch )
1169{
1170 dprintf(("CRTDLL: _mbctohira\n"));
1171 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1172 return FALSE;
1173}
1174
1175
1176/*********************************************************************
1177 * _mbctokata (CRTDLL.189)
1178 */
1179int CDECL CRTDLL__mbctokata( unsigned int ch )
1180{
1181 dprintf(("CRTDLL: _mbctokata\n"));
1182 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1183 return FALSE;
1184}
1185
1186
1187/*********************************************************************
1188 * _mbctolower (CRTDLL.190)
1189 */
1190unsigned int CDECL CRTDLL__mbctolower( unsigned int ch )
1191{
1192 dprintf(("CRTDLL: _mbctolower\n"));
1193 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194 return FALSE;
1195}
1196
1197
1198/*********************************************************************
1199 * _mbctombb (CRTDLL.191)
1200 */
1201unsigned int CDECL CRTDLL__mbctombb( unsigned int ch )
1202{
1203 dprintf(("CRTDLL: _mbctombb\n"));
1204 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1205 return FALSE;
1206}
1207
1208
1209/*********************************************************************
1210 * _mbctoupper (CRTDLL.192)
1211 */
1212unsigned int CDECL CRTDLL__mbctoupper( unsigned int ch )
1213{
1214 dprintf(("CRTDLL: _mbctoupper\n"));
1215 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1216 return FALSE;
1217}
1218
1219
1220/*********************************************************************
1221 * _mbsbtype (CRTDLL.194)
1222 */
1223int CDECL CRTDLL__mbsbtype( const unsigned char *s1, int ch )
1224{
1225 dprintf(("CRTDLL: _mbsbtype\n"));
1226 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1227 return FALSE;
1228}
1229
1230
1231/*********************************************************************
1232 * _mbscat (CRTDLL.195)
1233 */
1234unsigned char * CDECL CRTDLL__mbscat( unsigned char *s1, const unsigned char *s2 )
1235{
1236 dprintf(("CRTDLL: _mbscat\n"));
1237 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1238 return FALSE;
1239}
1240
1241
1242/*********************************************************************
1243 * _mbschr (CRTDLL.196)
1244 */
1245unsigned char * CDECL CRTDLL__mbschr( const unsigned char *s, unsigned int ch )
1246{
1247 dprintf(("CRTDLL: _mbschr\n"));
1248 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1249 return FALSE;
1250}
1251
1252
1253/*********************************************************************
1254 * _mbscmp (CRTDLL.197)
1255 */
1256int CDECL CRTDLL__mbscmp( const unsigned char *s1, const unsigned char *s2 )
1257{
1258 dprintf(("CRTDLL: _mbscmp\n"));
1259 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1260 return FALSE;
1261}
1262
1263
1264/*********************************************************************
1265 * _mbscpy (CRTDLL.198)
1266 */
1267unsigned char * CDECL CRTDLL__mbscpy( unsigned char *s1, const unsigned char *s2 )
1268{
1269 dprintf(("CRTDLL: _mbscpy\n"));
1270 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1271 return FALSE;
1272}
1273
1274
1275/*********************************************************************
1276 * _mbscspn (CRTDLL.199)
1277 */
1278size_t CDECL CRTDLL__mbscspn( const unsigned char *s, const unsigned char *charset )
1279{
1280 dprintf(("CRTDLL: _mbscspn\n"));
1281 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1282 return FALSE;
1283}
1284
1285
1286/*********************************************************************
1287 * CRTDLL__mbsinc (CRTDLL.203)
1288 */
1289LPSTR CDECL CRTDLL__mbsinc( LPCSTR str )
1290{
1291 int len = mblen( str, MB_LEN_MAX );
1292 if (len < 1) len = 1;
1293 return (LPSTR)(str + len);
1294}
1295
1296
1297/*********************************************************************
1298 * CRTDLL__mbslen (CRTDLL.204)
1299 */
1300INT CDECL CRTDLL__mbslen( LPCSTR str )
1301{
1302 INT len, total = 0;
1303 while ((len = mblen( str, MB_LEN_MAX )) > 0)
1304 {
1305 str += len;
1306 total++;
1307 }
1308 return total;
1309}
1310
1311
1312/*********************************************************************
1313 * CRTDLL__mbsdec (CRTDLL.200)
1314 */
1315unsigned char * CDECL CRTDLL__mbsdec( const unsigned char *s, const unsigned char *ch )
1316{
1317 dprintf(("CRTDLL: _mbsdec\n"));
1318 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1319 return FALSE;
1320}
1321
1322
1323/*********************************************************************
1324 * CRTDLL__mbsdec (CRTDLL.201)
1325 */
1326unsigned char * CDECL CRTDLL__mbsdup( unsigned char *src )
1327{
1328 dprintf(("CRTDLL: _mbsdup\n"));
1329 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1330 return FALSE;
1331}
1332
1333
1334/*********************************************************************
1335 * CRTDLL__mbsicmp (CRTDLL.202)
1336 */
1337int CDECL CRTDLL__mbsicmp( const unsigned char *s1, const unsigned char *s2 )
1338{
1339 dprintf(("CRTDLL: _mbsicmp\n"));
1340 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1341 return FALSE;
1342}
1343
1344
1345/*********************************************************************
1346 * CRTDLL__mbslwr (CRTDLL.205)
1347 */
1348unsigned char * CDECL CRTDLL__mbslwr( unsigned char *s )
1349{
1350 dprintf(("CRTDLL: _mbslwr\n"));
1351 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1352 return FALSE;
1353}
1354
1355
1356/*********************************************************************
1357 * CRTDLL__mbsnbcat (CRTDLL.206)
1358 */
1359unsigned char * CDECL CRTDLL__mbsnbcat( unsigned char *s1, const unsigned char *s2, size_t n )
1360{
1361 dprintf(("CRTDLL: _mbsnbcat\n"));
1362 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1363 return FALSE;
1364}
1365
1366
1367/*********************************************************************
1368 * CRTDLL__mbsnbcmp (CRTDLL.207)
1369 */
1370int CDECL CRTDLL__mbsnbcmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1371{
1372 dprintf(("CRTDLL: _mbsnbcmp\n"));
1373 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1374 return FALSE;
1375}
1376
1377
1378/*********************************************************************
1379 * CRTDLL__mbsnbcnt (CRTDLL.208)
1380 */
1381size_t CDECL CRTDLL__mbsnbcnt( const unsigned char *s, size_t n )
1382{
1383 dprintf(("CRTDLL: _mbsnbcnt\n"));
1384 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1385 return FALSE;
1386}
1387
1388
1389/*********************************************************************
1390 * CRTDLL__mbsnbcpy (CRTDLL.209)
1391 */
1392unsigned char * CDECL CRTDLL__mbsnbcpy( unsigned char *s1, const unsigned char *s2, size_t n )
1393{
1394 dprintf(("CRTDLL: _mbsnbcpy\n"));
1395 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1396 return FALSE;
1397}
1398
1399
1400/*********************************************************************
1401 * CRTDLL__mbsnbicmp (CRTDLL.210)
1402 */
1403int CDECL CRTDLL__mbsnbicmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1404{
1405 dprintf(("CRTDLL: _mbsnbicmp\n"));
1406 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1407 return FALSE;
1408}
1409
1410
1411/*********************************************************************
1412 * CRTDLL__mbsnbset (CRTDLL.211)
1413 */
1414unsigned char * CDECL CRTDLL__mbsnbset( unsigned char *s, unsigned int ch, size_t n )
1415{
1416 dprintf(("CRTDLL: _mbsnbset\n"));
1417 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1418 return FALSE;
1419}
1420
1421
1422/*********************************************************************
1423 * CRTDLL__mbsncat (CRTDLL.212)
1424 */
1425unsigned char * CDECL CRTDLL__mbsncat( unsigned char *s1, const unsigned char *s2, size_t n )
1426{
1427 dprintf(("CRTDLL: _mbsncat\n"));
1428 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1429 return FALSE;
1430}
1431
1432
1433/*********************************************************************
1434 * CRTDLL__mbsnccnt (CRTDLL.213)
1435 */
1436size_t CDECL CRTDLL__mbsnccnt( const unsigned char *s, size_t n )
1437{
1438 dprintf(("CRTDLL: _mbsnccnt\n"));
1439 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1440 return FALSE;
1441}
1442
1443
1444/*********************************************************************
1445 * CRTDLL__mbsncmp (CRTDLL.214)
1446 */
1447int CDECL CRTDLL__mbsncmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1448{
1449 dprintf(("CRTDLL: _mbsncmp\n"));
1450 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1451 return FALSE;
1452}
1453
1454
1455/*********************************************************************
1456 * CRTDLL__mbsncpy (CRTDLL.215)
1457 */
1458unsigned char * CDECL CRTDLL__mbsncpy( unsigned char *s1, const unsigned char *s2, size_t n )
1459{
1460 dprintf(("CRTDLL: _mbsncpy\n"));
1461 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1462 return FALSE;
1463}
1464
1465
1466/*********************************************************************
1467 * CRTDLL__mbsnextc (CRTDLL.216)
1468 */
1469unsigned int CDECL CRTDLL__mbsnextc( const unsigned char *s )
1470{
1471 dprintf(("CRTDLL: _mbsnextc\n"));
1472 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1473 return FALSE;
1474}
1475
1476
1477/*********************************************************************
1478 * CRTDLL__mbsnicmp (CRTDLL.217)
1479 */
1480int CDECL CRTDLL__mbsnicmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1481{
1482 dprintf(("CRTDLL: _mbsnicmp\n"));
1483 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1484 return FALSE;
1485}
1486
1487
1488/*********************************************************************
1489 * CRTDLL__mbsninc (CRTDLL.218)
1490 */
1491unsigned char * CDECL CRTDLL__mbsninc( const unsigned char *s, size_t count )
1492{
1493 dprintf(("CRTDLL: _mbsninc\n"));
1494 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1495 return FALSE;
1496}
1497
1498
1499/*********************************************************************
1500 * CRTDLL__mbsnset (CRTDLL.219)
1501 */
1502unsigned char * CDECL CRTDLL__mbsnset( unsigned char *s, unsigned int ch, size_t n )
1503{
1504 dprintf(("CRTDLL: _mbsnset\n"));
1505 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1506 return FALSE;
1507}
1508
1509
1510/*********************************************************************
1511 * CRTDLL__mbspbrk (CRTDLL.220)
1512 */
1513unsigned char * CDECL CRTDLL__mbspbrk( const unsigned char *s, const unsigned char *charset )
1514{
1515 dprintf(("CRTDLL: _mbspbrk\n"));
1516 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1517 return FALSE;
1518}
1519
1520
1521/*********************************************************************
1522 * CRTDLL__mbsrchr (CRTDLL.221)
1523 */
1524unsigned char * CDECL CRTDLL__mbsrchr( const unsigned char *s, unsigned int ch )
1525{
1526 dprintf(("CRTDLL: _mbsrchr\n"));
1527 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1528 return FALSE;
1529}
1530
1531
1532/*********************************************************************
1533 * CRTDLL__mbsrev (CRTDLL.222)
1534 */
1535unsigned char * CDECL CRTDLL__mbsrev( unsigned char *s )
1536{
1537 dprintf(("CRTDLL: _mbsrev\n"));
1538 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1539 return FALSE;
1540}
1541
1542
1543/*********************************************************************
1544 * CRTDLL__mbsset (CRTDLL.223)
1545 */
1546unsigned char * CDECL CRTDLL__mbsset( unsigned char *s, unsigned int ch )
1547{
1548 dprintf(("CRTDLL: _mbsset\n"));
1549 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1550 return FALSE;
1551}
1552
1553
1554/*********************************************************************
1555 * CRTDLL__mbsspn (CRTDLL.224)
1556 */
1557size_t CDECL CRTDLL__mbsspn( const unsigned char *s, const unsigned char *charset )
1558{
1559 dprintf(("CRTDLL: _mbsspn\n"));
1560 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1561 return FALSE;
1562}
1563
1564
1565/*********************************************************************
1566 * CRTDLL__mbsspnp (CRTDLL.225)
1567 */
1568unsigned char * CDECL CRTDLL__mbsspnp( const unsigned char *s, const unsigned char *charset )
1569{
1570 dprintf(("CRTDLL: _mbsspnp\n"));
1571 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1572 return FALSE;
1573}
1574
1575
1576/*********************************************************************
1577 * CRTDLL__mbsstr (CRTDLL.226)
1578 */
1579unsigned char * CDECL CRTDLL__mbsstr( const unsigned char *s1, const unsigned char *s2 )
1580{
1581 dprintf(("CRTDLL: _mbsstr\n"));
1582 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1583 return FALSE;
1584}
1585
1586
1587/*********************************************************************
1588 * CRTDLL__mbstok (CRTDLL.227)
1589 */
1590unsigned char * CDECL CRTDLL__mbstok( unsigned char *s, const unsigned char *delim )
1591{
1592 dprintf(("CRTDLL: _mbstok\n"));
1593 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1594 return FALSE;
1595}
1596
1597
1598/*********************************************************************
1599 * CRTDLL__mbsupr (CRTDLL.229)
1600 */
1601unsigned char * CDECL CRTDLL__mbsupr( unsigned char *s )
1602{
1603 dprintf(("CRTDLL: _mbsupr\n"));
1604 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1605 return FALSE;
1606}
1607
1608
1609/*********************************************************************
1610 * _mkdir (CRTDLL.232)
1611 */
1612INT CDECL CRTDLL__mkdir(LPCSTR newdir)
1613{
1614 dprintf(("CRTDLL: mkdir\n"));
1615 if (!CreateDirectoryA(newdir,NULL))
1616 return -1;
1617 return 0;
1618}
1619
1620
1621/*********************************************************************
1622 * _mktemp (CRTDLL.233)
1623 */
1624char * CDECL CRTDLL__mktemp( char * templt )
1625{
1626 dprintf(("CRTDLL: _mktemp\n"));
1627 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1628 return FALSE;
1629}
1630
1631
1632/*********************************************************************
1633 * _msize (CRTDLL.234)
1634 */
1635size_t CDECL CRTDLL__msize( void *ptr )
1636{
1637 dprintf(("CRTDLL: _msize\n"));
1638 return (_msize(ptr));
1639}
1640
1641
1642/*********************************************************************
1643 * _open (CRTDLL.237)
1644 */
1645INT CDECL CRTDLL__open(const char *path,int oflag,...)
1646{
1647 dprintf(("CRTDLL: _open\n"));
1648 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1649 return FALSE;
1650}
1651
1652
1653/*********************************************************************
1654 * _open_osfhandle (CRTDLL.238)
1655 */
1656INT CDECL CRTDLL__open_osfhandle( long osfhandle, int flags )
1657{
1658 dprintf(("CRTDLL: _open_osfhandle\n"));
1659 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1660 return FALSE;
1661}
1662
1663
1664/*********************************************************************
1665 * _pclose (CRTDLL.244)
1666 */
1667INT CDECL CRTDLL__pclose( FILE *fp )
1668{
1669 dprintf(("CRTDLL: _pclose\n"));
1670 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1671 return FALSE;
1672}
1673
1674
1675/*********************************************************************
1676 * _pctype_dll (CRTDLL.245)
1677 * FIXME - Could not find anything about it
1678 */
1679INT CDECL CRTDLL__pctype_dll(DWORD ret)
1680{
1681 dprintf(("CRTDLL: _pctype_dll\n"));
1682
1683 return 0;
1684}
1685
1686
1687/*********************************************************************
1688 * _pipe (CRTDLL.247)
1689 */
1690INT CDECL CRTDLL__pipe( int *phandles, unsigned psize, int textmode )
1691{
1692 dprintf(("CRTDLL: _pipe\n"));
1693 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1694 return FALSE;
1695}
1696
1697
1698/*********************************************************************
1699 * _popen (CRTDLL.248)
1700 */
1701FILE * CDECL CRTDLL__popen( const char *command, const char *mode )
1702{
1703 dprintf(("CRTDLL: _popen\n"));
1704 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1705 return FALSE;
1706}
1707
1708/*********************************************************************
1709 * _read (CRTDLL.254)
1710 *
1711 * BUGS
1712 * Unimplemented
1713 */
1714INT CDECL CRTDLL__read(INT fd, LPVOID buf, UINT count)
1715{
1716 dprintf(("CRTDLL: _read\n"));
1717 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1718 return FALSE;
1719}
1720
1721
1722/*********************************************************************
1723 * _putw (CRTDLL.252)
1724 */
1725INT CDECL CRTDLL__putw( int binint, FILE *fp )
1726{
1727 dprintf(("CRTDLL: _putw\n"));
1728 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1729 return FALSE;
1730}
1731
1732
1733/*********************************************************************
1734 * CRTDLL__rotl (CRTDLL.257)
1735 */
1736unsigned int CDECL CRTDLL__rotl( unsigned int value, unsigned int shift )
1737{
1738 dprintf(("CRTDLL: _rotl\n"));
1739 return (_rotl(value, shift));
1740}
1741
1742
1743/*********************************************************************
1744 * CRTDLL__rotr (CRTDLL.258)
1745 */
1746unsigned int CDECL CRTDLL__rotr( unsigned int value, unsigned int shift )
1747{
1748 dprintf(("CRTDLL: _rotr\n"));
1749 return (_rotr(value, shift));
1750}
1751
1752
1753/*********************************************************************
1754 * CRTDLL__searchenv (CRTDLL.260)
1755 */
1756void CDECL CRTDLL__searchenv( const char *name, const char *env_var, char *buf )
1757{
1758 dprintf(("CRTDLL: _searchenv\n"));
1759 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1760}
1761
1762
1763/*********************************************************************
1764 * CRTDLL__setjmp (CRTDLL.262)
1765 */
1766int CDECL CRTDLL__setjmp( jmp_buf env )
1767{
1768 dprintf(("CRTDLL: _setjmp -> setjmp\n"));
1769 return(setjmp( env));
1770}
1771
1772
1773/*********************************************************************
1774 * CRTDLL__stat (CRTDLL.278)
1775 */
1776int CDECL CRTDLL__stat( const char *s1, struct stat * n )
1777{
1778 dprintf(("CRTDLL: _stat\n"));
1779 return(_stat(s1, n));
1780}
1781
1782
1783/*********************************************************************
1784 * CRTDLL__strdate (CRTDLL.281)
1785 */
1786char * CDECL CRTDLL__strdate( char *buf )
1787{
1788 dprintf(("CRTDLL: _strdate\n"));
1789 return(_strdate(buf));
1790}
1791
1792
1793/*********************************************************************
1794 * CRTDLL__strdec (CRTDLL.282)
1795 */
1796char * CDECL CRTDLL__strdec( const char *, const char *p )
1797{
1798 dprintf(("CRTDLL: _strdec\n"));
1799 return( (char *)(p-1) );
1800}
1801
1802
1803/*********************************************************************
1804 * CRTDLL__strdup (CRTDLL.283)
1805 */
1806char * CDECL CRTDLL__strdup( const char *string )
1807{
1808 dprintf(("CRTDLL: _strdup\n"));
1809 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1810 return FALSE;
1811}
1812
1813
1814/*********************************************************************
1815 * CRTDLL__stricoll (CRTDLL.286)
1816 */
1817int CDECL CRTDLL__stricoll( const char *s1, const char *s2 )
1818{
1819 dprintf(("CRTDLL: _stricoll\n"));
1820 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1821 return FALSE;
1822}
1823
1824
1825/*********************************************************************
1826 * CRTDLL__strinc (CRTDLL.287)
1827 */
1828char * CDECL CRTDLL__strinc( const char *p )
1829{
1830 dprintf(("CRTDLL: _strinc\n"));
1831 return( (char *)(p+1) );
1832}
1833
1834
1835/*********************************************************************
1836 * CRTDLL__strncnt (CRTDLL.289)
1837 */
1838size_t CDECL CRTDLL__strncnt( const char *p, size_t l )
1839{
1840 dprintf(("CRTDLL: _strncnt\n"));
1841 size_t i;
1842 i = strlen(p);
1843 return( (i>l) ? l : i );
1844}
1845
1846/*********************************************************************
1847 * CRTDLL__strnextc (CRTDLL.290)
1848 */
1849unsigned int CDECL CRTDLL__strnextc( const char *p )
1850{
1851 dprintf(("CRTDLL: _strnextc\n"));
1852 return( (unsigned int)*p );
1853}
1854
1855
1856/*********************************************************************
1857 * CRTDLL__strninc (CRTDLL.292)
1858 */
1859char * CDECL CRTDLL__strninc( const char *p, size_t l )
1860{
1861 dprintf(("CRTDLL: _strninc\n"));
1862 return( (char *)(p+l) );
1863}
1864
1865
1866/*********************************************************************
1867 * CRTDLL__strnset (CRTDLL.293)
1868 */
1869char * CDECL CRTDLL__strnset( char *string, int c, size_t len )
1870{
1871 dprintf(("CRTDLL: _strnset\n"));
1872 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1873 return FALSE;
1874}
1875
1876
1877/*********************************************************************
1878 * CRTDLL__strrev (CRTDLL.294)
1879 */
1880char * CDECL CRTDLL__strrev( char *string )
1881{
1882 dprintf(("CRTDLL: _strrev\n"));
1883 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1884 return FALSE;
1885}
1886
1887
1888/*********************************************************************
1889 * CRTDLL__strset (CRTDLL.295)
1890 */
1891char * CDECL CRTDLL__strset( char *string, int c )
1892{
1893 dprintf(("CRTDLL: _strset\n"));
1894 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1895 return FALSE;
1896}
1897
1898
1899/*********************************************************************
1900 * CRTDLL__strspnp (CRTDLL.296)
1901 */
1902char * CDECL CRTDLL__strspnp( const char *p1, const char *p2 )
1903{
1904 dprintf(("CRTDLL: _strspnp\n"));
1905 return( (*(p1 += strspn(p1,p2))!='\0') ? (char*)p1 : NULL );
1906}
1907
1908
1909/*********************************************************************
1910 * CRTDLL__strtime (CRTDLL.297)
1911 */
1912char * CDECL CRTDLL__strtime( char *buf )
1913{
1914 dprintf(("CRTDLL: _strtime\n"));
1915 return (_strtime(buf));
1916}
1917
1918
1919/*********************************************************************
1920 * CRTDLL__tempnam (CRTDLL.303)
1921 */
1922char * CDECL CRTDLL__tempnam( char *dir, char *prefix )
1923{
1924 dprintf(("CRTDLL: _tempnam\n"));
1925 return (_tempnam(dir, prefix));
1926}
1927
1928
1929/*********************************************************************
1930 * CRTDLL__tolower (CRTDLL.305)
1931 */
1932int CDECL CRTDLL__tolower(int n)
1933{
1934 dprintf(("CRTDLL: _tolower\n"));
1935 return (_tolower(n));
1936}
1937
1938
1939/*********************************************************************
1940 * CRTDLL__toupper (CRTDLL.306)
1941 */
1942int CDECL CRTDLL__toupper(int n)
1943{
1944 dprintf(("CRTDLL: _toupper\n"));
1945 return (_toupper(n));
1946}
1947
1948
1949/*********************************************************************
1950 * CRTDLL__utime (CRTDLL.314)
1951 */
1952int CDECL CRTDLL__utime( char *path, struct utimbuf * times )
1953{
1954 dprintf(("CRTDLL: _utime\n"));
1955 return (_utime(path, times));
1956}
1957
1958
1959/*********************************************************************
1960 * CRTDLL__vsnwprintf (CRTDLL.316)
1961 */
1962int CDECL CRTDLL__vsnwprintf( wchar_t *s1, size_t n, const wchar_t *s2, va_list arg )
1963{
1964 dprintf(("CRTDLL: _vsnwprintf\n"));
1965 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1966 return FALSE;
1967}
1968
1969
1970/*********************************************************************
1971 * CRTDLL__wcsdup (CRTDLL.317)
1972 */
1973wchar_t * CDECL CRTDLL__wcsdup( const wchar_t *s1 )
1974{
1975 dprintf(("CRTDLL: _wcsdup\n"));
1976 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1977 return FALSE;
1978}
1979
1980
1981/*********************************************************************
1982 * CRTDLL__wcsicoll (CRTDLL.319)
1983 */
1984int CDECL CRTDLL__wcsicoll( const wchar_t *s1, const wchar_t *s2 )
1985{
1986 dprintf(("CRTDLL: _wcsicoll\n"));
1987 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1988 return FALSE;
1989}
1990
1991
1992/*********************************************************************
1993 * CRTDLL__wcsnset (CRTDLL.322)
1994 */
1995LPWSTR CDECL CRTDLL__wcsnset( LPWSTR str, WCHAR c, INT n )
1996{
1997 LPWSTR ret = str;
1998 while ((n-- > 0) && *str) *str++ = c;
1999 return ret;
2000}
2001
2002
2003/*********************************************************************
2004 * CRTDLL__wcsrev (CRTDLL.323)
2005 */
2006wchar_t * CDECL CRTDLL__wcsrev( wchar_t *s1 )
2007{
2008 dprintf(("CRTDLL: _wcsrev\n"));
2009 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2010 return FALSE;
2011}
2012
2013
2014/*********************************************************************
2015 * CRTDLL__wcsset (CRTDLL.324)
2016 */
2017LPWSTR CDECL CRTDLL__wcsset( LPWSTR str, WCHAR c )
2018{
2019 LPWSTR ret = str;
2020 while (*str) *str++ = c;
2021 return ret;
2022}
2023
2024/*********************************************************************
2025 * isleadbyte (CRTDLL.335)
2026 */
2027void CDECL CRTDLL_abort( void )
2028{
2029 dprintf(("CRTDLL: abort\n"));
2030 abort();
2031}
2032
2033/*********************************************************************
2034 * acos (CRTDLL.336)
2035 */
2036double CDECL CRTDLL_acos( double x )
2037{
2038 dprintf(("CRTDLL: acos\n"));
2039 return (acos(x));
2040}
2041
2042/*********************************************************************
2043 * asctime (CRTDLL.338)
2044 */
2045char * CDECL CRTDLL_asctime( const struct tm *timeptr )
2046{
2047 dprintf(("CRTDLL: asctime\n"));
2048 return (asctime(timeptr));
2049}
2050
2051/*********************************************************************
2052 * asin (CRTDLL.339)
2053 */
2054double CDECL CRTDLL_asin( double x )
2055{
2056 dprintf(("CRTDLL: asin\n"));
2057 return (asin(x));
2058}
2059
2060/*********************************************************************
2061 * atan2 (CRTDLL.341)
2062 */
2063double CDECL CRTDLL_atan2( double y, double x )
2064{
2065 dprintf(("CRTDLL: atan2\n"));
2066 return (atan2(y, x));
2067}
2068
2069/*********************************************************************
2070 * atexit (CRTDLL.342)
2071 */
2072int CDECL CRTDLL_atexit( register void ( *func )( void ) )
2073{
2074 dprintf(("CRTDLL: atexit\n"));
2075 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2076 return FALSE;
2077}
2078
2079/*********************************************************************
2080 * atof (CRTDLL.343)
2081 */
2082double CDECL CRTDLL_atof( const char *nptr )
2083{
2084 dprintf(("CRTDLL: atof\n"));
2085 return (atof(nptr));
2086}
2087
2088/*********************************************************************
2089 * bsearch (CRTDLL.346)
2090 */
2091void * CDECL CRTDLL_bsearch( const void *key, const void *base, size_t nmemb,
2092 size_t size, int (*compar)(const void *pkey, const void *pbase) )
2093{
2094 dprintf(("CRTDLL: bsearch\n"));
2095 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2096 return FALSE;
2097}
2098
2099/*********************************************************************
2100 * calloc (CRTDLL.347)
2101 */
2102void * CDECL CRTDLL_calloc( size_t n, size_t size )
2103{
2104 dprintf(("CRTDLL: calloc\n"));
2105 return (calloc(n, size));
2106}
2107
2108/*********************************************************************
2109 * clearerr (CRTDLL.349)
2110 */
2111void CDECL CRTDLL_clearerr( FILE *fp )
2112{
2113 dprintf(("CRTDLL: clearerr\n"));
2114 clearerr(fp);
2115}
2116
2117/*********************************************************************
2118 * clock (CRTDLL.350)
2119 */
2120clock_t CDECL CRTDLL_clock( void )
2121{
2122 dprintf(("CRTDLL: clock\n"));
2123 return (clock());
2124}
2125
2126/*********************************************************************
2127 * cosh (CRTDLL.352)
2128 */
2129double CDECL CRTDLL_cosh( double x )
2130{
2131 dprintf(("CRTDLL: cosh\n"));
2132 return (cosh(x));
2133}
2134
2135/*********************************************************************
2136 * ctime (CRTDLL.353)
2137 */
2138char * CDECL CRTDLL_ctime( const time_t *timer )
2139{
2140 dprintf(("CRTDLL: ctime\n"));
2141 return (ctime(timer));
2142}
2143
2144/*********************************************************************
2145 * difftime (CRTDLL.354)
2146 */
2147double CDECL CRTDLL_difftime( time_t t1, time_t t0 )
2148{
2149 dprintf(("CRTDLL: difftime\n"));
2150 return (difftime(t1, t0));
2151}
2152
2153/*********************************************************************
2154 * div (CRTDLL.355)
2155 */
2156div_t CDECL CRTDLL_div( int numer, int denom )
2157{
2158 dprintf(("CRTDLL: div\n"));
2159 return (div(numer, denom));
2160}
2161
2162/*********************************************************************
2163 * exit (CRTDLL.356)
2164 */
2165void CDECL CRTDLL_exit(DWORD ret)
2166{
2167 dprintf(("CRTDLL: exit\n"));
2168 ExitProcess(ret);
2169}
2170
2171/*********************************************************************
2172 * exp (CRTDLL.357)
2173 */
2174double CDECL CRTDLL_exp( double x )
2175{
2176 dprintf(("CRTDLL: exp\n"));
2177 return (exp(x));
2178}
2179
2180/*********************************************************************
2181 * fclose (CRTDLL.359)
2182 */
2183int CDECL CRTDLL_fclose( FILE *fp )
2184{
2185 dprintf(("CRTDLL: fclose\n"));
2186 return (fclose(fp));
2187}
2188
2189/*********************************************************************
2190 * feof (CRTDLL.360)
2191 */
2192int CDECL CRTDLL_feof( FILE *fp )
2193{
2194 dprintf(("CRTDLL: feof\n"));
2195 return (feof(fp));
2196}
2197
2198/*********************************************************************
2199 * ferror (CRTDLL.361)
2200 */
2201int CDECL CRTDLL_ferror( FILE *fp )
2202{
2203 dprintf(("CRTDLL: ferror\n"));
2204 return (ferror(fp));
2205}
2206
2207/*********************************************************************
2208 * fflush (CRTDLL.362)
2209 */
2210int CDECL CRTDLL_fflush( FILE *fp )
2211{
2212 dprintf(("CRTDLL: fflush\n"));
2213 return (fflush(fp));
2214}
2215
2216/*********************************************************************
2217 * fgetc (CRTDLL.363)
2218 */
2219int CDECL CRTDLL_fgetc( FILE *fp )
2220{
2221 dprintf(("CRTDLL: fgetc\n"));
2222 return (fgetc(fp));
2223}
2224
2225/*********************************************************************
2226 * fgetpos (CRTDLL.364)
2227 */
2228int CDECL CRTDLL_fgetpos( FILE *fp, fpos_t *pos )
2229{
2230 dprintf(("CRTDLL: fgetpos\n"));
2231 return (fgetpos(fp, pos));
2232}
2233
2234/*********************************************************************
2235 * fgets (CRTDLL.365)
2236 */
2237char * CDECL CRTDLL_fgets( char *s, int n, FILE *fp )
2238{
2239 dprintf(("CRTDLL: fgets\n"));
2240 return (fgets(s, n, fp));
2241}
2242
2243/*********************************************************************
2244 * fgetwc (CRTDLL.366)
2245 */
2246wint_t CDECL CRTDLL_fgetwc( FILE *f )
2247{
2248 dprintf(("CRTDLL: fgetwc\n"));
2249 return (fgetwc(f));
2250}
2251
2252/*********************************************************************
2253 * fmod (CRTDLL.368)
2254 */
2255double CDECL CRTDLL_fmod(double x, double y )
2256{
2257 dprintf(("CRTDLL: fmod\n"));
2258 return (fmod(x,y));
2259}
2260
2261/*********************************************************************
2262 * fopen (CRTDLL.369)
2263 */
2264FILE * CDECL CRTDLL_fopen( const char *filename, const char *mode )
2265{
2266 dprintf(("CRTDLL: fopen\n"));
2267 return (fopen( filename, mode));
2268}
2269
2270/*********************************************************************
2271 * fprintf (CRTDLL.370)
2272 */
2273INT CDECL CRTDLL_fprintf( CRTDLL_FILE *file, LPSTR format, ... )
2274{
2275 dprintf(("CRTDLL: fprintf\n"));
2276 va_list valist;
2277 INT res;
2278
2279 va_start( valist, format );
2280 res = CRTDLL_vfprintf( file, format, valist );
2281 va_end( valist );
2282 return res;
2283}
2284
2285/*********************************************************************
2286 * fputc (CRTDLL.371)
2287 */
2288int CDECL CRTDLL_fputc( int c, FILE *fp )
2289{
2290 dprintf(("CRTDLL: fputc\n"));
2291 return (fputc(c, fp));
2292}
2293
2294/*********************************************************************
2295 * fputs (CRTDLL.372)
2296 */
2297int CDECL CRTDLL_fputs( const char *s, FILE *fp )
2298{
2299 dprintf(("CRTDLL: fputs\n"));
2300 return (fputs(s, fp));
2301}
2302
2303/*********************************************************************
2304 * fputwc (CRTDLL.373)
2305 */
2306wint_t CDECL CRTDLL_fputwc( wint_t wc, FILE *strm )
2307{
2308 dprintf(("CRTDLL: fputwc\n"));
2309 return (fputwc(wc, strm));
2310}
2311
2312/*********************************************************************
2313 * fread (CRTDLL.374)
2314 */
2315size_t CDECL CRTDLL_fread( void *ptr, size_t size, size_t n, FILE *fp )
2316{
2317 dprintf(("CRTDLL: fread\n"));
2318 return (fread(ptr, size, n, fp));
2319}
2320
2321/*********************************************************************
2322 * free (CRTDLL.375)
2323 */
2324VOID CDECL CRTDLL_free(LPVOID ptr)
2325{
2326 dprintf(("CRTDLL: free\n"));
2327 HeapFree(GetProcessHeap(),0,ptr);
2328}
2329
2330/*********************************************************************
2331 * freopen (CRTDLL.376)
2332 */
2333FILE * CDECL CRTDLL_freopen( const char *filename, const char *mode, FILE *fp )
2334{
2335 dprintf(("CRTDLL: freopen\n"));
2336 return (freopen(filename, mode, fp));
2337}
2338
2339/*********************************************************************
2340 * frexp (CRTDLL.377)
2341 */
2342double CDECL CRTDLL_frexp( double value, int *exp )
2343{
2344 dprintf(("CRTDLL: frexp\n"));
2345 return (frexp(value, exp));
2346}
2347
2348/*********************************************************************
2349 * fscanf (CRTDLL.378)
2350 */
2351int CDECL CRTDLL_fscanf( FILE*fp, const char *format, ... )
2352{
2353 dprintf(("CRTDLL: frexp\n"));
2354 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2355 return FALSE;
2356}
2357
2358/*********************************************************************
2359 * fseek (CRTDLL.379)
2360 */
2361int CDECL CRTDLL_fseek( FILE *fp, long int offset, int whence )
2362{
2363 dprintf(("CRTDLL: fseek\n"));
2364 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2365 return FALSE;
2366}
2367
2368/*********************************************************************
2369 * fsetpos (CRTDLL.380)
2370 */
2371int CDECL CRTDLL_fsetpos( FILE *fp, const fpos_t *pos )
2372{
2373 dprintf(("CRTDLL: fsetpos\n"));
2374 return (fsetpos(fp, pos));
2375}
2376
2377/*********************************************************************
2378 * ftell (CRTDLL.381)
2379 */
2380long int CDECL CRTDLL_ftell( FILE *fp )
2381{
2382 dprintf(("CRTDLL: ftell\n"));
2383 return (ftell(fp));
2384}
2385
2386/*********************************************************************
2387 * fwprintf (CRTDLL.382)
2388 */
2389int CDECL CRTDLL_fwprintf( FILE *strm, const wchar_t *format, ... )
2390{
2391 dprintf(("CRTDLL: fwprintf\n"));
2392 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2393 return FALSE;
2394}
2395
2396/*********************************************************************
2397 * fwrite (CRTDLL.383)
2398 */
2399DWORD CDECL CRTDLL_fwrite( LPVOID ptr, INT size, INT nmemb, CRTDLL_FILE *file )
2400{
2401 DWORD ret;
2402
2403 dprintf(("CRTDLL: fwrite\n"));
2404 WriteFile( file->handle, ptr, size * nmemb, &ret, NULL );
2405 return ret / size;
2406}
2407
2408/*********************************************************************
2409 * fwscanf (CRTDLL.384)
2410 */
2411int CDECL CRTDLL_fwscanf( FILE *strm, const wchar_t *format, ... )
2412{
2413 dprintf(("CRTDLL: fwscanf\n"));
2414 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2415 return FALSE;
2416}
2417
2418/*********************************************************************
2419 * getc (CRTDLL.385)
2420 */
2421int CDECL CRTDLL_getc( FILE *fp )
2422{
2423 dprintf(("CRTDLL: getc\n"));
2424 return (getc(fp));
2425}
2426
2427/*********************************************************************
2428 * getchar (CRTDLL.386)
2429 */
2430int CDECL CRTDLL_getchar( void )
2431{
2432 dprintf(("CRTDLL: getchar\n"));
2433 return (getchar());
2434}
2435
2436/*********************************************************************
2437 * getenv (CRTDLL.387)
2438 */
2439char * CDECL CRTDLL_getenv( const char *name )
2440{
2441 dprintf(("CRTDLL: getenv\n"));
2442 return (getenv(name));
2443}
2444
2445/*********************************************************************
2446 * gets (CRTDLL.388)
2447 */
2448char * CDECL CRTDLL_gets( char *s )
2449{
2450 dprintf(("CRTDLL: gets\n"));
2451 return (gets(s));
2452}
2453
2454/*********************************************************************
2455 * gmtime (CRTDLL.389)
2456 */
2457struct tm * CDECL CRTDLL_gmtime( const time_t *timer )
2458{
2459 dprintf(("CRTDLL: gmtime\n"));
2460 return (gmtime(timer));
2461}
2462
2463/*********************************************************************
2464 * is_wctype (CRTDLL.390)
2465 * FIXME - Could not find anything about it
2466 */
2467INT CDECL CRTDLL_is_wctype(DWORD ret)
2468{
2469 dprintf(("CRTDLL: is_wctype\n"));
2470 return 0;
2471}
2472
2473/*********************************************************************
2474 * isalnum (CRTDLL.391)
2475 */
2476int CDECL CRTDLL_isalnum(int i)
2477{
2478 dprintf(("CRTDLL: isalnum(%08xh)\n", i));
2479 return (isalnum(i));
2480}
2481
2482/*********************************************************************
2483 * iscntrl (CRTDLL.393)
2484 */
2485int CDECL CRTDLL_iscntrl(int i)
2486{
2487 dprintf(("CRTDLL: iscntrl(%08xh)\n", i));
2488 return (iscntrl(i));
2489}
2490
2491/*********************************************************************
2492 * isgraph (CRTDLL.395)
2493 */
2494int CDECL CRTDLL_isgraph(int i)
2495{
2496 dprintf(("CRTDLL: isgraph(%08xh)\n", i));
2497 return (isgraph(i));
2498}
2499
2500/*********************************************************************
2501 * isleadbyte (CRTDLL.396)
2502 */
2503int CDECL CRTDLL_isleadbyte(int i)
2504{
2505 dprintf(("CRTDLL: isleadbyte(%08xh)\n", i));
2506 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2507 return FALSE;
2508}
2509
2510/*********************************************************************
2511 * ispunct (CRTDLL.399)
2512 */
2513int CDECL CRTDLL_ispunct(int i)
2514{
2515 dprintf(("CRTDLL: ispunct(%08xh)\n", i));
2516 return (ispunct(i));
2517}
2518
2519/*********************************************************************
2520 * iswalnum (CRTDLL.402)
2521 */
2522int CDECL CRTDLL_iswalnum(wint_t i)
2523{
2524 dprintf(("CRTDLL: iswalnum(%08xh)\n", i));
2525
2526 return (iswalnum(i));
2527}
2528
2529/*********************************************************************
2530 * iswascii (CRTDLL.404)
2531 */
2532int CDECL CRTDLL_iswascii(wint_t i)
2533{
2534 dprintf(("CRTDLL: iswascii(%08xh)\n", i));
2535
2536 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2537 return FALSE;
2538}
2539
2540/*********************************************************************
2541 * iswcntrl (CRTDLL.405)
2542 */
2543int CDECL CRTDLL_iswcntrl(wint_t i)
2544{
2545 dprintf(("CRTDLL: iswcntrl(%08xh)\n", i));
2546
2547 return (iswcntrl(i));
2548}
2549
2550/*********************************************************************
2551 * iswdigit (CRTDLL.407)
2552 */
2553int CDECL CRTDLL_iswdigit(wint_t i)
2554{
2555 dprintf(("CRTDLL: iswdigit(%08xh)\n", i));
2556
2557 return (iswdigit(i));
2558}
2559
2560/*********************************************************************
2561 * iswgraph (CRTDLL.408)
2562 */
2563int CDECL CRTDLL_iswgraph(wint_t i)
2564{
2565 dprintf(("CRTDLL: iswgraph(%08xh)\n", i));
2566
2567 return (iswgraph(i));
2568}
2569
2570/*********************************************************************
2571 * iswlower (CRTDLL.409)
2572 */
2573int CDECL CRTDLL_iswlower(wint_t i)
2574{
2575 dprintf(("CRTDLL: iswlower(%08xh)\n", i));
2576
2577 return (iswlower(i));
2578}
2579
2580/*********************************************************************
2581 * iswprint (CRTDLL.410)
2582 */
2583int CDECL CRTDLL_iswprint(wint_t i)
2584{
2585 dprintf(("CRTDLL: iswprint(%08xh)\n", i));
2586
2587 return (iswprint(i));
2588}
2589
2590/*********************************************************************
2591 * iswpunct (CRTDLL.411)
2592 */
2593int CDECL CRTDLL_iswpunct(wint_t i)
2594{
2595 dprintf(("CRTDLL: iswpunct(%08xh)\n", i));
2596
2597 return (iswpunct(i));
2598}
2599
2600/*********************************************************************
2601 * iswspace (CRTDLL.412)
2602 */
2603int CDECL CRTDLL_iswspace(wint_t i)
2604{
2605 dprintf(("CRTDLL: iswspace(%08xh)\n", i));
2606
2607 return (iswspace(i));
2608}
2609
2610/*********************************************************************
2611 * iswupper (CRTDLL.413)
2612 */
2613int CDECL CRTDLL_iswupper(wint_t i)
2614{
2615 dprintf(("CRTDLL: iswupper(%08xh)\n", i));
2616
2617 return (iswupper(i));
2618}
2619
2620/*********************************************************************
2621 * iswxdigit (CRTDLL.414)
2622 */
2623int CDECL CRTDLL_iswxdigit(wint_t i)
2624{
2625 dprintf(("CRTDLL: iswxdigit(%08xh)\n", i));
2626
2627 return (iswxdigit(i));
2628}
2629
2630/*********************************************************************
2631 * ldexp (CRTDLL.417)
2632 */
2633double CDECL CRTDLL_ldexp( double x, int exp )
2634{
2635 dprintf(("CRTDLL: ldexp\n"));
2636
2637 return (ldexp(x, exp));
2638}
2639
2640/*********************************************************************
2641 * ldiv (CRTDLL.418)
2642 */
2643ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom )
2644{
2645 dprintf(("CRTDLL: ldiv\n"));
2646
2647 return (ldiv(numer, denom));
2648}
2649
2650/*********************************************************************
2651 * localeconv (CRTDLL.419)
2652 */
2653struct lconv * CDECL CRTDLL_localeconv(void)
2654{
2655 dprintf(("CRTDLL: localeconv\n"));
2656 return (localeconv());
2657}
2658
2659/*********************************************************************
2660 * localtime (CRTDLL.420)
2661 */
2662struct tm * CDECL CRTDLL_localtime( const time_t *timer )
2663{
2664 dprintf(("CRTDLL: localtime\n"));
2665 return (localtime(timer));
2666}
2667
2668/*********************************************************************
2669 * log10 (CRTDLL.422)
2670 */
2671double CDECL CRTDLL_log10( double x )
2672{
2673 dprintf(("CRTDLL: log10\n"));
2674 return (log10(x));
2675}
2676
2677/*********************************************************************
2678 * longjmp (CRTDLL.423)
2679 */
2680VOID CDECL CRTDLL_longjmp(jmp_buf env, int val)
2681{
2682 dprintf(("CRTDLL: longjmp\n"));
2683 longjmp(env, val);
2684}
2685
2686/*********************************************************************
2687 * malloc (CRTDLL.424)
2688 */
2689VOID* CDECL CRTDLL_malloc(DWORD size)
2690{
2691 dprintf(("CRTDLL: malloc\n"));
2692 return HeapAlloc(GetProcessHeap(),0,size);
2693}
2694
2695/*********************************************************************
2696 * mblen (CRTDLL.425)
2697 */
2698INT CDECL CRTDLL_mblen( const char *s, size_t n )
2699{
2700 dprintf(("CRTDLL: mblen\n"));
2701 return (mblen(s, n));
2702}
2703
2704/*********************************************************************
2705 * CRTDLL_mbtowc (CRTDLL.427)
2706 */
2707INT CDECL CRTDLL_mbtowc( WCHAR *dst, LPCSTR str, INT n )
2708{
2709 wchar_t res;
2710 int ret = mbtowc( &res, str, n );
2711 if (dst) *dst = (WCHAR)res;
2712 return ret;
2713}
2714
2715/*********************************************************************
2716 * mktime (CRTDLL.433)
2717 */
2718time_t CDECL CRTDLL_mktime( struct tm *timeptr )
2719{
2720 dprintf(("CRTDLL: mktime\n"));
2721 return mktime( timeptr );
2722}
2723
2724/*********************************************************************
2725 * modf (CRTDLL.434)
2726 */
2727double CDECL CRTDLL_modf( double value, double *iptr )
2728{
2729 dprintf(("CRTDLL: modf\n"));
2730 return modf( value, iptr );
2731}
2732
2733/*********************************************************************
2734 * perror (CRTDLL.435)
2735 */
2736void CDECL CRTDLL_perror( const char *s )
2737{
2738 dprintf(("CRTDLL: perror\n"));
2739 perror( s );
2740}
2741
2742/*********************************************************************
2743 * printf (CRTDLL.437)
2744 */
2745int CDECL CRTDLL_printf( const char *format, ... )
2746{
2747 dprintf(("CRTDLL: printf\n"));
2748 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2749 return FALSE;
2750}
2751
2752/*********************************************************************
2753 * putc (CRTDLL.438)
2754 */
2755int CDECL CRTDLL_putc( int c, FILE *fp )
2756{
2757 dprintf(("CRTDLL: putc\n"));
2758 return putc( c, fp );
2759}
2760
2761/*********************************************************************
2762 * putchar (CRTDLL.439)
2763 */
2764int CDECL CRTDLL_putchar( int c )
2765{
2766 dprintf(("CRTDLL: putchar\n"));
2767 return putchar( c );
2768}
2769
2770/*********************************************************************
2771 * puts (CRTDLL.440)
2772 */
2773int CDECL CRTDLL_puts( const char *s )
2774{
2775 dprintf(("CRTDLL: puts\n"));
2776 return puts( s );
2777}
2778
2779/*********************************************************************
2780 * raise (CRTDLL.442)
2781 */
2782int CDECL CRTDLL_raise( int sig )
2783{
2784 dprintf(("CRTDLL: raise\n"));
2785 return raise( sig );
2786}
2787
2788/*********************************************************************
2789 * rand (CRTDLL.443)
2790 */
2791int CDECL CRTDLL_rand( void )
2792{
2793 dprintf(("CRTDLL: rand\n"));
2794 return (rand());
2795}
2796
2797/*********************************************************************
2798 * realloc (CRTDLL.444)
2799 */
2800void * CDECL CRTDLL_realloc( void *ptr, size_t size )
2801{
2802 dprintf(("CRTDLL: realloc\n"));
2803 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2804 return FALSE;
2805}
2806
2807/*********************************************************************
2808 * remove (CRTDLL.445)
2809 */
2810INT CDECL CRTDLL_remove(LPCSTR file)
2811{
2812 dprintf(("CRTDLL: remove\n"));
2813 if (!DeleteFileA(file))
2814 return -1;
2815 return 0;
2816}
2817
2818/*********************************************************************
2819 * rename (CRTDLL.446)
2820 */
2821int CDECL CRTDLL_rename (const char *old, const char *new2)
2822{
2823 dprintf(("CRTDLL: rename\n"));
2824 return (rename(old, new2));
2825}
2826
2827/*********************************************************************
2828 * rewind (CRTDLL.447)
2829 */
2830void CDECL CRTDLL_rewind( FILE *fp )
2831{
2832 dprintf(("CRTDLL: rewind\n"));
2833 rewind(fp);
2834}
2835
2836/*********************************************************************
2837 * scanf (CRTDLL.448)
2838 */
2839int CDECL CRTDLL_scanf( const char *format, ... )
2840{
2841 dprintf(("CRTDLL: scanf\n"));
2842 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2843 return FALSE;
2844}
2845
2846/*********************************************************************
2847 * setbuf (CRTDLL.449)
2848 */
2849void CDECL CRTDLL_setbuf( FILE *fp, char *buf )
2850{
2851 dprintf(("CRTDLL: setbuf\n"));
2852 setbuf(fp, buf);
2853}
2854
2855/*********************************************************************
2856 * setlocale (CRTDLL.450)
2857 */
2858char * CDECL CRTDLL_setlocale(int category,const char *locale)
2859{
2860 dprintf(("CRTDLL: setlocale\n"));
2861 return (setlocale(category, locale));
2862}
2863
2864/*********************************************************************
2865 * setvbuf (CRTDLL.451)
2866 */
2867int CDECL CRTDLL_setvbuf( FILE *fp, char *buf, int mode, size_t size )
2868{
2869 dprintf(("CRTDLL: setvbuf\n"));
2870 return (setvbuf(fp, buf, mode, size));
2871}
2872
2873/*********************************************************************
2874 * signal (CRTDLL.452)
2875 */
2876void CDECL CRTDLL_signal( int sig, void (*func)(int))
2877{
2878 dprintf(("CRTDLL: signal\n"));
2879 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2880}
2881
2882/*********************************************************************
2883 * sinh (CRTDLL.454)
2884 */
2885double CDECL CRTDLL_sinh( double x )
2886{
2887 dprintf(("CRTDLL: sinh\n"));
2888 return (sinh(x));
2889}
2890
2891/*********************************************************************
2892 * srand (CRTDLL.457)
2893 */
2894void CDECL CRTDLL_srand( unsigned int seed )
2895{
2896 dprintf(("CRTDLL: srand\n"));
2897 srand(seed);
2898}
2899
2900/*********************************************************************
2901 * strcoll (CRTDLL.462)
2902 */
2903int CDECL CRTDLL_strcoll( const char *s1, const char *s2 )
2904{
2905 dprintf(("CRTDLL: strcoll\n"));
2906 return strcoll(s1, s2);
2907}
2908
2909/*********************************************************************
2910 * strerror (CRTDLL.465)
2911 */
2912char * CDECL CRTDLL_strerror( int errnum )
2913{
2914 dprintf(("CRTDLL: strerror\n"));
2915 return strerror(errnum);
2916}
2917
2918/*********************************************************************
2919 * strftime (CRTDLL.466)
2920 */
2921size_t CDECL CRTDLL_strftime( char *s, size_t maxsiz, const char *fmt, const struct tm *tp )
2922{
2923 dprintf(("CRTDLL: strftime\n"));
2924 return strftime(s, maxsiz, fmt, tp);
2925}
2926
2927
2928/*********************************************************************
2929 * strtod (CRTDLL.475)
2930 */
2931double CDECL CRTDLL_strtod( const char *nptr, char **endptr )
2932{
2933 dprintf(("CRTDLL: strtod\n"));
2934 return strtod(nptr, endptr);
2935}
2936
2937/*********************************************************************
2938 * strtok (CRTDLL.476)
2939 */
2940char * CDECL CRTDLL_strtok( char *s1, const char *s2 )
2941{
2942 dprintf(("CRTDLL: strtok\n"));
2943 return strtok(s1, s2);
2944}
2945
2946/*********************************************************************
2947 * strtol (CRTDLL.477)
2948 */
2949long int CDECL CRTDLL_strtol( const char *nptr, char **endptr, int base )
2950{
2951 dprintf(("CRTDLL: strtol\n"));
2952 return strtol(nptr, endptr, base);
2953}
2954
2955/*********************************************************************
2956 * strtoul (CRTDLL.478)
2957 */
2958unsigned long CDECL CRTDLL_strtoul( const char *nptr, char **endptr, int base )
2959{
2960 dprintf(("CRTDLL: strtoul\n"));
2961 return strtoul(nptr, endptr, base);
2962}
2963
2964/*********************************************************************
2965 * strxfrm (CRTDLL.479)
2966 */
2967size_t CDECL CRTDLL_strxfrm( char *s1, const char *s2, size_t n )
2968{
2969 dprintf(("CRTDLL: strxfrm\n"));
2970 return strxfrm(s1, s2, n);
2971}
2972
2973/*********************************************************************
2974 * swscanf (CRTDLL.481)
2975 */
2976int CDECL CRTDLL_swscanf( const wchar_t *s1, const wchar_t *s2, ... )
2977{
2978 dprintf(("CRTDLL: swscanf\n"));
2979 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2980 return FALSE;
2981}
2982
2983/*********************************************************************
2984 * system (CRTDLL.482)
2985 */
2986int CDECL CRTDLL_system( const char *string )
2987{
2988 dprintf(("CRTDLL: system\n"));
2989 return system(string);
2990}
2991
2992/*********************************************************************
2993 * tanh (CRTDLL.485)
2994 */
2995double CDECL CRTDLL_tanh( double x )
2996{
2997 dprintf(("CRTDLL: tanh\n"));
2998 return tanh(x);
2999}
3000
3001/*********************************************************************
3002 * time (CRTDLL.485)
3003 */
3004time_t CDECL CRTDLL_time( time_t *timer )
3005{
3006 dprintf(("CRTDLL: time\n"));
3007
3008 return time(timer);
3009}
3010
3011/*********************************************************************
3012 * tmpnam (CRTDLL.486)
3013 */
3014FILE * CDECL CRTDLL_tmpfile( void )
3015{
3016 dprintf(("CRTDLL: tmpfile\n"));
3017 return (tmpfile());
3018}
3019
3020/*********************************************************************
3021 * tmpnam (CRTDLL.487)
3022 */
3023char * CDECL CRTDLL_tmpnam( char *s )
3024{
3025 dprintf(("CRTDLL: tmpnam\n"));
3026
3027 return (tmpnam(s));
3028}
3029
3030/*********************************************************************
3031 * ungetc (CRTDLL.492)
3032 */
3033INT CDECL CRTDLL_ungetc(int c)
3034{
3035 dprintf(("CRTDLL: ungetc\n"));
3036 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3037 return FALSE;
3038}
3039
3040/*********************************************************************
3041 * ungetwc (CRTDLL.493)
3042 */
3043wint_t CDECL CRTDLL_ungetwc( wint_t wc, FILE *strm )
3044{
3045 dprintf(("CRTDLL: ungetwc\n"));
3046
3047 return (ungetwc(wc, strm));
3048}
3049
3050/*********************************************************************
3051 * vfprintf (CRTDLL.494)
3052 */
3053INT CDECL CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args )
3054{
3055 dprintf(("CRTDLL: vprintf\n"));
3056 char buffer[2048]; /* FIXME... */
3057
3058 vsprintf( buffer, format, args );
3059 return CRTDLL_fwrite( buffer, 1, strlen(buffer), file );
3060}
3061
3062/*********************************************************************
3063 * vfwprintf (CRTDLL.495)
3064 */
3065int CDECL CRTDLL_vfwprintf( FILE *F, const wchar_t *s, va_list arg )
3066{
3067 dprintf(("CRTDLL: vfwprintf\n"));
3068 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3069 return FALSE;
3070}
3071
3072/*********************************************************************
3073 * vprintf (CRTDLL.496)
3074 */
3075int CDECL CRTDLL_vprintf( const char *format, __va_list arg )
3076{
3077 dprintf(("CRTDLL: vprintf\n"));
3078
3079 return (vprintf(format, arg));
3080}
3081
3082/*********************************************************************
3083 * vswprintf (CRTDLL.498)
3084 */
3085int CDECL CRTDLL_vswprintf( wchar_t *s , size_t t, const wchar_t *format, va_list arg )
3086{
3087 dprintf(("CRTDLL: vswprintf\n"));
3088
3089 return (vswprintf(s, t, format, arg));
3090}
3091
3092/*********************************************************************
3093 * vwprintf (CRTDLL.499)
3094 */
3095int CDECL CRTDLL_vwprintf( const wchar_t *s, va_list arg)
3096{
3097 dprintf(("CRTDLL: vwprintf\n"));
3098 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3099 return FALSE;
3100}
3101
3102
3103/*********************************************************************
3104 * wcscoll (CRTDLL.503)
3105 */
3106int CDECL CRTDLL_wcscoll(const wchar_t *s1, const wchar_t *s2)
3107{
3108 dprintf(("CRTDLL: wcscoll\n"));
3109
3110 return (wcscoll(s1, s2));
3111}
3112
3113/*********************************************************************
3114 * wcsftime (CRTDLL.506)
3115 */
3116size_t CDECL CRTDLL_wcsftime( wchar_t *s, size_t maxsize,
3117 const wchar_t *format, const struct tm *timeptr )
3118{
3119 dprintf(("CRTDLL: wcsftime\n"));
3120
3121 return (wcsftime(s, maxsize, format, timeptr));
3122}
3123
3124/*********************************************************************
3125 * wcstod (CRTDLL.515)
3126 */
3127double CDECL CRTDLL_wcstod( const wchar_t *nptr, wchar_t **endptr )
3128{
3129 dprintf(("CRTDLL: wcstod\n"));
3130 return (wcstod(nptr, endptr));
3131}
3132
3133/*********************************************************************
3134 * wcsxfrm (CRTDLL.520)
3135 */
3136size_t CDECL CRTDLL_wcsxfrm( wchar_t *s1, const wchar_t *s2, size_t n )
3137{
3138 dprintf(("CRTDLL: wcsxfrm\n"));
3139
3140 return (wcsxfrm(s1, s2, n));
3141}
3142
3143/*********************************************************************
3144 * wcstomb (CRTDLL.521)
3145 */
3146int CDECL CRTDLL_wctomb( char *s, wchar_t wchar )
3147{
3148 dprintf(("CRTDLL: wctomb\n"));
3149
3150 return (wctomb(s,wchar));
3151}
3152
3153/*********************************************************************
3154 * wprintf (CRTDLL.522)
3155 */
3156int CDECL CRTDLL_wprintf( const wchar_t *s, ... )
3157{
3158 dprintf(("CRTDLL: wprintf\n"));
3159 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3160 return FALSE;
3161}
3162
3163/*********************************************************************
3164 * wscanf (CRTDLL.523)
3165 */
3166int CDECL CRTDLL_wscanf( const wchar_t *s, ... )
3167{
3168 dprintf(("CRTDLL: wscanf\n"));
3169 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3170 return FALSE;
3171}
3172
3173
3174INT WINAPI lstrncmpiA( LPCSTR str1, LPCSTR str2, INT n )
3175{
3176 dprintf(("CRTDLL: lstrncmpiA\n"));
3177 //CB: implement!
3178 return 0;
3179}
Note: See TracBrowser for help on using the repository browser.