misc/crtdll.c

   1 /*
   2  * The C RunTime DLL
   3  *
   4  * Implements C run-time functionality as known from UNIX.
   5  *
   6  * Copyright 1996,1998 Marcus Meissner
   7  * Copyright 1996 Jukka Iivonen
   8  * Copyright 1997 Uwe Bonnes
   9  */
  10
  11 /*
  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
  19 AJ 990101:
  20 - needs a proper stdio emulation based on Win32 file handles
  21 - should set CRTDLL errno from GetLastError() in every function
  22 */
  23
  24 /* NOTE: This file also implements the wcs* functions. They _ARE_ in
  25  * the newer Linux libcs, but use 4 byte wide characters, so are unusable,
  26  * since we need 2 byte wide characters. - Marcus Meissner, 981031
  27  */
  28
  29 #include <errno.h>
  30 #include <stdlib.h>
  31 #include <stdarg.h>
  32 #include <string.h>
  33 #include <sys/stat.h>
  34 #include <sys/times.h>
  35 #include <unistd.h>
  36 #include <time.h>
  37 #include <ctype.h>
  38 #include <math.h>
  39 #include <fcntl.h>
  40 #include <setjmp.h>
  41 #include "win.h"
  42 #include "windows.h"
  43 #include "winerror.h"
  44 #include "debug.h"
  45 #include "module.h"
  46 #include "heap.h"
  47 #include "crtdll.h"
  48 #include "drive.h"
  49 #include "file.h"
  50 #include "except.h"
  51 #include "options.h"
  52 #include "winnls.h"
  53
  54 static DOS_FULL_NAME CRTDLL_tmpname;
  55
  56 UINT32 CRTDLL_argc_dll;         /* CRTDLL.23 */
  57 LPSTR *CRTDLL_argv_dll;         /* CRTDLL.24 */
  58 LPSTR  CRTDLL_acmdln_dll;       /* CRTDLL.38 */
  59 UINT32 CRTDLL_basemajor_dll;    /* CRTDLL.42 */
  60 UINT32 CRTDLL_baseminor_dll;    /* CRTDLL.43 */
  61 UINT32 CRTDLL_baseversion_dll;  /* CRTDLL.44 */
  62 UINT32 CRTDLL_commode_dll;      /* CRTDLL.59 */
  63 LPSTR  CRTDLL_environ_dll;      /* CRTDLL.75 */
  64 UINT32 CRTDLL_fmode_dll;        /* CRTDLL.104 */
  65 UINT32 CRTDLL_osmajor_dll;      /* CRTDLL.241 */
  66 UINT32 CRTDLL_osminor_dll;      /* CRTDLL.242 */
  67 UINT32 CRTDLL_osmode_dll;       /* CRTDLL.243 */
  68 UINT32 CRTDLL_osver_dll;        /* CRTDLL.244 */
  69 UINT32 CRTDLL_osversion_dll;    /* CRTDLL.245 */
  70 UINT32 CRTDLL_winmajor_dll;     /* CRTDLL.329 */
  71 UINT32 CRTDLL_winminor_dll;     /* CRTDLL.330 */
  72 UINT32 CRTDLL_winver_dll;       /* CRTDLL.331 */
  73
  74 /* FIXME: structure layout is obviously not correct */
  75 typedef struct
  76 {
  77     HANDLE32 handle;
  78     int      pad[7];
  79 } CRTDLL_FILE;
  80
  81 CRTDLL_FILE CRTDLL_iob[3];
  82
  83 static CRTDLL_FILE * const CRTDLL_stdin  = &CRTDLL_iob[0];
  84 static CRTDLL_FILE * const CRTDLL_stdout = &CRTDLL_iob[1];
  85 static CRTDLL_FILE * const CRTDLL_stderr = &CRTDLL_iob[2];
  86
  87 typedef VOID (*new_handler_type)(VOID);
  88
  89 static new_handler_type new_handler;
  90
  91 /*********************************************************************
  92  *                  _GetMainArgs  (CRTDLL.022)
  93  */
  94 DWORD __cdecl CRTDLL__GetMainArgs(LPDWORD argc,LPSTR **argv,
  95                                 LPSTR *environ,DWORD flag)
  96 {
  97         char *cmdline;
  98         char  **xargv;
  99         int     xargc,i,afterlastspace;
 100         DWORD   version;
 101
 102         TRACE(crtdll,"(%p,%p,%p,%ld).\n",
 103                 argc,argv,environ,flag
 104         );
 105         CRTDLL_acmdln_dll = cmdline = HEAP_strdupA( GetProcessHeap(), 0,
 106                                                     GetCommandLine32A() );
 107         TRACE(crtdll,"got '%s'\n", cmdline);
 108
 109         version = GetVersion32();
 110         CRTDLL_osver_dll       = version >> 16;
 111         CRTDLL_winminor_dll    = version & 0xFF;
 112         CRTDLL_winmajor_dll    = (version>>8) & 0xFF;
 113         CRTDLL_baseversion_dll = version >> 16;
 114         CRTDLL_winver_dll      = ((version >> 8) & 0xFF) + ((version & 0xFF) << 8);
 115         CRTDLL_baseminor_dll   = (version >> 16) & 0xFF;
 116         CRTDLL_basemajor_dll   = (version >> 24) & 0xFF;
 117         CRTDLL_osversion_dll   = version & 0xFFFF;
 118         CRTDLL_osminor_dll     = version & 0xFF;
 119         CRTDLL_osmajor_dll     = (version>>8) & 0xFF;
 120
 121         /* missing threading init */
 122
 123         i=0;xargv=NULL;xargc=0;afterlastspace=0;
 124         while (cmdline[i]) {
 125                 if (cmdline[i]==' ') {
 126                         xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
 127                                                    sizeof(char*)*(++xargc));
 128                         cmdline[i]='\0';
 129                         xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
 130                                                        cmdline+afterlastspace);
 131                         i++;
 132                         while (cmdline[i]==' ')
 133                                 i++;
 134                         if (cmdline[i])
 135                                 afterlastspace=i;
 136                 } else
 137                         i++;
 138         }
 139         xargv=(char**)HeapReAlloc( GetProcessHeap(), 0, xargv,
 140                                    sizeof(char*)*(++xargc));
 141         cmdline[i]='\0';
 142         xargv[xargc-1] = HEAP_strdupA( GetProcessHeap(), 0,
 143                                        cmdline+afterlastspace);
 144         CRTDLL_argc_dll = xargc;
 145         *argc           = xargc;
 146         CRTDLL_argv_dll = xargv;
 147         *argv           = xargv;
 148
 149         TRACE(crtdll,"found %d arguments\n",
 150                 CRTDLL_argc_dll);
 151         CRTDLL_environ_dll = *environ = GetEnvironmentStrings32A();
 152         return 0;
 153 }
 154
 155
 156 typedef void (*_INITTERMFUN)();
 157
 158 /* fixme: move to header */
 159 struct find_t
 160 {   unsigned    attrib;
 161     time_t      time_create;    /* -1 when not avaiable */
 162     time_t      time_access;    /* -1 when not avaiable */
 163     time_t      time_write;
 164     unsigned long       size;   /* fixme: 64 bit ??*/
 165     char        name[260];
 166 };
 167  /*********************************************************************
 168  *                  _findfirst    (CRTDLL.099)
 169  *
 170  * BUGS
 171  *   Unimplemented
 172  */
 173 DWORD __cdecl CRTDLL__findfirst(LPCSTR fname,  struct find_t * x2)
 174 {
 175   FIXME(crtdll, ":(%s,%p): stub\n",fname,x2);
 176   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 177   return FALSE;
 178 }
 179
 180 /*********************************************************************
 181  *                  _findnext     (CRTDLL.100)
 182  *
 183  * BUGS
 184  *   Unimplemented
 185  */
 186 INT32 __cdecl CRTDLL__findnext(DWORD hand, struct find_t * x2)
 187 {
 188   FIXME(crtdll, ":(%ld,%p): stub\n",hand,x2);
 189   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 190   return FALSE;
 191 }
 192
 193 /*********************************************************************
 194  *                  _fstat        (CRTDLL.111)
 195  *
 196  * BUGS
 197  *   Unimplemented
 198  */
 199 int __cdecl CRTDLL__fstat(int file, struct stat* buf)
 200 {
 201   FIXME(crtdll, ":(%d,%p): stub\n",file,buf);
 202   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 203   return FALSE;
 204 }
 205
 206 /*********************************************************************
 207  *                  _initterm     (CRTDLL.135)
 208  */
 209 DWORD __cdecl CRTDLL__initterm(_INITTERMFUN *start,_INITTERMFUN *end)
 210 {
 211         _INITTERMFUN    *current;
 212
 213         TRACE(crtdll,"(%p,%p)\n",start,end);
 214         current=start;
 215         while (current<end) {
 216                 if (*current) (*current)();
 217                 current++;
 218         }
 219         return 0;
 220 }
 221
 222 /*********************************************************************
 223  *                  _fdopen     (CRTDLL.91)
 224  */
 225 CRTDLL_FILE * __cdecl CRTDLL__fdopen(INT32 handle, LPCSTR mode)
 226 {
 227     CRTDLL_FILE *file;
 228
 229     switch (handle)
 230     {
 231     case 0:
 232         file = CRTDLL_stdin;
 233         if (!file->handle) file->handle = GetStdHandle( STD_INPUT_HANDLE );
 234         break;
 235     case 1:
 236         file = CRTDLL_stdout;
 237         if (!file->handle) file->handle = GetStdHandle( STD_OUTPUT_HANDLE );
 238         break;
 239     case 2:
 240         file=CRTDLL_stderr;
 241         if (!file->handle) file->handle = GetStdHandle( STD_ERROR_HANDLE );
 242         break;
 243     default:
 244         file = HeapAlloc( GetProcessHeap(), 0, sizeof(*file) );
 245         file->handle = handle;
 246         break;
 247     }
 248   TRACE(crtdll, "open handle %d mode %s  got file %p\n",
 249                handle, mode, file);
 250   return file;
 251 }
 252
 253
 254 /*******************************************************************
 255  *         _global_unwind2  (CRTDLL.129)
 256  */
 257 void __cdecl CRTDLL__global_unwind2( PEXCEPTION_FRAME frame )
 258 {
 259     RtlUnwind( frame, 0, NULL, 0 );
 260 }
 261
 262 /*******************************************************************
 263  *         _local_unwind2  (CRTDLL.173)
 264  */
 265 void __cdecl CRTDLL__local_unwind2( PEXCEPTION_FRAME endframe, DWORD nr )
 266 {
 267     TRACE(crtdll,"(%p,%ld)\n",endframe,nr);
 268 }
 269 /*********************************************************************
 270  *                  _read     (CRTDLL.256)
 271  *
 272  * BUGS
 273  *   Unimplemented
 274  */
 275 INT32 __cdecl CRTDLL__read(INT32 fd, LPVOID buf, UINT32 count)
 276 {
 277   FIXME(crtdll,":(%d,%p,%d): stub\n",fd,buf,count);
 278   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 279   return FALSE;
 280 }
 281
 282 /*********************************************************************
 283  *                  fopen     (CRTDLL.372)
 284  */
 285 CRTDLL_FILE * __cdecl CRTDLL_fopen(LPCSTR path, LPCSTR mode)
 286 {
 287   CRTDLL_FILE *file = NULL;
 288   HFILE32 handle;
 289 #if 0
 290   DOS_FULL_NAME full_name;
 291
 292   if (!DOSFS_GetFullName( path, FALSE, &full_name )) {
 293     WARN(crtdll, "file %s bad name\n",path);
 294    return 0;
 295   }
 296
 297   file=fopen(full_name.long_name ,mode);
 298 #endif
 299   INT32 flagmode=0;
 300
 301   if ((strchr(mode,'r')&&strchr(mode,'a'))||
 302       (strchr(mode,'r')&&strchr(mode,'w'))||
 303       (strchr(mode,'w')&&strchr(mode,'a')))
 304     return NULL;
 305
 306   if (strstr(mode,"r+")) flagmode=O_RDWR;
 307   else if (strchr(mode,'r')) flagmode = O_RDONLY;
 308   else if (strstr(mode,"w+")) flagmode= O_RDWR | O_TRUNC | O_CREAT;
 309   else if (strchr(mode,'w')) flagmode = O_WRONLY | O_TRUNC | O_CREAT;
 310   else if (strstr(mode,"a+")) flagmode= O_RDWR | O_CREAT | O_APPEND;
 311   else if (strchr(mode,'w')) flagmode = O_RDWR | O_CREAT | O_APPEND;
 312   else if (strchr(mode,'b'))
 313     TRACE(crtdll, "%s in BINARY mode\n",path);
 314
 315   if ((handle = FILE_Open(path, flagmode,0)) != INVALID_HANDLE_VALUE32)
 316   {
 317       file = HeapAlloc( GetProcessHeap(), 0, sizeof(*file) );
 318       file->handle = handle;
 319   }
 320   TRACE(crtdll, "file %s mode %s got handle %d file %p\n",
 321                  path,mode,handle,file);
 322   return file;
 323 }
 324
 325 /*********************************************************************
 326  *                  fread     (CRTDLL.377)
 327  */
 328 DWORD __cdecl CRTDLL_fread(LPVOID ptr, INT32 size, INT32 nmemb, CRTDLL_FILE *file)
 329 {
 330 #if 0
 331   int i=0;
 332   void *temp=ptr;
 333
 334   /* If we would honour CR/LF <-> LF translation, we could do it like this.
 335      We should keep track of all files opened, and probably files with \
 336      known binary extensions must be unchanged */
 337   while ( (i < (nmemb*size)) && (ret==1)) {
 338     ret=fread(temp,1,1,file);
 339     TRACE(crtdll, "got %c 0x%02x ret %d\n",
 340                  (isalpha(*(unsigned char*)temp))? *(unsigned char*)temp:
 341                  ' ',*(unsigned char*)temp, ret);
 342     if (*(unsigned char*)temp != 0xd) { /* skip CR */
 343       temp++;
 344       i++;
 345     }
 346     else
 347       TRACE(crtdll, "skipping ^M\n");
 348   }
 349   TRACE(crtdll, "0x%08x items of size %d from file %p to %p\n",
 350                nmemb,size,file,ptr,);
 351   if(i!=nmemb)
 352     WARN(crtdll, " failed!\n");
 353
 354   return i;
 355 #else
 356   DWORD ret;
 357
 358   TRACE(crtdll, "0x%08x items of size %d from file %p to %p\n",
 359                nmemb,size,file,ptr);
 360   if (!ReadFile( file->handle, ptr, size * nmemb, &ret, NULL ))
 361       WARN(crtdll, " failed!\n");
 362
 363   return ret / size;
 364 #endif
 365 }
 366 /*********************************************************************
 367  *                  freopen    (CRTDLL.379)
 368  *
 369  * BUGS
 370  *   Unimplemented
 371  */
 372 DWORD __cdecl CRTDLL_freopen(LPCSTR path, LPCSTR mode, LPVOID stream)
 373 {
 374   FIXME(crtdll, ":(%s,%s,%p): stub\n", path, mode, stream);
 375   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 376   return FALSE;
 377 }
 378
 379 /*********************************************************************
 380  *                  fscanf     (CRTDLL.381)
 381  */
 382 INT32 __cdecl CRTDLL_fscanf( CRTDLL_FILE *stream, LPSTR format, ... )
 383 {
 384 #if 0
 385     va_list valist;
 386     INT32 res;
 387
 388     va_start( valist, format );
 389 #ifdef HAVE_VFSCANF
 390     res = vfscanf( xlat_file_ptr(stream), format, valist );
 391 #endif
 392     va_end( valist );
 393     return res;
 394 #endif
 395     FIXME(crtdll,"broken\n");
 396     return 0;
 397 }
 398
 399 /*********************************************************************
 400  *                  fseek     (CRTDLL.382)
 401  */
 402 LONG __cdecl CRTDLL_fseek( CRTDLL_FILE *file, LONG offset, INT32 whence)
 403 {
 404   TRACE(crtdll, "file %p to 0x%08lx pos %s\n",
 405         file,offset,(whence==SEEK_SET)?"SEEK_SET":
 406         (whence==SEEK_CUR)?"SEEK_CUR":
 407         (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
 408   if (SetFilePointer( file->handle, offset, NULL, whence ) != 0xffffffff)
 409       return 0;
 410   WARN(crtdll, " failed!\n");
 411   return -1;
 412 }
 413
 414 /*********************************************************************
 415  *                  fsetpos     (CRTDLL.383)
 416  */
 417 INT32 __cdecl CRTDLL_fsetpos( CRTDLL_FILE *file, INT32 *pos )
 418 {
 419     TRACE(crtdll, "file %p pos %d\n", file, *pos );
 420     return CRTDLL_fseek(file, *pos, SEEK_SET);
 421 }
 422
 423 /*********************************************************************
 424  *                  ftell     (CRTDLL.384)
 425  */
 426 LONG __cdecl CRTDLL_ftell( CRTDLL_FILE *file )
 427 {
 428     return SetFilePointer( file->handle, 0, NULL, SEEK_CUR );
 429 }
 430
 431 /*********************************************************************
 432  *                  fwrite     (CRTDLL.386)
 433  */
 434 DWORD __cdecl CRTDLL_fwrite( LPVOID ptr, INT32 size, INT32 nmemb, CRTDLL_FILE *file )
 435 {
 436     DWORD ret;
 437
 438     TRACE(crtdll, "0x%08x items of size %d to file %p from %p\n",
 439           nmemb,size,file,ptr);
 440     if (!WriteFile( file->handle, ptr, size * nmemb, &ret, NULL ))
 441         WARN(crtdll, " failed!\n");
 442     return ret / size;
 443 }
 444
 445 /*********************************************************************
 446  *                  setbuf     (CRTDLL.452)
 447  */
 448 INT32 __cdecl CRTDLL_setbuf(CRTDLL_FILE *file, LPSTR buf)
 449 {
 450   TRACE(crtdll, "(file %p buf %p)\n", file, buf);
 451   /* this doesn't work:"void value not ignored as it ought to be"
 452   return setbuf(file,buf);
 453   */
 454   /* FIXME: no buffering for now */
 455   return 0;
 456 }
 457
 458 /*********************************************************************
 459  *                  _open_osfhandle         (CRTDLL.240)
 460  */
 461 HFILE32 __cdecl CRTDLL__open_osfhandle(LONG osfhandle, INT32 flags)
 462 {
 463 HFILE32 handle;
 464
 465         switch (osfhandle) {
 466         case STD_INPUT_HANDLE :
 467         case 0 :
 468           handle=0;
 469           break;
 470         case STD_OUTPUT_HANDLE:
 471         case 1:
 472           handle=1;
 473           break;
 474         case STD_ERROR_HANDLE:
 475         case 2:
 476           handle=2;
 477           break;
 478         default:
 479           return (-1);
 480         }
 481         TRACE(crtdll, "(handle %08lx,flags %d) return %d\n",
 482                      osfhandle,flags,handle);
 483         return handle;
 484
 485 }
 486
 487 /*********************************************************************
 488  *                  srand         (CRTDLL.460)
 489  */
 490 void __cdecl CRTDLL_srand(DWORD seed)
 491 {
 492         /* FIXME: should of course be thread? process? local */
 493         srand(seed);
 494 }
 495
 496 /*********************************************************************
 497  *                  vfprintf       (CRTDLL.373)
 498  */
 499 INT32 __cdecl CRTDLL_vfprintf( CRTDLL_FILE *file, LPSTR format, va_list args )
 500 {
 501     char buffer[1024];  /* FIXME... */
 502
 503     vsprintf( buffer, format, args );
 504     return CRTDLL_fwrite( buffer, 1, strlen(buffer), file );
 505 }
 506
 507 /*********************************************************************
 508  *                  fprintf       (CRTDLL.373)
 509  */
 510 INT32 __cdecl CRTDLL_fprintf( CRTDLL_FILE *file, LPSTR format, ... )
 511 {
 512     va_list valist;
 513     INT32 res;
 514
 515     va_start( valist, format );
 516     res = CRTDLL_vfprintf( file, format, valist );
 517     va_end( valist );
 518     return res;
 519 }
 520
 521 /*********************************************************************
 522  *                  time          (CRTDLL.488)
 523  */
 524 time_t __cdecl CRTDLL_time(time_t *timeptr)
 525 {
 526         time_t  curtime = time(NULL);
 527
 528         if (timeptr)
 529                 *timeptr = curtime;
 530         return curtime;
 531 }
 532
 533 /*********************************************************************
 534  *                            (CRTDLL.350)
 535  */
 536 clock_t __cdecl CRTDLL_clock(void)
 537 {
 538         struct tms alltimes;
 539         clock_t res;
 540
 541         times(&alltimes);
 542         res = alltimes.tms_utime + alltimes.tms_stime+
 543                alltimes.tms_cutime + alltimes.tms_cstime;
 544         /* Fixme: We need some symbolic representation
 545            for (Hostsystem_)CLOCKS_PER_SEC
 546            and (Emulated_system_)CLOCKS_PER_SEC
 547            10 holds only for Windows/Linux_i86)
 548            */
 549         return 10*res;
 550 }
 551
 552 /*********************************************************************
 553  *                  _isatty       (CRTDLL.137)
 554  */
 555 BOOL32 __cdecl CRTDLL__isatty(DWORD x)
 556 {
 557         TRACE(crtdll,"(%ld)\n",x);
 558         return TRUE;
 559 }
 560
 561 /*********************************************************************
 562  *                  _write        (CRTDLL.332)
 563  */
 564 INT32 __cdecl CRTDLL__write(INT32 fd,LPCVOID buf,UINT32 count)
 565 {
 566         INT32 len=0;
 567
 568         if (fd == -1)
 569           len = -1;
 570         else if (fd<=2)
 571           len = (UINT32)write(fd,buf,(LONG)count);
 572         else
 573           len = _lwrite32(fd,buf,count);
 574         TRACE(crtdll,"%d/%d byte to dfh %d from %p,\n",
 575                        len,count,fd,buf);
 576         return len;
 577 }
 578
 579
 580 /*********************************************************************
 581  *                  _cexit          (CRTDLL.49)
 582  *
 583  *  FIXME: What the heck is the difference between
 584  *  FIXME           _c_exit         (CRTDLL.47)
 585  *  FIXME           _cexit          (CRTDLL.49)
 586  *  FIXME           _exit           (CRTDLL.87)
 587  *  FIXME           exit            (CRTDLL.359)
 588  *
 589  * atexit-processing comes to mind -- MW.
 590  *
 591  */
 592 void __cdecl CRTDLL__cexit(INT32 ret)
 593 {
 594         TRACE(crtdll,"(%d)\n",ret);
 595         ExitProcess(ret);
 596 }
 597
 598
 599 /*********************************************************************
 600  *                  exit          (CRTDLL.359)
 601  */
 602 void __cdecl CRTDLL_exit(DWORD ret)
 603 {
 604         TRACE(crtdll,"(%ld)\n",ret);
 605         ExitProcess(ret);
 606 }
 607
 608
 609 /*********************************************************************
 610  *                  _abnormal_termination          (CRTDLL.36)
 611  */
 612 INT32 __cdecl CRTDLL__abnormal_termination(void)
 613 {
 614         TRACE(crtdll,"(void)\n");
 615         return 0;
 616 }
 617
 618
 619 /*********************************************************************
 620  *                  _access          (CRTDLL.37)
 621  */
 622 INT32 __cdecl CRTDLL__access(LPCSTR filename, INT32 mode)
 623 {
 624     DWORD attr = GetFileAttributes32A(filename);
 625
 626     if (attr == -1)
 627     {
 628         if (GetLastError() == ERROR_INVALID_ACCESS)
 629             errno = EACCES;
 630         else
 631             errno = ENOENT;
 632         return -1;
 633     }
 634
 635     if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
 636     {
 637         errno = EACCES;
 638         return -1;
 639     }
 640     else
 641         return 0;
 642 }
 643
 644
 645 /*********************************************************************
 646  *                  fflush        (CRTDLL.365)
 647  */
 648 INT32 __cdecl CRTDLL_fflush( CRTDLL_FILE *file )
 649 {
 650     return FlushFileBuffers( file->handle ) ? 0 : -1;
 651 }
 652
 653
 654 /*********************************************************************
 655  *                  rand          (CRTDLL.446)
 656  */
 657 INT32 __cdecl CRTDLL_rand()
 658 {
 659     return rand();
 660 }
 661
 662
 663 /*********************************************************************
 664  *                  putchar       (CRTDLL.442)
 665  */
 666 void __cdecl CRTDLL_putchar( INT32 x )
 667 {
 668     putchar(x);
 669 }
 670
 671
 672 /*********************************************************************
 673  *                  fputc       (CRTDLL.374)
 674  */
 675 INT32 __cdecl CRTDLL_fputc( INT32 c, CRTDLL_FILE *file )
 676 {
 677     char ch = (char)c;
 678     DWORD res;
 679     TRACE(crtdll, "%c to file %p\n",c,file);
 680     if (!WriteFile( file->handle, &ch, 1, &res, NULL )) return -1;
 681     return c;
 682 }
 683
 684
 685 /*********************************************************************
 686  *                  fputs       (CRTDLL.375)
 687  */
 688 INT32 __cdecl CRTDLL_fputs( LPCSTR s, CRTDLL_FILE *file )
 689 {
 690     DWORD res;
 691     TRACE(crtdll, "%s to file %p\n",s,file);
 692     if (!WriteFile( file->handle, s, strlen(s), &res, NULL )) return -1;
 693     return res;
 694 }
 695
 696
 697 /*********************************************************************
 698  *                  puts       (CRTDLL.443)
 699  */
 700 INT32 __cdecl CRTDLL_puts(LPCSTR s)
 701 {
 702     TRACE(crtdll, "%s \n",s);
 703     return puts(s);
 704 }
 705
 706
 707 /*********************************************************************
 708  *                  putc       (CRTDLL.441)
 709  */
 710 INT32 __cdecl CRTDLL_putc( INT32 c, CRTDLL_FILE *file )
 711 {
 712     return CRTDLL_fputc( c, file );
 713 }
 714
 715 /*********************************************************************
 716  *                  fgetc       (CRTDLL.366)
 717  */
 718 INT32 __cdecl CRTDLL_fgetc( CRTDLL_FILE *file )
 719 {
 720     DWORD res;
 721     char ch;
 722     if (!ReadFile( file->handle, &ch, 1, &res, NULL )) return -1;
 723     return ch;
 724 }
 725
 726
 727 /*********************************************************************
 728  *                  getc       (CRTDLL.388)
 729  */
 730 INT32 __cdecl CRTDLL_getc( CRTDLL_FILE *file )
 731 {
 732     return CRTDLL_fgetc( file );
 733 }
 734
 735
 736 /*********************************************************************
 737  *                  fgets       (CRTDLL.368)
 738  */
 739 CHAR* __cdecl CRTDLL_fgets( LPSTR s, INT32 size, CRTDLL_FILE *file )
 740 {
 741     int    cc;
 742     LPSTR  buf_start = s;
 743
 744     /* BAD, for the whole WINE process blocks... just done this way to test
 745      * windows95's ftp.exe.
 746      */
 747
 748     for(cc = CRTDLL_fgetc(file); cc != EOF && cc != '\n'; cc = CRTDLL_fgetc(file))
 749         if (cc != '\r')
 750         {
 751             if (--size <= 0) break;
 752             *s++ = (char)cc;
 753         }
 754
 755     *s = '\0';
 756
 757     TRACE(crtdll,"got '%s'\n", buf_start);
 758     return buf_start;
 759 }
 760
 761
 762 /*********************************************************************
 763  *                  gets          (CRTDLL.391)
 764  */
 765 LPSTR __cdecl CRTDLL_gets(LPSTR buf)
 766 {
 767     int    cc;
 768     LPSTR  buf_start = buf;
 769
 770     /* BAD, for the whole WINE process blocks... just done this way to test
 771      * windows95's ftp.exe.
 772      */
 773
 774     for(cc = fgetc(stdin); cc != EOF && cc != '\n'; cc = fgetc(stdin))
 775         if(cc != '\r') *buf++ = (char)cc;
 776
 777     *buf = '\0';
 778
 779     TRACE(crtdll,"got '%s'\n", buf_start);
 780     return buf_start;
 781 }
 782
 783
 784 /*********************************************************************
 785  *                  _rotl          (CRTDLL.259)
 786  */
 787 UINT32 __cdecl CRTDLL__rotl(UINT32 x,INT32 shift)
 788 {
 789    unsigned int ret = (x >> shift)|( x >>((sizeof(x))-shift));
 790
 791    TRACE(crtdll, "got 0x%08x rot %d ret 0x%08x\n",
 792                   x,shift,ret);
 793    return ret;
 794
 795 }
 796 /*********************************************************************
 797  *                  _lrotl          (CRTDLL.176)
 798  */
 799 DWORD __cdecl CRTDLL__lrotl(DWORD x,INT32 shift)
 800 {
 801    unsigned long ret = (x >> shift)|( x >>((sizeof(x))-shift));
 802
 803    TRACE(crtdll, "got 0x%08lx rot %d ret 0x%08lx\n",
 804                   x,shift,ret);
 805    return ret;
 806
 807 }
 808
 809
 810 /*********************************************************************
 811  *                  _mbsicmp      (CRTDLL.204)
 812  */
 813 int __cdecl CRTDLL__mbsicmp(unsigned char *x,unsigned char *y)
 814 {
 815     do {
 816         if (!*x)
 817             return !!*y;
 818         if (!*y)
 819             return !!*x;
 820         /* FIXME: MBCS handling... */
 821         if (*x!=*y)
 822             return 1;
 823         x++;
 824         y++;
 825     } while (1);
 826 }
 827
 828
 829 /*********************************************************************
 830  *                  _mbsinc       (CRTDLL.205)
 831  */
 832 unsigned char * __cdecl CRTDLL__mbsinc(unsigned char *x)
 833 {
 834     /* FIXME: mbcs */
 835     return x++;
 836 }
 837
 838
 839 /*********************************************************************
 840  *                  vsprintf      (CRTDLL.500)
 841  */
 842 INT32 __cdecl CRTDLL_vsprintf( LPSTR buffer, LPCSTR spec, va_list args )
 843 {
 844     return wvsprintf32A( buffer, spec, args );
 845 }
 846
 847 /*********************************************************************
 848  *                  vswprintf      (CRTDLL.501)
 849  */
 850 INT32 __cdecl CRTDLL_vswprintf( LPWSTR buffer, LPCWSTR spec, va_list args )
 851 {
 852     return wvsprintf32W( buffer, spec, args );
 853 }
 854
 855 /*********************************************************************
 856  *                  _mbscpy       (CRTDLL.200)
 857  */
 858 unsigned char* __cdecl CRTDLL__mbscpy(unsigned char *x,unsigned char *y)
 859 {
 860     TRACE(crtdll,"CRTDLL_mbscpy %s and %s\n",x,y);
 861     return strcpy(x,y);
 862 }
 863
 864
 865 /*********************************************************************
 866  *                  _mbscat       (CRTDLL.197)
 867  */
 868 unsigned char* __cdecl CRTDLL__mbscat(unsigned char *x,unsigned char *y)
 869 {
 870     return strcat(x,y);
 871 }
 872
 873
 874 /*********************************************************************
 875  *                  _strcmpi   (CRTDLL.282) (CRTDLL.287)
 876  */
 877 INT32 __cdecl CRTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
 878 {
 879     return lstrcmpi32A( s1, s2 );
 880 }
 881
 882
 883 /*********************************************************************
 884  *                  _strnicmp   (CRTDLL.293)
 885  */
 886 INT32 __cdecl CRTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT32 n )
 887 {
 888     return lstrncmpi32A( s1, s2, n );
 889 }
 890
 891
 892 /*********************************************************************
 893  *                  _strlwr      (CRTDLL.293)
 894  *
 895  * convert a string in place to lowercase
 896  */
 897 LPSTR __cdecl CRTDLL__strlwr(LPSTR x)
 898 {
 899   unsigned char *y =x;
 900
 901   TRACE(crtdll, "CRTDLL_strlwr got %s\n", x);
 902   while (*y) {
 903     if ((*y > 0x40) && (*y< 0x5b))
 904       *y = *y + 0x20;
 905     y++;
 906   }
 907   TRACE(crtdll, "   returned %s\n", x);
 908
 909   return x;
 910 }
 911
 912 /*********************************************************************
 913  *                  system       (CRTDLL.485)
 914  */
 915 INT32 __cdecl CRTDLL_system(LPSTR x)
 916 {
 917 #define SYSBUF_LENGTH 1500
 918   char buffer[SYSBUF_LENGTH];
 919   unsigned char *y = x;
 920   unsigned char *bp;
 921   int i;
 922
 923   sprintf( buffer, "%s \"", Options.argv0 );
 924   bp = buffer + strlen(buffer);
 925   i = strlen(buffer) + strlen(x) +2;
 926
 927   /* Calculate needed buffer size to prevent overflow.  */
 928   while (*y) {
 929     if (*y =='\\') i++;
 930     y++;
 931   }
 932   /* If buffer too short, exit.  */
 933   if (i > SYSBUF_LENGTH) {
 934     TRACE(crtdll,"_system buffer to small\n");
 935     return 127;
 936   }
 937
 938   y =x;
 939
 940   while (*y) {
 941     *bp = *y;
 942     bp++; y++;
 943     if (*(y-1) =='\\') *bp++ = '\\';
 944   }
 945   /* Remove spaces from end of string.  */
 946   while (*(y-1) == ' ') {
 947     bp--;y--;
 948   }
 949   *bp++ = '"';
 950   *bp = 0;
 951   TRACE(crtdll, "_system got '%s', executing '%s'\n",x,buffer);
 952
 953   return system(buffer);
 954 }
 955
 956 /*********************************************************************
 957  *                  _strupr       (CRTDLL.300)
 958  */
 959 LPSTR __cdecl CRTDLL__strupr(LPSTR x)
 960 {
 961         LPSTR   y=x;
 962
 963         while (*y) {
 964                 *y=toupper(*y);
 965                 y++;
 966         }
 967         return x;
 968 }
 969
 970 /*********************************************************************
 971  *                  _wcsupr       (CRTDLL.328)
 972  */
 973 LPWSTR __cdecl CRTDLL__wcsupr(LPWSTR x)
 974 {
 975         LPWSTR  y=x;
 976
 977         while (*y) {
 978                 *y=towupper(*y);
 979                 y++;
 980         }
 981         return x;
 982 }
 983
 984 /*********************************************************************
 985  *                  _wcslwr       (CRTDLL.323)
 986  */
 987 LPWSTR __cdecl CRTDLL__wcslwr(LPWSTR x)
 988 {
 989         LPWSTR  y=x;
 990
 991         while (*y) {
 992                 *y=towlower(*y);
 993                 y++;
 994         }
 995         return x;
 996 }
 997
 998
 999 /*********************************************************************
1000  *                  longjmp        (CRTDLL.426)
1001  */
1002 VOID __cdecl CRTDLL_longjmp(jmp_buf env, int val)
1003 {
1004     FIXME(crtdll,"CRTDLL_longjmp semistup, expect crash\n");
1005     return longjmp(env, val);
1006 }
1007
1008 /*********************************************************************
1009  *                  malloc        (CRTDLL.427)
1010  */
1011 VOID* __cdecl CRTDLL_malloc(DWORD size)
1012 {
1013     return HeapAlloc(GetProcessHeap(),0,size);
1014 }
1015
1016 /*********************************************************************
1017  *                  new           (CRTDLL.001)
1018  */
1019 VOID* __cdecl CRTDLL_new(DWORD size)
1020 {
1021     VOID* result;
1022     if(!(result = HeapAlloc(GetProcessHeap(),0,size)) && new_handler)
1023         (*new_handler)();
1024     return result;
1025 }
1026
1027 /*********************************************************************
1028  *                  set_new_handler(CRTDLL.003)
1029  */
1030 new_handler_type __cdecl CRTDLL_set_new_handler(new_handler_type func)
1031 {
1032     new_handler_type old_handler = new_handler;
1033     new_handler = func;
1034     return old_handler;
1035 }
1036
1037 /*********************************************************************
1038  *                  calloc        (CRTDLL.350)
1039  */
1040 VOID* __cdecl CRTDLL_calloc(DWORD size, DWORD count)
1041 {
1042     return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size * count );
1043 }
1044
1045 /*********************************************************************
1046  *                  realloc        (CRTDLL.447)
1047  */
1048 VOID* __cdecl CRTDLL_realloc( VOID *ptr, DWORD size )
1049 {
1050     return HeapReAlloc( GetProcessHeap(), 0, ptr, size );
1051 }
1052
1053 /*********************************************************************
1054  *                  free          (CRTDLL.427)
1055  */
1056 VOID __cdecl CRTDLL_free(LPVOID ptr)
1057 {
1058     HeapFree(GetProcessHeap(),0,ptr);
1059 }
1060
1061 /*********************************************************************
1062  *                  delete       (CRTDLL.002)
1063  */
1064 VOID __cdecl CRTDLL_delete(VOID* ptr)
1065 {
1066     HeapFree(GetProcessHeap(),0,ptr);
1067 }
1068
1069 /*********************************************************************
1070  *                  _strdup          (CRTDLL.285)
1071  */
1072 LPSTR __cdecl CRTDLL__strdup(LPCSTR ptr)
1073 {
1074     return HEAP_strdupA(GetProcessHeap(),0,ptr);
1075 }
1076
1077 /*********************************************************************
1078  *                  _wcsdup          (CRTDLL.320)
1079  */
1080 LPWSTR __cdecl CRTDLL__wcsdup(LPCWSTR ptr)
1081 {
1082     return HEAP_strdupW(GetProcessHeap(),0,ptr);
1083 }
1084
1085 /*********************************************************************
1086  *                  fclose           (CRTDLL.362)
1087  */
1088 INT32 __cdecl CRTDLL_fclose( CRTDLL_FILE *file )
1089 {
1090     TRACE(crtdll,"%p\n", file );
1091     if (!CloseHandle( file->handle )) return -1;
1092     HeapFree( GetProcessHeap(), 0, file );
1093     return 0;
1094 }
1095
1096 /*********************************************************************
1097  *                  _unlink           (CRTDLL.315)
1098  */
1099 INT32 __cdecl CRTDLL__unlink(LPCSTR pathname)
1100 {
1101     int ret=0;
1102     DOS_FULL_NAME full_name;
1103
1104     if (!DOSFS_GetFullName( pathname, FALSE, &full_name )) {
1105       WARN(crtdll, "CRTDLL_unlink file %s bad name\n",pathname);
1106       return EOF;
1107     }
1108
1109     ret=unlink(full_name.long_name);
1110     TRACE(crtdll,"(%s unix %s)\n",
1111                    pathname,full_name.long_name);
1112     if(ret)
1113       WARN(crtdll, " Failed!\n");
1114
1115     return ret;
1116 }
1117
1118 /*********************************************************************
1119  *                  rename           (CRTDLL.449)
1120  */
1121 INT32 __cdecl CRTDLL_rename(LPCSTR oldpath,LPCSTR newpath)
1122 {
1123     BOOL32 ok = MoveFileEx32A( oldpath, newpath, MOVEFILE_REPLACE_EXISTING );
1124     return ok ? 0 : -1;
1125 }
1126
1127
1128 /*********************************************************************
1129  *                  _stat          (CRTDLL.280)
1130  */
1131
1132 struct win_stat
1133 {
1134     UINT16 win_st_dev;
1135     UINT16 win_st_ino;
1136     UINT16 win_st_mode;
1137     INT16  win_st_nlink;
1138     INT16  win_st_uid;
1139     INT16  win_st_gid;
1140     UINT32 win_st_rdev;
1141     INT32  win_st_size;
1142     INT32  win_st_atime;
1143     INT32  win_st_mtime;
1144     INT32  win_st_ctime;
1145 };
1146
1147 int __cdecl CRTDLL__stat(const char * filename, struct win_stat * buf)
1148 {
1149     int ret=0;
1150     DOS_FULL_NAME full_name;
1151     struct stat mystat;
1152
1153     if (!DOSFS_GetFullName( filename, TRUE, &full_name ))
1154     {
1155       WARN(crtdll, "CRTDLL__stat filename %s bad name\n",filename);
1156       return -1;
1157     }
1158     ret=stat(full_name.long_name,&mystat);
1159     TRACE(crtdll,"CRTDLL__stat %s\n", filename);
1160     if(ret)
1161       WARN(crtdll, " Failed!\n");
1162
1163     /* FIXME: should check what Windows returns */
1164
1165     buf->win_st_dev   = mystat.st_dev;
1166     buf->win_st_ino   = mystat.st_ino;
1167     buf->win_st_mode  = mystat.st_mode;
1168     buf->win_st_nlink = mystat.st_nlink;
1169     buf->win_st_uid   = mystat.st_uid;
1170     buf->win_st_gid   = mystat.st_gid;
1171     buf->win_st_rdev  = mystat.st_rdev;
1172     buf->win_st_size  = mystat.st_size;
1173     buf->win_st_atime = mystat.st_atime;
1174     buf->win_st_mtime = mystat.st_mtime;
1175     buf->win_st_ctime = mystat.st_ctime;
1176     return ret;
1177 }
1178
1179 /*********************************************************************
1180  *                  _open           (CRTDLL.239)
1181  */
1182 HFILE32 __cdecl CRTDLL__open(LPCSTR path,INT32 flags)
1183 {
1184     HFILE32 ret=0;
1185     int wineflags=0;
1186
1187     /* FIXME:
1188        the flags in lcc's header differ from the ones in Linux, e.g.
1189        Linux: define O_APPEND         02000   (= 0x400)
1190        lcc:  define _O_APPEND       0x0008
1191        so here a scheme to translate them
1192        Probably lcc is wrong here, but at least a hack to get is going
1193        */
1194     wineflags = (flags & 3);
1195     if (flags & 0x0008 ) wineflags |= O_APPEND;
1196     if (flags & 0x0100 ) wineflags |= O_CREAT;
1197     if (flags & 0x0200 ) wineflags |= O_TRUNC;
1198     if (flags & 0x0400 ) wineflags |= O_EXCL;
1199     if (flags & 0xf0f4 )
1200       TRACE(crtdll,"CRTDLL_open file unsupported flags 0x%04x\n",flags);
1201     /* End Fixme */
1202
1203     ret = FILE_Open(path,wineflags,0);
1204     TRACE(crtdll,"CRTDLL_open file %s mode 0x%04x (lccmode 0x%04x) got dfh %d\n",
1205                    path,wineflags,flags,ret);
1206     return ret;
1207 }
1208
1209 /*********************************************************************
1210  *                  _close           (CRTDLL.57)
1211  */
1212 INT32 __cdecl CRTDLL__close(HFILE32 fd)
1213 {
1214     int ret=_lclose32(fd);
1215
1216     TRACE(crtdll,"(%d)\n",fd);
1217     if(ret)
1218       WARN(crtdll, " Failed!\n");
1219
1220     return ret;
1221 }
1222
1223 /*********************************************************************
1224  *                  feof           (CRTDLL.363)
1225  */
1226 INT32 __cdecl CRTDLL_feof( CRTDLL_FILE *file )
1227 {
1228     FIXME(crtdll,"stub\n" );
1229     return 0;
1230 }
1231
1232 /*********************************************************************
1233  *                  setlocale           (CRTDLL.453)
1234  */
1235 LPSTR __cdecl CRTDLL_setlocale(INT32 category,LPCSTR locale)
1236 {
1237         LPSTR categorystr;
1238
1239         switch (category) {
1240         case CRTDLL_LC_ALL: categorystr="LC_ALL";break;
1241         case CRTDLL_LC_COLLATE: categorystr="LC_COLLATE";break;
1242         case CRTDLL_LC_CTYPE: categorystr="LC_CTYPE";break;
1243         case CRTDLL_LC_MONETARY: categorystr="LC_MONETARY";break;
1244         case CRTDLL_LC_NUMERIC: categorystr="LC_NUMERIC";break;
1245         case CRTDLL_LC_TIME: categorystr="LC_TIME";break;
1246         default: categorystr = "UNKNOWN?";break;
1247         }
1248         FIXME(crtdll,"(%s,%s),stub!\n",categorystr,locale);
1249         return "C";
1250 }
1251
1252 /*********************************************************************
1253  *                  wcscat           (CRTDLL.503)
1254  */
1255 LPWSTR __cdecl CRTDLL_wcscat( LPWSTR s1, LPCWSTR s2 )
1256 {
1257     return lstrcat32W( s1, s2 );
1258 }
1259
1260 /*********************************************************************
1261  *                  wcschr           (CRTDLL.504)
1262  */
1263 LPWSTR __cdecl CRTDLL_wcschr(LPCWSTR str,WCHAR xchar)
1264 {
1265         LPCWSTR s;
1266
1267         s=str;
1268         do {
1269                 if (*s==xchar)
1270                         return (LPWSTR)s;
1271         } while (*s++);
1272         return NULL;
1273 }
1274
1275 /*********************************************************************
1276  *                  wcscmp           (CRTDLL.505)
1277  */
1278 INT32 __cdecl CRTDLL_wcscmp( LPCWSTR s1, LPCWSTR s2 )
1279 {
1280     return lstrcmp32W( s1, s2 );
1281 }
1282
1283 /*********************************************************************
1284  *                  wcscpy           (CRTDLL.507)
1285  */
1286 LPWSTR __cdecl CRTDLL_wcscpy( LPWSTR s1, LPCWSTR s2 )
1287 {
1288     return lstrcpy32W( s1, s2 );
1289 }
1290
1291 /*********************************************************************
1292  *                  wcscspn           (CRTDLL.508)
1293  */
1294 INT32 __cdecl CRTDLL_wcscspn(LPWSTR str,LPWSTR reject)
1295 {
1296         LPWSTR  s,t;
1297
1298         s=str;
1299         do {
1300                 t=reject;
1301                 while (*t) { if (*t==*s) break;t++;}
1302                 if (*t) break;
1303                 s++;
1304         } while (*s);
1305         return s-str; /* nr of wchars */
1306 }
1307
1308 /*********************************************************************
1309  *                  wcslen           (CRTDLL.510)
1310  */
1311 INT32 __cdecl CRTDLL_wcslen( LPCWSTR s )
1312 {
1313     return lstrlen32W( s );
1314 }
1315
1316 /*********************************************************************
1317  *                  wcsncat           (CRTDLL.511)
1318  */
1319 LPWSTR __cdecl CRTDLL_wcsncat( LPWSTR s1, LPCWSTR s2, INT32 n )
1320 {
1321     return lstrcatn32W( s1, s2, n );
1322 }
1323
1324 /*********************************************************************
1325  *                  wcsncmp           (CRTDLL.512)
1326  */
1327 INT32 __cdecl CRTDLL_wcsncmp( LPCWSTR s1, LPCWSTR s2, INT32 n )
1328 {
1329     return lstrncmp32W( s1, s2, n );
1330 }
1331
1332 /*********************************************************************
1333  *                  wcsncpy           (CRTDLL.513)
1334  */
1335 LPWSTR __cdecl CRTDLL_wcsncpy( LPWSTR s1, LPCWSTR s2, INT32 n )
1336 {
1337     return lstrcpyn32W( s1, s2, n );
1338 }
1339
1340 /*********************************************************************
1341  *                  wcsspn           (CRTDLL.516)
1342  */
1343 INT32 __cdecl CRTDLL_wcsspn(LPWSTR str,LPWSTR accept)
1344 {
1345         LPWSTR  s,t;
1346
1347         s=str;
1348         do {
1349                 t=accept;
1350                 while (*t) { if (*t==*s) break;t++;}
1351                 if (!*t) break;
1352                 s++;
1353         } while (*s);
1354         return s-str; /* nr of wchars */
1355 }
1356
1357 /*********************************************************************
1358  *                  _wcsicmp           (CRTDLL.321)
1359  */
1360 DWORD __cdecl CRTDLL__wcsicmp( LPCWSTR s1, LPCWSTR s2 )
1361 {
1362     return lstrcmpi32W( s1, s2 );
1363 }
1364
1365 /*********************************************************************
1366  *                  _wcsicoll           (CRTDLL.322)
1367  */
1368 DWORD __cdecl CRTDLL__wcsicoll(LPCWSTR a1,LPCWSTR a2)
1369 {
1370     /* FIXME: handle collates */
1371     return lstrcmpi32W(a1,a2);
1372 }
1373
1374 /*********************************************************************
1375  *                  _wcsnicmp           (CRTDLL.324)
1376  */
1377 DWORD __cdecl CRTDLL__wcsnicmp( LPCWSTR s1, LPCWSTR s2, INT32 len )
1378 {
1379     return lstrncmpi32W( s1, s2, len );
1380 }
1381
1382 /*********************************************************************
1383  *                  wcscoll           (CRTDLL.506)
1384  */
1385 DWORD __cdecl CRTDLL_wcscoll(LPWSTR a1,LPWSTR a2)
1386 {
1387     /* FIXME: handle collates */
1388     return lstrcmp32W(a1,a2);
1389 }
1390
1391 /*********************************************************************
1392  *                  _wcsrev           (CRTDLL.326)
1393  */
1394 VOID __cdecl CRTDLL__wcsrev(LPWSTR s) {
1395         LPWSTR  e;
1396
1397         e=s;
1398         while (*e)
1399                 e++;
1400         while (s<e) {
1401                 WCHAR   a;
1402
1403                 a=*s;*s=*e;*e=a;
1404                 s++;e--;
1405         }
1406 }
1407
1408 /*********************************************************************
1409  *                  wcsstr           (CRTDLL.517)
1410  */
1411 LPWSTR __cdecl CRTDLL_wcsstr(LPWSTR s,LPWSTR b)
1412 {
1413         LPWSTR  x,y,c;
1414
1415         x=s;
1416         while (*x) {
1417                 if (*x==*b) {
1418                         y=x;c=b;
1419                         while (*y && *c && *y==*c) { c++;y++; }
1420                         if (!*c)
1421                                 return x;
1422                 }
1423                 x++;
1424         }
1425         return NULL;
1426 }
1427
1428 /*********************************************************************
1429  *                  wcstombs   (CRTDLL.521)
1430  */
1431 INT32 __cdecl CRTDLL_wcstombs( LPSTR dst, LPCWSTR src, INT32 len )
1432 {
1433     lstrcpynWtoA( dst, src, len );
1434     return strlen(dst);  /* FIXME: is this right? */
1435 }
1436
1437 /*********************************************************************
1438  *                  wcsrchr           (CRTDLL.515)
1439  */
1440 LPWSTR __cdecl CRTDLL_wcsrchr(LPWSTR str,WCHAR xchar)
1441 {
1442         LPWSTR  s;
1443
1444         s=str+lstrlen32W(str);
1445         do {
1446                 if (*s==xchar)
1447                         return s;
1448                 s--;
1449         } while (s>=str);
1450         return NULL;
1451 }
1452
1453 /*********************************************************************
1454  *                  _setmode           (CRTDLL.265)
1455  * FIXME: At present we ignore the request to translate CR/LF to LF.
1456  *
1457  * We allways translate when we read with fgets, we never do with fread
1458  *
1459  */
1460 INT32 __cdecl CRTDLL__setmode( INT32 fh,INT32 mode)
1461 {
1462         /* FIXME */
1463 #define O_TEXT     0x4000
1464 #define O_BINARY   0x8000
1465
1466         FIXME(crtdll, "on fhandle %d mode %s, STUB.\n",
1467                       fh,(mode=O_TEXT)?"O_TEXT":
1468                       (mode=O_BINARY)?"O_BINARY":"UNKNOWN");
1469         return -1;
1470 }
1471
1472 /*********************************************************************
1473  *                  _fpreset           (CRTDLL.107)
1474  */
1475 VOID __cdecl CRTDLL__fpreset(void)
1476 {
1477        FIXME(crtdll," STUB.\n");
1478 }
1479
1480 /*********************************************************************
1481  *                  atexit           (CRTDLL.345)
1482  */
1483 INT32 __cdecl CRTDLL_atexit(LPVOID x)
1484 {
1485         FIXME(crtdll,"(%p), STUB.\n",x);
1486         return 0; /* successful */
1487 }
1488
1489 /*********************************************************************
1490  *                  mblen          (CRTDLL.428)
1491  * FIXME: check multibyte support
1492  */
1493 WCHAR  __cdecl CRTDLL_mblen(CHAR *mb,INT32 size)
1494 {
1495
1496     int ret=1;
1497
1498     if (!mb)
1499       ret = 0;
1500     else if ((size<1)||(!*(mb+1)))
1501       ret = -1;
1502     else if (!(*mb))
1503       ret =0;
1504
1505     TRACE(crtdll,"CRTDLL_mlen %s for max %d bytes ret %d\n",mb,size,ret);
1506
1507     return ret;
1508 }
1509
1510 /*********************************************************************
1511  *                  mbstowcs           (CRTDLL.429)
1512  * FIXME: check multibyte support
1513  */
1514 INT32 __cdecl CRTDLL_mbstowcs(LPWSTR wcs, LPCSTR mbs, INT32 size)
1515 {
1516
1517 /* Slightly modified lstrcpynAtoW functions from memory/strings.c
1518  *  We need the number of characters transfered
1519  *  FIXME: No multibyte support yet
1520  */
1521
1522     LPWSTR p = wcs;
1523     LPCSTR src= mbs;
1524     int ret, n=size;
1525
1526     while ((n-- > 0) && *src) {
1527       *p++ = (WCHAR)(unsigned char)*src++;
1528         }
1529     p++;
1530     ret = (p -wcs);
1531
1532     TRACE(crtdll,"CRTDLL_mbstowcs %s for %d chars put %d wchars\n",
1533                    mbs,size,ret);
1534     return ret;
1535 }
1536
1537 /*********************************************************************
1538  *                  mbtowc           (CRTDLL.430)
1539  * FIXME: check multibyte support
1540  */
1541 WCHAR __cdecl CRTDLL_mbtowc(WCHAR* wc,CHAR* mb,INT32 size)
1542 {
1543    int ret;
1544
1545    if (!mb)
1546      ret = 0;
1547    else if (!wc)
1548      ret =-1;
1549    else
1550      if ( (ret = mblen(mb,size)) != -1 )
1551        {
1552          if (ret <= sizeof(char))
1553            *wc = (WCHAR) ((unsigned char)*mb);
1554         else
1555         ret=   -1;
1556         }
1557      else
1558        ret = -1;
1559
1560    TRACE(crtdll,"CRTDLL_mbtowc %s for %d chars\n",mb,size);
1561
1562    return ret;
1563 }
1564
1565 /*********************************************************************
1566  *                  _isctype           (CRTDLL.138)
1567  */
1568 BOOL32 __cdecl CRTDLL__isctype(CHAR x,CHAR type)
1569 {
1570         if ((type & CRTDLL_SPACE) && isspace(x))
1571                 return TRUE;
1572         if ((type & CRTDLL_PUNCT) && ispunct(x))
1573                 return TRUE;
1574         if ((type & CRTDLL_LOWER) && islower(x))
1575                 return TRUE;
1576         if ((type & CRTDLL_UPPER) && isupper(x))
1577                 return TRUE;
1578         if ((type & CRTDLL_ALPHA) && isalpha(x))
1579                 return TRUE;
1580         if ((type & CRTDLL_DIGIT) && isdigit(x))
1581                 return TRUE;
1582         if ((type & CRTDLL_CONTROL) && iscntrl(x))
1583                 return TRUE;
1584         /* check CRTDLL_LEADBYTE */
1585         return FALSE;
1586 }
1587
1588 /*********************************************************************
1589  *                  _chdrive           (CRTDLL.52)
1590  *
1591  *  newdir      [I] drive to change to, A=1
1592  *
1593  */
1594 BOOL32 __cdecl CRTDLL__chdrive(INT32 newdrive)
1595 {
1596         /* FIXME: generates errnos */
1597         return DRIVE_SetCurrentDrive(newdrive-1);
1598 }
1599
1600 /*********************************************************************
1601  *                  _chdir           (CRTDLL.51)
1602  */
1603 INT32 __cdecl CRTDLL__chdir(LPCSTR newdir)
1604 {
1605         if (!SetCurrentDirectory32A(newdir))
1606                 return 1;
1607         return 0;
1608 }
1609
1610 /*********************************************************************
1611  *                  _fullpath           (CRTDLL.114)
1612  */
1613 LPSTR __cdecl CRTDLL__fullpath(LPSTR buf, LPCSTR name, INT32 size)
1614 {
1615   DOS_FULL_NAME full_name;
1616
1617   if (!buf)
1618   {
1619       size = 256;
1620       if(!(buf = CRTDLL_malloc(size))) return NULL;
1621   }
1622   if (!DOSFS_GetFullName( name, FALSE, &full_name )) return NULL;
1623   lstrcpyn32A(buf,full_name.short_name,size);
1624   TRACE(crtdll,"CRTDLL_fullpath got %s\n",buf);
1625   return buf;
1626 }
1627
1628 /*********************************************************************
1629  *                  _splitpath           (CRTDLL.279)
1630  */
1631 VOID __cdecl CRTDLL__splitpath(LPCSTR path, LPSTR drive, LPSTR directory, LPSTR filename, LPSTR extension )
1632 {
1633   /* drive includes :
1634      directory includes leading and trailing (forward and backward slashes)
1635      filename without dot and slashes
1636      extension with leading dot
1637      */
1638   char * drivechar,*dirchar,*namechar;
1639
1640   TRACE(crtdll,"CRTDLL__splitpath got %s\n",path);
1641
1642   drivechar  = strchr(path,':');
1643   dirchar    = strrchr(path,'/');
1644   namechar   = strrchr(path,'\\');
1645   dirchar = MAX(dirchar,namechar);
1646   if (dirchar)
1647     namechar   = strrchr(dirchar,'.');
1648   else
1649     namechar   = strrchr(path,'.');
1650
1651
1652   if (drive)
1653     {
1654       *drive = 0x00;
1655       if (drivechar)
1656         {
1657           strncat(drive,path,drivechar-path+1);
1658           path = drivechar+1;
1659         }
1660     }
1661   if (directory)
1662     {
1663       *directory = 0x00;
1664       if (dirchar)
1665         {
1666           strncat(directory,path,dirchar-path+1);
1667           path = dirchar+1;
1668         }
1669     }
1670   if (filename)
1671     {
1672       *filename = 0x00;
1673       if (namechar)
1674         {
1675           strncat(filename,path,namechar-path);
1676           if (extension)
1677             {
1678               *extension = 0x00;
1679               strcat(extension,namechar);
1680             }
1681         }
1682     }
1683
1684   TRACE(crtdll,"CRTDLL__splitpath found %s %s %s %s\n",drive,directory,filename,extension);
1685
1686 }
1687
1688 /*********************************************************************
1689  *                  _getcwd           (CRTDLL.120)
1690  */
1691 CHAR* __cdecl CRTDLL__getcwd(LPSTR buf, INT32 size)
1692 {
1693   char test[1];
1694   int len;
1695
1696   len = size;
1697   if (!buf) {
1698     if (size < 0) /* allocate as big as nescessary */
1699       len =GetCurrentDirectory32A(1,test) + 1;
1700     if(!(buf = CRTDLL_malloc(len)))
1701     {
1702         /* set error to OutOfRange */
1703         return( NULL );
1704     }
1705   }
1706   size = len;
1707   if(!(len =GetCurrentDirectory32A(len,buf)))
1708     {
1709       return NULL;
1710     }
1711   if (len > size)
1712     {
1713       /* set error to ERANGE */
1714       TRACE(crtdll,"CRTDLL_getcwd buffer to small\n");
1715       return NULL;
1716     }
1717   return buf;
1718
1719 }
1720
1721 /*********************************************************************
1722  *                  _getdcwd           (CRTDLL.121)
1723  */
1724 CHAR* __cdecl CRTDLL__getdcwd(INT32 drive,LPSTR buf, INT32 size)
1725 {
1726   char test[1];
1727   int len;
1728
1729   FIXME(crtdll,"(\"%c:\",%s,%d)\n",drive+'A',buf,size);
1730   len = size;
1731   if (!buf) {
1732     if (size < 0) /* allocate as big as nescessary */
1733       len =GetCurrentDirectory32A(1,test) + 1;
1734     if(!(buf = CRTDLL_malloc(len)))
1735     {
1736         /* set error to OutOfRange */
1737         return( NULL );
1738     }
1739   }
1740   size = len;
1741   if(!(len =GetCurrentDirectory32A(len,buf)))
1742     {
1743       return NULL;
1744     }
1745   if (len > size)
1746     {
1747       /* set error to ERANGE */
1748       TRACE(crtdll,"buffer to small\n");
1749       return NULL;
1750     }
1751   return buf;
1752
1753 }
1754
1755 /*********************************************************************
1756  *                  _getdrive           (CRTDLL.124)
1757  *
1758  *  Return current drive, 1 for A, 2 for B
1759  */
1760 INT32 __cdecl CRTDLL__getdrive(VOID)
1761 {
1762     return DRIVE_GetCurrentDrive() + 1;
1763 }
1764
1765 /*********************************************************************
1766  *                  _mkdir           (CRTDLL.234)
1767  */
1768 INT32 __cdecl CRTDLL__mkdir(LPCSTR newdir)
1769 {
1770         if (!CreateDirectory32A(newdir,NULL))
1771                 return -1;
1772         return 0;
1773 }
1774
1775 /*********************************************************************
1776  *                  remove           (CRTDLL.448)
1777  */
1778 INT32 __cdecl CRTDLL_remove(LPCSTR file)
1779 {
1780         if (!DeleteFile32A(file))
1781                 return -1;
1782         return 0;
1783 }
1784
1785 /*********************************************************************
1786  *                  _errno           (CRTDLL.52)
1787  * Yes, this is a function.
1788  */
1789 LPINT32 __cdecl CRTDLL__errno()
1790 {
1791         static  int crtdllerrno;
1792
1793         /* FIXME: we should set the error at the failing function call time */
1794         crtdllerrno = LastErrorToErrno(GetLastError());
1795         return &crtdllerrno;
1796 }
1797
1798 /*********************************************************************
1799  *                  _tempnam           (CRTDLL.305)
1800  *
1801  */
1802 LPSTR __cdecl CRTDLL__tempnam(LPCSTR dir, LPCSTR prefix)
1803 {
1804
1805      char *ret;
1806      DOS_FULL_NAME tempname;
1807
1808      if ((ret = tempnam(dir,prefix))==NULL) {
1809        WARN(crtdll, "Unable to get unique filename\n");
1810        return NULL;
1811      }
1812      if (!DOSFS_GetFullName(ret,FALSE,&tempname))
1813      {
1814        TRACE(crtdll, "Wrong path?\n");
1815        return NULL;
1816      }
1817      free(ret);
1818      if ((ret = CRTDLL_malloc(strlen(tempname.short_name)+1)) == NULL) {
1819          WARN(crtdll, "CRTDL_malloc for shortname failed\n");
1820          return NULL;
1821      }
1822      if ((ret = strcpy(ret,tempname.short_name)) == NULL) {
1823        WARN(crtdll, "Malloc for shortname failed\n");
1824        return NULL;
1825      }
1826
1827      TRACE(crtdll,"dir %s prefix %s got %s\n",
1828                     dir,prefix,ret);
1829      return ret;
1830
1831 }
1832 /*********************************************************************
1833  *                  tmpnam           (CRTDLL.490)
1834  *
1835  * lcclnk from lcc-win32 relies on a terminating dot in the name returned
1836  *
1837  */
1838 LPSTR __cdecl CRTDLL_tmpnam(LPSTR s)
1839 {
1840      char *ret;
1841
1842      if ((ret =tmpnam(s))== NULL) {
1843        WARN(crtdll, "Unable to get unique filename\n");
1844        return NULL;
1845      }
1846      if (!DOSFS_GetFullName(ret,FALSE,&CRTDLL_tmpname))
1847      {
1848        TRACE(crtdll, "Wrong path?\n");
1849        return NULL;
1850      }
1851      strcat(CRTDLL_tmpname.short_name,".");
1852      TRACE(crtdll,"for buf %p got %s\n",
1853                     s,CRTDLL_tmpname.short_name);
1854      TRACE(crtdll,"long got %s\n",
1855                     CRTDLL_tmpname.long_name);
1856      if ( s != NULL)
1857        return strcpy(s,CRTDLL_tmpname.short_name);
1858      else
1859        return CRTDLL_tmpname.short_name;
1860
1861 }
1862
1863 /*********************************************************************
1864  *                  _itoa           (CRTDLL.165)
1865  */
1866 LPSTR  __cdecl CRTDLL__itoa(INT32 x,LPSTR buf,INT32 buflen)
1867 {
1868     wsnprintf32A(buf,buflen,"%d",x);
1869     return buf;
1870 }
1871
1872 /*********************************************************************
1873  *                  _ltoa           (CRTDLL.180)
1874  */
1875 LPSTR  __cdecl CRTDLL__ltoa(long x,LPSTR buf,INT32 radix)
1876 {
1877     switch(radix) {
1878         case  2: FIXME(crtdll, "binary format not implemented !\n");
1879                  break;
1880         case  8: wsnprintf32A(buf,0x80,"%o",x);
1881                  break;
1882         case 10: wsnprintf32A(buf,0x80,"%d",x);
1883                  break;
1884         case 16: wsnprintf32A(buf,0x80,"%x",x);
1885                  break;
1886         default: FIXME(crtdll, "radix %d not implemented !\n", radix);
1887     }
1888     return buf;
1889 }
1890
1891 /*********************************************************************
1892  *                  _ultoa           (CRTDLL.311)
1893  */
1894 LPSTR  __cdecl CRTDLL__ultoa(long x,LPSTR buf,INT32 radix)
1895 {
1896     switch(radix) {
1897         case  2: FIXME(crtdll, "binary format not implemented !\n");
1898                  break;
1899         case  8: wsnprintf32A(buf,0x80,"%lo",x);
1900                  break;
1901         case 10: wsnprintf32A(buf,0x80,"%ld",x);
1902                  break;
1903         case 16: wsnprintf32A(buf,0x80,"%lx",x);
1904                  break;
1905         default: FIXME(crtdll, "radix %d not implemented !\n", radix);
1906     }
1907     return buf;
1908 }
1909
1910 typedef VOID (*sig_handler_type)(VOID);
1911
1912 /*********************************************************************
1913  *                  signal           (CRTDLL.455)
1914  */
1915 VOID __cdecl CRTDLL_signal(int sig, sig_handler_type ptr)
1916 {
1917     FIXME(crtdll, "(%d %p):stub.\n", sig, ptr);
1918 }
1919
1920 /*********************************************************************
1921  *                  _ftol           (CRTDLL.113)
1922  */
1923 LONG __cdecl CRTDLL__ftol(double fl) {
1924         return (LONG)fl;
1925 }
1926 /*********************************************************************
1927  *                  _sleep           (CRTDLL.267)
1928  */
1929 VOID __cdecl CRTDLL__sleep(unsigned long timeout)
1930 {
1931   TRACE(crtdll,"CRTDLL__sleep for %ld milliseconds\n",timeout);
1932   Sleep((timeout)?timeout:1);
1933 }
1934
1935 /*********************************************************************
1936  *                  getenv           (CRTDLL.437)
1937  */
1938 LPSTR __cdecl CRTDLL_getenv(const char *name)
1939 {
1940      LPSTR environ = GetEnvironmentStrings32A();
1941      LPSTR pp,pos = NULL;
1942      unsigned int length;
1943
1944      for (pp = environ; (*pp); pp = pp + strlen(pp) +1)
1945        {
1946          pos =strchr(pp,'=');
1947          if (pos)
1948            length = pos -pp;
1949          else
1950            length = strlen(pp);
1951          if (!strncmp(pp,name,length)) break;
1952        }
1953      if ((pp)&& (pos))
1954        {
1955          pp = pos+1;
1956          TRACE(crtdll,"got %s\n",pp);
1957        }
1958      FreeEnvironmentStrings32A( environ );
1959      return pp;
1960 }
1961
1962 /*********************************************************************
1963  *                  _mbsrchr           (CRTDLL.223)
1964  */
1965 LPSTR __cdecl CRTDLL__mbsrchr(LPSTR s,CHAR x) {
1966         /* FIXME: handle multibyte strings */
1967         return strrchr(s,x);
1968 }
1969
1970 /*********************************************************************
1971  *                  _memicmp           (CRTDLL.233)(NTDLL.868)
1972  * A stringcompare, without \0 check
1973  * RETURNS
1974  *      -1:if first string is alphabetically before second string
1975  *      1:if second ''    ''      ''          ''   first   ''
1976  *      0:if both are equal.
1977  */
1978 INT32 __cdecl CRTDLL__memicmp(
1979         LPCSTR s1,      /* [in] first string */
1980         LPCSTR s2,      /* [in] second string */
1981         DWORD len       /* [in] length to compare */
1982 ) {
1983         int     i;
1984
1985         for (i=0;i<len;i++) {
1986                 if (tolower(s1[i])<tolower(s2[i]))
1987                         return -1;
1988                 if (tolower(s1[i])>tolower(s2[i]))
1989                         return  1;
1990         }
1991         return 0;
1992 }
1993 /*********************************************************************
1994  *                  __dllonexit           (CRTDLL.25)
1995  */
1996 VOID __cdecl CRTDLL__dllonexit ()
1997 {
1998         FIXME(crtdll,"stub\n");
1999 }
2000
2001 /*********************************************************************
2002  *                  wcstok           (CRTDLL.519)
2003  * Like strtok, but for wide character strings. s is modified, yes.
2004  */
2005 LPWSTR CRTDLL_wcstok(LPWSTR s,LPCWSTR delim) {
2006         static LPWSTR nexttok = NULL;
2007         LPWSTR  x,ret;
2008
2009         if (!s)
2010                 s = nexttok;
2011         if (!s)
2012                 return NULL;
2013         x = s;
2014         while (*x && !CRTDLL_wcschr(delim,*x))
2015                 x++;
2016         ret = nexttok;
2017         if (*x) {
2018                 *x='\0';
2019                 nexttok = x+1;
2020         } else
2021                 nexttok = NULL;
2022         return ret;
2023 }
2024
2025 /*********************************************************************
2026  *                  wcstol           (CRTDLL.520)
2027  * Like strtol, but for wide character strings.
2028  */
2029 INT32 CRTDLL_wcstol(LPWSTR s,LPWSTR *end,INT32 base) {
2030         LPSTR   sA = HEAP_strdupWtoA(GetProcessHeap(),0,s),endA;
2031         INT32   ret = strtol(sA,&endA,base);
2032
2033         HeapFree(GetProcessHeap(),0,sA);
2034         if (end) *end = s+(endA-sA); /* pointer magic checked. */
2035         return ret;
2036 }
2037 /*********************************************************************
2038  *                  strdate           (CRTDLL.283)
2039  */
2040 LPSTR __cdecl CRTDLL__strdate (LPSTR date)
2041 {       FIXME (crtdll,"%p stub\n", date);
2042         return 0;
2043 }
2044
2045 /*********************************************************************
2046  *                  strtime           (CRTDLL.299)
2047  */
2048 LPSTR __cdecl CRTDLL__strtime (LPSTR date)
2049 {       FIXME (crtdll,"%p stub\n", date);
2050         return 0;
2051 }