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