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>
48 extern int FILE_GetUnixHandle( HFILE32 );
50 static DOS_FULL_NAME CRTDLL_tmpname;
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 * _findfirst (CRTDLL.099)
149 DWORD __cdecl CRTDLL__findfirst(LPCSTR fname,struct find_t* x2)
151 FIXME(crtdll, ":(%s,%p): stub\n",fname,x2);
152 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
156 /*********************************************************************
157 * _findnext (CRTDLL.100)
162 INT32 __cdecl CRTDLL__findnext(DWORD hand,struct find_t* x2)
164 FIXME(crtdll, ":(%ld,%p): stub\n",hand,x2);
165 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
169 /*********************************************************************
170 * _fstat (CRTDLL.111)
175 int __cdecl CRTDLL__fstat(int file, struct stat* buf)
177 FIXME(crtdll, ":(%d,%p): stub\n",file,buf);
178 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
182 /*********************************************************************
183 * _initterm (CRTDLL.135)
185 DWORD __cdecl CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
187 _INITTERMFUN *current;
189 TRACE(crtdll,"(%p,%p)\n",start,end);
191 while (current<end) {
192 if (*current) (*current)();
198 /*********************************************************************
199 * _fdopen (CRTDLL.91)
201 DWORD __cdecl CRTDLL__fdopen(INT32 handle, LPCSTR mode)
209 case 1 : file=stdout;
211 case 2 : file=stderr;
214 file=fdopen(handle,mode);
216 TRACE(crtdll, "open handle %d mode %s got file %p\n",
221 static FILE *xlat_file_ptr(void *ptr)
225 /* CRT sizeof(FILE) == 32 */
226 dif = ((char *)ptr - (char *)CRTDLL_iob) / 32;
229 case 0: return stdin;
230 case 1: return stdout;
231 case 2: return stderr;
236 /*******************************************************************
237 * _global_unwind2 (CRTDLL.129)
239 void __cdecl CRTDLL__global_unwind2( PEXCEPTION_FRAME frame )
241 RtlUnwind( frame, 0, NULL, 0 );
244 /*******************************************************************
245 * _local_unwind2 (CRTDLL.173)
247 void __cdecl CRTDLL__local_unwind2( PEXCEPTION_FRAME endframe, DWORD nr )
249 TRACE(crtdll,"(%p,%ld)\n",endframe,nr);
251 /*********************************************************************
257 INT32 __cdecl CRTDLL__read(INT32 fd, LPVOID buf, UINT32 count)
259 FIXME(crtdll,":(%d,%p,%d): stub\n",fd,buf,count);
260 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
264 /*********************************************************************
267 DWORD __cdecl CRTDLL_fopen(LPCSTR path, LPCSTR mode)
272 DOS_FULL_NAME full_name;
274 if (!DOSFS_GetFullName( path, FALSE, &full_name )) {
275 WARN(crtdll, "file %s bad name\n",path);
279 file=fopen(full_name.long_name ,mode);
284 if ((strchr(mode,'r')&&strchr(mode,'a'))||
285 (strchr(mode,'r')&&strchr(mode,'w'))||
286 (strchr(mode,'w')&&strchr(mode,'a')))
289 if (strstr(mode,"r+")) flagmode=O_RDWR;
290 else if (strchr(mode,'r')) flagmode = O_RDONLY;
291 else if (strstr(mode,"w+")) flagmode= O_RDWR | O_TRUNC | O_CREAT;
292 else if (strchr(mode,'w')) flagmode = O_WRONLY | O_TRUNC | O_CREAT;
293 else if (strstr(mode,"a+")) flagmode= O_RDWR | O_CREAT | O_APPEND;
294 else if (strchr(mode,'w')) flagmode = O_RDWR | O_CREAT | O_APPEND;
295 else if (strchr(mode,'b'))
296 TRACE(crtdll, "%s in BINARY mode\n",path);
298 dos_fildes=FILE_Open(path, flagmode);
299 unix_fildes=FILE_GetUnixHandle(dos_fildes);
300 file = fdopen(unix_fildes,mode);
302 TRACE(crtdll, "file %s mode %s got ufh %d dfh %d file %p\n",
303 path,mode,unix_fildes,dos_fildes,file);
307 /*********************************************************************
310 DWORD __cdecl CRTDLL_fread(LPVOID ptr, INT32 size, INT32 nmemb, LPVOID vfile)
313 FILE *file=xlat_file_ptr(vfile);
318 /* If we would honour CR/LF <-> LF translation, we could do it like this.
319 We should keep track of all files opened, and probably files with \
320 known binary extensions must be unchanged */
321 while ( (i < (nmemb*size)) && (ret==1)) {
322 ret=fread(temp,1,1,file);
323 TRACE(crtdll, "got %c 0x%02x ret %d\n",
324 (isalpha(*(unsigned char*)temp))? *(unsigned char*)temp:
325 ' ',*(unsigned char*)temp, ret);
326 if (*(unsigned char*)temp != 0xd) { /* skip CR */
331 TRACE(crtdll, "skipping ^M\n");
333 TRACE(crtdll, "0x%08x items of size %d from file %p to %p\n",
334 nmemb,size,file,ptr,);
336 WARN(crtdll, " failed!\n");
341 ret=fread(ptr,size,nmemb,file);
342 TRACE(crtdll, "0x%08x items of size %d from file %p to %p\n",
343 nmemb,size,file,ptr);
345 WARN(crtdll, " failed!\n");
350 /*********************************************************************
351 * freopen (CRTDLL.379)
356 DWORD __cdecl CRTDLL_freopen(LPCSTR path, LPCSTR mode, LPVOID stream)
358 FIXME(crtdll, ":(%s,%s,%p): stub\n", path, mode, stream);
359 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
363 /*********************************************************************
364 * fscanf (CRTDLL.381)
366 INT32 __cdecl CRTDLL_fscanf( LPVOID stream, LPSTR format, ... )
371 va_start( valist, format );
373 res = vfscanf( xlat_file_ptr(stream), format, valist );
379 /*********************************************************************
382 LONG __cdecl CRTDLL_fseek(LPVOID stream, LONG offset, INT32 whence)
386 ret=fseek(xlat_file_ptr(stream),offset,whence);
387 TRACE(crtdll, "file %p to 0x%08lx pos %s\n",
388 stream,offset,(whence==SEEK_SET)?"SEEK_SET":
389 (whence==SEEK_CUR)?"SEEK_CUR":
390 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
392 WARN(crtdll, " failed!\n");
397 /*********************************************************************
398 * fsetpos (CRTDLL.383)
400 INT32 __cdecl CRTDLL_fsetpos(LPVOID stream, fpos_t *pos)
402 TRACE(crtdll, "file %p\n", stream);
403 return fseek(xlat_file_ptr(stream), *pos, SEEK_SET);
406 /*********************************************************************
409 LONG __cdecl CRTDLL_ftell(LPVOID stream)
413 ret=ftell(xlat_file_ptr(stream));
414 TRACE(crtdll, "file %p at 0x%08lx\n",
419 /*********************************************************************
420 * fwrite (CRTDLL.386)
422 DWORD __cdecl CRTDLL_fwrite(LPVOID ptr, INT32 size, INT32 nmemb, LPVOID vfile)
425 FILE *file=xlat_file_ptr(vfile);
427 ret=fwrite(ptr,size,nmemb,file);
428 TRACE(crtdll, "0x%08x items of size %d from %p to file %p\n",
429 nmemb,size,ptr,file);
431 WARN(crtdll, " Failed!\n");
436 /*********************************************************************
437 * setbuf (CRTDLL.452)
439 INT32 __cdecl CRTDLL_setbuf(LPVOID file, LPSTR buf)
441 TRACE(crtdll, "(file %p buf %p)\n", file, buf);
442 /* this doesn't work:"void value not ignored as it ought to be"
443 return setbuf(file,buf);
445 setbuf(xlat_file_ptr(file),buf);
449 /*********************************************************************
450 * _open_osfhandle (CRTDLL.240)
452 HFILE32 __cdecl CRTDLL__open_osfhandle(LONG osfhandle, INT32 flags)
457 case STD_INPUT_HANDLE :
461 case STD_OUTPUT_HANDLE:
465 case STD_ERROR_HANDLE:
472 TRACE(crtdll, "(handle %08lx,flags %d) return %d\n",
473 osfhandle,flags,handle);
478 /*********************************************************************
481 void __cdecl CRTDLL_srand(DWORD seed)
483 /* FIXME: should of course be thread? process? local */
487 /*********************************************************************
488 * fprintf (CRTDLL.373)
490 INT32 __cdecl CRTDLL_fprintf( FILE *file, LPSTR format, ... )
495 va_start( valist, format );
496 res = vfprintf( xlat_file_ptr(file), format, valist );
501 /*********************************************************************
502 * vfprintf (CRTDLL.373)
504 INT32 __cdecl CRTDLL_vfprintf( FILE *file, LPSTR format, va_list args )
506 return vfprintf( xlat_file_ptr(file), format, args );
509 /*********************************************************************
512 time_t __cdecl CRTDLL_time(time_t *timeptr)
514 time_t curtime = time(NULL);
521 /*********************************************************************
524 clock_t __cdecl CRTDLL_clock(void)
530 res = alltimes.tms_utime + alltimes.tms_stime+
531 alltimes.tms_cutime + alltimes.tms_cstime;
532 /* Fixme: We need some symbolic representation
533 for (Hostsystem_)CLOCKS_PER_SEC
534 and (Emulated_system_)CLOCKS_PER_SEC
535 10 holds only for Windows/Linux_i86)
540 /*********************************************************************
541 * _isatty (CRTDLL.137)
543 BOOL32 __cdecl CRTDLL__isatty(DWORD x)
545 TRACE(crtdll,"(%ld)\n",x);
549 /*********************************************************************
550 * _write (CRTDLL.332)
552 INT32 __cdecl CRTDLL__write(INT32 fd,LPCVOID buf,UINT32 count)
559 len = (UINT32)write(fd,buf,(LONG)count);
561 len = _lwrite32(fd,buf,count);
562 TRACE(crtdll,"%d/%d byte to dfh %d from %p,\n",
568 /*********************************************************************
571 * FIXME: What the heck is the difference between
572 * FIXME _c_exit (CRTDLL.47)
573 * FIXME _cexit (CRTDLL.49)
574 * FIXME _exit (CRTDLL.87)
575 * FIXME exit (CRTDLL.359)
577 * atexit-processing comes to mind -- MW.
580 void __cdecl CRTDLL__cexit(INT32 ret)
582 TRACE(crtdll,"(%d)\n",ret);
587 /*********************************************************************
590 void __cdecl CRTDLL_exit(DWORD ret)
592 TRACE(crtdll,"(%ld)\n",ret);
597 /*********************************************************************
598 * _abnormal_termination (CRTDLL.36)
600 INT32 __cdecl CRTDLL__abnormal_termination(void)
602 TRACE(crtdll,"(void)\n");
607 /*********************************************************************
608 * _access (CRTDLL.37)
610 INT32 __cdecl CRTDLL__access(LPCSTR filename, INT32 mode)
612 DWORD attr = GetFileAttributes32A(filename);
616 if (GetLastError() == ERROR_INVALID_ACCESS)
623 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
633 /*********************************************************************
634 * fflush (CRTDLL.365)
636 INT32 __cdecl CRTDLL_fflush(LPVOID stream)
640 ret = fflush(xlat_file_ptr(stream));
641 TRACE(crtdll,"%p returnd %d\n",stream,ret);
643 WARN(crtdll, " Failed!\n");
649 /*********************************************************************
652 LPSTR __cdecl CRTDLL_gets(LPSTR buf)
655 /* BAD, for the whole WINE process blocks... just done this way to test
656 * windows95's ftp.exe.
659 TRACE(crtdll,"got %s\n",ret);
664 /*********************************************************************
667 INT32 __cdecl CRTDLL_rand()
673 /*********************************************************************
674 * putchar (CRTDLL.442)
676 void __cdecl CRTDLL_putchar( INT32 x )
682 /*********************************************************************
685 INT32 __cdecl CRTDLL_fputc( INT32 c, FILE *stream )
687 TRACE(crtdll, "%c to file %p\n",c,stream);
688 return fputc(c,xlat_file_ptr(stream));
692 /*********************************************************************
695 INT32 __cdecl CRTDLL_fputs( LPCSTR s, FILE *stream )
697 TRACE(crtdll, "%s to file %p\n",s,stream);
698 return fputs(s,xlat_file_ptr(stream));
702 /*********************************************************************
705 INT32 __cdecl CRTDLL_puts(LPCSTR s)
707 TRACE(crtdll, "%s \n",s);
712 /*********************************************************************
715 INT32 __cdecl CRTDLL_putc(INT32 c, FILE *stream)
717 TRACE(crtdll, " %c to file %p\n",c,stream);
718 return fputc(c,xlat_file_ptr(stream));
720 /*********************************************************************
723 INT32 __cdecl CRTDLL_fgetc( FILE *stream )
725 int ret= fgetc(xlat_file_ptr(stream));
726 TRACE(crtdll, "got %d\n",ret);
731 /*********************************************************************
734 INT32 __cdecl CRTDLL_getc( FILE *stream )
736 int ret= fgetc(xlat_file_ptr(stream));
737 TRACE(crtdll, "got %d\n",ret);
741 /*********************************************************************
744 UINT32 __cdecl CRTDLL__rotl(UINT32 x,INT32 shift)
746 unsigned int ret = (x >> shift)|( x >>((sizeof(x))-shift));
748 TRACE(crtdll, "got 0x%08x rot %d ret 0x%08x\n",
753 /*********************************************************************
754 * _lrotl (CRTDLL.176)
756 DWORD __cdecl CRTDLL__lrotl(DWORD x,INT32 shift)
758 unsigned long ret = (x >> shift)|( x >>((sizeof(x))-shift));
760 TRACE(crtdll, "got 0x%08lx rot %d ret 0x%08lx\n",
767 /*********************************************************************
770 CHAR* __cdecl CRTDLL_fgets(LPSTR s,INT32 size, LPVOID stream)
775 ret=fgets(s, size,xlat_file_ptr(stream));
776 /*FIXME: Control with CRTDLL_setmode */
777 control_M= strrchr(s,'\r');
778 /*delete CR if we read a DOS File */
784 TRACE(crtdll, "got %s for %d chars from file %p\n",
787 WARN(crtdll, " Failed!\n");
793 /*********************************************************************
794 * _mbsicmp (CRTDLL.204)
796 int __cdecl CRTDLL__mbsicmp(unsigned char *x,unsigned char *y)
803 /* FIXME: MBCS handling... */
812 /*********************************************************************
813 * _mbsinc (CRTDLL.205)
815 unsigned char * __cdecl CRTDLL__mbsinc(unsigned char *x)
822 /*********************************************************************
823 * vsprintf (CRTDLL.500)
825 INT32 __cdecl CRTDLL_vsprintf( LPSTR buffer, LPCSTR spec, va_list args )
827 return wvsprintf32A( buffer, spec, args );
830 /*********************************************************************
831 * vswprintf (CRTDLL.501)
833 INT32 __cdecl CRTDLL_vswprintf( LPWSTR buffer, LPCWSTR spec, va_list args )
835 return wvsprintf32W( buffer, spec, args );
838 /*********************************************************************
839 * _mbscpy (CRTDLL.200)
841 unsigned char* __cdecl CRTDLL__mbscpy(unsigned char *x,unsigned char *y)
843 TRACE(crtdll,"CRTDLL_mbscpy %s and %s\n",x,y);
848 /*********************************************************************
849 * _mbscat (CRTDLL.197)
851 unsigned char* __cdecl CRTDLL__mbscat(unsigned char *x,unsigned char *y)
857 /*********************************************************************
858 * _strcmpi (CRTDLL.282) (CRTDLL.287)
860 INT32 __cdecl CRTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
862 return lstrcmpi32A( s1, s2 );
866 /*********************************************************************
867 * _strnicmp (CRTDLL.293)
869 INT32 __cdecl CRTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT32 n )
871 return lstrncmpi32A( s1, s2, n );
875 /*********************************************************************
876 * _strlwr (CRTDLL.293)
878 * convert a string in place to lowercase
880 LPSTR __cdecl CRTDLL__strlwr(LPSTR x)
884 TRACE(crtdll, "CRTDLL_strlwr got %s\n", x);
886 if ((*y > 0x40) && (*y< 0x5b))
890 TRACE(crtdll, " returned %s\n", x);
895 /*********************************************************************
896 * system (CRTDLL.485)
898 INT32 __cdecl CRTDLL_system(LPSTR x)
900 #define SYSBUF_LENGTH 1500
901 char buffer[SYSBUF_LENGTH];
902 unsigned char *y = x;
906 sprintf( buffer, "%s \"", Options.argv0 );
907 bp = buffer + strlen(buffer);
908 i = strlen(buffer) + strlen(x) +2;
910 /* Calculate needed buffer size to prevent overflow. */
915 /* If buffer too short, exit. */
916 if (i > SYSBUF_LENGTH) {
917 TRACE(crtdll,"_system buffer to small\n");
926 if (*(y-1) =='\\') *bp++ = '\\';
928 /* Remove spaces from end of string. */
929 while (*(y-1) == ' ') {
934 TRACE(crtdll, "_system got '%s', executing '%s'\n",x,buffer);
936 return system(buffer);
939 /*********************************************************************
940 * _strupr (CRTDLL.300)
942 LPSTR __cdecl CRTDLL__strupr(LPSTR x)
953 /*********************************************************************
954 * _wcsupr (CRTDLL.328)
956 LPWSTR __cdecl CRTDLL__wcsupr(LPWSTR x)
967 /*********************************************************************
968 * _wcslwr (CRTDLL.323)
970 LPWSTR __cdecl CRTDLL__wcslwr(LPWSTR x)
982 /*********************************************************************
983 * longjmp (CRTDLL.426)
985 VOID __cdecl CRTDLL_longjmp(jmp_buf env, int val)
987 FIXME(crtdll,"CRTDLL_longjmp semistup, expect crash\n");
988 return longjmp(env, val);
991 /*********************************************************************
992 * malloc (CRTDLL.427)
994 VOID* __cdecl CRTDLL_malloc(DWORD size)
996 return HeapAlloc(GetProcessHeap(),0,size);
999 /*********************************************************************
1002 VOID* __cdecl CRTDLL_new(DWORD size)
1005 if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
1010 /*********************************************************************
1011 * set_new_handler(CRTDLL.003)
1013 new_handler_type __cdecl CRTDLL_set_new_handler(new_handler_type func)
1015 new_handler_type old_handler = new_handler;
1020 /*********************************************************************
1021 * calloc (CRTDLL.350)
1023 VOID* __cdecl CRTDLL_calloc(DWORD size, DWORD count)
1025 return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
1028 /*********************************************************************
1029 * realloc (CRTDLL.447)
1031 VOID* __cdecl CRTDLL_realloc( VOID *ptr, DWORD size )
1033 return HeapReAlloc( GetProcessHeap(), 0, ptr, size );
1036 /*********************************************************************
1039 VOID __cdecl CRTDLL_free(LPVOID ptr)
1041 HeapFree(GetProcessHeap(),0,ptr);
1044 /*********************************************************************
1045 * delete (CRTDLL.002)
1047 VOID __cdecl CRTDLL_delete(VOID* ptr)
1049 HeapFree(GetProcessHeap(),0,ptr);
1052 /*********************************************************************
1053 * _strdup (CRTDLL.285)
1055 LPSTR __cdecl CRTDLL__strdup(LPCSTR ptr)
1057 return HEAP_strdupA(GetProcessHeap(),0,ptr);
1060 /*********************************************************************
1061 * _wcsdup (CRTDLL.320)
1063 LPWSTR __cdecl CRTDLL__wcsdup(LPCWSTR ptr)
1065 return HEAP_strdupW(GetProcessHeap(),0,ptr);
1068 /*********************************************************************
1069 * fclose (CRTDLL.362)
1071 INT32 __cdecl CRTDLL_fclose( FILE *stream )
1074 HFILE32 dos_handle=1;
1077 stream=xlat_file_ptr(stream);
1078 unix_handle=fileno(stream);
1080 if (unix_handle<4) ret= fclose(stream);
1082 while(FILE_GetUnixHandle(dos_handle) != unix_handle) dos_handle++;
1084 ret = _lclose32( dos_handle);
1086 TRACE(crtdll,"(%p) ufh %d dfh %d\n",
1087 stream,unix_handle,dos_handle);
1090 WARN(crtdll, " Failed!\n");
1095 /*********************************************************************
1096 * _unlink (CRTDLL.315)
1098 INT32 __cdecl CRTDLL__unlink(LPCSTR pathname)
1101 DOS_FULL_NAME full_name;
1103 if (!DOSFS_GetFullName( pathname, FALSE, &full_name )) {
1104 WARN(crtdll, "CRTDLL_unlink file %s bad name\n",pathname);
1108 ret=unlink(full_name.long_name);
1109 TRACE(crtdll,"(%s unix %s)\n",
1110 pathname,full_name.long_name);
1112 WARN(crtdll, " Failed!\n");
1117 /*********************************************************************
1118 * rename (CRTDLL.449)
1120 INT32 __cdecl CRTDLL_rename(LPCSTR oldpath,LPCSTR newpath)
1122 BOOL32 ok = MoveFileEx32A( oldpath, newpath, MOVEFILE_REPLACE_EXISTING );
1127 /*********************************************************************
1128 * _stat (CRTDLL.280)
1146 int __cdecl CRTDLL__stat(const char * filename, struct win_stat * buf)
1149 DOS_FULL_NAME full_name;
1152 if (!DOSFS_GetFullName( filename, TRUE, &full_name ))
1154 WARN(crtdll, "CRTDLL__stat filename %s bad name\n",filename);
1157 ret=stat(full_name.long_name,&mystat);
1158 TRACE(crtdll,"CRTDLL__stat %s\n", filename);
1160 WARN(crtdll, " Failed!\n");
1162 /* FIXME: should check what Windows returns */
1164 buf->win_st_dev = mystat.st_dev;
1165 buf->win_st_ino = mystat.st_ino;
1166 buf->win_st_mode = mystat.st_mode;
1167 buf->win_st_nlink = mystat.st_nlink;
1168 buf->win_st_uid = mystat.st_uid;
1169 buf->win_st_gid = mystat.st_gid;
1170 buf->win_st_rdev = mystat.st_rdev;
1171 buf->win_st_size = mystat.st_size;
1172 buf->win_st_atime = mystat.st_atime;
1173 buf->win_st_mtime = mystat.st_mtime;
1174 buf->win_st_ctime = mystat.st_ctime;
1178 /*********************************************************************
1179 * _open (CRTDLL.239)
1181 HFILE32 __cdecl CRTDLL__open(LPCSTR path,INT32 flags)
1187 the flags in lcc's header differ from the ones in Linux, e.g.
1188 Linux: define O_APPEND 02000 (= 0x400)
1189 lcc: define _O_APPEND 0x0008
1190 so here a scheme to translate them
1191 Probably lcc is wrong here, but at least a hack to get is going
1193 wineflags = (flags & 3);
1194 if (flags & 0x0008 ) wineflags |= O_APPEND;
1195 if (flags & 0x0100 ) wineflags |= O_CREAT;
1196 if (flags & 0x0200 ) wineflags |= O_TRUNC;
1197 if (flags & 0x0400 ) wineflags |= O_EXCL;
1198 if (flags & 0xf0f4 )
1199 TRACE(crtdll,"CRTDLL_open file unsupported flags 0x%04x\n",flags);
1202 ret = FILE_Open(path,wineflags);
1203 TRACE(crtdll,"CRTDLL_open file %s mode 0x%04x (lccmode 0x%04x) got dfh %d\n",
1204 path,wineflags,flags,ret);
1208 /*********************************************************************
1209 * _close (CRTDLL.57)
1211 INT32 __cdecl CRTDLL__close(HFILE32 fd)
1213 int ret=_lclose32(fd);
1215 TRACE(crtdll,"(%d)\n",fd);
1217 WARN(crtdll, " Failed!\n");
1222 /*********************************************************************
1225 INT32 __cdecl CRTDLL_feof( FILE *stream )
1229 ret=feof(xlat_file_ptr(stream));
1230 TRACE(crtdll,"(%p) %s\n",stream,(ret)?"true":"false");
1234 /*********************************************************************
1235 * setlocale (CRTDLL.453)
1237 LPSTR __cdecl CRTDLL_setlocale(INT32 category,LPCSTR locale)
1242 case CRTDLL_LC_ALL: categorystr="LC_ALL";break;
1243 case CRTDLL_LC_COLLATE: categorystr="LC_COLLATE";break;
1244 case CRTDLL_LC_CTYPE: categorystr="LC_CTYPE";break;
1245 case CRTDLL_LC_MONETARY: categorystr="LC_MONETARY";break;
1246 case CRTDLL_LC_NUMERIC: categorystr="LC_NUMERIC";break;
1247 case CRTDLL_LC_TIME: categorystr="LC_TIME";break;
1248 default: categorystr = "UNKNOWN?";break;
1250 FIXME(crtdll,"(%s,%s),stub!\n",categorystr,locale);
1254 /*********************************************************************
1255 * wcscat (CRTDLL.503)
1257 LPWSTR __cdecl CRTDLL_wcscat( LPWSTR s1, LPCWSTR s2 )
1259 return lstrcat32W( s1, s2 );
1262 /*********************************************************************
1263 * wcschr (CRTDLL.504)
1265 LPWSTR __cdecl CRTDLL_wcschr(LPCWSTR str,WCHAR xchar)
1277 /*********************************************************************
1278 * wcscmp (CRTDLL.505)
1280 INT32 __cdecl CRTDLL_wcscmp( LPCWSTR s1, LPCWSTR s2 )
1282 return lstrcmp32W( s1, s2 );
1285 /*********************************************************************
1286 * wcscpy (CRTDLL.507)
1288 LPWSTR __cdecl CRTDLL_wcscpy( LPWSTR s1, LPCWSTR s2 )
1290 return lstrcpy32W( s1, s2 );
1293 /*********************************************************************
1294 * wcscspn (CRTDLL.508)
1296 INT32 __cdecl CRTDLL_wcscspn(LPWSTR str,LPWSTR reject)
1303 while (*t) { if (*t==*s) break;t++;}
1307 return s-str; /* nr of wchars */
1310 /*********************************************************************
1311 * wcslen (CRTDLL.510)
1313 INT32 __cdecl CRTDLL_wcslen( LPCWSTR s )
1315 return lstrlen32W( s );
1318 /*********************************************************************
1319 * wcsncat (CRTDLL.511)
1321 LPWSTR __cdecl CRTDLL_wcsncat( LPWSTR s1, LPCWSTR s2, INT32 n )
1323 return lstrcatn32W( s1, s2, n );
1326 /*********************************************************************
1327 * wcsncmp (CRTDLL.512)
1329 INT32 __cdecl CRTDLL_wcsncmp( LPCWSTR s1, LPCWSTR s2, INT32 n )
1331 return lstrncmp32W( s1, s2, n );
1334 /*********************************************************************
1335 * wcsncpy (CRTDLL.513)
1337 LPWSTR __cdecl CRTDLL_wcsncpy( LPWSTR s1, LPCWSTR s2, INT32 n )
1339 return lstrcpyn32W( s1, s2, n );
1342 /*********************************************************************
1343 * wcsspn (CRTDLL.516)
1345 INT32 __cdecl CRTDLL_wcsspn(LPWSTR str,LPWSTR accept)
1352 while (*t) { if (*t==*s) break;t++;}
1356 return s-str; /* nr of wchars */
1359 /*********************************************************************
1360 * _wcsicmp (CRTDLL.321)
1362 DWORD __cdecl CRTDLL__wcsicmp( LPCWSTR s1, LPCWSTR s2 )
1364 return lstrcmpi32W( s1, s2 );
1367 /*********************************************************************
1368 * _wcsicoll (CRTDLL.322)
1370 DWORD __cdecl CRTDLL__wcsicoll(LPCWSTR a1,LPCWSTR a2)
1372 /* FIXME: handle collates */
1373 return lstrcmpi32W(a1,a2);
1376 /*********************************************************************
1377 * _wcsnicmp (CRTDLL.324)
1379 DWORD __cdecl CRTDLL__wcsnicmp( LPCWSTR s1, LPCWSTR s2, INT32 len )
1381 return lstrncmpi32W( s1, s2, len );
1384 /*********************************************************************
1385 * wcscoll (CRTDLL.506)
1387 DWORD __cdecl CRTDLL_wcscoll(LPWSTR a1,LPWSTR a2)
1389 /* FIXME: handle collates */
1390 return lstrcmp32W(a1,a2);
1393 /*********************************************************************
1394 * _wcsrev (CRTDLL.326)
1396 VOID __cdecl CRTDLL__wcsrev(LPWSTR s) {
1410 /*********************************************************************
1411 * wcsstr (CRTDLL.517)
1413 LPWSTR __cdecl CRTDLL_wcsstr(LPWSTR s,LPWSTR b)
1421 while (*y && *c && *y==*c) { c++;y++; }
1430 /*********************************************************************
1431 * wcstombs (CRTDLL.521)
1433 INT32 __cdecl CRTDLL_wcstombs( LPSTR dst, LPCWSTR src, INT32 len )
1435 lstrcpynWtoA( dst, src, len );
1436 return strlen(dst); /* FIXME: is this right? */
1439 /*********************************************************************
1440 * wcsrchr (CRTDLL.515)
1442 LPWSTR __cdecl CRTDLL_wcsrchr(LPWSTR str,WCHAR xchar)
1446 s=str+lstrlen32W(str);
1455 /*********************************************************************
1456 * _setmode (CRTDLL.265)
1457 * FIXME: At present we ignore the request to translate CR/LF to LF.
1459 * We allways translate when we read with fgets, we never do with fread
1462 INT32 __cdecl CRTDLL__setmode( INT32 fh,INT32 mode)
1465 #define O_TEXT 0x4000
1466 #define O_BINARY 0x8000
1468 FIXME(crtdll, "on fhandle %d mode %s, STUB.\n",
1469 fh,(mode=O_TEXT)?"O_TEXT":
1470 (mode=O_BINARY)?"O_BINARY":"UNKNOWN");
1474 /*********************************************************************
1475 * _fpreset (CRTDLL.107)
1477 VOID __cdecl CRTDLL__fpreset(void)
1479 FIXME(crtdll," STUB.\n");
1482 /*********************************************************************
1483 * atexit (CRTDLL.345)
1485 INT32 __cdecl CRTDLL_atexit(LPVOID x)
1487 FIXME(crtdll,"(%p), STUB.\n",x);
1488 return 0; /* successful */
1491 /*********************************************************************
1492 * mblen (CRTDLL.428)
1493 * FIXME: check multibyte support
1495 WCHAR __cdecl CRTDLL_mblen(CHAR *mb,INT32 size)
1502 else if ((size<1)||(!*(mb+1)))
1507 TRACE(crtdll,"CRTDLL_mlen %s for max %d bytes ret %d\n",mb,size,ret);
1512 /*********************************************************************
1513 * mbstowcs (CRTDLL.429)
1514 * FIXME: check multibyte support
1516 INT32 __cdecl CRTDLL_mbstowcs(LPWSTR wcs, LPCSTR mbs, INT32 size)
1519 /* Slightly modified lstrcpynAtoW functions from memory/strings.c
1520 * We need the number of characters transfered
1521 * FIXME: No multibyte support yet
1528 while ((n-- > 0) && *src) {
1529 *p++ = (WCHAR)(unsigned char)*src++;
1534 TRACE(crtdll,"CRTDLL_mbstowcs %s for %d chars put %d wchars\n",
1539 /*********************************************************************
1540 * mbtowc (CRTDLL.430)
1541 * FIXME: check multibyte support
1543 WCHAR __cdecl CRTDLL_mbtowc(WCHAR* wc,CHAR* mb,INT32 size)
1552 if ( (ret = mblen(mb,size)) != -1 )
1554 if (ret <= sizeof(char))
1555 *wc = (WCHAR) ((unsigned char)*mb);
1562 TRACE(crtdll,"CRTDLL_mbtowc %s for %d chars\n",mb,size);
1567 /*********************************************************************
1568 * _isctype (CRTDLL.138)
1570 BOOL32 __cdecl CRTDLL__isctype(CHAR x,CHAR type)
1572 if ((type & CRTDLL_SPACE) && isspace(x))
1574 if ((type & CRTDLL_PUNCT) && ispunct(x))
1576 if ((type & CRTDLL_LOWER) && islower(x))
1578 if ((type & CRTDLL_UPPER) && isupper(x))
1580 if ((type & CRTDLL_ALPHA) && isalpha(x))
1582 if ((type & CRTDLL_DIGIT) && isdigit(x))
1584 if ((type & CRTDLL_CONTROL) && iscntrl(x))
1586 /* check CRTDLL_LEADBYTE */
1590 /*********************************************************************
1591 * _chdrive (CRTDLL.52)
1593 * newdir [I] drive to change to, A=1
1596 BOOL32 __cdecl CRTDLL__chdrive(INT32 newdrive)
1598 /* FIXME: generates errnos */
1599 return DRIVE_SetCurrentDrive(newdrive-1);
1602 /*********************************************************************
1603 * _chdir (CRTDLL.51)
1605 INT32 __cdecl CRTDLL__chdir(LPCSTR newdir)
1607 if (!SetCurrentDirectory32A(newdir))
1612 /*********************************************************************
1613 * _fullpath (CRTDLL.114)
1615 LPSTR __cdecl CRTDLL__fullpath(LPSTR buf, LPCSTR name, INT32 size)
1617 DOS_FULL_NAME full_name;
1622 if(!(buf = CRTDLL_malloc(size))) return NULL;
1624 if (!DOSFS_GetFullName( name, FALSE, &full_name )) return NULL;
1625 lstrcpyn32A(buf,full_name.short_name,size);
1626 TRACE(crtdll,"CRTDLL_fullpath got %s\n",buf);
1630 /*********************************************************************
1631 * _splitpath (CRTDLL.279)
1633 VOID __cdecl CRTDLL__splitpath(LPCSTR path, LPSTR drive, LPSTR directory, LPSTR filename, LPSTR extension )
1636 directory includes leading and trailing (forward and backward slashes)
1637 filename without dot and slashes
1638 extension with leading dot
1640 char * drivechar,*dirchar,*namechar;
1642 TRACE(crtdll,"CRTDLL__splitpath got %s\n",path);
1644 drivechar = strchr(path,':');
1645 dirchar = strrchr(path,'/');
1646 namechar = strrchr(path,'\\');
1647 dirchar = MAX(dirchar,namechar);
1649 namechar = strrchr(dirchar,'.');
1651 namechar = strrchr(path,'.');
1659 strncat(drive,path,drivechar-path+1);
1668 strncat(directory,path,dirchar-path+1);
1677 strncat(filename,path,namechar-path);
1681 strcat(extension,namechar);
1686 TRACE(crtdll,"CRTDLL__splitpath found %s %s %s %s\n",drive,directory,filename,extension);
1690 /*********************************************************************
1691 * _getcwd (CRTDLL.120)
1693 CHAR* __cdecl CRTDLL__getcwd(LPSTR buf, INT32 size)
1700 if (size < 0) /* allocate as big as nescessary */
1701 len =GetCurrentDirectory32A(1,test) + 1;
1702 if(!(buf = CRTDLL_malloc(len)))
1704 /* set error to OutOfRange */
1709 if(!(len =GetCurrentDirectory32A(len,buf)))
1715 /* set error to ERANGE */
1716 TRACE(crtdll,"CRTDLL_getcwd buffer to small\n");
1723 /*********************************************************************
1724 * _getdrive (CRTDLL.124)
1726 * Return current drive, 1 for A, 2 for B
1728 INT32 __cdecl CRTDLL__getdrive(VOID)
1730 return DRIVE_GetCurrentDrive() + 1;
1733 /*********************************************************************
1734 * _mkdir (CRTDLL.234)
1736 INT32 __cdecl CRTDLL__mkdir(LPCSTR newdir)
1738 if (!CreateDirectory32A(newdir,NULL))
1743 /*********************************************************************
1744 * _errno (CRTDLL.52)
1745 * Yes, this is a function.
1747 LPINT32 __cdecl CRTDLL__errno()
1749 static int crtdllerrno;
1751 /* FIXME: we should set the error at the failing function call time */
1752 crtdllerrno = LastErrorToErrno(GetLastError());
1753 return &crtdllerrno;
1756 /*********************************************************************
1757 * _tempnam (CRTDLL.305)
1760 LPSTR __cdecl CRTDLL__tempnam(LPCSTR dir, LPCSTR prefix)
1764 DOS_FULL_NAME tempname;
1766 if ((ret = tempnam(dir,prefix))==NULL) {
1767 WARN(crtdll, "Unable to get unique filename\n");
1770 if (!DOSFS_GetFullName(ret,FALSE,&tempname))
1772 TRACE(crtdll, "Wrong path?\n");
1776 if ((ret = CRTDLL_malloc(strlen(tempname.short_name)+1)) == NULL) {
1777 WARN(crtdll, "CRTDL_malloc for shortname failed\n");
1780 if ((ret = strcpy(ret,tempname.short_name)) == NULL) {
1781 WARN(crtdll, "Malloc for shortname failed\n");
1785 TRACE(crtdll,"dir %s prefix %s got %s\n",
1790 /*********************************************************************
1791 * tmpnam (CRTDLL.490)
1793 * lcclnk from lcc-win32 relies on a terminating dot in the name returned
1796 LPSTR __cdecl CRTDLL_tmpnam(LPSTR s)
1800 if ((ret =tmpnam(s))== NULL) {
1801 WARN(crtdll, "Unable to get unique filename\n");
1804 if (!DOSFS_GetFullName(ret,FALSE,&CRTDLL_tmpname))
1806 TRACE(crtdll, "Wrong path?\n");
1809 strcat(CRTDLL_tmpname.short_name,".");
1810 TRACE(crtdll,"for buf %p got %s\n",
1811 s,CRTDLL_tmpname.short_name);
1812 TRACE(crtdll,"long got %s\n",
1813 CRTDLL_tmpname.long_name);
1815 return strcpy(s,CRTDLL_tmpname.short_name);
1817 return CRTDLL_tmpname.short_name;
1821 /*********************************************************************
1822 * _itoa (CRTDLL.165)
1824 LPSTR __cdecl CRTDLL__itoa(INT32 x,LPSTR buf,INT32 buflen)
1826 wsnprintf32A(buf,buflen,"%d",x);
1830 /*********************************************************************
1831 * _ltoa (CRTDLL.180)
1833 LPSTR __cdecl CRTDLL__ltoa(long x,LPSTR buf,INT32 radix)
1836 case 2: FIXME(crtdll, "binary format not implemented !\n");
1838 case 8: wsnprintf32A(buf,0x80,"%o",x);
1840 case 10: wsnprintf32A(buf,0x80,"%d",x);
1842 case 16: wsnprintf32A(buf,0x80,"%x",x);
1844 default: FIXME(crtdll, "radix %d not implemented !\n", radix);
1849 typedef VOID (*sig_handler_type)(VOID);
1851 /*********************************************************************
1852 * signal (CRTDLL.455)
1854 VOID __cdecl CRTDLL_signal(int sig, sig_handler_type ptr)
1856 FIXME(crtdll, "(%d %p):stub.\n", sig, ptr);
1859 /*********************************************************************
1860 * _ftol (CRTDLL.113)
1862 LONG __cdecl CRTDLL__ftol(double fl) {
1865 /*********************************************************************
1866 * _sleep (CRTDLL.267)
1868 VOID __cdecl CRTDLL__sleep(unsigned long timeout)
1870 TRACE(crtdll,"CRTDLL__sleep for %ld milliseconds\n",timeout);
1871 Sleep((timeout)?timeout:1);
1874 /*********************************************************************
1875 * getenv (CRTDLL.437)
1877 LPSTR __cdecl CRTDLL_getenv(const char *name)
1879 LPSTR environ = GetEnvironmentStrings32A();
1880 LPSTR pp,pos = NULL;
1881 unsigned int length;
1883 for (pp = environ; (*pp); pp = pp + strlen(pp) +1)
1885 pos =strchr(pp,'=');
1889 length = strlen(pp);
1890 if (!strncmp(pp,name,length)) break;
1895 TRACE(crtdll,"got %s\n",pp);
1897 FreeEnvironmentStrings32A( environ );
1901 /*********************************************************************
1902 * _mbsrchr (CRTDLL.223)
1904 LPSTR __cdecl CRTDLL__mbsrchr(LPSTR s,CHAR x) {
1905 /* FIXME: handle multibyte strings */
1906 return strrchr(s,x);
1909 /*********************************************************************
1910 * _memicmp (CRTDLL.233)(NTDLL.868)
1911 * A stringcompare, without \0 check
1913 * -1:if first string is alphabetically before second string
1914 * 1:if second '' '' '' '' first ''
1915 * 0:if both are equal.
1917 INT32 __cdecl CRTDLL__memicmp(
1918 LPCSTR s1, /* [in] first string */
1919 LPCSTR s2, /* [in] second string */
1920 DWORD len /* [in] length to compare */
1924 for (i=0;i<len;i++) {
1925 if (tolower(s1[i])<tolower(s2[i]))
1927 if (tolower(s1[i])>tolower(s2[i]))
1932 /*********************************************************************
1933 * __dllonexit (CRTDLL.25)
1935 VOID __cdecl CRTDLL__dllonexit ()
1936 { FIXME(crtdll,"stub\n");