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

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

update from Jens Weissner
File size: 74.3 KB
Line 
1/* $Id: crtdll.cpp,v 1.4 1999-09-18 15:58: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// unsigned int _mbbtombc( unsigned int __ch );
1100// unsigned int _mbctombb( unsigned int __ch );
1101
1102
1103/*********************************************************************
1104 * _mbscspn (CRTDLL.199)
1105 */
1106size_t CDECL CRTDLL__mbscspn( const unsigned char *s, const unsigned char *charset )
1107{
1108 dprintf(("CRTDLL: _mbscspn\n"));
1109 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1110 return FALSE;
1111}
1112
1113
1114
1115/*********************************************************************
1116 * CRTDLL__mbsinc (CRTDLL.203)
1117 */
1118LPSTR CDECL CRTDLL__mbsinc( LPCSTR str )
1119{
1120 int len = mblen( str, MB_LEN_MAX );
1121 if (len < 1) len = 1;
1122 return (LPSTR)(str + len);
1123}
1124
1125
1126/*********************************************************************
1127 * CRTDLL__mbslen (CRTDLL.204)
1128 */
1129INT CDECL CRTDLL__mbslen( LPCSTR str )
1130{
1131 INT len, total = 0;
1132 while ((len = mblen( str, MB_LEN_MAX )) > 0)
1133 {
1134 str += len;
1135 total++;
1136 }
1137 return total;
1138}
1139
1140
1141/*********************************************************************
1142 * CRTDLL__mbsdec (CRTDLL.200)
1143 */
1144unsigned char * CDECL CRTDLL__mbsdec( const unsigned char *s, const unsigned char *ch )
1145{
1146 dprintf(("CRTDLL: _mbsdec\n"));
1147 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1148 return FALSE;
1149}
1150
1151
1152/*********************************************************************
1153 * CRTDLL__mbsdec (CRTDLL.201)
1154 */
1155unsigned char * CDECL CRTDLL__mbsdup( unsigned char *src )
1156{
1157 dprintf(("CRTDLL: _mbsdup\n"));
1158 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1159 return FALSE;
1160}
1161
1162
1163/*********************************************************************
1164 * CRTDLL__mbsicmp (CRTDLL.202)
1165 */
1166int CDECL CRTDLL__mbsicmp( const unsigned char *s1, const unsigned char *s2 )
1167{
1168 dprintf(("CRTDLL: _mbsicmp\n"));
1169 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1170 return FALSE;
1171}
1172
1173
1174/*********************************************************************
1175 * CRTDLL__mbslwr (CRTDLL.205)
1176 */
1177unsigned char * CDECL CRTDLL__mbslwr( unsigned char *s )
1178{
1179 dprintf(("CRTDLL: _mbslwr\n"));
1180 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1181 return FALSE;
1182}
1183
1184
1185/*********************************************************************
1186 * CRTDLL__mbsnbcat (CRTDLL.206)
1187 */
1188unsigned char * CDECL CRTDLL__mbsnbcat( unsigned char *s1, const unsigned char *s2, size_t n )
1189{
1190 dprintf(("CRTDLL: _mbsnbcat\n"));
1191 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1192 return FALSE;
1193}
1194
1195
1196/*********************************************************************
1197 * CRTDLL__mbsnbcmp (CRTDLL.207)
1198 */
1199int CDECL CRTDLL__mbsnbcmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1200{
1201 dprintf(("CRTDLL: _mbsnbcmp\n"));
1202 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1203 return FALSE;
1204}
1205
1206
1207/*********************************************************************
1208 * CRTDLL__mbsnbcnt (CRTDLL.208)
1209 */
1210size_t CDECL CRTDLL__mbsnbcnt( const unsigned char *s, size_t n )
1211{
1212 dprintf(("CRTDLL: _mbsnbcnt\n"));
1213 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1214 return FALSE;
1215}
1216
1217
1218/*********************************************************************
1219 * CRTDLL__mbsnbcpy (CRTDLL.209)
1220 */
1221unsigned char * CDECL CRTDLL__mbsnbcpy( unsigned char *s1, const unsigned char *s2, size_t n )
1222{
1223 dprintf(("CRTDLL: _mbsnbcpy\n"));
1224 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1225 return FALSE;
1226}
1227
1228
1229/*********************************************************************
1230 * CRTDLL__mbsnbicmp (CRTDLL.210)
1231 */
1232int CDECL CRTDLL__mbsnbicmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1233{
1234 dprintf(("CRTDLL: _mbsnbicmp\n"));
1235 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1236 return FALSE;
1237}
1238
1239
1240/*********************************************************************
1241 * CRTDLL__mbsnbset (CRTDLL.211)
1242 */
1243unsigned char * CDECL CRTDLL__mbsnbset( unsigned char *s, unsigned int ch, size_t n )
1244{
1245 dprintf(("CRTDLL: _mbsnbset\n"));
1246 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1247 return FALSE;
1248}
1249
1250
1251/*********************************************************************
1252 * CRTDLL__mbsncat (CRTDLL.212)
1253 */
1254unsigned char * CDECL CRTDLL__mbsncat( unsigned char *s1, const unsigned char *s2, size_t n )
1255{
1256 dprintf(("CRTDLL: _mbsncat\n"));
1257 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1258 return FALSE;
1259}
1260
1261
1262/*********************************************************************
1263 * CRTDLL__mbsnccnt (CRTDLL.213)
1264 */
1265size_t CDECL CRTDLL__mbsnccnt( const unsigned char *s, size_t n )
1266{
1267 dprintf(("CRTDLL: _mbsnccnt\n"));
1268 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1269 return FALSE;
1270}
1271
1272
1273/*********************************************************************
1274 * CRTDLL__mbsncmp (CRTDLL.214)
1275 */
1276int CDECL CRTDLL__mbsncmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1277{
1278 dprintf(("CRTDLL: _mbsncmp\n"));
1279 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1280 return FALSE;
1281}
1282
1283
1284/*********************************************************************
1285 * CRTDLL__mbsncpy (CRTDLL.215)
1286 */
1287unsigned char * CDECL CRTDLL__mbsncpy( unsigned char *s1, const unsigned char *s2, size_t n )
1288{
1289 dprintf(("CRTDLL: _mbsncpy\n"));
1290 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1291 return FALSE;
1292}
1293
1294
1295/*********************************************************************
1296 * CRTDLL__mbsnextc (CRTDLL.216)
1297 */
1298unsigned int CDECL CRTDLL__mbsnextc( const unsigned char *s )
1299{
1300 dprintf(("CRTDLL: _mbsnextc\n"));
1301 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1302 return FALSE;
1303}
1304
1305
1306/*********************************************************************
1307 * CRTDLL__mbsnicmp (CRTDLL.217)
1308 */
1309int CDECL CRTDLL__mbsnicmp( const unsigned char *s1, const unsigned char *s2, size_t n )
1310{
1311 dprintf(("CRTDLL: _mbsnicmp\n"));
1312 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1313 return FALSE;
1314}
1315
1316
1317/*********************************************************************
1318 * CRTDLL__mbsninc (CRTDLL.218)
1319 */
1320unsigned char * CDECL CRTDLL__mbsninc( const unsigned char *s, size_t count )
1321{
1322 dprintf(("CRTDLL: _mbsninc\n"));
1323 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1324 return FALSE;
1325}
1326
1327
1328/*********************************************************************
1329 * CRTDLL__mbsnset (CRTDLL.219)
1330 */
1331unsigned char * CDECL CRTDLL__mbsnset( unsigned char *s, unsigned int ch, size_t n )
1332{
1333 dprintf(("CRTDLL: _mbsnset\n"));
1334 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1335 return FALSE;
1336}
1337
1338
1339/*********************************************************************
1340 * CRTDLL__mbspbrk (CRTDLL.220)
1341 */
1342unsigned char * CDECL CRTDLL__mbspbrk( const unsigned char *s, const unsigned char *charset )
1343{
1344 dprintf(("CRTDLL: _mbspbrk\n"));
1345 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1346 return FALSE;
1347}
1348
1349
1350/*********************************************************************
1351 * CRTDLL__mbsrchr (CRTDLL.221)
1352 */
1353unsigned char * CDECL CRTDLL__mbsrchr( const unsigned char *s, unsigned int ch )
1354{
1355 dprintf(("CRTDLL: _mbsrchr\n"));
1356 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1357 return FALSE;
1358}
1359
1360
1361/*********************************************************************
1362 * CRTDLL__mbsrev (CRTDLL.222)
1363 */
1364unsigned char * CDECL CRTDLL__mbsrev( unsigned char *s )
1365{
1366 dprintf(("CRTDLL: _mbsrev\n"));
1367 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1368 return FALSE;
1369}
1370
1371
1372/*********************************************************************
1373 * CRTDLL__mbsset (CRTDLL.223)
1374 */
1375unsigned char * CDECL CRTDLL__mbsset( unsigned char *s, unsigned int ch )
1376{
1377 dprintf(("CRTDLL: _mbsset\n"));
1378 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1379 return FALSE;
1380}
1381
1382
1383/*********************************************************************
1384 * CRTDLL__mbsspn (CRTDLL.224)
1385 */
1386size_t CDECL CRTDLL__mbsspn( const unsigned char *s, const unsigned char *charset )
1387{
1388 dprintf(("CRTDLL: _mbsspn\n"));
1389 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1390 return FALSE;
1391}
1392
1393
1394/*********************************************************************
1395 * CRTDLL__mbsspnp (CRTDLL.225)
1396 */
1397unsigned char * CDECL CRTDLL__mbsspnp( const unsigned char *s, const unsigned char *charset )
1398{
1399 dprintf(("CRTDLL: _mbsspnp\n"));
1400 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1401 return FALSE;
1402}
1403
1404
1405/*********************************************************************
1406 * CRTDLL__mbsstr (CRTDLL.226)
1407 */
1408unsigned char * CDECL CRTDLL__mbsstr( const unsigned char *s1, const unsigned char *s2 )
1409{
1410 dprintf(("CRTDLL: _mbsstr\n"));
1411 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1412 return FALSE;
1413}
1414
1415
1416/*********************************************************************
1417 * CRTDLL__mbstok (CRTDLL.227)
1418 */
1419unsigned char * CDECL CRTDLL__mbstok( unsigned char *s, const unsigned char *delim )
1420{
1421 dprintf(("CRTDLL: _mbstok\n"));
1422 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1423 return FALSE;
1424}
1425
1426
1427/*********************************************************************
1428 * CRTDLL__mbsupr (CRTDLL.229)
1429 */
1430unsigned char * CDECL CRTDLL__mbsupr( unsigned char *s )
1431{
1432 dprintf(("CRTDLL: _mbsupr\n"));
1433 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434 return FALSE;
1435}
1436
1437
1438/*********************************************************************
1439 * _mkdir (CRTDLL.232)
1440 */
1441INT CDECL CRTDLL__mkdir(LPCSTR newdir)
1442{
1443 dprintf(("CRTDLL: mkdir\n"));
1444 if (!CreateDirectoryA(newdir,NULL))
1445 return -1;
1446 return 0;
1447}
1448
1449
1450/*********************************************************************
1451 * _mktemp (CRTDLL.233)
1452 */
1453char * CDECL CRTDLL__mktemp( char * templt )
1454{
1455 dprintf(("CRTDLL: _mktemp\n"));
1456 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1457 return FALSE;
1458}
1459
1460
1461/*********************************************************************
1462 * _msize (CRTDLL.234)
1463 */
1464size_t CDECL CRTDLL__msize( void *ptr )
1465{
1466 dprintf(("CRTDLL: _msize\n"));
1467 return (_msize(ptr));
1468}
1469
1470
1471/*********************************************************************
1472 * _open (CRTDLL.237)
1473 */
1474INT CDECL CRTDLL__open(const char *path,int oflag,...)
1475{
1476 dprintf(("CRTDLL: _open\n"));
1477 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1478 return FALSE;
1479}
1480
1481
1482/*********************************************************************
1483 * _open_osfhandle (CRTDLL.238)
1484 */
1485INT CDECL CRTDLL__open_osfhandle( long osfhandle, int flags )
1486{
1487 dprintf(("CRTDLL: _open_osfhandle\n"));
1488 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1489 return FALSE;
1490}
1491
1492
1493/*********************************************************************
1494 * _pclose (CRTDLL.244)
1495 */
1496INT CDECL CRTDLL__pclose( FILE *fp )
1497{
1498 dprintf(("CRTDLL: _pclose\n"));
1499 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1500 return FALSE;
1501}
1502
1503
1504/*********************************************************************
1505 * _pctype_dll (CRTDLL.245)
1506 * FIXME - Could not find anything about it
1507 */
1508INT CDECL CRTDLL__pctype_dll(DWORD ret)
1509{
1510 dprintf(("CRTDLL: _pctype_dll\n"));
1511
1512 return 0;
1513}
1514
1515
1516/*********************************************************************
1517 * _pipe (CRTDLL.247)
1518 */
1519INT CDECL CRTDLL__pipe( int *phandles, unsigned psize, int textmode )
1520{
1521 dprintf(("CRTDLL: _pipe\n"));
1522 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1523 return FALSE;
1524}
1525
1526
1527/*********************************************************************
1528 * _popen (CRTDLL.248)
1529 */
1530FILE * CDECL CRTDLL__popen( const char *command, const char *mode )
1531{
1532 dprintf(("CRTDLL: _popen\n"));
1533 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1534 return FALSE;
1535}
1536
1537/*********************************************************************
1538 * _read (CRTDLL.254)
1539 *
1540 * BUGS
1541 * Unimplemented
1542 */
1543INT CDECL CRTDLL__read(INT fd, LPVOID buf, UINT count)
1544{
1545 dprintf(("CRTDLL: _read\n"));
1546 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1547 return FALSE;
1548}
1549
1550
1551/*********************************************************************
1552 * _putw (CRTDLL.252)
1553 */
1554INT CDECL CRTDLL__putw( int binint, FILE *fp )
1555{
1556 dprintf(("CRTDLL: _putw\n"));
1557 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1558 return FALSE;
1559}
1560
1561
1562/*********************************************************************
1563 * CRTDLL__rotl (CRTDLL.257)
1564 */
1565unsigned int CDECL CRTDLL__rotl( unsigned int value, unsigned int shift )
1566{
1567 dprintf(("CRTDLL: _rotl\n"));
1568 return (_rotl(value, shift));
1569}
1570
1571
1572/*********************************************************************
1573 * CRTDLL__rotr (CRTDLL.258)
1574 */
1575unsigned int CDECL CRTDLL__rotr( unsigned int value, unsigned int shift )
1576{
1577 dprintf(("CRTDLL: _rotr\n"));
1578 return (_rotr(value, shift));
1579}
1580
1581
1582/*********************************************************************
1583 * CRTDLL__searchenv (CRTDLL.260)
1584 */
1585void CDECL CRTDLL__searchenv( const char *name, const char *env_var, char *buf )
1586{
1587 dprintf(("CRTDLL: _searchenv\n"));
1588 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1589}
1590
1591
1592/*********************************************************************
1593 * CRTDLL__setjmp (CRTDLL.262)
1594 */
1595int CDECL CRTDLL__setjmp( jmp_buf env )
1596{
1597 dprintf(("CRTDLL: _setjmp -> setjmp\n"));
1598 return(setjmp( env));
1599}
1600
1601
1602/*********************************************************************
1603 * CRTDLL__stat (CRTDLL.278)
1604 */
1605int CDECL CRTDLL__stat( const char *s1, struct stat * n )
1606{
1607 dprintf(("CRTDLL: _stat\n"));
1608 return(_stat(s1, n));
1609}
1610
1611
1612/*********************************************************************
1613 * CRTDLL__strdate (CRTDLL.281)
1614 */
1615char * CDECL CRTDLL__strdate( char *buf )
1616{
1617 dprintf(("CRTDLL: _strdate\n"));
1618 return(_strdate(buf));
1619}
1620
1621
1622/*********************************************************************
1623 * CRTDLL__strdec (CRTDLL.282)
1624 */
1625char * CDECL CRTDLL__strdec( const char *, const char *p )
1626{
1627 dprintf(("CRTDLL: _strdec\n"));
1628 return( (char *)(p-1) );
1629}
1630
1631
1632/*********************************************************************
1633 * CRTDLL__strdup (CRTDLL.283)
1634 */
1635char * CDECL CRTDLL__strdup( const char *string )
1636{
1637 dprintf(("CRTDLL: _strdup\n"));
1638 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1639 return FALSE;
1640}
1641
1642
1643/*********************************************************************
1644 * CRTDLL__stricoll (CRTDLL.286)
1645 */
1646int CDECL CRTDLL__stricoll( const char *s1, const char *s2 )
1647{
1648 dprintf(("CRTDLL: _stricoll\n"));
1649 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1650 return FALSE;
1651}
1652
1653
1654/*********************************************************************
1655 * CRTDLL__strinc (CRTDLL.287)
1656 */
1657char * CDECL CRTDLL__strinc( const char *p )
1658{
1659 dprintf(("CRTDLL: _strinc\n"));
1660 return( (char *)(p+1) );
1661}
1662
1663
1664/*********************************************************************
1665 * CRTDLL__strncnt (CRTDLL.289)
1666 */
1667size_t CDECL CRTDLL__strncnt( const char *p, size_t l )
1668{
1669 dprintf(("CRTDLL: _strncnt\n"));
1670 size_t i;
1671 i = strlen(p);
1672 return( (i>l) ? l : i );
1673}
1674
1675/*********************************************************************
1676 * CRTDLL__strnextc (CRTDLL.290)
1677 */
1678unsigned int CDECL CRTDLL__strnextc( const char *p )
1679{
1680 dprintf(("CRTDLL: _strnextc\n"));
1681 return( (unsigned int)*p );
1682}
1683
1684
1685/*********************************************************************
1686 * CRTDLL__strninc (CRTDLL.292)
1687 */
1688char * CDECL CRTDLL__strninc( const char *p, size_t l )
1689{
1690 dprintf(("CRTDLL: _strninc\n"));
1691 return( (char *)(p+l) );
1692}
1693
1694
1695/*********************************************************************
1696 * CRTDLL__strnset (CRTDLL.293)
1697 */
1698char * CDECL CRTDLL__strnset( char *string, int c, size_t len )
1699{
1700 dprintf(("CRTDLL: _strnset\n"));
1701 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1702 return FALSE;
1703}
1704
1705
1706/*********************************************************************
1707 * CRTDLL__strrev (CRTDLL.294)
1708 */
1709char * CDECL CRTDLL__strrev( char *string )
1710{
1711 dprintf(("CRTDLL: _strrev\n"));
1712 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1713 return FALSE;
1714}
1715
1716
1717/*********************************************************************
1718 * CRTDLL__strset (CRTDLL.295)
1719 */
1720char * CDECL CRTDLL__strset( char *string, int c )
1721{
1722 dprintf(("CRTDLL: _strset\n"));
1723 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1724 return FALSE;
1725}
1726
1727
1728/*********************************************************************
1729 * CRTDLL__strspnp (CRTDLL.296)
1730 */
1731char * CDECL CRTDLL__strspnp( const char *p1, const char *p2 )
1732{
1733 dprintf(("CRTDLL: _strspnp\n"));
1734 return( (*(p1 += strspn(p1,p2))!='\0') ? (char*)p1 : NULL );
1735}
1736
1737
1738/*********************************************************************
1739 * CRTDLL__strtime (CRTDLL.297)
1740 */
1741char * CDECL CRTDLL__strtime( char *buf )
1742{
1743 dprintf(("CRTDLL: _strtime\n"));
1744 return (_strtime(buf));
1745}
1746
1747
1748/*********************************************************************
1749 * CRTDLL__tempnam (CRTDLL.303)
1750 */
1751char * CDECL CRTDLL__tempnam( char *dir, char *prefix )
1752{
1753 dprintf(("CRTDLL: _tempnam\n"));
1754 return (_tempnam(dir, prefix));
1755}
1756
1757
1758/*********************************************************************
1759 * CRTDLL__tolower (CRTDLL.305)
1760 */
1761int CDECL CRTDLL__tolower(int n)
1762{
1763 dprintf(("CRTDLL: _tolower\n"));
1764 return (_tolower(n));
1765}
1766
1767
1768/*********************************************************************
1769 * CRTDLL__toupper (CRTDLL.306)
1770 */
1771int CDECL CRTDLL__toupper(int n)
1772{
1773 dprintf(("CRTDLL: _toupper\n"));
1774 return (_toupper(n));
1775}
1776
1777
1778/*********************************************************************
1779 * CRTDLL__utime (CRTDLL.314)
1780 */
1781int CDECL CRTDLL__utime( char *path, struct utimbuf * times )
1782{
1783 dprintf(("CRTDLL: _utime\n"));
1784 return (_utime(path, times));
1785}
1786
1787
1788/*********************************************************************
1789 * CRTDLL__vsnwprintf (CRTDLL.316)
1790 */
1791int CDECL CRTDLL__vsnwprintf( wchar_t *s1, size_t n, const wchar_t *s2, va_list arg )
1792{
1793 dprintf(("CRTDLL: _vsnwprintf\n"));
1794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1795 return FALSE;
1796}
1797
1798
1799/*********************************************************************
1800 * CRTDLL__wcsdup (CRTDLL.317)
1801 */
1802wchar_t * CDECL CRTDLL__wcsdup( const wchar_t *s1 )
1803{
1804 dprintf(("CRTDLL: _wcsdup\n"));
1805 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1806 return FALSE;
1807}
1808
1809
1810/*********************************************************************
1811 * CRTDLL__wcsicoll (CRTDLL.319)
1812 */
1813int CDECL CRTDLL__wcsicoll( const wchar_t *s1, const wchar_t *s2 )
1814{
1815 dprintf(("CRTDLL: _wcsicoll\n"));
1816 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1817 return FALSE;
1818}
1819
1820
1821/*********************************************************************
1822 * CRTDLL__wcsnset (CRTDLL.322)
1823 */
1824LPWSTR CDECL CRTDLL__wcsnset( LPWSTR str, WCHAR c, INT n )
1825{
1826 LPWSTR ret = str;
1827 while ((n-- > 0) && *str) *str++ = c;
1828 return ret;
1829}
1830
1831
1832/*********************************************************************
1833 * CRTDLL__wcsrev (CRTDLL.323)
1834 */
1835wchar_t * CDECL CRTDLL__wcsrev( wchar_t *s1 )
1836{
1837 dprintf(("CRTDLL: _wcsrev\n"));
1838 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1839 return FALSE;
1840}
1841
1842
1843/*********************************************************************
1844 * CRTDLL__wcsset (CRTDLL.324)
1845 */
1846LPWSTR CDECL CRTDLL__wcsset( LPWSTR str, WCHAR c )
1847{
1848 LPWSTR ret = str;
1849 while (*str) *str++ = c;
1850 return ret;
1851}
1852
1853/*********************************************************************
1854 * isleadbyte (CRTDLL.335)
1855 */
1856void CDECL CRTDLL_abort( void )
1857{
1858 dprintf(("CRTDLL: abort\n"));
1859 abort();
1860}
1861
1862/*********************************************************************
1863 * acos (CRTDLL.336)
1864 */
1865double CDECL CRTDLL_acos( double x )
1866{
1867 dprintf(("CRTDLL: acos\n"));
1868 return (acos(x));
1869}
1870
1871/*********************************************************************
1872 * asctime (CRTDLL.338)
1873 */
1874char * CDECL CRTDLL_asctime( const struct tm *timeptr )
1875{
1876 dprintf(("CRTDLL: asctime\n"));
1877 return (asctime(timeptr));
1878}
1879
1880/*********************************************************************
1881 * asin (CRTDLL.339)
1882 */
1883double CDECL CRTDLL_asin( double x )
1884{
1885 dprintf(("CRTDLL: asin\n"));
1886 return (asin(x));
1887}
1888
1889/*********************************************************************
1890 * atan2 (CRTDLL.341)
1891 */
1892double CDECL CRTDLL_atan2( double y, double x )
1893{
1894 dprintf(("CRTDLL: atan2\n"));
1895 return (atan2(y, x));
1896}
1897
1898/*********************************************************************
1899 * atexit (CRTDLL.342)
1900 */
1901int CDECL CRTDLL_atexit( register void ( *func )( void ) )
1902{
1903 dprintf(("CRTDLL: atexit\n"));
1904 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1905 return FALSE;
1906}
1907
1908/*********************************************************************
1909 * atof (CRTDLL.343)
1910 */
1911double CDECL CRTDLL_atof( const char *nptr )
1912{
1913 dprintf(("CRTDLL: atof\n"));
1914 return (atof(nptr));
1915}
1916
1917/*********************************************************************
1918 * bsearch (CRTDLL.346)
1919 */
1920void * CDECL CRTDLL_bsearch( const void *key, const void *base, size_t nmemb,
1921 size_t size, int (*compar)(const void *pkey, const void *pbase) )
1922{
1923 dprintf(("CRTDLL: bsearch\n"));
1924 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1925 return FALSE;
1926}
1927
1928/*********************************************************************
1929 * calloc (CRTDLL.347)
1930 */
1931void * CDECL CRTDLL_calloc( size_t n, size_t size )
1932{
1933 dprintf(("CRTDLL: calloc\n"));
1934 return (calloc(n, size));
1935}
1936
1937/*********************************************************************
1938 * clearerr (CRTDLL.349)
1939 */
1940void CDECL CRTDLL_clearerr( FILE *fp )
1941{
1942 dprintf(("CRTDLL: clearerr\n"));
1943 clearerr(fp);
1944}
1945
1946/*********************************************************************
1947 * clock (CRTDLL.350)
1948 */
1949clock_t CDECL CRTDLL_clock( void )
1950{
1951 dprintf(("CRTDLL: clock\n"));
1952 return (clock());
1953}
1954
1955/*********************************************************************
1956 * cosh (CRTDLL.352)
1957 */
1958double CDECL CRTDLL_cosh( double x )
1959{
1960 dprintf(("CRTDLL: cosh\n"));
1961 return (cosh(x));
1962}
1963
1964/*********************************************************************
1965 * ctime (CRTDLL.353)
1966 */
1967char * CDECL CRTDLL_ctime( const time_t *timer )
1968{
1969 dprintf(("CRTDLL: ctime\n"));
1970 return (ctime(timer));
1971}
1972
1973/*********************************************************************
1974 * difftime (CRTDLL.354)
1975 */
1976double CDECL CRTDLL_difftime( time_t t1, time_t t0 )
1977{
1978 dprintf(("CRTDLL: difftime\n"));
1979 return (difftime(t1, t0));
1980}
1981
1982/*********************************************************************
1983 * div (CRTDLL.355)
1984 */
1985div_t CDECL CRTDLL_div( int numer, int denom )
1986{
1987 dprintf(("CRTDLL: div\n"));
1988 return (div(numer, denom));
1989}
1990
1991/*********************************************************************
1992 * exit (CRTDLL.356)
1993 */
1994void CDECL CRTDLL_exit(DWORD ret)
1995{
1996 dprintf(("CRTDLL: exit\n"));
1997 ExitProcess(ret);
1998}
1999
2000/*********************************************************************
2001 * exp (CRTDLL.357)
2002 */
2003double CDECL CRTDLL_exp( double x )
2004{
2005 dprintf(("CRTDLL: exp\n"));
2006 return (exp(x));
2007}
2008
2009/*********************************************************************
2010 * fclose (CRTDLL.359)
2011 */
2012int CDECL CRTDLL_fclose( FILE *fp )
2013{
2014 dprintf(("CRTDLL: fclose\n"));
2015 return (fclose(fp));
2016}
2017
2018/*********************************************************************
2019 * feof (CRTDLL.360)
2020 */
2021int CDECL CRTDLL_feof( FILE *fp )
2022{
2023 dprintf(("CRTDLL: feof\n"));
2024 return (feof(fp));
2025}
2026
2027/*********************************************************************
2028 * ferror (CRTDLL.361)
2029 */
2030int CDECL CRTDLL_ferror( FILE *fp )
2031{
2032 dprintf(("CRTDLL: ferror\n"));
2033 return (ferror(fp));
2034}
2035
2036/*********************************************************************
2037 * fflush (CRTDLL.362)
2038 */
2039int CDECL CRTDLL_fflush( FILE *fp )
2040{
2041 dprintf(("CRTDLL: fflush\n"));
2042 return (fflush(fp));
2043}
2044
2045/*********************************************************************
2046 * fgetc (CRTDLL.363)
2047 */
2048int CDECL CRTDLL_fgetc( FILE *fp )
2049{
2050 dprintf(("CRTDLL: fgetc\n"));
2051 return (fgetc(fp));
2052}
2053
2054/*********************************************************************
2055 * fgetpos (CRTDLL.364)
2056 */
2057int CDECL CRTDLL_fgetpos( FILE *fp, fpos_t *pos )
2058{
2059 dprintf(("CRTDLL: fgetpos\n"));
2060 return (fgetpos(fp, pos));
2061}
2062
2063/*********************************************************************
2064 * fgets (CRTDLL.365)
2065 */
2066char * CDECL CRTDLL_fgets( char *s, int n, FILE *fp )
2067{
2068 dprintf(("CRTDLL: fgets\n"));
2069 return (fgets(s, n, fp));
2070}
2071
2072/*********************************************************************
2073 * fgetwc (CRTDLL.366)
2074 */
2075wint_t CDECL CRTDLL_fgetwc( FILE *f )
2076{
2077 dprintf(("CRTDLL: fgetwc\n"));
2078 return (fgetwc(f));
2079}
2080
2081/*********************************************************************
2082 * fmod (CRTDLL.368)
2083 */
2084double CDECL CRTDLL_fmod(double x, double y )
2085{
2086 dprintf(("CRTDLL: fmod\n"));
2087 return (fmod(x,y));
2088}
2089
2090/*********************************************************************
2091 * fopen (CRTDLL.369)
2092 */
2093FILE * CDECL CRTDLL_fopen( const char *filename, const char *mode )
2094{
2095 dprintf(("CRTDLL: fopen\n"));
2096 return (fopen( filename, mode));
2097}
2098
2099/*********************************************************************
2100 * fprintf (CRTDLL.370)
2101 */
2102INT CDECL CRTDLL_fprintf( CRTDLL_FILE *file, LPSTR format, ... )
2103{
2104 dprintf(("CRTDLL: fprintf\n"));
2105 va_list valist;
2106 INT res;
2107
2108 va_start( valist, format );
2109 res = CRTDLL_vfprintf( file, format, valist );
2110 va_end( valist );
2111 return res;
2112}
2113
2114/*********************************************************************
2115 * fputc (CRTDLL.371)
2116 */
2117int CDECL CRTDLL_fputc( int c, FILE *fp )
2118{
2119 dprintf(("CRTDLL: fputc\n"));
2120 return (fputc(c, fp));
2121}
2122
2123/*********************************************************************
2124 * fputs (CRTDLL.372)
2125 */
2126int CDECL CRTDLL_fputs( const char *s, FILE *fp )
2127{
2128 dprintf(("CRTDLL: fputs\n"));
2129 return (fputs(s, fp));
2130}
2131
2132/*********************************************************************
2133 * fputwc (CRTDLL.373)
2134 */
2135wint_t CDECL CRTDLL_fputwc( wint_t wc, FILE *strm )
2136{
2137 dprintf(("CRTDLL: fputwc\n"));
2138 return (fputwc(wc, strm));
2139}
2140
2141/*********************************************************************
2142 * fread (CRTDLL.374)
2143 */
2144size_t CDECL CRTDLL_fread( void *ptr, size_t size, size_t n, FILE *fp )
2145{
2146 dprintf(("CRTDLL: fread\n"));
2147 return (fread(ptr, size, n, fp));
2148}
2149
2150/*********************************************************************
2151 * free (CRTDLL.375)
2152 */
2153VOID CDECL CRTDLL_free(LPVOID ptr)
2154{
2155 dprintf(("CRTDLL: free\n"));
2156 HeapFree(GetProcessHeap(),0,ptr);
2157}
2158
2159/*********************************************************************
2160 * freopen (CRTDLL.376)
2161 */
2162FILE * CDECL CRTDLL_freopen( const char *filename, const char *mode, FILE *fp )
2163{
2164 dprintf(("CRTDLL: freopen\n"));
2165 return (freopen(filename, mode, fp));
2166}
2167
2168/*********************************************************************
2169 * frexp (CRTDLL.377)
2170 */
2171double CDECL CRTDLL_frexp( double value, int *exp )
2172{
2173 dprintf(("CRTDLL: frexp\n"));
2174 return (frexp(value, exp));
2175}
2176
2177/*********************************************************************
2178 * fscanf (CRTDLL.378)
2179 */
2180int CDECL CRTDLL_fscanf( FILE*fp, const char *format, ... )
2181{
2182 dprintf(("CRTDLL: frexp\n"));
2183 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2184 return FALSE;
2185}
2186
2187/*********************************************************************
2188 * fseek (CRTDLL.379)
2189 */
2190int CDECL CRTDLL_fseek( FILE *fp, long int offset, int whence )
2191{
2192 dprintf(("CRTDLL: fseek\n"));
2193 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2194 return FALSE;
2195}
2196
2197/*********************************************************************
2198 * fsetpos (CRTDLL.380)
2199 */
2200int CDECL CRTDLL_fsetpos( FILE *fp, const fpos_t *pos )
2201{
2202 dprintf(("CRTDLL: fsetpos\n"));
2203 return (fsetpos(fp, pos));
2204}
2205
2206/*********************************************************************
2207 * ftell (CRTDLL.381)
2208 */
2209long int CDECL CRTDLL_ftell( FILE *fp )
2210{
2211 dprintf(("CRTDLL: ftell\n"));
2212 return (ftell(fp));
2213}
2214
2215/*********************************************************************
2216 * fwprintf (CRTDLL.382)
2217 */
2218int CDECL CRTDLL_fwprintf( FILE *strm, const wchar_t *format, ... )
2219{
2220 dprintf(("CRTDLL: fwprintf\n"));
2221 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2222 return FALSE;
2223}
2224
2225/*********************************************************************
2226 * fwrite (CRTDLL.383)
2227 */
2228DWORD CDECL CRTDLL_fwrite( LPVOID ptr, INT size, INT nmemb, CRTDLL_FILE *file )
2229{
2230 DWORD ret;
2231
2232 dprintf(("CRTDLL: fwrite\n"));
2233 WriteFile( file->handle, ptr, size * nmemb, &ret, NULL );
2234 return ret / size;
2235}
2236
2237/*********************************************************************
2238 * fwscanf (CRTDLL.384)
2239 */
2240int CDECL CRTDLL_fwscanf( FILE *strm, const wchar_t *format, ... )
2241{
2242 dprintf(("CRTDLL: fwscanf\n"));
2243 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2244 return FALSE;
2245}
2246
2247/*********************************************************************
2248 * getc (CRTDLL.385)
2249 */
2250int CDECL CRTDLL_getc( FILE *fp )
2251{
2252 dprintf(("CRTDLL: getc\n"));
2253 return (getc(fp));
2254}
2255
2256/*********************************************************************
2257 * getchar (CRTDLL.386)
2258 */
2259int CDECL CRTDLL_getchar( void )
2260{
2261 dprintf(("CRTDLL: getchar\n"));
2262 return (getchar());
2263}
2264
2265/*********************************************************************
2266 * getenv (CRTDLL.387)
2267 */
2268char * CDECL CRTDLL_getenv( const char *name )
2269{
2270 dprintf(("CRTDLL: getenv\n"));
2271 return (getenv(name));
2272}
2273
2274/*********************************************************************
2275 * gets (CRTDLL.388)
2276 */
2277char * CDECL CRTDLL_gets( char *s )
2278{
2279 dprintf(("CRTDLL: gets\n"));
2280 return (gets(s));
2281}
2282
2283/*********************************************************************
2284 * gmtime (CRTDLL.389)
2285 */
2286struct tm * CDECL CRTDLL_gmtime( const time_t *timer )
2287{
2288 dprintf(("CRTDLL: gmtime\n"));
2289 return (gmtime(timer));
2290}
2291
2292/*********************************************************************
2293 * is_wctype (CRTDLL.390)
2294 * FIXME - Could not find anything about it
2295 */
2296INT CDECL CRTDLL_is_wctype(DWORD ret)
2297{
2298 dprintf(("CRTDLL: is_wctype\n"));
2299 return 0;
2300}
2301
2302/*********************************************************************
2303 * isalnum (CRTDLL.391)
2304 */
2305int CDECL CRTDLL_isalnum(int i)
2306{
2307 dprintf(("CRTDLL: isalnum(%08xh)\n", i));
2308 return (isalnum(i));
2309}
2310
2311/*********************************************************************
2312 * iscntrl (CRTDLL.393)
2313 */
2314int CDECL CRTDLL_iscntrl(int i)
2315{
2316 dprintf(("CRTDLL: iscntrl(%08xh)\n", i));
2317 return (iscntrl(i));
2318}
2319
2320/*********************************************************************
2321 * isgraph (CRTDLL.395)
2322 */
2323int CDECL CRTDLL_isgraph(int i)
2324{
2325 dprintf(("CRTDLL: isgraph(%08xh)\n", i));
2326 return (isgraph(i));
2327}
2328
2329/*********************************************************************
2330 * isleadbyte (CRTDLL.396)
2331 */
2332int CDECL CRTDLL_isleadbyte(int i)
2333{
2334 dprintf(("CRTDLL: isleadbyte(%08xh)\n", i));
2335 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2336 return FALSE;
2337}
2338
2339/*********************************************************************
2340 * ispunct (CRTDLL.399)
2341 */
2342int CDECL CRTDLL_ispunct(int i)
2343{
2344 dprintf(("CRTDLL: ispunct(%08xh)\n", i));
2345 return (ispunct(i));
2346}
2347
2348/*********************************************************************
2349 * iswalnum (CRTDLL.402)
2350 */
2351int CDECL CRTDLL_iswalnum(wint_t i)
2352{
2353 dprintf(("CRTDLL: iswalnum(%08xh)\n", i));
2354
2355 return (iswalnum(i));
2356}
2357
2358/*********************************************************************
2359 * iswascii (CRTDLL.404)
2360 */
2361int CDECL CRTDLL_iswascii(wint_t i)
2362{
2363 dprintf(("CRTDLL: iswascii(%08xh)\n", i));
2364
2365 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2366 return FALSE;
2367}
2368
2369/*********************************************************************
2370 * iswcntrl (CRTDLL.405)
2371 */
2372int CDECL CRTDLL_iswcntrl(wint_t i)
2373{
2374 dprintf(("CRTDLL: iswcntrl(%08xh)\n", i));
2375
2376 return (iswcntrl(i));
2377}
2378
2379/*********************************************************************
2380 * iswdigit (CRTDLL.407)
2381 */
2382int CDECL CRTDLL_iswdigit(wint_t i)
2383{
2384 dprintf(("CRTDLL: iswdigit(%08xh)\n", i));
2385
2386 return (iswdigit(i));
2387}
2388
2389/*********************************************************************
2390 * iswgraph (CRTDLL.408)
2391 */
2392int CDECL CRTDLL_iswgraph(wint_t i)
2393{
2394 dprintf(("CRTDLL: iswgraph(%08xh)\n", i));
2395
2396 return (iswgraph(i));
2397}
2398
2399/*********************************************************************
2400 * iswlower (CRTDLL.409)
2401 */
2402int CDECL CRTDLL_iswlower(wint_t i)
2403{
2404 dprintf(("CRTDLL: iswlower(%08xh)\n", i));
2405
2406 return (iswlower(i));
2407}
2408
2409/*********************************************************************
2410 * iswprint (CRTDLL.410)
2411 */
2412int CDECL CRTDLL_iswprint(wint_t i)
2413{
2414 dprintf(("CRTDLL: iswprint(%08xh)\n", i));
2415
2416 return (iswprint(i));
2417}
2418
2419/*********************************************************************
2420 * iswpunct (CRTDLL.411)
2421 */
2422int CDECL CRTDLL_iswpunct(wint_t i)
2423{
2424 dprintf(("CRTDLL: iswpunct(%08xh)\n", i));
2425
2426 return (iswpunct(i));
2427}
2428
2429/*********************************************************************
2430 * iswspace (CRTDLL.412)
2431 */
2432int CDECL CRTDLL_iswspace(wint_t i)
2433{
2434 dprintf(("CRTDLL: iswspace(%08xh)\n", i));
2435
2436 return (iswspace(i));
2437}
2438
2439/*********************************************************************
2440 * iswupper (CRTDLL.413)
2441 */
2442int CDECL CRTDLL_iswupper(wint_t i)
2443{
2444 dprintf(("CRTDLL: iswupper(%08xh)\n", i));
2445
2446 return (iswupper(i));
2447}
2448
2449/*********************************************************************
2450 * iswxdigit (CRTDLL.414)
2451 */
2452int CDECL CRTDLL_iswxdigit(wint_t i)
2453{
2454 dprintf(("CRTDLL: iswxdigit(%08xh)\n", i));
2455
2456 return (iswxdigit(i));
2457}
2458
2459/*********************************************************************
2460 * ldexp (CRTDLL.417)
2461 */
2462double CDECL CRTDLL_ldexp( double x, int exp )
2463{
2464 dprintf(("CRTDLL: ldexp\n"));
2465
2466 return (ldexp(x, exp));
2467}
2468
2469/*********************************************************************
2470 * ldiv (CRTDLL.418)
2471 */
2472ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom )
2473{
2474 dprintf(("CRTDLL: ldiv\n"));
2475
2476 return (ldiv(numer, denom));
2477}
2478
2479/*********************************************************************
2480 * localeconv (CRTDLL.419)
2481 */
2482struct lconv * CDECL CRTDLL_localeconv(void)
2483{
2484 dprintf(("CRTDLL: localeconv\n"));
2485 return (localeconv());
2486}
2487
2488/*********************************************************************
2489 * localtime (CRTDLL.420)
2490 */
2491struct tm * CDECL CRTDLL_localtime( const time_t *timer )
2492{
2493 dprintf(("CRTDLL: localtime\n"));
2494 return (localtime(timer));
2495}
2496
2497/*********************************************************************
2498 * log10 (CRTDLL.422)
2499 */
2500double CDECL CRTDLL_log10( double x )
2501{
2502 dprintf(("CRTDLL: log10\n"));
2503 return (log10(x));
2504}
2505
2506/*********************************************************************
2507 * longjmp (CRTDLL.423)
2508 */
2509VOID CDECL CRTDLL_longjmp(jmp_buf env, int val)
2510{
2511 dprintf(("CRTDLL: longjmp\n"));
2512 longjmp(env, val);
2513}
2514
2515/*********************************************************************
2516 * malloc (CRTDLL.424)
2517 */
2518VOID* CDECL CRTDLL_malloc(DWORD size)
2519{
2520 dprintf(("CRTDLL: malloc\n"));
2521 return HeapAlloc(GetProcessHeap(),0,size);
2522}
2523
2524/*********************************************************************
2525 * mblen (CRTDLL.425)
2526 */
2527INT CDECL CRTDLL_mblen( const char *s, size_t n )
2528{
2529 dprintf(("CRTDLL: mblen\n"));
2530 return (mblen(s, n));
2531}
2532
2533/*********************************************************************
2534 * CRTDLL_mbtowc (CRTDLL.427)
2535 */
2536INT CDECL CRTDLL_mbtowc( WCHAR *dst, LPCSTR str, INT n )
2537{
2538 wchar_t res;
2539 int ret = mbtowc( &res, str, n );
2540 if (dst) *dst = (WCHAR)res;
2541 return ret;
2542}
2543
2544/*********************************************************************
2545 * mktime (CRTDLL.433)
2546 */
2547time_t CDECL CRTDLL_mktime( struct tm *timeptr )
2548{
2549 dprintf(("CRTDLL: mktime\n"));
2550 return mktime( timeptr );
2551}
2552
2553/*********************************************************************
2554 * modf (CRTDLL.434)
2555 */
2556double CDECL CRTDLL_modf( double value, double *iptr )
2557{
2558 dprintf(("CRTDLL: modf\n"));
2559 return modf( value, iptr );
2560}
2561
2562/*********************************************************************
2563 * perror (CRTDLL.435)
2564 */
2565void CDECL CRTDLL_perror( const char *s )
2566{
2567 dprintf(("CRTDLL: perror\n"));
2568 perror( s );
2569}
2570
2571/*********************************************************************
2572 * printf (CRTDLL.437)
2573 */
2574int CDECL CRTDLL_printf( const char *format, ... )
2575{
2576 dprintf(("CRTDLL: printf\n"));
2577 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2578 return FALSE;
2579}
2580
2581/*********************************************************************
2582 * putc (CRTDLL.438)
2583 */
2584int CDECL CRTDLL_putc( int c, FILE *fp )
2585{
2586 dprintf(("CRTDLL: putc\n"));
2587 return putc( c, fp );
2588}
2589
2590/*********************************************************************
2591 * putchar (CRTDLL.439)
2592 */
2593int CDECL CRTDLL_putchar( int c )
2594{
2595 dprintf(("CRTDLL: putchar\n"));
2596 return putchar( c );
2597}
2598
2599/*********************************************************************
2600 * puts (CRTDLL.440)
2601 */
2602int CDECL CRTDLL_puts( const char *s )
2603{
2604 dprintf(("CRTDLL: puts\n"));
2605 return puts( s );
2606}
2607
2608/*********************************************************************
2609 * raise (CRTDLL.442)
2610 */
2611int CDECL CRTDLL_raise( int sig )
2612{
2613 dprintf(("CRTDLL: raise\n"));
2614 return raise( sig );
2615}
2616
2617/*********************************************************************
2618 * rand (CRTDLL.443)
2619 */
2620int CDECL CRTDLL_rand( void )
2621{
2622 dprintf(("CRTDLL: rand\n"));
2623 return (rand());
2624}
2625
2626/*********************************************************************
2627 * realloc (CRTDLL.444)
2628 */
2629void * CDECL CRTDLL_realloc( void *ptr, size_t size )
2630{
2631 dprintf(("CRTDLL: realloc\n"));
2632 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2633 return FALSE;
2634}
2635
2636/*********************************************************************
2637 * remove (CRTDLL.445)
2638 */
2639INT CDECL CRTDLL_remove(LPCSTR file)
2640{
2641 dprintf(("CRTDLL: remove\n"));
2642 if (!DeleteFileA(file))
2643 return -1;
2644 return 0;
2645}
2646
2647/*********************************************************************
2648 * rename (CRTDLL.446)
2649 */
2650int CDECL CRTDLL_rename (const char *old, const char *new2)
2651{
2652 dprintf(("CRTDLL: rename\n"));
2653 return (rename(old, new2));
2654}
2655
2656/*********************************************************************
2657 * rewind (CRTDLL.447)
2658 */
2659void CDECL CRTDLL_rewind( FILE *fp )
2660{
2661 dprintf(("CRTDLL: rewind\n"));
2662 rewind(fp);
2663}
2664
2665/*********************************************************************
2666 * scanf (CRTDLL.448)
2667 */
2668int CDECL CRTDLL_scanf( const char *format, ... )
2669{
2670 dprintf(("CRTDLL: scanf\n"));
2671 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2672 return FALSE;
2673}
2674
2675/*********************************************************************
2676 * setbuf (CRTDLL.449)
2677 */
2678void CDECL CRTDLL_setbuf( FILE *fp, char *buf )
2679{
2680 dprintf(("CRTDLL: setbuf\n"));
2681 setbuf(fp, buf);
2682}
2683
2684/*********************************************************************
2685 * setlocale (CRTDLL.450)
2686 */
2687char * CDECL CRTDLL_setlocale(int category,const char *locale)
2688{
2689 dprintf(("CRTDLL: setlocale\n"));
2690 return (setlocale(category, locale));
2691}
2692
2693/*********************************************************************
2694 * setvbuf (CRTDLL.451)
2695 */
2696int CDECL CRTDLL_setvbuf( FILE *fp, char *buf, int mode, size_t size )
2697{
2698 dprintf(("CRTDLL: setvbuf\n"));
2699 return (setvbuf(fp, buf, mode, size));
2700}
2701
2702/*********************************************************************
2703 * signal (CRTDLL.452)
2704 */
2705void CDECL CRTDLL_signal( int sig, void (*func)(int))
2706{
2707 dprintf(("CRTDLL: signal\n"));
2708 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2709}
2710
2711/*********************************************************************
2712 * sinh (CRTDLL.454)
2713 */
2714double CDECL CRTDLL_sinh( double x )
2715{
2716 dprintf(("CRTDLL: sinh\n"));
2717 return (sinh(x));
2718}
2719
2720/*********************************************************************
2721 * srand (CRTDLL.457)
2722 */
2723void CDECL CRTDLL_srand( unsigned int seed )
2724{
2725 dprintf(("CRTDLL: srand\n"));
2726 srand(seed);
2727}
2728
2729/*********************************************************************
2730 * strcoll (CRTDLL.462)
2731 */
2732int CDECL CRTDLL_strcoll( const char *s1, const char *s2 )
2733{
2734 dprintf(("CRTDLL: strcoll\n"));
2735 return strcoll(s1, s2);
2736}
2737
2738/*********************************************************************
2739 * strerror (CRTDLL.465)
2740 */
2741char * CDECL CRTDLL_strerror( int errnum )
2742{
2743 dprintf(("CRTDLL: strerror\n"));
2744 return strerror(errnum);
2745}
2746
2747/*********************************************************************
2748 * strftime (CRTDLL.466)
2749 */
2750size_t CDECL CRTDLL_strftime( char *s, size_t maxsiz, const char *fmt, const struct tm *tp )
2751{
2752 dprintf(("CRTDLL: strftime\n"));
2753 return strftime(s, maxsiz, fmt, tp);
2754}
2755
2756
2757/*********************************************************************
2758 * strtod (CRTDLL.475)
2759 */
2760double CDECL CRTDLL_strtod( const char *nptr, char **endptr )
2761{
2762 dprintf(("CRTDLL: strtod\n"));
2763 return strtod(nptr, endptr);
2764}
2765
2766/*********************************************************************
2767 * strtok (CRTDLL.476)
2768 */
2769char * CDECL CRTDLL_strtok( char *s1, const char *s2 )
2770{
2771 dprintf(("CRTDLL: strtok\n"));
2772 return strtok(s1, s2);
2773}
2774
2775/*********************************************************************
2776 * strtol (CRTDLL.477)
2777 */
2778long int CDECL CRTDLL_strtol( const char *nptr, char **endptr, int base )
2779{
2780 dprintf(("CRTDLL: strtol\n"));
2781 return strtol(nptr, endptr, base);
2782}
2783
2784/*********************************************************************
2785 * strtoul (CRTDLL.478)
2786 */
2787unsigned long CDECL CRTDLL_strtoul( const char *nptr, char **endptr, int base )
2788{
2789 dprintf(("CRTDLL: strtoul\n"));
2790 return strtoul(nptr, endptr, base);
2791}
2792
2793/*********************************************************************
2794 * strxfrm (CRTDLL.479)
2795 */
2796size_t CDECL CRTDLL_strxfrm( char *s1, const char *s2, size_t n )
2797{
2798 dprintf(("CRTDLL: strxfrm\n"));
2799 return strxfrm(s1, s2, n);
2800}
2801
2802/*********************************************************************
2803 * swscanf (CRTDLL.481)
2804 */
2805int CDECL CRTDLL_swscanf( const wchar_t *s1, const wchar_t *s2, ... )
2806{
2807 dprintf(("CRTDLL: swscanf\n"));
2808 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2809 return FALSE;
2810}
2811
2812/*********************************************************************
2813 * system (CRTDLL.482)
2814 */
2815int CDECL CRTDLL_system( const char *string )
2816{
2817 dprintf(("CRTDLL: system\n"));
2818 return system(string);
2819}
2820
2821/*********************************************************************
2822 * tanh (CRTDLL.485)
2823 */
2824double CDECL CRTDLL_tanh( double x )
2825{
2826 dprintf(("CRTDLL: tanh\n"));
2827 return tanh(x);
2828}
2829
2830/*********************************************************************
2831 * time (CRTDLL.485)
2832 */
2833time_t CDECL CRTDLL_time( time_t *timer )
2834{
2835 dprintf(("CRTDLL: time\n"));
2836
2837 return time(timer);
2838}
2839
2840/*********************************************************************
2841 * tmpnam (CRTDLL.486)
2842 */
2843FILE * CDECL CRTDLL_tmpfile( void )
2844{
2845 dprintf(("CRTDLL: tmpfile\n"));
2846 return (tmpfile());
2847}
2848
2849/*********************************************************************
2850 * tmpnam (CRTDLL.487)
2851 */
2852char * CDECL CRTDLL_tmpnam( char *s )
2853{
2854 dprintf(("CRTDLL: tmpnam\n"));
2855
2856 return (tmpnam(s));
2857}
2858
2859/*********************************************************************
2860 * ungetc (CRTDLL.492)
2861 */
2862INT CDECL CRTDLL_ungetc(int c)
2863{
2864 dprintf(("CRTDLL: ungetc\n"));
2865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2866 return FALSE;
2867}
2868
2869/*********************************************************************
2870 * ungetwc (CRTDLL.493)
2871 */
2872wint_t CDECL CRTDLL_ungetwc( wint_t wc, FILE *strm )
2873{
2874 dprintf(("CRTDLL: ungetwc\n"));
2875
2876 return (ungetwc(wc, strm));
2877}
2878
2879/*********************************************************************
2880 * vfprintf (CRTDLL.494)
2881 */
2882INT CDECL CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args )
2883{
2884 dprintf(("CRTDLL: vprintf\n"));
2885 char buffer[2048]; /* FIXME... */
2886
2887 vsprintf( buffer, format, args );
2888 return CRTDLL_fwrite( buffer, 1, strlen(buffer), file );
2889}
2890
2891/*********************************************************************
2892 * vfwprintf (CRTDLL.495)
2893 */
2894int CDECL CRTDLL_vfwprintf( FILE *F, const wchar_t *s, va_list arg )
2895{
2896 dprintf(("CRTDLL: vfwprintf\n"));
2897 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2898 return FALSE;
2899}
2900
2901/*********************************************************************
2902 * vprintf (CRTDLL.496)
2903 */
2904int CDECL CRTDLL_vprintf( const char *format, __va_list arg )
2905{
2906 dprintf(("CRTDLL: vprintf\n"));
2907
2908 return (vprintf(format, arg));
2909}
2910
2911/*********************************************************************
2912 * vswprintf (CRTDLL.498)
2913 */
2914int CDECL CRTDLL_vswprintf( wchar_t *s , size_t t, const wchar_t *format, va_list arg )
2915{
2916 dprintf(("CRTDLL: vswprintf\n"));
2917
2918 return (vswprintf(s, t, format, arg));
2919}
2920
2921/*********************************************************************
2922 * vwprintf (CRTDLL.499)
2923 */
2924int CDECL CRTDLL_vwprintf( const wchar_t *s, va_list arg)
2925{
2926 dprintf(("CRTDLL: vwprintf\n"));
2927 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2928 return FALSE;
2929}
2930
2931
2932/*********************************************************************
2933 * wcscoll (CRTDLL.503)
2934 */
2935int CDECL CRTDLL_wcscoll(const wchar_t *s1, const wchar_t *s2)
2936{
2937 dprintf(("CRTDLL: wcscoll\n"));
2938
2939 return (wcscoll(s1, s2));
2940}
2941
2942/*********************************************************************
2943 * wcsftime (CRTDLL.506)
2944 */
2945size_t CDECL CRTDLL_wcsftime( wchar_t *s, size_t maxsize,
2946 const wchar_t *format, const struct tm *timeptr )
2947{
2948 dprintf(("CRTDLL: wcsftime\n"));
2949
2950 return (wcsftime(s, maxsize, format, timeptr));
2951}
2952
2953/*********************************************************************
2954 * wcstod (CRTDLL.515)
2955 */
2956double CDECL CRTDLL_wcstod( const wchar_t *nptr, wchar_t **endptr )
2957{
2958 dprintf(("CRTDLL: wcstod\n"));
2959 return (wcstod(nptr, endptr));
2960}
2961
2962/*********************************************************************
2963 * wcsxfrm (CRTDLL.520)
2964 */
2965size_t CDECL CRTDLL_wcsxfrm( wchar_t *s1, const wchar_t *s2, size_t n )
2966{
2967 dprintf(("CRTDLL: wcsxfrm\n"));
2968
2969 return (wcsxfrm(s1, s2, n));
2970}
2971
2972/*********************************************************************
2973 * wcstomb (CRTDLL.521)
2974 */
2975int CDECL CRTDLL_wctomb( char *s, wchar_t wchar )
2976{
2977 dprintf(("CRTDLL: wctomb\n"));
2978
2979 return (wctomb(s,wchar));
2980}
2981
2982/*********************************************************************
2983 * wprintf (CRTDLL.522)
2984 */
2985int CDECL CRTDLL_wprintf( const wchar_t *s, ... )
2986{
2987 dprintf(("CRTDLL: wprintf\n"));
2988 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2989 return FALSE;
2990}
2991
2992/*********************************************************************
2993 * wscanf (CRTDLL.523)
2994 */
2995int CDECL CRTDLL_wscanf( const wchar_t *s, ... )
2996{
2997 dprintf(("CRTDLL: wscanf\n"));
2998 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2999 return FALSE;
3000}
3001
3002
Note: See TracBrowser for help on using the repository browser.