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

Last change on this file since 940 was 916, checked in by sandervl, 26 years ago

* empty log message *
File size: 39.1 KB
Line 
1/* $Id: crtdll.cpp,v 1.2 1999-09-13 09:05:13 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
34#include <crtdll.h>
35#include "crtinc.h"
36
37
38// DEFAULT_DEBUG_CHANNEL(crtdll)
39
40INT CDECL CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args );
41
42
43/*********************************************************************
44 * CRTDLL_MainInit (CRTDLL.init)
45 */
46BOOL WINAPI CRTDLL_Init(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
47{
48 if (fdwReason == DLL_PROCESS_ATTACH) {
49 CRTDLL__fdopen(0,"r");
50 CRTDLL__fdopen(1,"w");
51 CRTDLL__fdopen(2,"w");
52 }
53 return TRUE;
54}
55
56/*********************************************************************
57 * _XcptFilter (CRTDLL.21)
58 * FIXME - Could not find anything about it
59 */
60INT CDECL CRTDLL__XcptFilter(DWORD ret)
61{
62 dprintf(("CRTDLL: XcptFilter\n"));
63
64 return 0;
65}
66
67/*********************************************************************
68 * _GetMainArgs (CRTDLL.22)
69 */
70DWORD CDECL CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,
71 LPSTR *environ,DWORD flag)
72{
73 char *cmdline;
74 char **xargv;
75 int xargc,i,afterlastspace;
76 DWORD version;
77
78 dprintf(("CRTDLL: GetMainArgs\n"));
79
80 CRTDLL_acmdln_dll = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
81 GetCommandLineA() );
82
83 version = GetVersion();
84 CRTDLL_osver_dll = version >> 16;
85 CRTDLL_winminor_dll = version & 0xFF;
86 CRTDLL_winmajor_dll = (version>>8) & 0xFF;
87 CRTDLL_baseversion_dll = version >> 16;
88 CRTDLL_winver_dll = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
89 CRTDLL_baseminor_dll = (version >> 16) & 0xFF;
90 CRTDLL_basemajor_dll = (version >> 24) & 0xFF;
91 CRTDLL_osversion_dll = version & 0xFFFF;
92 CRTDLL_osminor_dll = version & 0xFF;
93 CRTDLL_osmajor_dll = (version>>8) & 0xFF;
94
95 /* missing threading init */
96/*
97 i=0;xargv=NULL;xargc=0;afterlastspace=0;
98 dprintf(("CRTDLL: GetMainArgs i loop\n"));
99 while (cmdline[i]) {
100 if (cmdline[i]==' ') {
101 dprintf(("CRTDLL: GetMainArgs *1\n"));
102 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
103 sizeof(char*)*(++xargc));
104 cmdline[i]='\0';
105 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
106 cmdline+afterlastspace);
107 i++;
108 dprintf(("CRTDLL: GetMainArgs *2\n"));
109 while (cmdline[i]==' ')
110 i++;
111 if (cmdline[i])
112 afterlastspace=i;
113 dprintf(("CRTDLL: GetMainArgs *3\n"));
114 } else
115 i++;
116
117 }
118 xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
119 sizeof(char*)*(++xargc));
120 dprintf(("CRTDLL: GetMainArgs *4\n"));
121 cmdline[i]='\0';
122 dprintf(("CRTDLL: GetMainArgs *5\n"));
123 xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
124 cmdline+afterlastspace);
125 dprintf(("CRTDLL: GetMainArgs *6\n"));
126 dprintf(("CRTDLL: GetMainArgs *7\n"));
127 CRTDLL_argc_dll = xargc;
128 dprintf(("CRTDLL: GetMainArgs *8\n"));
129 *argc = xargc;
130 dprintf(("CRTDLL: GetMainArgs *9\n"));
131 CRTDLL_argv_dll = xargv;
132 dprintf(("CRTDLL: GetMainArgs *11\n"));
133 *argv = xargv;
134*/
135 dprintf(("CRTDLL: GetMainArgs end\n"));
136 CRTDLL_environ_dll = *environ = GetEnvironmentStringsA();
137 return 0;
138}
139
140/*********************************************************************
141 * __mb_cur_max_dll (CRTDLL.31)
142 * FIXME - Could not find anything about it
143 */
144INT CDECL CRTDLL___mb_cur_max_dll(DWORD ret)
145{
146 dprintf(("CRTDLL: __mb_cur_max_dll\n"));
147
148 return 0;
149}
150
151/*********************************************************************
152 * _aexit_rtn_dll (CRTDLL.39)
153 * FIXME - Could not find anything about it
154 */
155INT CDECL CRTDLL__aexit_rtn_dll(DWORD ret)
156{
157 dprintf(("CRTDLL: _aexit_rtn_dll\n"));
158
159 return 0;
160}
161
162/*********************************************************************
163 * _amsg_exit (CRTDLL.40)
164 * FIXME - Could not find anything about it
165 */
166INT CDECL CRTDLL__amsg_exit(DWORD ret)
167{
168 dprintf(("CRTDLL: _amsg_exit\n"));
169
170 return 0;
171}
172
173/*********************************************************************
174 * _chdir (CRTDLL.51)
175 */
176INT CDECL CRTDLL__chdir(LPCSTR newdir)
177{
178 dprintf(("CRTDLL: chdir\n"));
179 if (!SetCurrentDirectoryA(newdir))
180 return 1;
181 return 0;
182}
183
184/*********************************************************************
185 * _except_handler2 (CRTDLL.78)
186 * FIXME - Could not find anything about it
187 */
188INT CDECL CRTDLL__except_handler2(DWORD ret)
189{
190 dprintf(("CRTDLL: _except_handler2\n"));
191
192 return 0;
193}
194
195/*********************************************************************
196 * _exit (CRTDLL.87)
197 */
198VOID CDECL CRTDLL__exit(DWORD ret)
199{
200 dprintf(("CRTDLL: exit\n"));
201 ExitProcess(ret);
202}
203
204/*********************************************************************
205 * _fdopen (CRTDLL.91)
206 */
207CRTDLL_FILE * CDECL CRTDLL__fdopen(INT handle, LPCSTR mode)
208{
209 dprintf(("CRTDLL: fdopen\n"));
210 CRTDLL_FILE *file;
211
212 switch (handle)
213 {
214 case 0:
215 file = CRTDLL_stdin;
216 if (!file->handle) file->handle = GetStdHandle( STD_INPUT_HANDLE );
217 break;
218 case 1:
219 file = CRTDLL_stdout;
220 if (!file->handle) file->handle = GetStdHandle( STD_OUTPUT_HANDLE );
221 break;
222 case 2:
223 file=CRTDLL_stderr;
224 if (!file->handle) file->handle = GetStdHandle( STD_ERROR_HANDLE );
225 break;
226 default:
227 file = (PCRTDLL_FILE)HeapAlloc( GetProcessHeap(), 0, sizeof(*file) );
228 file->handle = handle;
229 break;
230 }
231 return file;
232}
233
234 /*********************************************************************
235 * _findfirst (CRTDLL.099)
236 *
237 * BUGS
238 * Unimplemented
239 */
240DWORD CDECL CRTDLL__findfirst(LPCSTR fname, struct find_t * x2)
241{
242 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
243 return FALSE;
244}
245
246/*********************************************************************
247 * _findnext (CRTDLL.100)
248 *
249 * BUGS
250 * Unimplemented
251 */
252INT CDECL CRTDLL__findnext(DWORD hand, struct find_t * x2)
253{
254 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
255 return FALSE;
256}
257
258/*********************************************************************
259 * _fstat (CRTDLL.111)
260 *
261 * BUGS
262 * Unimplemented
263 */
264int CDECL CRTDLL__fstat(int file, struct stat* buf)
265{
266 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
267 return FALSE;
268}
269
270/*******************************************************************
271 * _global_unwind2 (CRTDLL.129)
272 */
273void CDECL CRTDLL__global_unwind2( PEXCEPTION_FRAME frame )
274{
275 dprintf(("CRTDLL: global_undwind2\n"));
276 RtlUnwind( frame, 0, NULL, 0 );
277}
278
279/*********************************************************************
280 * _initterm (CRTDLL.135)
281 */
282DWORD CDECL CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
283{
284 dprintf(("CRTDLL: initterm\n"));
285 _INITTERMFUN *current;
286
287 current=start;
288 while (current<end) {
289 if (*current) (*current)();
290 current++;
291 }
292 return 0;
293}
294
295/*********************************************************************
296 * _isctype (CRTDLL.138)
297 */
298BOOL CDECL CRTDLL__isctype(CHAR x,CHAR type)
299{
300 dprintf(("CRTDLL: isctype\n"));
301 if ((type & CRTDLL_SPACE) && isspace(x))
302 return TRUE;
303 if ((type & CRTDLL_PUNCT) && ispunct(x))
304 return TRUE;
305 if ((type & CRTDLL_LOWER) && islower(x))
306 return TRUE;
307 if ((type & CRTDLL_UPPER) && isupper(x))
308 return TRUE;
309 if ((type & CRTDLL_ALPHA) && isalpha(x))
310 return TRUE;
311 if ((type & CRTDLL_DIGIT) && isdigit(x))
312 return TRUE;
313 if ((type & CRTDLL_CONTROL) && iscntrl(x))
314 return TRUE;
315 /* check CRTDLL_LEADBYTE */
316 return FALSE;
317}
318
319/*******************************************************************
320 * _local_unwind2 (CRTDLL.172)
321 */
322void CDECL CRTDLL__local_unwind2( PEXCEPTION_FRAME endframe, DWORD nr )
323{
324 dprintf(("CRTDLL: local_undwind2\n"));
325}
326
327/*********************************************************************
328 * CRTDLL__mbsinc (CRTDLL.203)
329 */
330LPSTR CDECL CRTDLL__mbsinc( LPCSTR str )
331{
332 int len = mblen( str, MB_LEN_MAX );
333 if (len < 1) len = 1;
334 return (LPSTR)(str + len);
335}
336
337
338/*********************************************************************
339 * CRTDLL__mbslen (CRTDLL.204)
340 */
341INT CDECL CRTDLL__mbslen( LPCSTR str )
342{
343 INT len, total = 0;
344 while ((len = mblen( str, MB_LEN_MAX )) > 0)
345 {
346 str += len;
347 total++;
348 }
349 return total;
350}
351
352/*********************************************************************
353 * _mkdir (CRTDLL.232)
354 */
355INT CDECL CRTDLL__mkdir(LPCSTR newdir)
356{
357 dprintf(("CRTDLL: mkdir\n"));
358 if (!CreateDirectoryA(newdir,NULL))
359 return -1;
360 return 0;
361}
362
363
364/*********************************************************************
365 * _pctype_dll (CRTDLL.245)
366 * FIXME - Could not find anything about it
367 */
368INT CDECL CRTDLL__pctype_dll(DWORD ret)
369{
370 dprintf(("CRTDLL: _pctype_dll\n"));
371
372 return 0;
373}
374
375/*********************************************************************
376 * _read (CRTDLL.254)
377 *
378 * BUGS
379 * Unimplemented
380 */
381INT CDECL CRTDLL__read(INT fd, LPVOID buf, UINT count)
382{
383 dprintf(("CRTDLL: _read\n"));
384 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
385 return FALSE;
386}
387
388/*********************************************************************
389 * CRTDLL__wcsnset (CRTDLL.322)
390 */
391LPWSTR CDECL CRTDLL__wcsnset( LPWSTR str, WCHAR c, INT n )
392{
393 LPWSTR ret = str;
394 while ((n-- > 0) && *str) *str++ = c;
395 return ret;
396}
397
398/*********************************************************************
399 * CRTDLL__wcsset (CRTDLL.324)
400 */
401LPWSTR CDECL CRTDLL__wcsset( LPWSTR str, WCHAR c )
402{
403 LPWSTR ret = str;
404 while (*str) *str++ = c;
405 return ret;
406}
407
408/*********************************************************************
409 * isleadbyte (CRTDLL.335)
410 */
411void CDECL CRTDLL_abort( void )
412{
413 dprintf(("CRTDLL: abort\n"));
414 abort();
415}
416
417/*********************************************************************
418 * acos (CRTDLL.336)
419 */
420double CDECL CRTDLL_acos( double x )
421{
422 dprintf(("CRTDLL: acos\n"));
423 return (acos(x));
424}
425
426/*********************************************************************
427 * asctime (CRTDLL.338)
428 */
429char * CDECL CRTDLL_asctime( const struct tm *timeptr )
430{
431 dprintf(("CRTDLL: asctime\n"));
432 return (asctime(timeptr));
433}
434
435/*********************************************************************
436 * asin (CRTDLL.339)
437 */
438double CDECL CRTDLL_asin( double x )
439{
440 dprintf(("CRTDLL: asin\n"));
441 return (asin(x));
442}
443
444/*********************************************************************
445 * atan2 (CRTDLL.341)
446 */
447double CDECL CRTDLL_atan2( double y, double x )
448{
449 dprintf(("CRTDLL: atan2\n"));
450 return (atan2(y, x));
451}
452
453/*********************************************************************
454 * atexit (CRTDLL.342)
455 */
456int CDECL CRTDLL_atexit( register void ( *func )( void ) )
457{
458 dprintf(("CRTDLL: atexit\n"));
459 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
460 return FALSE;
461}
462
463/*********************************************************************
464 * atof (CRTDLL.343)
465 */
466double CDECL CRTDLL_atof( const char *nptr )
467{
468 dprintf(("CRTDLL: atof\n"));
469 return (atof(nptr));
470}
471
472/*********************************************************************
473 * bsearch (CRTDLL.346)
474 */
475void * CDECL CRTDLL_bsearch( const void *key, const void *base, size_t nmemb,
476 size_t size, int (*compar)(const void *pkey, const void *pbase) )
477{
478 dprintf(("CRTDLL: bsearch\n"));
479 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
480 return FALSE;
481}
482
483/*********************************************************************
484 * calloc (CRTDLL.347)
485 */
486void * CDECL CRTDLL_calloc( size_t n, size_t size )
487{
488 dprintf(("CRTDLL: calloc\n"));
489 return (calloc(n, size));
490}
491
492/*********************************************************************
493 * clearerr (CRTDLL.349)
494 */
495void CDECL CRTDLL_clearerr( FILE *fp )
496{
497 dprintf(("CRTDLL: clearerr\n"));
498 clearerr(fp);
499}
500
501/*********************************************************************
502 * clock (CRTDLL.350)
503 */
504clock_t CDECL CRTDLL_clock( void )
505{
506 dprintf(("CRTDLL: clock\n"));
507 return (clock());
508}
509
510/*********************************************************************
511 * cosh (CRTDLL.352)
512 */
513double CDECL CRTDLL_cosh( double x )
514{
515 dprintf(("CRTDLL: cosh\n"));
516 return (cosh(x));
517}
518
519/*********************************************************************
520 * ctime (CRTDLL.353)
521 */
522char * CDECL CRTDLL_ctime( const time_t *timer )
523{
524 dprintf(("CRTDLL: ctime\n"));
525 return (ctime(timer));
526}
527
528/*********************************************************************
529 * difftime (CRTDLL.354)
530 */
531double CDECL CRTDLL_difftime( time_t t1, time_t t0 )
532{
533 dprintf(("CRTDLL: difftime\n"));
534 return (difftime(t1, t0));
535}
536
537/*********************************************************************
538 * div (CRTDLL.355)
539 */
540div_t CDECL CRTDLL_div( int numer, int denom )
541{
542 dprintf(("CRTDLL: div\n"));
543 return (div(numer, denom));
544}
545
546/*********************************************************************
547 * exit (CRTDLL.356)
548 */
549void CDECL CRTDLL_exit(DWORD ret)
550{
551 dprintf(("CRTDLL: exit\n"));
552 ExitProcess(ret);
553}
554
555/*********************************************************************
556 * exp (CRTDLL.357)
557 */
558double CDECL CRTDLL_exp( double x )
559{
560 dprintf(("CRTDLL: exp\n"));
561 return (exp(x));
562}
563
564/*********************************************************************
565 * fclose (CRTDLL.359)
566 */
567int CDECL CRTDLL_fclose( FILE *fp )
568{
569 dprintf(("CRTDLL: fclose\n"));
570 return (fclose(fp));
571}
572
573/*********************************************************************
574 * feof (CRTDLL.360)
575 */
576int CDECL CRTDLL_feof( FILE *fp )
577{
578 dprintf(("CRTDLL: feof\n"));
579 return (feof(fp));
580}
581
582/*********************************************************************
583 * ferror (CRTDLL.361)
584 */
585int CDECL CRTDLL_ferror( FILE *fp )
586{
587 dprintf(("CRTDLL: ferror\n"));
588 return (ferror(fp));
589}
590
591/*********************************************************************
592 * fflush (CRTDLL.362)
593 */
594int CDECL CRTDLL_fflush( FILE *fp )
595{
596 dprintf(("CRTDLL: fflush\n"));
597 return (fflush(fp));
598}
599
600/*********************************************************************
601 * fgetc (CRTDLL.363)
602 */
603int CDECL CRTDLL_fgetc( FILE *fp )
604{
605 dprintf(("CRTDLL: fgetc\n"));
606 return (fgetc(fp));
607}
608
609/*********************************************************************
610 * fgetpos (CRTDLL.364)
611 */
612int CDECL CRTDLL_fgetpos( FILE *fp, fpos_t *pos )
613{
614 dprintf(("CRTDLL: fgetpos\n"));
615 return (fgetpos(fp, pos));
616}
617
618/*********************************************************************
619 * fgets (CRTDLL.365)
620 */
621char * CDECL CRTDLL_fgets( char *s, int n, FILE *fp )
622{
623 dprintf(("CRTDLL: fgets\n"));
624 return (fgets(s, n, fp));
625}
626
627/*********************************************************************
628 * fgetwc (CRTDLL.366)
629 */
630wint_t CDECL CRTDLL_fgetwc( FILE *f )
631{
632 dprintf(("CRTDLL: fgetwc\n"));
633 return (fgetwc(f));
634}
635
636/*********************************************************************
637 * fmod (CRTDLL.368)
638 */
639double CDECL CRTDLL_fmod(double x, double y )
640{
641 dprintf(("CRTDLL: fmod\n"));
642 return (fmod(x,y));
643}
644
645/*********************************************************************
646 * fopen (CRTDLL.369)
647 */
648FILE * CDECL CRTDLL_fopen( const char *filename, const char *mode )
649{
650 dprintf(("CRTDLL: fopen\n"));
651 return (fopen( filename, mode));
652}
653
654/*********************************************************************
655 * fprintf (CRTDLL.370)
656 */
657INT CDECL CRTDLL_fprintf( CRTDLL_FILE *file, LPSTR format, ... )
658{
659 dprintf(("CRTDLL: fprintf\n"));
660 va_list valist;
661 INT res;
662
663 va_start( valist, format );
664 res = CRTDLL_vfprintf( file, format, valist );
665 va_end( valist );
666 return res;
667}
668
669/*********************************************************************
670 * fputc (CRTDLL.371)
671 */
672int CDECL CRTDLL_fputc( int c, FILE *fp )
673{
674 dprintf(("CRTDLL: fputc\n"));
675 return (fputc(c, fp));
676}
677
678/*********************************************************************
679 * fputs (CRTDLL.372)
680 */
681int CDECL CRTDLL_fputs( const char *s, FILE *fp )
682{
683 dprintf(("CRTDLL: fputs\n"));
684 return (fputs(s, fp));
685}
686
687/*********************************************************************
688 * fputwc (CRTDLL.373)
689 */
690wint_t CDECL CRTDLL_fputwc( wint_t wc, FILE *strm )
691{
692 dprintf(("CRTDLL: fputwc\n"));
693 return (fputwc(wc, strm));
694}
695
696/*********************************************************************
697 * fread (CRTDLL.374)
698 */
699size_t CDECL CRTDLL_fread( void *ptr, size_t size, size_t n, FILE *fp )
700{
701 dprintf(("CRTDLL: fread\n"));
702 return (fread(ptr, size, n, fp));
703}
704
705/*********************************************************************
706 * free (CRTDLL.375)
707 */
708VOID CDECL CRTDLL_free(LPVOID ptr)
709{
710 dprintf(("CRTDLL: free\n"));
711 HeapFree(GetProcessHeap(),0,ptr);
712}
713
714/*********************************************************************
715 * freopen (CRTDLL.376)
716 */
717FILE * CDECL CRTDLL_freopen( const char *filename, const char *mode, FILE *fp )
718{
719 dprintf(("CRTDLL: freopen\n"));
720 return (freopen(filename, mode, fp));
721}
722
723/*********************************************************************
724 * frexp (CRTDLL.377)
725 */
726double CDECL CRTDLL_frexp( double value, int *exp )
727{
728 dprintf(("CRTDLL: frexp\n"));
729 return (frexp(value, exp));
730}
731
732/*********************************************************************
733 * fscanf (CRTDLL.378)
734 */
735int CDECL CRTDLL_fscanf( FILE*fp, const char *format, ... )
736{
737 dprintf(("CRTDLL: frexp\n"));
738 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
739 return FALSE;
740}
741
742/*********************************************************************
743 * fseek (CRTDLL.379)
744 */
745int CDECL CRTDLL_fseek( FILE *fp, long int offset, int whence )
746{
747 dprintf(("CRTDLL: fseek\n"));
748 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
749 return FALSE;
750}
751
752/*********************************************************************
753 * fsetpos (CRTDLL.380)
754 */
755int CDECL CRTDLL_fsetpos( FILE *fp, const fpos_t *pos )
756{
757 dprintf(("CRTDLL: fsetpos\n"));
758 return (fsetpos(fp, pos));
759}
760
761/*********************************************************************
762 * ftell (CRTDLL.381)
763 */
764long int CDECL CRTDLL_ftell( FILE *fp )
765{
766 dprintf(("CRTDLL: ftell\n"));
767 return (ftell(fp));
768}
769
770/*********************************************************************
771 * fwprintf (CRTDLL.382)
772 */
773int CDECL CRTDLL_fwprintf( FILE *strm, const wchar_t *format, ... )
774{
775 dprintf(("CRTDLL: fwprintf\n"));
776 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
777 return FALSE;
778}
779
780/*********************************************************************
781 * fwrite (CRTDLL.383)
782 */
783DWORD CDECL CRTDLL_fwrite( LPVOID ptr, INT size, INT nmemb, CRTDLL_FILE *file )
784{
785 DWORD ret;
786
787 dprintf(("CRTDLL: fwrite\n"));
788 WriteFile( file->handle, ptr, size * nmemb, &ret, NULL );
789 return ret / size;
790}
791
792/*********************************************************************
793 * fwscanf (CRTDLL.384)
794 */
795int CDECL CRTDLL_fwscanf( FILE *strm, const wchar_t *format, ... )
796{
797 dprintf(("CRTDLL: fwscanf\n"));
798 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
799 return FALSE;
800}
801
802/*********************************************************************
803 * getc (CRTDLL.385)
804 */
805int CDECL CRTDLL_getc( FILE *fp )
806{
807 dprintf(("CRTDLL: getc\n"));
808 return (getc(fp));
809}
810
811/*********************************************************************
812 * getchar (CRTDLL.386)
813 */
814int CDECL CRTDLL_getchar( void )
815{
816 dprintf(("CRTDLL: getchar\n"));
817 return (getchar());
818}
819
820/*********************************************************************
821 * getenv (CRTDLL.387)
822 */
823char * CDECL CRTDLL_getenv( const char *name )
824{
825 dprintf(("CRTDLL: getenv\n"));
826 return (getenv(name));
827}
828
829/*********************************************************************
830 * gets (CRTDLL.388)
831 */
832char * CDECL CRTDLL_gets( char *s )
833{
834 dprintf(("CRTDLL: gets\n"));
835 return (gets(s));
836}
837
838/*********************************************************************
839 * gmtime (CRTDLL.389)
840 */
841struct tm * CDECL CRTDLL_gmtime( const time_t *timer )
842{
843 dprintf(("CRTDLL: gmtime\n"));
844 return (gmtime(timer));
845}
846
847/*********************************************************************
848 * is_wctype (CRTDLL.390)
849 * FIXME - Could not find anything about it
850 */
851INT CDECL CRTDLL_is_wctype(DWORD ret)
852{
853 dprintf(("CRTDLL: is_wctype\n"));
854 return 0;
855}
856
857/*********************************************************************
858 * isalnum (CRTDLL.391)
859 */
860int CDECL CRTDLL_isalnum(int i)
861{
862 dprintf(("CRTDLL: isalnum(%08xh)\n", i));
863 return (isalnum(i));
864}
865
866/*********************************************************************
867 * iscntrl (CRTDLL.393)
868 */
869int CDECL CRTDLL_iscntrl(int i)
870{
871 dprintf(("CRTDLL: iscntrl(%08xh)\n", i));
872 return (iscntrl(i));
873}
874
875/*********************************************************************
876 * isgraph (CRTDLL.395)
877 */
878int CDECL CRTDLL_isgraph(int i)
879{
880 dprintf(("CRTDLL: isgraph(%08xh)\n", i));
881 return (isgraph(i));
882}
883
884/*********************************************************************
885 * isleadbyte (CRTDLL.396)
886 */
887int CDECL CRTDLL_isleadbyte(int i)
888{
889 dprintf(("CRTDLL: isleadbyte(%08xh)\n", i));
890 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
891 return FALSE;
892}
893
894/*********************************************************************
895 * ispunct (CRTDLL.399)
896 */
897int CDECL CRTDLL_ispunct(int i)
898{
899 dprintf(("CRTDLL: ispunct(%08xh)\n", i));
900 return (ispunct(i));
901}
902
903/*********************************************************************
904 * iswalnum (CRTDLL.402)
905 */
906int CDECL CRTDLL_iswalnum(wint_t i)
907{
908 dprintf(("CRTDLL: iswalnum(%08xh)\n", i));
909
910 return (iswalnum(i));
911}
912
913/*********************************************************************
914 * iswascii (CRTDLL.404)
915 */
916int CDECL CRTDLL_iswascii(wint_t i)
917{
918 dprintf(("CRTDLL: iswascii(%08xh)\n", i));
919
920 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
921 return FALSE;
922}
923
924/*********************************************************************
925 * iswcntrl (CRTDLL.405)
926 */
927int CDECL CRTDLL_iswcntrl(wint_t i)
928{
929 dprintf(("CRTDLL: iswcntrl(%08xh)\n", i));
930
931 return (iswcntrl(i));
932}
933
934/*********************************************************************
935 * iswdigit (CRTDLL.407)
936 */
937int CDECL CRTDLL_iswdigit(wint_t i)
938{
939 dprintf(("CRTDLL: iswdigit(%08xh)\n", i));
940
941 return (iswdigit(i));
942}
943
944/*********************************************************************
945 * iswgraph (CRTDLL.408)
946 */
947int CDECL CRTDLL_iswgraph(wint_t i)
948{
949 dprintf(("CRTDLL: iswgraph(%08xh)\n", i));
950
951 return (iswgraph(i));
952}
953
954/*********************************************************************
955 * iswlower (CRTDLL.409)
956 */
957int CDECL CRTDLL_iswlower(wint_t i)
958{
959 dprintf(("CRTDLL: iswlower(%08xh)\n", i));
960
961 return (iswlower(i));
962}
963
964/*********************************************************************
965 * iswprint (CRTDLL.410)
966 */
967int CDECL CRTDLL_iswprint(wint_t i)
968{
969 dprintf(("CRTDLL: iswprint(%08xh)\n", i));
970
971 return (iswprint(i));
972}
973
974/*********************************************************************
975 * iswpunct (CRTDLL.411)
976 */
977int CDECL CRTDLL_iswpunct(wint_t i)
978{
979 dprintf(("CRTDLL: iswpunct(%08xh)\n", i));
980
981 return (iswpunct(i));
982}
983
984/*********************************************************************
985 * iswspace (CRTDLL.412)
986 */
987int CDECL CRTDLL_iswspace(wint_t i)
988{
989 dprintf(("CRTDLL: iswspace(%08xh)\n", i));
990
991 return (iswspace(i));
992}
993
994/*********************************************************************
995 * iswupper (CRTDLL.413)
996 */
997int CDECL CRTDLL_iswupper(wint_t i)
998{
999 dprintf(("CRTDLL: iswupper(%08xh)\n", i));
1000
1001 return (iswupper(i));
1002}
1003
1004/*********************************************************************
1005 * iswxdigit (CRTDLL.414)
1006 */
1007int CDECL CRTDLL_iswxdigit(wint_t i)
1008{
1009 dprintf(("CRTDLL: iswxdigit(%08xh)\n", i));
1010
1011 return (iswxdigit(i));
1012}
1013
1014/*********************************************************************
1015 * ldexp (CRTDLL.417)
1016 */
1017double CDECL CRTDLL_ldexp( double x, int exp )
1018{
1019 dprintf(("CRTDLL: ldexp\n"));
1020
1021 return (ldexp(x, exp));
1022}
1023
1024/*********************************************************************
1025 * ldiv (CRTDLL.418)
1026 */
1027ldiv_t CDECL CRTDLL_ldiv( long int numer, long int denom )
1028{
1029 dprintf(("CRTDLL: ldiv\n"));
1030
1031 return (ldiv(numer, denom));
1032}
1033
1034/*********************************************************************
1035 * localeconv (CRTDLL.419)
1036 */
1037struct lconv * CDECL CRTDLL_localeconv(void)
1038{
1039 dprintf(("CRTDLL: localeconv\n"));
1040 return (localeconv());
1041}
1042
1043/*********************************************************************
1044 * localtime (CRTDLL.420)
1045 */
1046struct tm * CDECL CRTDLL_localtime( const time_t *timer )
1047{
1048 dprintf(("CRTDLL: localtime\n"));
1049 return (localtime(timer));
1050}
1051
1052/*********************************************************************
1053 * log10 (CRTDLL.422)
1054 */
1055double CDECL CRTDLL_log10( double x )
1056{
1057 dprintf(("CRTDLL: log10\n"));
1058 return (log10(x));
1059}
1060
1061/*********************************************************************
1062 * longjmp (CRTDLL.423)
1063 */
1064VOID CDECL CRTDLL_longjmp(jmp_buf env, int val)
1065{
1066 dprintf(("CRTDLL: longjmp\n"));
1067 longjmp(env, val);
1068}
1069
1070/*********************************************************************
1071 * malloc (CRTDLL.424)
1072 */
1073VOID* CDECL CRTDLL_malloc(DWORD size)
1074{
1075 dprintf(("CRTDLL: malloc\n"));
1076 return HeapAlloc(GetProcessHeap(),0,size);
1077}
1078
1079/*********************************************************************
1080 * mblen (CRTDLL.425)
1081 */
1082INT CDECL CRTDLL_mblen( const char *s, size_t n )
1083{
1084 dprintf(("CRTDLL: mblen\n"));
1085 return (mblen(s, n));
1086}
1087
1088/*********************************************************************
1089 * CRTDLL_mbtowc (CRTDLL.427)
1090 */
1091INT CDECL CRTDLL_mbtowc( WCHAR *dst, LPCSTR str, INT n )
1092{
1093 wchar_t res;
1094 int ret = mbtowc( &res, str, n );
1095 if (dst) *dst = (WCHAR)res;
1096 return ret;
1097}
1098
1099/*********************************************************************
1100 * mktime (CRTDLL.433)
1101 */
1102time_t CDECL CRTDLL_mktime( struct tm *timeptr )
1103{
1104 dprintf(("CRTDLL: mktime\n"));
1105 return mktime( timeptr );
1106}
1107
1108/*********************************************************************
1109 * modf (CRTDLL.434)
1110 */
1111double CDECL CRTDLL_modf( double value, double *iptr )
1112{
1113 dprintf(("CRTDLL: modf\n"));
1114 return modf( value, iptr );
1115}
1116
1117/*********************************************************************
1118 * perror (CRTDLL.435)
1119 */
1120void CDECL CRTDLL_perror( const char *s )
1121{
1122 dprintf(("CRTDLL: perror\n"));
1123 perror( s );
1124}
1125
1126/*********************************************************************
1127 * printf (CRTDLL.437)
1128 */
1129int CDECL CRTDLL_printf( const char *format, ... )
1130{
1131 dprintf(("CRTDLL: printf\n"));
1132 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1133 return FALSE;
1134}
1135
1136/*********************************************************************
1137 * putc (CRTDLL.438)
1138 */
1139int CDECL CRTDLL_putc( int c, FILE *fp )
1140{
1141 dprintf(("CRTDLL: putc\n"));
1142 return putc( c, fp );
1143}
1144
1145/*********************************************************************
1146 * putchar (CRTDLL.439)
1147 */
1148int CDECL CRTDLL_putchar( int c )
1149{
1150 dprintf(("CRTDLL: putchar\n"));
1151 return putchar( c );
1152}
1153
1154/*********************************************************************
1155 * puts (CRTDLL.440)
1156 */
1157int CDECL CRTDLL_puts( const char *s )
1158{
1159 dprintf(("CRTDLL: puts\n"));
1160 return puts( s );
1161}
1162
1163/*********************************************************************
1164 * raise (CRTDLL.442)
1165 */
1166int CDECL CRTDLL_raise( int sig )
1167{
1168 dprintf(("CRTDLL: raise\n"));
1169 return raise( sig );
1170}
1171
1172/*********************************************************************
1173 * rand (CRTDLL.443)
1174 */
1175int CDECL CRTDLL_rand( void )
1176{
1177 dprintf(("CRTDLL: rand\n"));
1178 return (rand());
1179}
1180
1181/*********************************************************************
1182 * realloc (CRTDLL.444)
1183 */
1184void * CDECL CRTDLL_realloc( void *ptr, size_t size )
1185{
1186 dprintf(("CRTDLL: realloc\n"));
1187 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1188 return FALSE;
1189}
1190
1191/*********************************************************************
1192 * remove (CRTDLL.445)
1193 */
1194INT CDECL CRTDLL_remove(LPCSTR file)
1195{
1196 dprintf(("CRTDLL: remove\n"));
1197 if (!DeleteFileA(file))
1198 return -1;
1199 return 0;
1200}
1201
1202/*********************************************************************
1203 * rename (CRTDLL.446)
1204 */
1205int CDECL CRTDLL_rename (const char *old, const char *new2)
1206{
1207 dprintf(("CRTDLL: rename\n"));
1208 return (rename(old, new2));
1209}
1210
1211/*********************************************************************
1212 * rewind (CRTDLL.447)
1213 */
1214void CDECL CRTDLL_rewind( FILE *fp )
1215{
1216 dprintf(("CRTDLL: rewind\n"));
1217 rewind(fp);
1218}
1219
1220/*********************************************************************
1221 * scanf (CRTDLL.448)
1222 */
1223int CDECL CRTDLL_scanf( const char *format, ... )
1224{
1225 dprintf(("CRTDLL: scanf\n"));
1226 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1227 return FALSE;
1228}
1229
1230/*********************************************************************
1231 * setbuf (CRTDLL.449)
1232 */
1233void CDECL CRTDLL_setbuf( FILE *fp, char *buf )
1234{
1235 dprintf(("CRTDLL: setbuf\n"));
1236 setbuf(fp, buf);
1237}
1238
1239/*********************************************************************
1240 * setlocale (CRTDLL.450)
1241 */
1242char * CDECL CRTDLL_setlocale(int category,const char *locale)
1243{
1244 dprintf(("CRTDLL: setlocale\n"));
1245 return (setlocale(category, locale));
1246}
1247
1248/*********************************************************************
1249 * setvbuf (CRTDLL.451)
1250 */
1251int CDECL CRTDLL_setvbuf( FILE *fp, char *buf, int mode, size_t size )
1252{
1253 dprintf(("CRTDLL: setvbuf\n"));
1254 return (setvbuf(fp, buf, mode, size));
1255}
1256
1257/*********************************************************************
1258 * signal (CRTDLL.452)
1259 */
1260void CDECL CRTDLL_signal( int sig, void (*func)(int))
1261{
1262 dprintf(("CRTDLL: signal\n"));
1263 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1264}
1265
1266/*********************************************************************
1267 * sinh (CRTDLL.454)
1268 */
1269double CDECL CRTDLL_sinh( double x )
1270{
1271 dprintf(("CRTDLL: sinh\n"));
1272 return (sinh(x));
1273}
1274
1275/*********************************************************************
1276 * srand (CRTDLL.457)
1277 */
1278void CDECL CRTDLL_srand( unsigned int seed )
1279{
1280 dprintf(("CRTDLL: srand\n"));
1281 srand(seed);
1282}
1283
1284/*********************************************************************
1285 * strcoll (CRTDLL.462)
1286 */
1287int CDECL CRTDLL_strcoll( const char *s1, const char *s2 )
1288{
1289 dprintf(("CRTDLL: strcoll\n"));
1290 return strcoll(s1, s2);
1291}
1292
1293/*********************************************************************
1294 * strerror (CRTDLL.465)
1295 */
1296char * CDECL CRTDLL_strerror( int errnum )
1297{
1298 dprintf(("CRTDLL: strerror\n"));
1299 return strerror(errnum);
1300}
1301
1302/*********************************************************************
1303 * strftime (CRTDLL.466)
1304 */
1305size_t CDECL CRTDLL_strftime( char *s, size_t maxsiz, const char *fmt, const struct tm *tp )
1306{
1307 dprintf(("CRTDLL: strftime\n"));
1308 return strftime(s, maxsiz, fmt, tp);
1309}
1310
1311
1312/*********************************************************************
1313 * strtod (CRTDLL.475)
1314 */
1315double CDECL CRTDLL_strtod( const char *nptr, char **endptr )
1316{
1317 dprintf(("CRTDLL: strtod\n"));
1318 return strtod(nptr, endptr);
1319}
1320
1321/*********************************************************************
1322 * strtok (CRTDLL.476)
1323 */
1324char * CDECL CRTDLL_strtok( char *s1, const char *s2 )
1325{
1326 dprintf(("CRTDLL: strtok\n"));
1327 return strtok(s1, s2);
1328}
1329
1330/*********************************************************************
1331 * strtol (CRTDLL.477)
1332 */
1333long int CDECL CRTDLL_strtol( const char *nptr, char **endptr, int base )
1334{
1335 dprintf(("CRTDLL: strtol\n"));
1336 return strtol(nptr, endptr, base);
1337}
1338
1339/*********************************************************************
1340 * strtoul (CRTDLL.478)
1341 */
1342unsigned long CDECL CRTDLL_strtoul( const char *nptr, char **endptr, int base )
1343{
1344 dprintf(("CRTDLL: strtoul\n"));
1345 return strtoul(nptr, endptr, base);
1346}
1347
1348/*********************************************************************
1349 * strxfrm (CRTDLL.479)
1350 */
1351size_t CDECL CRTDLL_strxfrm( char *s1, const char *s2, size_t n )
1352{
1353 dprintf(("CRTDLL: strxfrm\n"));
1354 return strxfrm(s1, s2, n);
1355}
1356
1357/*********************************************************************
1358 * swscanf (CRTDLL.481)
1359 */
1360int CDECL CRTDLL_swscanf( const wchar_t *s1, const wchar_t *s2, ... )
1361{
1362 dprintf(("CRTDLL: swscanf\n"));
1363 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1364 return FALSE;
1365}
1366
1367/*********************************************************************
1368 * system (CRTDLL.482)
1369 */
1370int CDECL CRTDLL_system( const char *string )
1371{
1372 dprintf(("CRTDLL: system\n"));
1373 return system(string);
1374}
1375
1376/*********************************************************************
1377 * tanh (CRTDLL.485)
1378 */
1379double CDECL CRTDLL_tanh( double x )
1380{
1381 dprintf(("CRTDLL: tanh\n"));
1382 return tanh(x);
1383}
1384
1385/*********************************************************************
1386 * time (CRTDLL.485)
1387 */
1388time_t CDECL CRTDLL_time( time_t *timer )
1389{
1390 dprintf(("CRTDLL: time\n"));
1391
1392 return time(timer);
1393}
1394
1395/*********************************************************************
1396 * tmpnam (CRTDLL.486)
1397 */
1398FILE * CDECL CRTDLL_tmpfile( void )
1399{
1400 dprintf(("CRTDLL: tmpfile\n"));
1401 return (tmpfile());
1402}
1403
1404/*********************************************************************
1405 * tmpnam (CRTDLL.487)
1406 */
1407char * CDECL CRTDLL_tmpnam( char *s )
1408{
1409 dprintf(("CRTDLL: tmpnam\n"));
1410
1411 return (tmpnam(s));
1412}
1413
1414/*********************************************************************
1415 * ungetc (CRTDLL.492)
1416 */
1417INT CDECL CRTDLL_ungetc(int c)
1418{
1419 dprintf(("CRTDLL: ungetc\n"));
1420 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421 return FALSE;
1422}
1423
1424/*********************************************************************
1425 * ungetwc (CRTDLL.493)
1426 */
1427wint_t CDECL CRTDLL_ungetwc( wint_t wc, FILE *strm )
1428{
1429 dprintf(("CRTDLL: ungetwc\n"));
1430
1431 return (ungetwc(wc, strm));
1432}
1433
1434/*********************************************************************
1435 * vfprintf (CRTDLL.494)
1436 */
1437INT CDECL CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args )
1438{
1439 dprintf(("CRTDLL: vprintf\n"));
1440 char buffer[2048]; /* FIXME... */
1441
1442 vsprintf( buffer, format, args );
1443 return CRTDLL_fwrite( buffer, 1, strlen(buffer), file );
1444}
1445
1446/*********************************************************************
1447 * vfwprintf (CRTDLL.495)
1448 */
1449int CDECL CRTDLL_vfwprintf( FILE *F, const wchar_t *s, va_list arg )
1450{
1451 dprintf(("CRTDLL: vfwprintf\n"));
1452 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1453 return FALSE;
1454}
1455
1456/*********************************************************************
1457 * vprintf (CRTDLL.496)
1458 */
1459int CDECL CRTDLL_vprintf( const char *format, __va_list arg )
1460{
1461 dprintf(("CRTDLL: vprintf\n"));
1462
1463 return (vprintf(format, arg));
1464}
1465
1466/*********************************************************************
1467 * vswprintf (CRTDLL.498)
1468 */
1469int CDECL CRTDLL_vswprintf( wchar_t *s , size_t t, const wchar_t *format, va_list arg )
1470{
1471 dprintf(("CRTDLL: vswprintf\n"));
1472
1473 return (vswprintf(s, t, format, arg));
1474}
1475
1476/*********************************************************************
1477 * vwprintf (CRTDLL.499)
1478 */
1479int CDECL CRTDLL_vwprintf( const wchar_t *s, va_list arg)
1480{
1481 dprintf(("CRTDLL: vwprintf\n"));
1482 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1483 return FALSE;
1484}
1485
1486
1487/*********************************************************************
1488 * wcscoll (CRTDLL.503)
1489 */
1490int CDECL CRTDLL_wcscoll(const wchar_t *s1, const wchar_t *s2)
1491{
1492 dprintf(("CRTDLL: wcscoll\n"));
1493
1494 return (wcscoll(s1, s2));
1495}
1496
1497/*********************************************************************
1498 * wcsftime (CRTDLL.506)
1499 */
1500size_t CDECL CRTDLL_wcsftime( wchar_t *s, size_t maxsize,
1501 const wchar_t *format, const struct tm *timeptr )
1502{
1503 dprintf(("CRTDLL: wcsftime\n"));
1504
1505 return (wcsftime(s, maxsize, format, timeptr));
1506}
1507
1508/*********************************************************************
1509 * wcstod (CRTDLL.515)
1510 */
1511double CDECL CRTDLL_wcstod( const wchar_t *nptr, wchar_t **endptr )
1512{
1513 dprintf(("CRTDLL: wcstod\n"));
1514 return (wcstod(nptr, endptr));
1515}
1516
1517/*********************************************************************
1518 * wcsxfrm (CRTDLL.520)
1519 */
1520size_t CDECL CRTDLL_wcsxfrm( wchar_t *s1, const wchar_t *s2, size_t n )
1521{
1522 dprintf(("CRTDLL: wcsxfrm\n"));
1523
1524 return (wcsxfrm(s1, s2, n));
1525}
1526
1527/*********************************************************************
1528 * wcstomb (CRTDLL.521)
1529 */
1530int CDECL CRTDLL_wctomb( char *s, wchar_t wchar )
1531{
1532 dprintf(("CRTDLL: wctomb\n"));
1533
1534 return (wctomb(s,wchar));
1535}
1536
1537/*********************************************************************
1538 * wprintf (CRTDLL.522)
1539 */
1540int CDECL CRTDLL_wprintf( const wchar_t *s, ... )
1541{
1542 dprintf(("CRTDLL: wprintf\n"));
1543 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1544 return FALSE;
1545}
1546
1547/*********************************************************************
1548 * wscanf (CRTDLL.523)
1549 */
1550int CDECL CRTDLL_wscanf( const wchar_t *s, ... )
1551{
1552 dprintf(("CRTDLL: wscanf\n"));
1553 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1554 return FALSE;
1555}
1556
1557
1558INT WINAPI lstrncmpiA( LPCSTR str1, LPCSTR str2, INT n )
1559{
1560 dprintf(("CRTDLL: lstrncmpiA\n"));
1561 //CB: implement!
1562 return 0;
1563}
Note: See TracBrowser for help on using the repository browser.