4 * Implements C run-time functionality as known from UNIX.
6 * Copyright 1996 Marcus Meissner
7 * Copyright 1996 Jukka Iivonen
8 * Copyright 1997 Uwe Bonnes
12 Unresolved issues Uwe Bonnes 970904:
13 - Handling of Binary/Text Files is crude. If in doubt, use fromdos or recode
14 - Arguments in crtdll.spec for functions with double argument
15 - system-call calls another wine process, but without debugging arguments
16 and uses the first wine executable in the path
17 - tested with ftp://ftp.remcomp.com/pub/remcomp/lcc-win32.zip, a C-Compiler
18 for Win32, based on lcc, from Jacob Navia
21 /* FIXME: all the file handling is hopelessly broken -- AJ */
28 #include <sys/times.h>
46 extern int FILE_GetUnixHandle( HFILE32
);
48 static DOS_FULL_NAME CRTDLL_tmpname
;
50 extern INT32
WIN32_wsprintf32W( DWORD
*args
);
52 UINT32 CRTDLL_argc_dll
; /* CRTDLL.23 */
53 LPSTR
*CRTDLL_argv_dll
; /* CRTDLL.24 */
54 LPSTR CRTDLL_acmdln_dll
; /* CRTDLL.38 */
55 UINT32 CRTDLL_basemajor_dll
; /* CRTDLL.42 */
56 UINT32 CRTDLL_baseminor_dll
; /* CRTDLL.43 */
57 UINT32 CRTDLL_baseversion_dll
; /* CRTDLL.44 */
58 UINT32 CRTDLL_commode_dll
; /* CRTDLL.59 */
59 LPSTR CRTDLL_environ_dll
; /* CRTDLL.75 */
60 UINT32 CRTDLL_fmode_dll
; /* CRTDLL.104 */
61 UINT32 CRTDLL_osmajor_dll
; /* CRTDLL.241 */
62 UINT32 CRTDLL_osminor_dll
; /* CRTDLL.242 */
63 UINT32 CRTDLL_osmode_dll
; /* CRTDLL.243 */
64 UINT32 CRTDLL_osver_dll
; /* CRTDLL.244 */
65 UINT32 CRTDLL_osversion_dll
; /* CRTDLL.245 */
66 UINT32 CRTDLL_winmajor_dll
; /* CRTDLL.329 */
67 UINT32 CRTDLL_winminor_dll
; /* CRTDLL.330 */
68 UINT32 CRTDLL_winver_dll
; /* CRTDLL.331 */
70 BYTE CRTDLL_iob
[32*3]; /* FIXME */
72 typedef VOID (*new_handler_type
)(VOID
);
74 static new_handler_type new_handler
;
76 /*********************************************************************
77 * _GetMainArgs (CRTDLL.022)
79 DWORD __cdecl
CRTDLL__GetMainArgs(LPDWORD argc
,LPSTR
**argv
,
80 LPSTR
*environ
,DWORD flag
)
84 int xargc
,i
,afterlastspace
;
87 TRACE(crtdll
,"(%p,%p,%p,%ld).\n",
88 argc
,argv
,environ
,flag
90 CRTDLL_acmdln_dll
= cmdline
= HEAP_strdupA( GetProcessHeap(), 0,
91 GetCommandLine32A() );
92 TRACE(crtdll
,"got '%s'\n", cmdline
);
94 version
= GetVersion32();
95 CRTDLL_osver_dll
= version
>> 16;
96 CRTDLL_winminor_dll
= version
& 0xFF;
97 CRTDLL_winmajor_dll
= (version
>>8) & 0xFF;
98 CRTDLL_baseversion_dll
= version
>> 16;
99 CRTDLL_winver_dll
= ((version
>> 8) & 0xFF) + ((version
& 0xFF) << 8);
100 CRTDLL_baseminor_dll
= (version
>> 16) & 0xFF;
101 CRTDLL_basemajor_dll
= (version
>> 24) & 0xFF;
102 CRTDLL_osversion_dll
= version
& 0xFFFF;
103 CRTDLL_osminor_dll
= version
& 0xFF;
104 CRTDLL_osmajor_dll
= (version
>>8) & 0xFF;
106 /* missing threading init */
108 i
=0;xargv
=NULL
;xargc
=0;afterlastspace
=0;
110 if (cmdline
[i
]==' ') {
111 xargv
=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv
,
112 sizeof(char*)*(++xargc
));
114 xargv
[xargc
-1] = HEAP_strdupA( GetProcessHeap(), 0,
115 cmdline
+afterlastspace
);
117 while (cmdline
[i
]==' ')
124 xargv
=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv
,
125 sizeof(char*)*(++xargc
));
127 xargv
[xargc
-1] = HEAP_strdupA( GetProcessHeap(), 0,
128 cmdline
+afterlastspace
);
129 CRTDLL_argc_dll
= xargc
;
131 CRTDLL_argv_dll
= xargv
;
134 TRACE(crtdll
,"found %d arguments\n",
136 CRTDLL_environ_dll
= *environ
= GetEnvironmentStrings32A();
141 typedef void (*_INITTERMFUN
)();
143 /*********************************************************************
144 * _initterm (CRTDLL.135)
146 DWORD __cdecl
CRTDLL__initterm(_INITTERMFUN
*start
,_INITTERMFUN
*end
)
148 _INITTERMFUN
*current
;
150 TRACE(crtdll
,"(%p,%p)\n",start
,end
);
152 while (current
<end
) {
153 if (*current
) (*current
)();
159 /*********************************************************************
160 * _fdopen (CRTDLL.91)
162 DWORD __cdecl
CRTDLL__fdopen(INT32 handle
, LPCSTR mode
)
170 case 1 : file
=stdout
;
172 case 2 : file
=stderr
;
175 file
=fdopen(handle
,mode
);
177 TRACE(crtdll
, "open handle %d mode %s got file %p\n",
182 static FILE *xlat_file_ptr(void *ptr
)
186 /* CRT sizeof(FILE) == 32 */
187 dif
= ((char *)ptr
- (char *)CRTDLL_iob
) / 32;
190 case 0: return stdin
;
191 case 1: return stdout
;
192 case 2: return stderr
;
197 /*******************************************************************
198 * _global_unwind2 (CRTDLL.129)
200 void __cdecl
CRTDLL__global_unwind2( CONTEXT
*context
)
202 /* Retrieve the arguments (args[0] is return addr, args[1] is first arg) */
203 DWORD
*args
= (DWORD
*)ESP_reg(context
);
204 RtlUnwind( (PEXCEPTION_FRAME
)args
[1], (LPVOID
)EIP_reg(context
),
208 /*******************************************************************
209 * _local_unwind2 (CRTDLL.173)
211 void __cdecl
CRTDLL__local_unwind2( CONTEXT
*context
)
213 /* Retrieve the arguments (args[0] is return addr, args[1] is first arg) */
214 DWORD
*args
= (DWORD
*)ESP_reg(context
);
215 PEXCEPTION_FRAME endframe
= (PEXCEPTION_FRAME
)args
[1];
217 TRACE(crtdll
,"(%p,%ld)\n",endframe
,nr
);
220 /*********************************************************************
223 DWORD __cdecl
CRTDLL_fopen(LPCSTR path
, LPCSTR mode
)
228 DOS_FULL_NAME full_name
;
230 if (!DOSFS_GetFullName( path
, FALSE
, &full_name
)) {
231 WARN(crtdll
, "file %s bad name\n",path
);
235 file
=fopen(full_name
.long_name
,mode
);
240 if ((strchr(mode
,'r')&&strchr(mode
,'a'))||
241 (strchr(mode
,'r')&&strchr(mode
,'w'))||
242 (strchr(mode
,'w')&&strchr(mode
,'a')))
245 if (strstr(mode
,"r+")) flagmode
=O_RDWR
;
246 else if (strchr(mode
,'r')) flagmode
= O_RDONLY
;
247 else if (strstr(mode
,"w+")) flagmode
= O_RDWR
| O_TRUNC
| O_CREAT
;
248 else if (strchr(mode
,'w')) flagmode
= O_WRONLY
| O_TRUNC
| O_CREAT
;
249 else if (strstr(mode
,"a+")) flagmode
= O_RDWR
| O_CREAT
| O_APPEND
;
250 else if (strchr(mode
,'w')) flagmode
= O_RDWR
| O_CREAT
| O_APPEND
;
251 else if (strchr(mode
,'b'))
252 TRACE(crtdll
, "%s in BINARY mode\n",path
);
254 dos_fildes
=FILE_Open(path
, flagmode
);
255 unix_fildes
=FILE_GetUnixHandle(dos_fildes
);
256 file
= fdopen(unix_fildes
,mode
);
258 TRACE(crtdll
, "file %s mode %s got ufh %d dfh %d file %p\n",
259 path
,mode
,unix_fildes
,dos_fildes
,file
);
263 /*********************************************************************
266 DWORD __cdecl
CRTDLL_fread(LPVOID ptr
, INT32 size
, INT32 nmemb
, LPVOID vfile
)
269 FILE *file
=xlat_file_ptr(vfile
);
274 /* If we would honour CR/LF <-> LF translation, we could do it like this.
275 We should keep track of all files opened, and probably files with \
276 known binary extensions must be unchanged */
277 while ( (i
< (nmemb
*size
)) && (ret
==1)) {
278 ret
=fread(temp
,1,1,file
);
279 TRACE(crtdll
, "got %c 0x%02x ret %d\n",
280 (isalpha(*(unsigned char*)temp
))? *(unsigned char*)temp
:
281 ' ',*(unsigned char*)temp
, ret
);
282 if (*(unsigned char*)temp
!= 0xd) { /* skip CR */
287 TRACE(crtdll
, "skipping ^M\n");
289 TRACE(crtdll
, "0x%08x items of size %d from file %p to %p\n",
290 nmemb
,size
,file
,ptr
,);
292 WARN(crtdll
, " failed!\n");
297 ret
=fread(ptr
,size
,nmemb
,file
);
298 TRACE(crtdll
, "0x%08x items of size %d from file %p to %p\n",
299 nmemb
,size
,file
,ptr
);
301 WARN(crtdll
, " failed!\n");
307 /*********************************************************************
310 LONG __cdecl
CRTDLL_fseek(LPVOID stream
, LONG offset
, INT32 whence
)
314 ret
=fseek(xlat_file_ptr(stream
),offset
,whence
);
315 TRACE(crtdll
, "file %p to 0x%08lx pos %s\n",
316 stream
,offset
,(whence
==SEEK_SET
)?"SEEK_SET":
317 (whence
==SEEK_CUR
)?"SEEK_CUR":
318 (whence
==SEEK_END
)?"SEEK_END":"UNKNOWN");
320 WARN(crtdll
, " failed!\n");
325 /*********************************************************************
328 LONG __cdecl
CRTDLL_ftell(LPVOID stream
)
332 ret
=ftell(xlat_file_ptr(stream
));
333 TRACE(crtdll
, "file %p at 0x%08lx\n",
338 /*********************************************************************
339 * fwrite (CRTDLL.386)
341 DWORD __cdecl
CRTDLL_fwrite(LPVOID ptr
, INT32 size
, INT32 nmemb
, LPVOID vfile
)
344 FILE *file
=xlat_file_ptr(vfile
);
346 ret
=fwrite(ptr
,size
,nmemb
,file
);
347 TRACE(crtdll
, "0x%08x items of size %d from %p to file %p\n",
348 nmemb
,size
,ptr
,file
);
350 WARN(crtdll
, " Failed!\n");
355 /*********************************************************************
356 * setbuf (CRTDLL.452)
358 INT32 __cdecl
CRTDLL_setbuf(LPVOID file
, LPSTR buf
)
360 TRACE(crtdll
, "(file %p buf %p)\n", file
, buf
);
361 /* this doesn't work:"void value not ignored as it ought to be"
362 return setbuf(file,buf);
364 setbuf(xlat_file_ptr(file
),buf
);
368 /*********************************************************************
369 * _open_osfhandle (CRTDLL.240)
371 HFILE32 __cdecl
CRTDLL__open_osfhandle(LONG osfhandle
, INT32 flags
)
376 case STD_INPUT_HANDLE
:
380 case STD_OUTPUT_HANDLE
:
384 case STD_ERROR_HANDLE
:
391 TRACE(crtdll
, "(handle %08lx,flags %d) return %d\n",
392 osfhandle
,flags
,handle
);
397 /*********************************************************************
400 void __cdecl
CRTDLL_srand(DWORD seed
)
402 /* FIXME: should of course be thread? process? local */
406 /*********************************************************************
407 * fprintf (CRTDLL.373)
409 INT32 __cdecl
CRTDLL_fprintf( FILE *file
, LPSTR format
, ... )
414 va_start( valist
, format
);
415 res
= vfprintf( xlat_file_ptr(file
), format
, valist
);
420 /*********************************************************************
421 * vfprintf (CRTDLL.373)
423 INT32 __cdecl
CRTDLL_vfprintf( FILE *file
, LPSTR format
, va_list args
)
425 return vfprintf( xlat_file_ptr(file
), format
, args
);
428 /*********************************************************************
431 time_t __cdecl
CRTDLL_time(time_t *timeptr
)
433 time_t curtime
= time(NULL
);
440 /*********************************************************************
443 clock_t __cdecl
CRTDLL_clock(void)
449 res
= alltimes
.tms_utime
+ alltimes
.tms_stime
+
450 alltimes
.tms_cutime
+ alltimes
.tms_cstime
;
451 /* Fixme: We need some symbolic representation
452 for (Hostsystem_)CLOCKS_PER_SEC
453 and (Emulated_system_)CLOCKS_PER_SEC
454 10 holds only for Windows/Linux_i86)
459 /*********************************************************************
460 * _isatty (CRTDLL.137)
462 BOOL32 __cdecl
CRTDLL__isatty(DWORD x
)
464 TRACE(crtdll
,"(%ld)\n",x
);
468 /*********************************************************************
469 * _write (CRTDLL.332)
471 INT32 __cdecl
CRTDLL__write(INT32 fd
,LPCVOID buf
,UINT32 count
)
478 len
= (UINT32
)write(fd
,buf
,(LONG
)count
);
480 len
= _lwrite32(fd
,buf
,count
);
481 TRACE(crtdll
,"%d/%d byte to dfh %d from %p,\n",
487 /*********************************************************************
490 * FIXME: What the heck is the difference between
491 * FIXME _c_exit (CRTDLL.47)
492 * FIXME _cexit (CRTDLL.49)
493 * FIXME _exit (CRTDLL.87)
494 * FIXME exit (CRTDLL.359)
496 * atexit-processing comes to mind -- MW.
499 void __cdecl
CRTDLL__cexit(INT32 ret
)
501 TRACE(crtdll
,"(%d)\n",ret
);
506 /*********************************************************************
509 void __cdecl
CRTDLL_exit(DWORD ret
)
511 TRACE(crtdll
,"(%ld)\n",ret
);
516 /*********************************************************************
517 * _abnormal_termination (CRTDLL.36 )
519 INT32 __cdecl
CRTDLL__abnormal_termination(void)
521 TRACE(crtdll
,"(void)\n");
526 /*********************************************************************
527 * fflush (CRTDLL.365)
529 INT32 __cdecl
CRTDLL_fflush(LPVOID stream
)
533 ret
= fflush(xlat_file_ptr(stream
));
534 TRACE(crtdll
,"%p returnd %d\n",stream
,ret
);
536 WARN(crtdll
, " Failed!\n");
542 /*********************************************************************
545 LPSTR __cdecl
CRTDLL_gets(LPSTR buf
)
548 /* BAD, for the whole WINE process blocks... just done this way to test
549 * windows95's ftp.exe.
552 TRACE(crtdll
,"got %s\n",ret
);
557 /*********************************************************************
560 INT32 __cdecl
CRTDLL_rand()
566 /*********************************************************************
567 * putchar (CRTDLL.442)
569 void __cdecl
CRTDLL_putchar( INT32 x
)
575 /*********************************************************************
578 INT32 __cdecl
CRTDLL_fputc( INT32 c
, FILE *stream
)
580 TRACE(crtdll
, "%c to file %p\n",c
,stream
);
581 return fputc(c
,xlat_file_ptr(stream
));
585 /*********************************************************************
588 INT32 __cdecl
CRTDLL_fputs( LPCSTR s
, FILE *stream
)
590 TRACE(crtdll
, "%s to file %p\n",s
,stream
);
591 return fputs(s
,xlat_file_ptr(stream
));
595 /*********************************************************************
598 INT32 __cdecl
CRTDLL_puts(LPCSTR s
)
600 TRACE(crtdll
, "%s \n",s
);
605 /*********************************************************************
608 INT32 __cdecl
CRTDLL_putc(INT32 c
, FILE *stream
)
610 TRACE(crtdll
, " %c to file %p\n",c
,stream
);
611 return fputc(c
,xlat_file_ptr(stream
));
613 /*********************************************************************
616 INT32 __cdecl
CRTDLL_fgetc( FILE *stream
)
618 int ret
= fgetc(xlat_file_ptr(stream
));
619 TRACE(crtdll
, "got %d\n",ret
);
624 /*********************************************************************
627 INT32 __cdecl
CRTDLL_getc( FILE *stream
)
629 int ret
= fgetc(xlat_file_ptr(stream
));
630 TRACE(crtdll
, "got %d\n",ret
);
634 /*********************************************************************
637 UINT32 __cdecl
CRTDLL__rotl(UINT32 x
,INT32 shift
)
639 unsigned int ret
= (x
>> shift
)|( x
>>((sizeof(x
))-shift
));
641 TRACE(crtdll
, "got 0x%08x rot %d ret 0x%08x\n",
646 /*********************************************************************
647 * _lrotl (CRTDLL.176)
649 DWORD __cdecl
CRTDLL__lrotl(DWORD x
,INT32 shift
)
651 unsigned long ret
= (x
>> shift
)|( x
>>((sizeof(x
))-shift
));
653 TRACE(crtdll
, "got 0x%08lx rot %d ret 0x%08lx\n",
660 /*********************************************************************
663 CHAR
* __cdecl
CRTDLL_fgets(LPSTR s
,INT32 size
, LPVOID stream
)
668 ret
=fgets(s
, size
,xlat_file_ptr(stream
));
669 /*FIXME: Control with CRTDLL_setmode */
670 control_M
= strrchr(s
,'\r');
671 /*delete CR if we read a DOS File */
677 TRACE(crtdll
, "got %s for %d chars from file %p\n",
680 WARN(crtdll
, " Failed!\n");
686 /*********************************************************************
687 * _mbsicmp (CRTDLL.204)
689 int __cdecl
CRTDLL__mbsicmp(unsigned char *x
,unsigned char *y
)
696 /* FIXME: MBCS handling... */
705 /*********************************************************************
706 * _mbsinc (CRTDLL.205)
708 unsigned char * __cdecl
CRTDLL__mbsinc(unsigned char *x
)
715 /*********************************************************************
716 * vsprintf (CRTDLL.500)
718 INT32 __cdecl
CRTDLL_vsprintf( LPSTR buffer
, LPCSTR spec
, va_list args
)
720 return wvsprintf32A( buffer
, spec
, args
);
723 /*********************************************************************
724 * vswprintf (CRTDLL.501)
726 INT32 __cdecl
CRTDLL_vswprintf( LPWSTR buffer
, LPCWSTR spec
, va_list args
)
728 return wvsprintf32W( buffer
, spec
, args
);
731 /*********************************************************************
732 * _mbscpy (CRTDLL.200)
734 unsigned char* __cdecl
CRTDLL__mbscpy(unsigned char *x
,unsigned char *y
)
736 TRACE(crtdll
,"CRTDLL_mbscpy %s and %s\n",x
,y
);
741 /*********************************************************************
742 * _mbscat (CRTDLL.197)
744 unsigned char* __cdecl
CRTDLL__mbscat(unsigned char *x
,unsigned char *y
)
750 /*********************************************************************
751 * _strcmpi (CRTDLL.282) (CRTDLL.287)
753 INT32 __cdecl
CRTDLL__strcmpi( LPCSTR s1
, LPCSTR s2
)
755 return lstrcmpi32A( s1
, s2
);
759 /*********************************************************************
760 * _strnicmp (CRTDLL.293)
762 INT32 __cdecl
CRTDLL__strnicmp( LPCSTR s1
, LPCSTR s2
, INT32 n
)
764 return lstrncmpi32A( s1
, s2
, n
);
768 /*********************************************************************
769 * _strlwr (CRTDLL.293)
771 * convert a string in place to lowercase
773 LPSTR
CRTDLL__strlwr(LPSTR x
)
777 TRACE(crtdll
, "CRTDLL_strlwr got %s\n", x
);
779 if ((*y
> 0x40) && (*y
< 0x5b))
783 TRACE(crtdll
, " returned %s\n", x
);
788 /*********************************************************************
789 * system (CRTDLL.485)
791 INT32
CRTDLL_system(LPSTR x
)
793 #define SYSBUF_LENGTH 1500
794 char buffer
[SYSBUF_LENGTH
];
795 unsigned char *y
= x
;
799 sprintf( buffer
, "%s \"", Options
.argv0
);
800 bp
= buffer
+ strlen(buffer
);
801 i
= strlen(buffer
) + strlen(x
) +2;
803 /* Calculate needed buffer size to prevent overflow. */
808 /* If buffer too short, exit. */
809 if (i
> SYSBUF_LENGTH
) {
810 TRACE(crtdll
,"_system buffer to small\n");
819 if (*(y
-1) =='\\') *bp
++ = '\\';
821 /* Remove spaces from end of string. */
822 while (*(y
-1) == ' ') {
827 TRACE(crtdll
, "_system got '%s', executing '%s'\n",x
,buffer
);
829 return system(buffer
);
832 /*********************************************************************
833 * _strupr (CRTDLL.300)
835 LPSTR __cdecl
CRTDLL__strupr(LPSTR x
)
846 /*********************************************************************
847 * _wcsupr (CRTDLL.328)
849 LPWSTR __cdecl
CRTDLL__wcsupr(LPWSTR x
)
860 /*********************************************************************
861 * _wcslwr (CRTDLL.323)
863 LPWSTR __cdecl
CRTDLL__wcslwr(LPWSTR x
)
875 /*********************************************************************
876 * longjmp (CRTDLL.426)
878 VOID __cdecl
CRTDLL_longjmp(jmp_buf env
, int val
)
880 FIXME(crtdll
,"CRTDLL_longjmp semistup, expect crash\n");
881 return longjmp(env
, val
);
884 /*********************************************************************
885 * malloc (CRTDLL.427)
887 VOID
* __cdecl
CRTDLL_malloc(DWORD size
)
889 return HeapAlloc(GetProcessHeap(),0,size
);
892 /*********************************************************************
895 VOID
* __cdecl
CRTDLL_new(DWORD size
)
898 if(!(result
= HeapAlloc(GetProcessHeap(),0,size
)) && new_handler
)
903 /*********************************************************************
904 * set_new_handler(CRTDLL.003)
906 new_handler_type __cdecl
CRTDLL_set_new_handler(new_handler_type func
)
908 new_handler_type old_handler
= new_handler
;
913 /*********************************************************************
914 * calloc (CRTDLL.350)
916 VOID
* __cdecl
CRTDLL_calloc(DWORD size
, DWORD count
)
918 return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, size
* count
);
921 /*********************************************************************
922 * realloc (CRTDLL.447)
924 VOID
* __cdecl
CRTDLL_realloc( VOID
*ptr
, DWORD size
)
926 return HeapReAlloc( GetProcessHeap(), 0, ptr
, size
);
929 /*********************************************************************
932 VOID __cdecl
CRTDLL_free(LPVOID ptr
)
934 HeapFree(GetProcessHeap(),0,ptr
);
937 /*********************************************************************
938 * delete (CRTDLL.002)
940 VOID __cdecl
CRTDLL_delete(VOID
* ptr
)
942 HeapFree(GetProcessHeap(),0,ptr
);
945 /*********************************************************************
946 * _strdup (CRTDLL.285)
948 LPSTR __cdecl
CRTDLL__strdup(LPSTR ptr
)
950 return HEAP_strdupA(GetProcessHeap(),0,ptr
);
954 /*********************************************************************
955 * fclose (CRTDLL.362)
957 INT32 __cdecl
CRTDLL_fclose( FILE *stream
)
960 HFILE32 dos_handle
=1;
963 stream
=xlat_file_ptr(stream
);
964 unix_handle
=fileno(stream
);
966 if (unix_handle
<4) ret
= fclose(stream
);
968 while(FILE_GetUnixHandle(dos_handle
) != unix_handle
) dos_handle
++;
970 ret
= _lclose32( dos_handle
);
972 TRACE(crtdll
,"(%p) ufh %d dfh %d\n",
973 stream
,unix_handle
,dos_handle
);
976 WARN(crtdll
, " Failed!\n");
981 /*********************************************************************
982 * _unlink (CRTDLL.315)
984 INT32 __cdecl
CRTDLL__unlink(LPCSTR pathname
)
987 DOS_FULL_NAME full_name
;
989 if (!DOSFS_GetFullName( pathname
, FALSE
, &full_name
)) {
990 WARN(crtdll
, "CRTDLL_unlink file %s bad name\n",pathname
);
994 ret
=unlink(full_name
.long_name
);
995 TRACE(crtdll
,"(%s unix %s)\n",
996 pathname
,full_name
.long_name
);
998 WARN(crtdll
, " Failed!\n");
1003 /*********************************************************************
1004 * rename (CRTDLL.449)
1006 INT32 __cdecl
CRTDLL_rename(LPCSTR oldpath
,LPCSTR newpath
)
1008 BOOL32 ok
= MoveFileEx32A( oldpath
, newpath
, MOVEFILE_REPLACE_EXISTING
);
1013 /*********************************************************************
1014 * _stat (CRTDLL.280)
1032 int __cdecl
CRTDLL__stat(const char * filename
, struct win_stat
* buf
)
1035 DOS_FULL_NAME full_name
;
1038 if (!DOSFS_GetFullName( filename
, TRUE
, &full_name
))
1040 WARN(crtdll
, "CRTDLL__stat filename %s bad name\n",filename
);
1043 ret
=stat(full_name
.long_name
,&mystat
);
1044 TRACE(crtdll
,"CRTDLL__stat %s\n", filename
);
1046 WARN(crtdll
, " Failed!\n");
1048 /* FIXME: should check what Windows returns */
1050 buf
->win_st_dev
= mystat
.st_dev
;
1051 buf
->win_st_ino
= mystat
.st_ino
;
1052 buf
->win_st_mode
= mystat
.st_mode
;
1053 buf
->win_st_nlink
= mystat
.st_nlink
;
1054 buf
->win_st_uid
= mystat
.st_uid
;
1055 buf
->win_st_gid
= mystat
.st_gid
;
1056 buf
->win_st_rdev
= mystat
.st_rdev
;
1057 buf
->win_st_size
= mystat
.st_size
;
1058 buf
->win_st_atime
= mystat
.st_atime
;
1059 buf
->win_st_mtime
= mystat
.st_mtime
;
1060 buf
->win_st_ctime
= mystat
.st_ctime
;
1064 /*********************************************************************
1065 * _open (CRTDLL.239)
1067 HFILE32 __cdecl
CRTDLL__open(LPCSTR path
,INT32 flags
)
1073 the flags in lcc's header differ from the ones in Linux, e.g.
1074 Linux: define O_APPEND 02000 (= 0x400)
1075 lcc: define _O_APPEND 0x0008
1076 so here a scheme to translate them
1077 Probably lcc is wrong here, but at least a hack to get is going
1079 wineflags
= (flags
& 3);
1080 if (flags
& 0x0008 ) wineflags
|= O_APPEND
;
1081 if (flags
& 0x0100 ) wineflags
|= O_CREAT
;
1082 if (flags
& 0x0200 ) wineflags
|= O_TRUNC
;
1083 if (flags
& 0x0400 ) wineflags
|= O_EXCL
;
1084 if (flags
& 0xf0f4 )
1085 TRACE(crtdll
,"CRTDLL_open file unsupported flags 0x%04x\n",flags
);
1088 ret
= FILE_Open(path
,wineflags
);
1089 TRACE(crtdll
,"CRTDLL_open file %s mode 0x%04x (lccmode 0x%04x) got dfh %d\n",
1090 path
,wineflags
,flags
,ret
);
1094 /*********************************************************************
1095 * _close (CRTDLL.57)
1097 INT32 __cdecl
CRTDLL__close(HFILE32 fd
)
1099 int ret
=_lclose32(fd
);
1101 TRACE(crtdll
,"(%d)\n",fd
);
1103 WARN(crtdll
, " Failed!\n");
1108 /*********************************************************************
1111 INT32 __cdecl
CRTDLL_feof( FILE *stream
)
1115 ret
=feof(xlat_file_ptr(stream
));
1116 TRACE(crtdll
,"(%p) %s\n",stream
,(ret
)?"true":"false");
1120 /*********************************************************************
1121 * setlocale (CRTDLL.453)
1123 LPSTR __cdecl
CRTDLL_setlocale(INT32 category
,LPCSTR locale
)
1128 case CRTDLL_LC_ALL
: categorystr
="LC_ALL";break;
1129 case CRTDLL_LC_COLLATE
: categorystr
="LC_COLLATE";break;
1130 case CRTDLL_LC_CTYPE
: categorystr
="LC_CTYPE";break;
1131 case CRTDLL_LC_MONETARY
: categorystr
="LC_MONETARY";break;
1132 case CRTDLL_LC_NUMERIC
: categorystr
="LC_NUMERIC";break;
1133 case CRTDLL_LC_TIME
: categorystr
="LC_TIME";break;
1134 default: categorystr
= "UNKNOWN?";break;
1136 FIXME(crtdll
,"(%s,%s),stub!\n",categorystr
,locale
);
1140 /*********************************************************************
1141 * wcscat (CRTDLL.503)
1143 LPWSTR __cdecl
CRTDLL_wcscat( LPWSTR s1
, LPCWSTR s2
)
1145 return lstrcat32W( s1
, s2
);
1148 /*********************************************************************
1149 * wcschr (CRTDLL.504)
1151 LPWSTR __cdecl
CRTDLL_wcschr(LPCWSTR str
,WCHAR xchar
)
1163 /*********************************************************************
1164 * wcscmp (CRTDLL.505)
1166 INT32 __cdecl
CRTDLL_wcscmp( LPCWSTR s1
, LPCWSTR s2
)
1168 return lstrcmp32W( s1
, s2
);
1171 /*********************************************************************
1172 * wcscpy (CRTDLL.507)
1174 LPWSTR __cdecl
CRTDLL_wcscpy( LPWSTR s1
, LPCWSTR s2
)
1176 return lstrcpy32W( s1
, s2
);
1179 /*********************************************************************
1180 * wcscspn (CRTDLL.508)
1182 INT32 __cdecl
CRTDLL_wcscspn(LPWSTR str
,LPWSTR reject
)
1189 while (*t
) { if (*t
==*s
) break;t
++;}
1193 return s
-str
; /* nr of wchars */
1196 /*********************************************************************
1197 * wcslen (CRTDLL.510)
1199 INT32 __cdecl
CRTDLL_wcslen( LPCWSTR s
)
1201 return lstrlen32W( s
);
1204 /*********************************************************************
1205 * wcsncat (CRTDLL.511)
1207 LPWSTR __cdecl
CRTDLL_wcsncat( LPWSTR s1
, LPCWSTR s2
, INT32 n
)
1209 return lstrcatn32W( s1
, s2
, n
);
1212 /*********************************************************************
1213 * wcsncmp (CRTDLL.512)
1215 INT32 __cdecl
CRTDLL_wcsncmp( LPCWSTR s1
, LPCWSTR s2
, INT32 n
)
1217 return lstrncmp32W( s1
, s2
, n
);
1220 /*********************************************************************
1221 * wcsncpy (CRTDLL.513)
1223 LPWSTR __cdecl
CRTDLL_wcsncpy( LPWSTR s1
, LPCWSTR s2
, INT32 n
)
1225 return lstrcpyn32W( s1
, s2
, n
);
1228 /*********************************************************************
1229 * wcsspn (CRTDLL.516)
1231 INT32 __cdecl
CRTDLL_wcsspn(LPWSTR str
,LPWSTR accept
)
1238 while (*t
) { if (*t
==*s
) break;t
++;}
1242 return s
-str
; /* nr of wchars */
1245 /*********************************************************************
1246 * towupper (CRTDLL.494)
1248 WCHAR __cdecl
CRTDLL_towupper(WCHAR x
)
1250 return (WCHAR
)toupper((CHAR
)x
);
1253 /*********************************************************************
1254 * _wcsicmp (CRTDLL.321)
1256 DWORD __cdecl
CRTDLL__wcsicmp( LPCWSTR s1
, LPCWSTR s2
)
1258 return lstrcmpi32W( s1
, s2
);
1261 /*********************************************************************
1262 * _wcsicoll (CRTDLL.322)
1264 DWORD __cdecl
CRTDLL__wcsicoll(LPCWSTR a1
,LPCWSTR a2
)
1266 /* FIXME: handle collates */
1267 return lstrcmpi32W(a1
,a2
);
1270 /*********************************************************************
1271 * _wcsnicmp (CRTDLL.324)
1273 DWORD __cdecl
CRTDLL__wcsnicmp( LPCWSTR s1
, LPCWSTR s2
, INT32 len
)
1275 return lstrncmpi32W( s1
, s2
, len
);
1278 /*********************************************************************
1279 * wcscoll (CRTDLL.506)
1281 DWORD __cdecl
CRTDLL_wcscoll(LPWSTR a1
,LPWSTR a2
)
1283 /* FIXME: handle collates */
1284 return lstrcmp32W(a1
,a2
);
1287 /*********************************************************************
1288 * _wcsrev (CRTDLL.326)
1290 VOID __cdecl
CRTDLL__wcsrev(LPWSTR s
) {
1304 /*********************************************************************
1305 * wcsstr (CRTDLL.517)
1307 LPWSTR __cdecl
CRTDLL_wcsstr(LPWSTR s
,LPWSTR b
)
1315 while (*y
&& *c
&& *y
==*c
) { c
++;y
++; }
1324 /*********************************************************************
1325 * wcstombs (CRTDLL.521)
1327 INT32 __cdecl
CRTDLL_wcstombs( LPSTR dst
, LPCWSTR src
, INT32 len
)
1329 lstrcpynWtoA( dst
, src
, len
);
1330 return strlen(dst
); /* FIXME: is this right? */
1333 /*********************************************************************
1334 * wcsrchr (CRTDLL.515)
1336 LPWSTR __cdecl
CRTDLL_wcsrchr(LPWSTR str
,WCHAR xchar
)
1340 s
=str
+lstrlen32W(str
);
1349 /*********************************************************************
1350 * _setmode (CRTDLL.265)
1351 * FIXME: At present we ignore the request to translate CR/LF to LF.
1353 * We allways translate when we read with fgets, we never do with fread
1356 INT32 __cdecl
CRTDLL__setmode( INT32 fh
,INT32 mode
)
1359 #define O_TEXT 0x4000
1360 #define O_BINARY 0x8000
1362 FIXME(crtdll
, "on fhandle %d mode %s, STUB.\n",
1363 fh
,(mode
=O_TEXT
)?"O_TEXT":
1364 (mode
=O_BINARY
)?"O_BINARY":"UNKNOWN");
1368 /*********************************************************************
1369 * atexit (CRTDLL.345)
1371 INT32 __cdecl
CRTDLL_atexit(LPVOID x
)
1373 FIXME(crtdll
,"(%p), STUB.\n",x
);
1374 return 0; /* successful */
1377 /*********************************************************************
1378 * mblen (CRTDLL.428)
1379 * FIXME: check multibyte support
1381 WCHAR __cdecl
CRTDLL_mblen(CHAR
*mb
,INT32 size
)
1388 else if ((size
<1)||(!*(mb
+1)))
1393 TRACE(crtdll
,"CRTDLL_mlen %s for max %d bytes ret %d\n",mb
,size
,ret
);
1398 /*********************************************************************
1399 * mbstowcs (CRTDLL.429)
1400 * FIXME: check multibyte support
1402 INT32 __cdecl
CRTDLL_mbstowcs(LPWSTR wcs
, LPCSTR mbs
, INT32 size
)
1405 /* Slightly modified lstrcpynAtoW functions from memory/strings.c
1406 * We need the number of characters transfered
1407 * FIXME: No multibyte support yet
1414 while ((n
-- > 0) && *src
) {
1415 *p
++ = (WCHAR
)(unsigned char)*src
++;
1420 TRACE(crtdll
,"CRTDLL_mbstowcs %s for %d chars put %d wchars\n",
1425 /*********************************************************************
1426 * mbtowc (CRTDLL.430)
1427 * FIXME: check multibyte support
1429 WCHAR __cdecl
CRTDLL_mbtowc(WCHAR
* wc
,CHAR
* mb
,INT32 size
)
1438 if ( (ret
= mblen(mb
,size
)) != -1 )
1440 if (ret
<= sizeof(char))
1441 *wc
= (WCHAR
) ((unsigned char)*mb
);
1448 TRACE(crtdll
,"CRTDLL_mbtowc %s for %d chars\n",mb
,size
);
1453 /*********************************************************************
1454 * _isctype (CRTDLL.138)
1456 BOOL32 __cdecl
CRTDLL__isctype(CHAR x
,CHAR type
)
1458 if ((type
& CRTDLL_SPACE
) && isspace(x
))
1460 if ((type
& CRTDLL_PUNCT
) && ispunct(x
))
1462 if ((type
& CRTDLL_LOWER
) && islower(x
))
1464 if ((type
& CRTDLL_UPPER
) && isupper(x
))
1466 if ((type
& CRTDLL_ALPHA
) && isalpha(x
))
1468 if ((type
& CRTDLL_DIGIT
) && isdigit(x
))
1470 if ((type
& CRTDLL_CONTROL
) && iscntrl(x
))
1472 /* check CRTDLL_LEADBYTE */
1476 /*********************************************************************
1477 * _chdrive (CRTDLL.52)
1479 BOOL32 __cdecl
CRTDLL__chdrive(INT32 newdrive
)
1481 /* FIXME: generates errnos */
1482 return DRIVE_SetCurrentDrive(newdrive
);
1485 /*********************************************************************
1486 * _chdir (CRTDLL.51)
1488 INT32 __cdecl
CRTDLL__chdir(LPCSTR newdir
)
1490 if (!SetCurrentDirectory32A(newdir
))
1495 /*********************************************************************
1496 * _fullpath (CRTDLL.114)
1498 LPSTR __cdecl
CRTDLL__fullpath(LPSTR buf
, LPCSTR name
, INT32 size
)
1500 DOS_FULL_NAME full_name
;
1505 if(!(buf
= CRTDLL_malloc(size
))) return NULL
;
1507 if (!DOSFS_GetFullName( name
, FALSE
, &full_name
)) return NULL
;
1508 lstrcpyn32A(buf
,full_name
.short_name
,size
);
1509 TRACE(crtdll
,"CRTDLL_fullpath got %s\n",buf
);
1513 /*********************************************************************
1514 * _splitpath (CRTDLL.279)
1516 VOID __cdecl
CRTDLL__splitpath(LPCSTR path
, LPSTR drive
, LPSTR directory
, LPSTR filename
, LPSTR extension
)
1519 directory includes leading and trailing (forward and backward slashes)
1520 filename without dot and slashes
1521 extension with leading dot
1523 char * drivechar
,*dirchar
,*namechar
;
1525 TRACE(crtdll
,"CRTDLL__splitpath got %s\n",path
);
1527 drivechar
= strchr(path
,':');
1528 dirchar
= strrchr(path
,'/');
1529 namechar
= strrchr(path
,'\\');
1530 dirchar
= MAX(dirchar
,namechar
);
1532 namechar
= strrchr(dirchar
,'.');
1534 namechar
= strrchr(path
,'.');
1542 strncat(drive
,path
,drivechar
-path
+1);
1551 strncat(directory
,path
,dirchar
-path
+1);
1560 strncat(filename
,path
,namechar
-path
);
1564 strcat(extension
,namechar
);
1569 TRACE(crtdll
,"CRTDLL__splitpath found %s %s %s %s\n",drive
,directory
,filename
,extension
);
1573 /*********************************************************************
1574 * _getcwd (CRTDLL.120)
1576 CHAR
* __cdecl
CRTDLL__getcwd(LPSTR buf
, INT32 size
)
1583 if (size
< 0) /* allocate as big as nescessary */
1584 len
=GetCurrentDirectory32A(1,test
) + 1;
1585 if(!(buf
= CRTDLL_malloc(len
)))
1587 /* set error to OutOfRange */
1592 if(!(len
=GetCurrentDirectory32A(len
,buf
)))
1598 /* set error to ERANGE */
1599 TRACE(crtdll
,"CRTDLL_getcwd buffer to small\n");
1606 /*********************************************************************
1607 * _mkdir (CRTDLL.234)
1609 INT32 __cdecl
CRTDLL__mkdir(LPCSTR newdir
)
1611 if (!CreateDirectory32A(newdir
,NULL
))
1616 /*********************************************************************
1617 * _errno (CRTDLL.52)
1618 * Yes, this is a function.
1620 LPINT32 __cdecl
CRTDLL__errno()
1622 static int crtdllerrno
;
1623 extern int LastErrorToErrno(DWORD
);
1625 /* FIXME: we should set the error at the failing function call time */
1626 crtdllerrno
= LastErrorToErrno(GetLastError());
1627 return &crtdllerrno
;
1630 /*********************************************************************
1631 * _tempnam (CRTDLL.305)
1634 LPSTR __cdecl
CRTDLL__tempnam(LPCSTR dir
, LPCSTR prefix
)
1638 DOS_FULL_NAME tempname
;
1640 if ((ret
= tempnam(dir
,prefix
))==NULL
) {
1641 WARN(crtdll
, "Unable to get unique filename\n");
1644 if (!DOSFS_GetFullName(ret
,FALSE
,&tempname
))
1646 TRACE(crtdll
, "Wrong path?\n");
1650 if ((ret
= CRTDLL_malloc(strlen(tempname
.short_name
)+1)) == NULL
) {
1651 WARN(crtdll
, "CRTDL_malloc for shortname failed\n");
1654 if ((ret
= strcpy(ret
,tempname
.short_name
)) == NULL
) {
1655 WARN(crtdll
, "Malloc for shortname failed\n");
1659 TRACE(crtdll
,"dir %s prefix %s got %s\n",
1664 /*********************************************************************
1665 * tmpnam (CRTDLL.490)
1667 * lcclnk from lcc-win32 relies on a terminating dot in the name returned
1670 LPSTR __cdecl
CRTDLL_tmpnam(LPSTR s
)
1674 if ((ret
=tmpnam(s
))== NULL
) {
1675 WARN(crtdll
, "Unable to get unique filename\n");
1678 if (!DOSFS_GetFullName(ret
,FALSE
,&CRTDLL_tmpname
))
1680 TRACE(crtdll
, "Wrong path?\n");
1683 strcat(CRTDLL_tmpname
.short_name
,".");
1684 TRACE(crtdll
,"for buf %p got %s\n",
1685 s
,CRTDLL_tmpname
.short_name
);
1686 TRACE(crtdll
,"long got %s\n",
1687 CRTDLL_tmpname
.long_name
);
1689 return strcpy(s
,CRTDLL_tmpname
.short_name
);
1691 return CRTDLL_tmpname
.short_name
;
1695 /*********************************************************************
1696 * _itoa (CRTDLL.165)
1698 LPSTR __cdecl
CRTDLL__itoa(INT32 x
,LPSTR buf
,INT32 buflen
)
1700 wsnprintf32A(buf
,buflen
,"%d",x
);
1704 typedef VOID (*sig_handler_type
)(VOID
);
1706 /*********************************************************************
1707 * signal (CRTDLL.455)
1709 VOID __cdecl
CRTDLL_signal(int sig
, sig_handler_type ptr
)
1711 FIXME(crtdll
, "(%d %p):stub.\n", sig
, ptr
);
1714 /*********************************************************************
1715 * _ftol (CRTDLL.113)
1717 LONG __cdecl
CRTDLL__ftol(double fl
) {
1720 /*********************************************************************
1721 * _sleep (CRTDLL.267)
1723 VOID __cdecl
CRTDLL__sleep(unsigned long timeout
)
1725 TRACE(crtdll
,"CRTDLL__sleep for %ld milliseconds\n",timeout
);
1726 Sleep((timeout
)?timeout
:1);
1728 /*********************************************************************
1729 * getenv (CRTDLL.437)
1731 LPSTR __cdecl
CRTDLL_getenv(const char *name
)
1733 LPSTR environ
= GetEnvironmentStrings32A();
1734 LPSTR pp
,pos
= NULL
;
1735 unsigned int length
;
1737 for (pp
= environ
; (*pp
); pp
= pp
+ strlen(pp
) +1)
1739 pos
=strchr(pp
,'=');
1743 length
= strlen(pp
);
1744 if (!strncmp(pp
,name
,length
)) break;
1749 TRACE(crtdll
,"got %s\n",pp
);
1751 FreeEnvironmentStrings32A( environ
);