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

Last change on this file since 2852 was 2844, checked in by sandervl, 26 years ago

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