git.oblomov.eu Git - wine/blob - dlls/msvcrt/file.c

   1 /*
   2  * msvcrt.dll file functions
   3  *
   4  * Copyright 1996,1998 Marcus Meissner
   5  * Copyright 1996 Jukka Iivonen
   6  * Copyright 1997,2000 Uwe Bonnes
   7  * Copyright 2000 Jon Griffiths
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <time.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winreg.h"
  37 #include "winternl.h"
  38 #include "msvcrt.h"
  39 #include "msvcrt/errno.h"
  40
  41 #include "wine/unicode.h"
  42 #include "msvcrt/fcntl.h"
  43 #include "msvcrt/io.h"
  44 #include "msvcrt/sys/locking.h"
  45 #include "msvcrt/stdio.h"
  46 #include "msvcrt/stdlib.h"
  47 #include "msvcrt/string.h"
  48 #include "msvcrt/sys/stat.h"
  49 #include "msvcrt/sys/utime.h"
  50 #include "msvcrt/time.h"
  51 #include "msvcrt/share.h"
  52 #include "msvcrt/wctype.h"
  53 #include "msvcrt/direct.h"
  54
  55 #include "wine/debug.h"
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  58
  59 /* for stat mode, permissions apply to all,owner and group */
  60 #define MSVCRT_S_IREAD  (_S_IREAD  | (_S_IREAD  >> 3) | (_S_IREAD  >> 6))
  61 #define MSVCRT_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
  62 #define MSVCRT_S_IEXEC  (_S_IEXEC  | (_S_IEXEC  >> 3) | (_S_IEXEC  >> 6))
  63
  64 /* _access() bit flags FIXME: incomplete */
  65 #define MSVCRT_W_OK      0x02
  66
  67
  68 /* FIXME: Make this dynamic */
  69 #define MSVCRT_MAX_FILES 257
  70
  71 HANDLE MSVCRT_handles[MSVCRT_MAX_FILES];
  72 MSVCRT_FILE* MSVCRT_files[MSVCRT_MAX_FILES];
  73 int  MSVCRT_flags[MSVCRT_MAX_FILES];
  74 char *MSVCRT_tempfiles[MSVCRT_MAX_FILES];
  75 MSVCRT_FILE MSVCRT__iob[3];
  76
  77 static int MSVCRT_fdstart = 3; /* first unallocated fd */
  78 static int MSVCRT_fdend = 3; /* highest allocated fd */
  79
  80 /* INTERNAL: process umask */
  81 static int MSVCRT_umask = 0;
  82
  83 /* INTERNAL: Static buffer for temp file name */
  84 static char MSVCRT_tmpname[MAX_PATH];
  85
  86 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
  87 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
  88 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
  89 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
  90
  91 #define TOUL(x) (ULONGLONG)(x)
  92 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
  93 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
  94 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
  95 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
  96
  97 extern CRITICAL_SECTION MSVCRT_file_cs;
  98 #define LOCK_FILES     EnterCriticalSection(&MSVCRT_file_cs)
  99 #define UNLOCK_FILES   LeaveCriticalSection(&MSVCRT_file_cs)
 100
 101 static void msvcrt_cp_from_stati64(const struct MSVCRT__stati64 *bufi64, struct MSVCRT__stat *buf)
 102 {
 103     buf->st_dev   = bufi64->st_dev;
 104     buf->st_ino   = bufi64->st_ino;
 105     buf->st_mode  = bufi64->st_mode;
 106     buf->st_nlink = bufi64->st_nlink;
 107     buf->st_uid   = bufi64->st_uid;
 108     buf->st_gid   = bufi64->st_gid;
 109     buf->st_rdev  = bufi64->st_rdev;
 110     buf->st_size  = bufi64->st_size;
 111     buf->st_atime = bufi64->st_atime;
 112     buf->st_mtime = bufi64->st_mtime;
 113     buf->st_ctime = bufi64->st_ctime;
 114 }
 115
 116 /* INTERNAL: Get the HANDLE for a fd */
 117 static HANDLE msvcrt_fdtoh(int fd)
 118 {
 119   if (fd < 0 || fd >= MSVCRT_fdend ||
 120       MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
 121   {
 122     WARN(":fd (%d) - no handle!\n",fd);
 123     *MSVCRT___doserrno() = 0;
 124     *MSVCRT__errno() = MSVCRT_EBADF;
 125    return INVALID_HANDLE_VALUE;
 126   }
 127   return MSVCRT_handles[fd];
 128 }
 129
 130 /* INTERNAL: free a file entry fd */
 131 static void msvcrt_free_fd(int fd)
 132 {
 133   MSVCRT_handles[fd] = INVALID_HANDLE_VALUE;
 134   MSVCRT_files[fd] = 0;
 135   MSVCRT_flags[fd] = 0;
 136   TRACE(":fd (%d) freed\n",fd);
 137   if (fd < 3)
 138     return; /* don't use 0,1,2 for user files */
 139   if (fd == MSVCRT_fdend - 1)
 140     MSVCRT_fdend--;
 141   if (fd < MSVCRT_fdstart)
 142     MSVCRT_fdstart = fd;
 143 }
 144
 145 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
 146 static int msvcrt_alloc_fd(HANDLE hand, int flag)
 147 {
 148   int fd = MSVCRT_fdstart;
 149
 150   TRACE(":handle (%p) allocating fd (%d)\n",hand,fd);
 151   if (fd >= MSVCRT_MAX_FILES)
 152   {
 153     WARN(":files exhausted!\n");
 154     return -1;
 155   }
 156   MSVCRT_handles[fd] = hand;
 157   MSVCRT_flags[fd] = flag;
 158
 159   /* locate next free slot */
 160   if (fd == MSVCRT_fdend)
 161     MSVCRT_fdstart = ++MSVCRT_fdend;
 162   else
 163     while(MSVCRT_fdstart < MSVCRT_fdend &&
 164           MSVCRT_handles[MSVCRT_fdstart] != INVALID_HANDLE_VALUE)
 165       MSVCRT_fdstart++;
 166
 167   return fd;
 168 }
 169
 170 /* INTERNAL: Allocate a FILE* for an fd slot
 171  * This is done lazily to avoid memory wastage for low level open/write
 172  * usage when a FILE* is not requested (but may be later).
 173  */
 174 static MSVCRT_FILE* msvcrt_alloc_fp(int fd)
 175 {
 176   TRACE(":fd (%d) allocating FILE*\n",fd);
 177   if (fd < 0 || fd >= MSVCRT_fdend ||
 178       MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
 179   {
 180     WARN(":invalid fd %d\n",fd);
 181     *MSVCRT___doserrno() = 0;
 182     *MSVCRT__errno() = MSVCRT_EBADF;
 183     return NULL;
 184   }
 185   if (!MSVCRT_files[fd])
 186   {
 187     if ((MSVCRT_files[fd] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
 188     {
 189       MSVCRT_files[fd]->_file = fd;
 190       MSVCRT_files[fd]->_flag = MSVCRT_flags[fd];
 191       MSVCRT_files[fd]->_flag &= ~MSVCRT__IOAPPEND; /* mask out, see above */
 192     }
 193   }
 194   TRACE(":got FILE* (%p)\n",MSVCRT_files[fd]);
 195   return MSVCRT_files[fd];
 196 }
 197
 198
 199 /* INTERNAL: Set up stdin, stderr and stdout */
 200 void msvcrt_init_io(void)
 201 {
 202   int i;
 203   memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
 204   DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
 205     GetCurrentProcess(), &MSVCRT_handles[0], 0, FALSE, DUPLICATE_SAME_ACCESS);
 206   MSVCRT_flags[0] = MSVCRT__iob[0]._flag = MSVCRT__IOREAD;
 207   DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
 208     GetCurrentProcess(), &MSVCRT_handles[1], 0, FALSE, DUPLICATE_SAME_ACCESS);
 209   MSVCRT_flags[1] = MSVCRT__iob[1]._flag = MSVCRT__IOWRT;
 210   DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
 211     GetCurrentProcess(), &MSVCRT_handles[2], 0, FALSE, DUPLICATE_SAME_ACCESS);
 212   MSVCRT_flags[2] = MSVCRT__iob[2]._flag = MSVCRT__IOWRT;
 213
 214   TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_handles[0],
 215         MSVCRT_handles[1],MSVCRT_handles[2]);
 216
 217   for (i = 0; i < 3; i++)
 218   {
 219     /* FILE structs for stdin/out/err are static and never deleted */
 220     MSVCRT_files[i] = &MSVCRT__iob[i];
 221     MSVCRT__iob[i]._file = i;
 222     MSVCRT_tempfiles[i] = NULL;
 223   }
 224 }
 225
 226 /* INTERNAL: Flush stdio file buffer */
 227 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
 228 {
 229   if(file->_bufsiz) {
 230         int cnt=file->_ptr-file->_base;
 231         if(cnt>0 && _write(file->_file, file->_base, cnt) != cnt) {
 232                 return MSVCRT_EOF;
 233         }
 234         file->_ptr=file->_base;
 235         file->_cnt=file->_bufsiz;
 236   }
 237   return 0;
 238 }
 239
 240 /* INTERNAL: Allocate stdio file buffer */
 241 static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
 242 {
 243         file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
 244         if(file->_base) {
 245                 file->_bufsiz = MSVCRT_BUFSIZ;
 246                 file->_flag |= MSVCRT__IOMYBUF;
 247         } else {
 248                 file->_base = (unsigned char *)(&file->_charbuf);
 249                 /* put here 2 ??? */
 250                 file->_bufsiz = sizeof(file->_charbuf);
 251         }
 252         file->_ptr = file->_base;
 253         file->_cnt = 0;
 254 }
 255
 256 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
 257 static void msvcrt_int_to_base32(int num, char *str)
 258 {
 259   char *p;
 260   int n = num;
 261   int digits = 0;
 262
 263   while (n != 0)
 264   {
 265     n >>= 5;
 266     digits++;
 267   }
 268   p = str + digits;
 269   *p = 0;
 270   while (--p >= str)
 271   {
 272     *p = (num & 31) + '0';
 273     if (*p > '9')
 274       *p += ('a' - '0' - 10);
 275     num >>= 5;
 276   }
 277 }
 278
 279 /*********************************************************************
 280  *              __p__iob(MSVCRT.@)
 281  */
 282 MSVCRT_FILE *__p__iob(void)
 283 {
 284  return &MSVCRT__iob[0];
 285 }
 286
 287 /*********************************************************************
 288  *              _access (MSVCRT.@)
 289  */
 290 int _access(const char *filename, int mode)
 291 {
 292   DWORD attr = GetFileAttributesA(filename);
 293
 294   TRACE("(%s,%d) %ld\n",filename,mode,attr);
 295
 296   if (!filename || attr == INVALID_FILE_ATTRIBUTES)
 297   {
 298     MSVCRT__set_errno(GetLastError());
 299     return -1;
 300   }
 301   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
 302   {
 303     MSVCRT__set_errno(ERROR_ACCESS_DENIED);
 304     return -1;
 305   }
 306   return 0;
 307 }
 308
 309 /*********************************************************************
 310  *              _waccess (MSVCRT.@)
 311  */
 312 int _waccess(const MSVCRT_wchar_t *filename, int mode)
 313 {
 314   DWORD attr = GetFileAttributesW(filename);
 315
 316   TRACE("(%s,%d) %ld\n",debugstr_w(filename),mode,attr);
 317
 318   if (!filename || attr == INVALID_FILE_ATTRIBUTES)
 319   {
 320     MSVCRT__set_errno(GetLastError());
 321     return -1;
 322   }
 323   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
 324   {
 325     MSVCRT__set_errno(ERROR_ACCESS_DENIED);
 326     return -1;
 327   }
 328   return 0;
 329 }
 330
 331 /*********************************************************************
 332  *              _chmod (MSVCRT.@)
 333  */
 334 int _chmod(const char *path, int flags)
 335 {
 336   DWORD oldFlags = GetFileAttributesA(path);
 337
 338   if (oldFlags != INVALID_FILE_ATTRIBUTES)
 339   {
 340     DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 341       oldFlags | FILE_ATTRIBUTE_READONLY;
 342
 343     if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
 344       return 0;
 345   }
 346   MSVCRT__set_errno(GetLastError());
 347   return -1;
 348 }
 349
 350 /*********************************************************************
 351  *              _wchmod (MSVCRT.@)
 352  */
 353 int _wchmod(const MSVCRT_wchar_t *path, int flags)
 354 {
 355   DWORD oldFlags = GetFileAttributesW(path);
 356
 357   if (oldFlags != INVALID_FILE_ATTRIBUTES)
 358   {
 359     DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 360       oldFlags | FILE_ATTRIBUTE_READONLY;
 361
 362     if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
 363       return 0;
 364   }
 365   MSVCRT__set_errno(GetLastError());
 366   return -1;
 367 }
 368
 369 /*********************************************************************
 370  *              _chsize (MSVCRT.@)
 371  */
 372 int _chsize(int fd, long size)
 373 {
 374     FIXME("(fd=%d, size=%ld): stub\n", fd, size);
 375     return -1;
 376 }
 377
 378 /*********************************************************************
 379  *              _dup (MSVCRT.@)
 380  */
 381 int _dup(int od)
 382 {
 383     FIXME("(od=%d): stub\n", od);
 384     return -1;
 385 }
 386
 387 /*********************************************************************
 388  *              _dup2 (MSVCRT.@)
 389  */
 390 int _dup2(int od, int nd)
 391 {
 392     FIXME("(od=%d, nd=%d): stub\n", od, nd);
 393     return -1;
 394 }
 395
 396 /*********************************************************************
 397  *              _unlink (MSVCRT.@)
 398  */
 399 int _unlink(const char *path)
 400 {
 401   TRACE("(%s)\n",path);
 402   if(DeleteFileA(path))
 403     return 0;
 404   TRACE("failed (%ld)\n",GetLastError());
 405   MSVCRT__set_errno(GetLastError());
 406   return -1;
 407 }
 408
 409 /*********************************************************************
 410  *              _wunlink (MSVCRT.@)
 411  */
 412 int _wunlink(const MSVCRT_wchar_t *path)
 413 {
 414   TRACE("(%s)\n",debugstr_w(path));
 415   if(DeleteFileW(path))
 416     return 0;
 417   TRACE("failed (%ld)\n",GetLastError());
 418   MSVCRT__set_errno(GetLastError());
 419   return -1;
 420 }
 421
 422 /* _flushall calls MSVCRT_fflush which calls _flushall */
 423 int MSVCRT_fflush(MSVCRT_FILE* file);
 424
 425 /*********************************************************************
 426  *              _flushall (MSVCRT.@)
 427  */
 428 int _flushall(void)
 429 {
 430   int i, num_flushed = 0;
 431
 432   for (i = 3; i < MSVCRT_fdend; i++)
 433     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
 434     {
 435 #if 0
 436       /* FIXME: flush, do not commit */
 437       if (_commit(i) == -1)
 438         if (MSVCRT_files[i])
 439           MSVCRT_files[i]->_flag |= MSVCRT__IOERR;
 440 #endif
 441       if(MSVCRT_files[i] && MSVCRT_files[i]->_flag & MSVCRT__IOWRT) {
 442         MSVCRT_fflush(MSVCRT_files[i]);
 443         num_flushed++;
 444       }
 445     }
 446
 447   TRACE(":flushed (%d) handles\n",num_flushed);
 448   return num_flushed;
 449 }
 450
 451 /*********************************************************************
 452  *              fflush (MSVCRT.@)
 453  */
 454 int MSVCRT_fflush(MSVCRT_FILE* file)
 455 {
 456   if(!file) {
 457         _flushall();
 458         return 0;
 459   } else {
 460         int res=msvcrt_flush_buffer(file);
 461         return res;
 462   }
 463 }
 464
 465 /*********************************************************************
 466  *              _close (MSVCRT.@)
 467  */
 468 int _close(int fd)
 469 {
 470   HANDLE hand = msvcrt_fdtoh(fd);
 471
 472   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 473   if (hand == INVALID_HANDLE_VALUE)
 474     return -1;
 475   /* flush stdio buffers */
 476   if(MSVCRT_files[fd]) {
 477         if(MSVCRT_files[fd]->_flag & MSVCRT__IOWRT)
 478                 MSVCRT_fflush(MSVCRT_files[fd]);
 479
 480         if(MSVCRT_files[fd]->_flag & MSVCRT__IOMYBUF)
 481                 MSVCRT_free(MSVCRT_files[fd]->_base);
 482   }
 483
 484   /* Don't free std FILE*'s, they are not dynamic */
 485   if (fd > 2 && MSVCRT_files[fd])
 486     MSVCRT_free(MSVCRT_files[fd]);
 487
 488   msvcrt_free_fd(fd);
 489
 490   if (!CloseHandle(hand))
 491   {
 492     WARN(":failed-last error (%ld)\n",GetLastError());
 493     MSVCRT__set_errno(GetLastError());
 494     return -1;
 495   }
 496   if (MSVCRT_tempfiles[fd])
 497   {
 498     TRACE("deleting temporary file '%s'\n",MSVCRT_tempfiles[fd]);
 499     _unlink(MSVCRT_tempfiles[fd]);
 500     MSVCRT_free(MSVCRT_tempfiles[fd]);
 501     MSVCRT_tempfiles[fd] = NULL;
 502   }
 503
 504   TRACE(":ok\n");
 505   return 0;
 506 }
 507
 508 /*********************************************************************
 509  *              _commit (MSVCRT.@)
 510  */
 511 int _commit(int fd)
 512 {
 513   HANDLE hand = msvcrt_fdtoh(fd);
 514
 515   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 516   if (hand == INVALID_HANDLE_VALUE)
 517     return -1;
 518
 519   if (!FlushFileBuffers(hand))
 520   {
 521     if (GetLastError() == ERROR_INVALID_HANDLE)
 522     {
 523       /* FlushFileBuffers fails for console handles
 524        * so we ignore this error.
 525        */
 526       return 0;
 527     }
 528     TRACE(":failed-last error (%ld)\n",GetLastError());
 529     MSVCRT__set_errno(GetLastError());
 530     return -1;
 531   }
 532   TRACE(":ok\n");
 533   return 0;
 534 }
 535
 536 /*********************************************************************
 537  *              _eof (MSVCRT.@)
 538  */
 539 int _eof(int fd)
 540 {
 541   DWORD curpos,endpos;
 542   HANDLE hand = msvcrt_fdtoh(fd);
 543
 544   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 545
 546   if (hand == INVALID_HANDLE_VALUE)
 547     return -1;
 548
 549   /* If we have a FILE* for this file, the EOF flag
 550    * will be set by the read()/write() functions.
 551    */
 552   if (MSVCRT_files[fd])
 553     return MSVCRT_flags[fd] & MSVCRT__IOEOF;
 554
 555   /* Otherwise we do it the hard way */
 556   curpos = SetFilePointer(hand, 0, NULL, SEEK_CUR);
 557   endpos = SetFilePointer(hand, 0, NULL, FILE_END);
 558
 559   if (curpos == endpos)
 560     return TRUE;
 561
 562   SetFilePointer(hand, curpos, 0, FILE_BEGIN);
 563   return FALSE;
 564 }
 565
 566 /*********************************************************************
 567  *              _fcloseall (MSVCRT.@)
 568  */
 569 int MSVCRT__fcloseall(void)
 570 {
 571   int num_closed = 0, i;
 572
 573   for (i = 3; i < MSVCRT_fdend; i++)
 574     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
 575     {
 576       _close(i);
 577       num_closed++;
 578     }
 579
 580   TRACE(":closed (%d) handles\n",num_closed);
 581   return num_closed;
 582 }
 583
 584 /* free everything on process exit */
 585 void msvcrt_free_io(void)
 586 {
 587     MSVCRT__fcloseall();
 588     _close(0);
 589     _close(1);
 590     _close(2);
 591 }
 592
 593 /*********************************************************************
 594  *              _lseeki64 (MSVCRT.@)
 595  */
 596 __int64 _lseeki64(int fd, __int64 offset, int whence)
 597 {
 598   DWORD ret, hoffset = (DWORD) (offset >> 32);
 599   HANDLE hand = msvcrt_fdtoh(fd);
 600
 601   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 602   if (hand == INVALID_HANDLE_VALUE)
 603     return -1;
 604
 605   if (whence < 0 || whence > 2)
 606   {
 607     *MSVCRT__errno() = MSVCRT_EINVAL;
 608     return -1;
 609   }
 610
 611   TRACE(":fd (%d) to 0x%08lx%08lx pos %s\n",
 612         fd,hoffset,(long)offset,
 613         (whence==SEEK_SET)?"SEEK_SET":
 614         (whence==SEEK_CUR)?"SEEK_CUR":
 615         (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
 616
 617   if (((ret = SetFilePointer(hand, (long)offset, &hoffset,
 618                              whence)) != INVALID_SET_FILE_POINTER) || !GetLastError())
 619   {
 620     if (MSVCRT_files[fd])
 621       MSVCRT_files[fd]->_flag &= ~MSVCRT__IOEOF;
 622     /* FIXME: What if we seek _to_ EOF - is EOF set? */
 623
 624     return ((__int64)hoffset << 32) | ret;
 625   }
 626   TRACE(":error-last error (%ld)\n",GetLastError());
 627   if (MSVCRT_files[fd])
 628     switch(GetLastError())
 629     {
 630     case ERROR_NEGATIVE_SEEK:
 631     case ERROR_SEEK_ON_DEVICE:
 632       MSVCRT__set_errno(GetLastError());
 633       MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
 634       break;
 635     default:
 636       break;
 637     }
 638   return -1;
 639 }
 640
 641 /*********************************************************************
 642  *              _lseek (MSVCRT.@)
 643  */
 644 LONG _lseek(int fd, LONG offset, int whence)
 645 {
 646     return _lseeki64(fd, offset, whence);
 647 }
 648
 649 /*********************************************************************
 650  *              _locking (MSVCRT.@)
 651  *
 652  * This is untested; the underlying LockFile doesn't work yet.
 653  */
 654 int _locking(int fd, int mode, LONG nbytes)
 655 {
 656   BOOL ret;
 657   DWORD cur_locn;
 658   HANDLE hand = msvcrt_fdtoh(fd);
 659
 660   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 661   if (hand == INVALID_HANDLE_VALUE)
 662     return -1;
 663
 664   if (mode < 0 || mode > 4)
 665   {
 666     *MSVCRT__errno() = MSVCRT_EINVAL;
 667     return -1;
 668   }
 669
 670   TRACE(":fd (%d) by 0x%08lx mode %s\n",
 671         fd,nbytes,(mode==_LK_UNLCK)?"_LK_UNLCK":
 672         (mode==_LK_LOCK)?"_LK_LOCK":
 673         (mode==_LK_NBLCK)?"_LK_NBLCK":
 674         (mode==_LK_RLCK)?"_LK_RLCK":
 675         (mode==_LK_NBRLCK)?"_LK_NBRLCK":
 676                           "UNKNOWN");
 677
 678   if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
 679   {
 680     FIXME ("Seek failed\n");
 681     *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
 682     return -1;
 683   }
 684   if (mode == _LK_LOCK || mode == _LK_RLCK)
 685   {
 686     int nretry = 10;
 687     ret = 1; /* just to satisfy gcc */
 688     while (nretry--)
 689     {
 690       ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
 691       if (ret) break;
 692       _sleep (1);
 693     }
 694   }
 695   else if (mode == _LK_UNLCK)
 696     ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
 697   else
 698     ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
 699   /* FIXME - what about error settings? */
 700   return ret ? 0 : -1;
 701 }
 702
 703 /*********************************************************************
 704  *              fseek (MSVCRT.@)
 705  */
 706 int MSVCRT_fseek(MSVCRT_FILE* file, long offset, int whence)
 707 {
 708   /* Flush output if needed */
 709   if(file->_flag & MSVCRT__IOWRT)
 710         msvcrt_flush_buffer(file);
 711
 712   if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
 713         offset -= file->_cnt;
 714   }
 715   /* Discard buffered input */
 716   file->_cnt = 0;
 717   file->_ptr = file->_base;
 718   /* Reset direction of i/o */
 719   if(file->_flag & MSVCRT__IORW) {
 720         file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
 721   }
 722   return (_lseek(file->_file,offset,whence) == -1)?-1:0;
 723 }
 724
 725 /*********************************************************************
 726  *              clearerr (MSVCRT.@)
 727  */
 728 void MSVCRT_clearerr(MSVCRT_FILE* file)
 729 {
 730   TRACE(":file (%p) fd (%d)\n",file,file->_file);
 731   file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
 732 }
 733
 734 /*********************************************************************
 735  *              rewind (MSVCRT.@)
 736  */
 737 void MSVCRT_rewind(MSVCRT_FILE* file)
 738 {
 739   TRACE(":file (%p) fd (%d)\n",file,file->_file);
 740   MSVCRT_fseek(file, 0L, SEEK_SET);
 741   MSVCRT_clearerr(file);
 742 }
 743
 744 /*********************************************************************
 745  *              _fdopen (MSVCRT.@)
 746  */
 747 MSVCRT_FILE* MSVCRT__fdopen(int fd, const char *mode)
 748 {
 749   MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
 750
 751   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
 752
 753   return file;
 754 }
 755
 756 /*********************************************************************
 757  *              _wfdopen (MSVCRT.@)
 758  */
 759 MSVCRT_FILE* MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
 760 {
 761   MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
 762
 763   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
 764   if (file)
 765     MSVCRT_rewind(file);
 766
 767   return file;
 768 }
 769
 770 /*********************************************************************
 771  *              _filelength (MSVCRT.@)
 772  */
 773 LONG _filelength(int fd)
 774 {
 775   LONG curPos = _lseek(fd, 0, SEEK_CUR);
 776   if (curPos != -1)
 777   {
 778     LONG endPos = _lseek(fd, 0, SEEK_END);
 779     if (endPos != -1)
 780     {
 781       if (endPos != curPos)
 782         _lseek(fd, curPos, SEEK_SET);
 783       return endPos;
 784     }
 785   }
 786   return -1;
 787 }
 788
 789 /*********************************************************************
 790  *              _filelengthi64 (MSVCRT.@)
 791  */
 792 __int64 _filelengthi64(int fd)
 793 {
 794   __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
 795   if (curPos != -1)
 796   {
 797     __int64 endPos = _lseeki64(fd, 0, SEEK_END);
 798     if (endPos != -1)
 799     {
 800       if (endPos != curPos)
 801         _lseeki64(fd, curPos, SEEK_SET);
 802       return endPos;
 803     }
 804   }
 805   return -1;
 806 }
 807
 808 /*********************************************************************
 809  *              _fileno (MSVCRT.@)
 810  */
 811 int MSVCRT__fileno(MSVCRT_FILE* file)
 812 {
 813   TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
 814   return file->_file;
 815 }
 816
 817 /*********************************************************************
 818  *              _fstati64 (MSVCRT.@)
 819  */
 820 int MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
 821 {
 822   DWORD dw;
 823   BY_HANDLE_FILE_INFORMATION hfi;
 824   HANDLE hand = msvcrt_fdtoh(fd);
 825
 826   TRACE(":fd (%d) stat (%p)\n",fd,buf);
 827   if (hand == INVALID_HANDLE_VALUE)
 828     return -1;
 829
 830   if (!buf)
 831   {
 832     WARN(":failed-NULL buf\n");
 833     MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
 834     return -1;
 835   }
 836
 837   memset(&hfi, 0, sizeof(hfi));
 838   memset(buf, 0, sizeof(struct MSVCRT__stati64));
 839   if (!GetFileInformationByHandle(hand, &hfi))
 840   {
 841     WARN(":failed-last error (%ld)\n",GetLastError());
 842     MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
 843     return -1;
 844   }
 845   FIXME(":dwFileAttributes = %ld, mode set to 0\n",hfi.dwFileAttributes);
 846   buf->st_nlink = hfi.nNumberOfLinks;
 847   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
 848   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
 849   buf->st_atime = dw;
 850   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
 851   buf->st_mtime = buf->st_ctime = dw;
 852   return 0;
 853 }
 854
 855 /*********************************************************************
 856  *              _fstat (MSVCRT.@)
 857  */
 858 int MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
 859 { int ret;
 860   struct MSVCRT__stati64 bufi64;
 861
 862   ret = MSVCRT__fstati64(fd, &bufi64);
 863   if (!ret)
 864       msvcrt_cp_from_stati64(&bufi64, buf);
 865   return ret;
 866 }
 867
 868 /*********************************************************************
 869  *              _futime (MSVCRT.@)
 870  */
 871 int _futime(int fd, struct _utimbuf *t)
 872 {
 873   HANDLE hand = msvcrt_fdtoh(fd);
 874   FILETIME at, wt;
 875
 876   if (!t)
 877   {
 878     MSVCRT_time_t currTime;
 879     MSVCRT_time(&currTime);
 880     RtlSecondsSince1970ToTime(currTime, (LARGE_INTEGER *)&at);
 881     memcpy(&wt, &at, sizeof(wt));
 882   }
 883   else
 884   {
 885     RtlSecondsSince1970ToTime(t->actime, (LARGE_INTEGER *)&at);
 886     if (t->actime == t->modtime)
 887       memcpy(&wt, &at, sizeof(wt));
 888     else
 889       RtlSecondsSince1970ToTime(t->modtime, (LARGE_INTEGER *)&wt);
 890   }
 891
 892   if (!SetFileTime(hand, NULL, &at, &wt))
 893   {
 894     MSVCRT__set_errno(GetLastError());
 895     return -1 ;
 896   }
 897   return 0;
 898 }
 899
 900 /*********************************************************************
 901  *              _get_osfhandle (MSVCRT.@)
 902  */
 903 long _get_osfhandle(int fd)
 904 {
 905   HANDLE hand = msvcrt_fdtoh(fd);
 906   HANDLE newhand = hand;
 907   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 908
 909   if (hand != INVALID_HANDLE_VALUE)
 910   {
 911     /* FIXME: I'm not convinced that I should be copying the
 912      * handle here - it may be leaked if the app doesn't
 913      * close it (and the API docs don't say that it should)
 914      * Not duplicating it means that it can't be inherited
 915      * and so lcc's wedit doesn't cope when it passes it to
 916      * child processes. I've an idea that it should either
 917      * be copied by CreateProcess, or marked as inheritable
 918      * when initialised, or maybe both? JG 21-9-00.
 919      */
 920     DuplicateHandle(GetCurrentProcess(),hand,GetCurrentProcess(),
 921                     &newhand,0,TRUE,DUPLICATE_SAME_ACCESS);
 922   }
 923   return (long)newhand;
 924 }
 925
 926 /*********************************************************************
 927  *              _isatty (MSVCRT.@)
 928  */
 929 int _isatty(int fd)
 930 {
 931   HANDLE hand = msvcrt_fdtoh(fd);
 932
 933   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 934   if (hand == INVALID_HANDLE_VALUE)
 935     return 0;
 936
 937   return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
 938 }
 939
 940 /*********************************************************************
 941  *              _mktemp (MSVCRT.@)
 942  */
 943 char *_mktemp(char *pattern)
 944 {
 945   int numX = 0;
 946   char *retVal = pattern;
 947   int id;
 948   char letter = 'a';
 949
 950   while(*pattern)
 951     numX = (*pattern++ == 'X')? numX + 1 : 0;
 952   if (numX < 5)
 953     return NULL;
 954   pattern--;
 955   id = GetCurrentProcessId();
 956   numX = 6;
 957   while(numX--)
 958   {
 959     int tempNum = id / 10;
 960     *pattern-- = id - (tempNum * 10) + '0';
 961     id = tempNum;
 962   }
 963   pattern++;
 964   do
 965   {
 966     if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
 967         GetLastError() == ERROR_FILE_NOT_FOUND)
 968       return retVal;
 969     *pattern = letter++;
 970   } while(letter != '|');
 971   return NULL;
 972 }
 973
 974 /*********************************************************************
 975  *              _wmktemp (MSVCRT.@)
 976  */
 977 MSVCRT_wchar_t *_wmktemp(MSVCRT_wchar_t *pattern)
 978 {
 979   int numX = 0;
 980   MSVCRT_wchar_t *retVal = pattern;
 981   int id;
 982   MSVCRT_wchar_t letter = 'a';
 983
 984   while(*pattern)
 985     numX = (*pattern++ == 'X')? numX + 1 : 0;
 986   if (numX < 5)
 987     return NULL;
 988   pattern--;
 989   id = GetCurrentProcessId();
 990   numX = 6;
 991   while(numX--)
 992   {
 993     int tempNum = id / 10;
 994     *pattern-- = id - (tempNum * 10) + '0';
 995     id = tempNum;
 996   }
 997   pattern++;
 998   do
 999   {
1000     if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1001         GetLastError() == ERROR_FILE_NOT_FOUND)
1002       return retVal;
1003     *pattern = letter++;
1004   } while(letter != '|');
1005   return NULL;
1006 }
1007
1008 /*********************************************************************
1009  *              _sopen (MSVCRT.@)
1010  */
1011 int MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
1012 {
1013   va_list ap;
1014   int pmode;
1015   DWORD access = 0, creation = 0;
1016   DWORD sharing;
1017   int ioflag = 0, fd;
1018   HANDLE hand;
1019   SECURITY_ATTRIBUTES sa;
1020
1021
1022   TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1023         path, oflags, shflags);
1024
1025   switch(oflags & (_O_RDONLY | _O_WRONLY | _O_RDWR))
1026   {
1027   case _O_RDONLY:
1028     access |= GENERIC_READ;
1029     ioflag |= MSVCRT__IOREAD;
1030     break;
1031   case _O_WRONLY:
1032     access |= GENERIC_WRITE;
1033     ioflag |= MSVCRT__IOWRT;
1034     break;
1035   case _O_RDWR:
1036     access |= GENERIC_WRITE | GENERIC_READ;
1037     ioflag |= MSVCRT__IORW;
1038     break;
1039   }
1040
1041   if (oflags & _O_CREAT)
1042   {
1043     va_start(ap, shflags);
1044       pmode = va_arg(ap, int);
1045     va_end(ap);
1046
1047     if(pmode & ~(_S_IREAD | _S_IWRITE))
1048       FIXME(": pmode 0x%04x ignored\n", pmode);
1049     else
1050       WARN(": pmode 0x%04x ignored\n", pmode);
1051
1052     if (oflags & _O_EXCL)
1053       creation = CREATE_NEW;
1054     else if (oflags & _O_TRUNC)
1055       creation = CREATE_ALWAYS;
1056     else
1057       creation = OPEN_ALWAYS;
1058   }
1059   else  /* no _O_CREAT */
1060   {
1061     if (oflags & _O_TRUNC)
1062       creation = TRUNCATE_EXISTING;
1063     else
1064       creation = OPEN_EXISTING;
1065   }
1066   if (oflags & _O_APPEND)
1067     ioflag |= MSVCRT__IOAPPEND;
1068
1069   if (oflags & _O_BINARY)
1070     ioflag |= _O_BINARY;
1071   else if (oflags & _O_TEXT)
1072     ioflag |= _O_TEXT;
1073   else if (*__p__fmode() & _O_BINARY)
1074     ioflag |= _O_BINARY;
1075   else
1076     ioflag |= _O_TEXT; /* default to TEXT*/
1077
1078   switch( shflags )
1079   {
1080     case _SH_DENYRW:
1081       sharing = 0L;
1082       break;
1083     case _SH_DENYWR:
1084       sharing = FILE_SHARE_READ;
1085       break;
1086     case _SH_DENYRD:
1087       sharing = FILE_SHARE_WRITE;
1088       break;
1089     case _SH_DENYNO:
1090       sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1091       break;
1092     default:
1093       ERR( "Unhandled shflags 0x%x\n", shflags );
1094       return -1;
1095   }
1096
1097   if (oflags & ~(_O_BINARY|_O_TEXT|_O_APPEND|_O_TRUNC|_O_EXCL
1098                 |_O_CREAT|_O_RDWR|_O_WRONLY|_O_TEMPORARY|_O_NOINHERIT))
1099     ERR(":unsupported oflags 0x%04x\n",oflags);
1100
1101   sa.nLength              = sizeof( SECURITY_ATTRIBUTES );
1102   sa.lpSecurityDescriptor = NULL;
1103   sa.bInheritHandle       = (oflags & _O_NOINHERIT) ? FALSE : TRUE;
1104
1105   hand = CreateFileA(path, access, sharing,
1106                       &sa, creation, FILE_ATTRIBUTE_NORMAL, 0);
1107
1108   if (hand == INVALID_HANDLE_VALUE)  {
1109     WARN(":failed-last error (%ld)\n",GetLastError());
1110     MSVCRT__set_errno(GetLastError());
1111     return -1;
1112   }
1113
1114   fd = msvcrt_alloc_fd(hand, ioflag);
1115
1116   TRACE(":fd (%d) handle (%p)\n",fd, hand);
1117
1118   if (fd > 0)
1119   {
1120     if (oflags & _O_TEMPORARY)
1121       MSVCRT_tempfiles[fd] = _strdup(path);
1122     if (ioflag & MSVCRT__IOAPPEND)
1123       _lseek(fd, 0, FILE_END);
1124   }
1125
1126   return fd;
1127 }
1128
1129 /*********************************************************************
1130  *              _wsopen (MSVCRT.@)
1131  */
1132 int MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
1133 {
1134   const unsigned int len = strlenW(path);
1135   char *patha = MSVCRT_calloc(len + 1,1);
1136   va_list ap;
1137   int pmode;
1138
1139   va_start(ap, shflags);
1140   pmode = va_arg(ap, int);
1141   va_end(ap);
1142
1143   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1144   {
1145     int retval = MSVCRT__sopen(patha,oflags,shflags,pmode);
1146     MSVCRT_free(patha);
1147     return retval;
1148   }
1149
1150   MSVCRT__set_errno(GetLastError());
1151   return -1;
1152 }
1153
1154 /*********************************************************************
1155  *              _open (MSVCRT.@)
1156  */
1157 int _open( const char *path, int flags, ... )
1158 {
1159   va_list ap;
1160
1161   if (flags & _O_CREAT)
1162   {
1163     int pmode;
1164     va_start(ap, flags);
1165     pmode = va_arg(ap, int);
1166     va_end(ap);
1167     return MSVCRT__sopen( path, flags, _SH_DENYNO, pmode );
1168   }
1169   else
1170     return MSVCRT__sopen( path, flags, _SH_DENYNO);
1171 }
1172
1173 /*********************************************************************
1174  *              _wopen (MSVCRT.@)
1175  */
1176 int _wopen(const MSVCRT_wchar_t *path,int flags,...)
1177 {
1178   const unsigned int len = strlenW(path);
1179   char *patha = MSVCRT_calloc(len + 1,1);
1180   va_list ap;
1181   int pmode;
1182
1183   va_start(ap, flags);
1184   pmode = va_arg(ap, int);
1185   va_end(ap);
1186
1187   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1188   {
1189     int retval = _open(patha,flags,pmode);
1190     MSVCRT_free(patha);
1191     return retval;
1192   }
1193
1194   MSVCRT__set_errno(GetLastError());
1195   return -1;
1196 }
1197
1198 /*********************************************************************
1199  *              _creat (MSVCRT.@)
1200  */
1201 int _creat(const char *path, int flags)
1202 {
1203   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
1204   return _open(path, usedFlags);
1205 }
1206
1207 /*********************************************************************
1208  *              _wcreat (MSVCRT.@)
1209  */
1210 int _wcreat(const MSVCRT_wchar_t *path, int flags)
1211 {
1212   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
1213   return _wopen(path, usedFlags);
1214 }
1215
1216 /*********************************************************************
1217  *              _open_osfhandle (MSVCRT.@)
1218  */
1219 int _open_osfhandle(long hand, int flags)
1220 {
1221   int fd;
1222
1223   /* _O_RDONLY (0) always matches, so set the read flag
1224    * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
1225    * file, so set the write flag. It also only sets _O_TEXT if it wants
1226    * text - it never sets _O_BINARY.
1227    */
1228   /* FIXME: handle more flags */
1229   flags |= MSVCRT__IOREAD|MSVCRT__IOWRT;
1230   if ( !( flags & _O_TEXT ) ) flags |= _O_BINARY;
1231
1232   fd = msvcrt_alloc_fd((HANDLE)hand,flags);
1233   TRACE(":handle (%ld) fd (%d) flags 0x%08x\n",hand,fd, flags);
1234   return fd;
1235 }
1236
1237 /*********************************************************************
1238  *              _rmtmp (MSVCRT.@)
1239  */
1240 int _rmtmp(void)
1241 {
1242   int num_removed = 0, i;
1243
1244   for (i = 3; i < MSVCRT_fdend; i++)
1245     if (MSVCRT_tempfiles[i])
1246     {
1247       _close(i);
1248       num_removed++;
1249     }
1250
1251   if (num_removed)
1252     TRACE(":removed (%d) temp files\n",num_removed);
1253   return num_removed;
1254 }
1255
1256 /*********************************************************************
1257  * (internal) remove_cr
1258  *
1259  *    Remove all \r inplace.
1260  * return the number of \r removed
1261  */
1262 static unsigned int remove_cr(char *buf, unsigned int count)
1263 {
1264     unsigned int i, j;
1265
1266     for (i = 0; i < count; i++) if (buf[i] == '\r') break;
1267     for (j = i + 1; j < count; j++) if (buf[j] != '\r') buf[i++] = buf[j];
1268     return count - i;
1269 }
1270
1271 /*********************************************************************
1272  *              _read (MSVCRT.@)
1273  */
1274 int _read(int fd, void *buf, unsigned int count)
1275 {
1276   DWORD num_read, all_read =0;
1277   char *bufstart = buf;
1278   HANDLE hand = msvcrt_fdtoh(fd);
1279
1280   /* Don't trace small reads, it gets *very* annoying */
1281   if (count > 4)
1282     TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
1283   if (hand == INVALID_HANDLE_VALUE)
1284     return -1;
1285
1286   /* Reading single bytes in O_TEXT mode makes things slow
1287    * So read big chunks, then remove the \r in memory and try reading
1288    * the rest until the request is satisfied or EOF is met
1289    */
1290   while (  all_read < count)
1291   {
1292       if (ReadFile(hand, bufstart+all_read, count - all_read, &num_read, NULL))
1293       {
1294           if (num_read != (count- all_read))
1295           {
1296               TRACE(":EOF\n");
1297               if ( MSVCRT_files[fd])
1298               {
1299                   MSVCRT_flags[fd] |= MSVCRT__IOEOF;
1300                   /*
1301                     MSVCRT_files[fd]->_flag |= MSVCRT__IOEOF;
1302                   */
1303               }
1304               if ((MSVCRT_flags[fd]& _O_BINARY ) !=  _O_BINARY )
1305                   num_read -= remove_cr(bufstart+all_read,num_read);
1306               all_read += num_read;
1307               if (count > 4)
1308                   TRACE("%s\n",debugstr_an(buf,all_read));
1309               return all_read;
1310           }
1311           if ((MSVCRT_flags[fd]& _O_BINARY ) !=  _O_BINARY )
1312           {
1313               num_read -= remove_cr(bufstart+all_read,num_read);
1314           }
1315           all_read += num_read;
1316       }
1317       else
1318       {
1319           TRACE(":failed-last error (%ld)\n",GetLastError());
1320           if (MSVCRT_files[fd])
1321               MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1322           return -1;
1323       }
1324   }
1325
1326   if (count > 4)
1327       TRACE("%s\n",debugstr_an(buf, all_read));
1328   return all_read;
1329 }
1330
1331 /*********************************************************************
1332  *              _getw (MSVCRT.@)
1333  */
1334 int MSVCRT__getw(MSVCRT_FILE* file)
1335 {
1336   int i;
1337   if (_read(file->_file, &i, sizeof(int)) != 1)
1338     return MSVCRT_EOF;
1339   return i;
1340 }
1341
1342 /*********************************************************************
1343  *              _setmode (MSVCRT.@)
1344  */
1345 int _setmode(int fd,int mode)
1346 {
1347   int ret = MSVCRT_flags[fd] & (_O_TEXT | _O_BINARY);
1348   if (mode & (~(_O_TEXT|_O_BINARY)))
1349     FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
1350   MSVCRT_flags[fd] &= ~(_O_TEXT|_O_BINARY);
1351   MSVCRT_flags[fd] |= mode & (_O_TEXT | _O_BINARY);
1352   return ret;
1353 }
1354
1355 /*********************************************************************
1356  *              _stati64 (MSVCRT.@)
1357  */
1358 int MSVCRT__stati64(const char* path, struct MSVCRT__stati64 * buf)
1359 {
1360   DWORD dw;
1361   WIN32_FILE_ATTRIBUTE_DATA hfi;
1362   unsigned short mode = MSVCRT_S_IREAD;
1363   int plen;
1364
1365   TRACE(":file (%s) buf(%p)\n",path,buf);
1366
1367   if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1368   {
1369       TRACE("failed (%ld)\n",GetLastError());
1370       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1371       return -1;
1372   }
1373
1374   memset(buf,0,sizeof(struct MSVCRT__stati64));
1375
1376   /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
1377      Bon 011120: This FIXME seems incorrect
1378                  Also a letter as first char isn't enough to be classified
1379                  as a drive letter
1380   */
1381   if (isalpha(*path)&& (*(path+1)==':'))
1382     buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
1383   else
1384     buf->st_dev = buf->st_rdev = _getdrive() - 1;
1385
1386   plen = strlen(path);
1387
1388   /* Dir, or regular file? */
1389   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1390       (path[plen-1] == '\\'))
1391     mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1392   else
1393   {
1394     mode |= _S_IFREG;
1395     /* executable? */
1396     if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
1397     {
1398       unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1399                                  (tolower(path[plen-3]) << 16);
1400       if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1401           mode |= MSVCRT_S_IEXEC;
1402     }
1403   }
1404
1405   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1406     mode |= MSVCRT_S_IWRITE;
1407
1408   buf->st_mode  = mode;
1409   buf->st_nlink = 1;
1410   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1411   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1412   buf->st_atime = dw;
1413   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1414   buf->st_mtime = buf->st_ctime = dw;
1415   TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1416         (long)(buf->st_size >> 32),(long)buf->st_size,
1417         buf->st_atime,buf->st_mtime, buf->st_ctime);
1418   return 0;
1419 }
1420
1421 /*********************************************************************
1422  *              _stat (MSVCRT.@)
1423  */
1424 int MSVCRT__stat(const char* path, struct MSVCRT__stat * buf)
1425 { int ret;
1426   struct MSVCRT__stati64 bufi64;
1427
1428   ret = MSVCRT__stati64( path, &bufi64);
1429   if (!ret)
1430       msvcrt_cp_from_stati64(&bufi64, buf);
1431   return ret;
1432 }
1433
1434 /*********************************************************************
1435  *              _wstati64 (MSVCRT.@)
1436  */
1437 int MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
1438 {
1439   DWORD dw;
1440   WIN32_FILE_ATTRIBUTE_DATA hfi;
1441   unsigned short mode = MSVCRT_S_IREAD;
1442   int plen;
1443
1444   TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1445
1446   if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1447   {
1448       TRACE("failed (%ld)\n",GetLastError());
1449       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1450       return -1;
1451   }
1452
1453   memset(buf,0,sizeof(struct MSVCRT__stat));
1454
1455   /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
1456   if (MSVCRT_iswalpha(*path))
1457     buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
1458   else
1459     buf->st_dev = buf->st_rdev = _getdrive() - 1;
1460
1461   plen = strlenW(path);
1462
1463   /* Dir, or regular file? */
1464   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1465       (path[plen-1] == '\\'))
1466     mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1467   else
1468   {
1469     mode |= _S_IFREG;
1470     /* executable? */
1471     if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
1472     {
1473       ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
1474                                ((ULONGLONG)tolowerW(path[plen-3]) << 32);
1475       if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
1476         mode |= MSVCRT_S_IEXEC;
1477     }
1478   }
1479
1480   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1481     mode |= MSVCRT_S_IWRITE;
1482
1483   buf->st_mode  = mode;
1484   buf->st_nlink = 1;
1485   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1486   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1487   buf->st_atime = dw;
1488   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1489   buf->st_mtime = buf->st_ctime = dw;
1490   TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1491         (long)(buf->st_size >> 32),(long)buf->st_size,
1492         buf->st_atime,buf->st_mtime, buf->st_ctime);
1493   return 0;
1494 }
1495
1496 /*********************************************************************
1497  *              _wstat (MSVCRT.@)
1498  */
1499 int MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
1500 {
1501   int ret;
1502   struct MSVCRT__stati64 bufi64;
1503
1504   ret = MSVCRT__wstati64( path, &bufi64 );
1505   if (!ret) msvcrt_cp_from_stati64(&bufi64, buf);
1506   return ret;
1507 }
1508
1509 /*********************************************************************
1510  *              _tell (MSVCRT.@)
1511  */
1512 long _tell(int fd)
1513 {
1514   return _lseek(fd, 0, SEEK_CUR);
1515 }
1516
1517 /*********************************************************************
1518  *              _telli64 (MSVCRT.@)
1519  */
1520 __int64 _telli64(int fd)
1521 {
1522   return _lseeki64(fd, 0, SEEK_CUR);
1523 }
1524
1525 /*********************************************************************
1526  *              _tempnam (MSVCRT.@)
1527  */
1528 char *_tempnam(const char *dir, const char *prefix)
1529 {
1530   char tmpbuf[MAX_PATH];
1531
1532   TRACE("dir (%s) prefix (%s)\n",dir,prefix);
1533   if (GetTempFileNameA(dir,prefix,0,tmpbuf))
1534   {
1535     TRACE("got name (%s)\n",tmpbuf);
1536     DeleteFileA(tmpbuf);
1537     return _strdup(tmpbuf);
1538   }
1539   TRACE("failed (%ld)\n",GetLastError());
1540   return NULL;
1541 }
1542
1543 /*********************************************************************
1544  *              _wtempnam (MSVCRT.@)
1545  */
1546 MSVCRT_wchar_t *_wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
1547 {
1548   MSVCRT_wchar_t tmpbuf[MAX_PATH];
1549
1550   TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
1551   if (GetTempFileNameW(dir,prefix,0,tmpbuf))
1552   {
1553     TRACE("got name (%s)\n",debugstr_w(tmpbuf));
1554     DeleteFileW(tmpbuf);
1555     return _wcsdup(tmpbuf);
1556   }
1557   TRACE("failed (%ld)\n",GetLastError());
1558   return NULL;
1559 }
1560
1561 /*********************************************************************
1562  *              _umask (MSVCRT.@)
1563  */
1564 int _umask(int umask)
1565 {
1566   int old_umask = MSVCRT_umask;
1567   TRACE("(%d)\n",umask);
1568   MSVCRT_umask = umask;
1569   return old_umask;
1570 }
1571
1572 /*********************************************************************
1573  *              _utime (MSVCRT.@)
1574  */
1575 int _utime(const char* path, struct _utimbuf *t)
1576 {
1577   int fd = _open(path, _O_WRONLY | _O_BINARY);
1578
1579   if (fd > 0)
1580   {
1581     int retVal = _futime(fd, t);
1582     _close(fd);
1583     return retVal;
1584   }
1585   return -1;
1586 }
1587
1588 /*********************************************************************
1589  *              _wutime (MSVCRT.@)
1590  */
1591 int _wutime(const MSVCRT_wchar_t* path, struct _utimbuf *t)
1592 {
1593   int fd = _wopen(path, _O_WRONLY | _O_BINARY);
1594
1595   if (fd > 0)
1596   {
1597     int retVal = _futime(fd, t);
1598     _close(fd);
1599     return retVal;
1600   }
1601   return -1;
1602 }
1603
1604 /*********************************************************************
1605  *              _write (MSVCRT.@)
1606  */
1607 int _write(int fd, const void* buf, unsigned int count)
1608 {
1609   DWORD num_written;
1610   HANDLE hand = msvcrt_fdtoh(fd);
1611
1612   /* Don't trace small writes, it gets *very* annoying */
1613 #if 0
1614   if (count > 32)
1615     TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
1616 #endif
1617   if (hand == INVALID_HANDLE_VALUE)
1618     {
1619       *MSVCRT__errno() = MSVCRT_EBADF;
1620       return -1;
1621     }
1622
1623   /* If appending, go to EOF */
1624   if (MSVCRT_flags[fd] & MSVCRT__IOAPPEND)
1625     _lseek(fd, 0, FILE_END);
1626
1627   if (MSVCRT_flags[fd] & _O_BINARY)
1628     {
1629       if (WriteFile(hand, buf, count, &num_written, NULL)
1630           &&  (num_written == count))
1631         return num_written;
1632       TRACE(":failed-last error (%ld)\n",GetLastError());
1633       if (MSVCRT_files[fd])
1634         {
1635           MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1636           *MSVCRT__errno() = MSVCRT_ENOSPC;
1637         }
1638     }
1639   else
1640   {
1641       unsigned int i, j, nr_lf;
1642       char *s=(char*)buf, *buf_start=(char*)buf, *p;
1643       /* find number of \n ( without preceeding \r */
1644       for ( nr_lf=0,i = 0; i <count; i++)
1645       {
1646           if (s[i]== '\n')
1647           {
1648               nr_lf++;
1649               /*if ((i >1) && (s[i-1] == '\r')) nr_lf--; */
1650           }
1651       }
1652       if (nr_lf)
1653       {
1654           if ((p = MSVCRT_malloc(count + nr_lf)))
1655           {
1656               for(s=(char*)buf, i=0, j=0; i<count; i++)
1657               {
1658                   if (s[i]== '\n')
1659                   {
1660                       p[j++] = '\r';
1661                       /*if ((i >1) && (s[i-1] == '\r'))j--;*/
1662                   }
1663                   p[j++] = s[i];
1664               }
1665           }
1666           else
1667           {
1668               FIXME("Malloc failed\n");
1669               nr_lf =0;
1670               p = (char*)buf;
1671           }
1672       }
1673       else
1674           p = (char*)buf;
1675
1676       if ((WriteFile(hand, p, count+nr_lf, &num_written, NULL) == 0 ) || (num_written != count+nr_lf))
1677       {
1678           TRACE(":failed-last error (%ld) num_written %ld\n",GetLastError(),num_written);
1679           if (MSVCRT_files[fd])
1680           {
1681               MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1682               *MSVCRT__errno() = MSVCRT_ENOSPC;
1683               if(nr_lf)
1684                   MSVCRT_free(p);
1685               return s - buf_start;
1686           }
1687       }
1688       else
1689       {
1690           if(nr_lf)
1691               MSVCRT_free(p);
1692           return count;
1693       }
1694   }
1695   return -1;
1696 }
1697
1698 /*********************************************************************
1699  *              _putw (MSVCRT.@)
1700  */
1701 int MSVCRT__putw(int val, MSVCRT_FILE* file)
1702 {
1703   return _write(file->_file, &val, sizeof(val)) == 1? val : MSVCRT_EOF;
1704 }
1705
1706 /*********************************************************************
1707  *              fclose (MSVCRT.@)
1708  */
1709 int MSVCRT_fclose(MSVCRT_FILE* file)
1710 {
1711   int r, flag;
1712
1713   flag = file->_flag;
1714   r=_close(file->_file);
1715   return ((r==MSVCRT_EOF) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
1716 }
1717
1718 /*********************************************************************
1719  *              feof (MSVCRT.@)
1720  */
1721 int MSVCRT_feof(MSVCRT_FILE* file)
1722 {
1723   return file->_flag & MSVCRT__IOEOF;
1724 }
1725
1726 /*********************************************************************
1727  *              ferror (MSVCRT.@)
1728  */
1729 int MSVCRT_ferror(MSVCRT_FILE* file)
1730 {
1731   return file->_flag & MSVCRT__IOERR;
1732 }
1733
1734 /*********************************************************************
1735  *              _filbuf (MSVCRT.@)
1736  */
1737 int MSVCRT__filbuf(MSVCRT_FILE* file)
1738 {
1739
1740   /* Allocate buffer if needed */
1741   if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
1742         msvcrt_alloc_buffer(file);
1743   }
1744   if(!(file->_flag & MSVCRT__IOREAD)) {
1745         if(file->_flag & MSVCRT__IORW) {
1746                 file->_flag |= MSVCRT__IOREAD;
1747         } else {
1748                 return MSVCRT_EOF;
1749         }
1750   }
1751   if(file->_flag & MSVCRT__IONBF) {
1752         unsigned char c;
1753         if (_read(file->_file,&c,1) != 1) {
1754                 file->_flag |= MSVCRT__IOEOF;
1755                 return MSVCRT_EOF;
1756         }
1757         return c;
1758   } else {
1759         file->_cnt = _read(file->_file, file->_base, file->_bufsiz);
1760         if(file->_cnt<0) file->_cnt = 0;
1761         if(!file->_cnt) {
1762                 file->_flag |= MSVCRT__IOEOF;
1763                 return MSVCRT_EOF;
1764         }
1765         file->_cnt--;
1766         file->_ptr = file->_base+1;
1767         return *(unsigned char *)file->_base;
1768   }
1769 }
1770
1771 /*********************************************************************
1772  *              fgetc (MSVCRT.@)
1773  */
1774 int MSVCRT_fgetc(MSVCRT_FILE* file)
1775 {
1776   if (file->_cnt>0) {
1777         file->_cnt--;
1778         return *(unsigned char *)file->_ptr++;
1779   } else {
1780         return MSVCRT__filbuf(file);
1781   }
1782 }
1783
1784 /*********************************************************************
1785  *              _fgetchar (MSVCRT.@)
1786  */
1787 int _fgetchar(void)
1788 {
1789   return MSVCRT_fgetc(MSVCRT_stdin);
1790 }
1791
1792 /*********************************************************************
1793  *              fgets (MSVCRT.@)
1794  */
1795 char *MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
1796 {
1797   int    cc = MSVCRT_EOF;
1798   char * buf_start = s;
1799
1800   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
1801         file,file->_file,s,size);
1802
1803   while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
1804     {
1805       *s++ = (char)cc;
1806       size --;
1807     }
1808   if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
1809   {
1810     TRACE(":nothing read\n");
1811     return NULL;
1812   }
1813   if ((cc != MSVCRT_EOF) && (size > 1))
1814     *s++ = cc;
1815   *s = '\0';
1816   TRACE(":got '%s'\n", debugstr_a(buf_start));
1817   return buf_start;
1818 }
1819
1820 /*********************************************************************
1821  *              fgetwc (MSVCRT.@)
1822  *
1823  * In _O_TEXT mode, bultibyte characters are read from the file, dropping
1824  * the CR from CR/LF combinations
1825  */
1826 MSVCRT_wint_t MSVCRT_fgetwc(MSVCRT_FILE* file)
1827 {
1828   char c;
1829
1830   if (file->_flag & _O_BINARY)
1831     {
1832       MSVCRT_wchar_t wc;
1833       if (_read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
1834         return MSVCRT_WEOF;
1835       return wc;
1836     }
1837   c = MSVCRT_fgetc(file);
1838   if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c))
1839     {
1840       FIXME("Treat Multibyte characters\n");
1841     }
1842   if (c == MSVCRT_EOF)
1843     return MSVCRT_WEOF;
1844   else
1845     return (MSVCRT_wint_t)c;
1846 }
1847
1848 /*********************************************************************
1849  *              getwc (MSVCRT.@)
1850  */
1851 MSVCRT_wint_t MSVCRT_getwc(MSVCRT_FILE* file)
1852 {
1853   return MSVCRT_fgetwc(file);
1854 }
1855
1856 /*********************************************************************
1857  *              _fgetwchar (MSVCRT.@)
1858  */
1859 MSVCRT_wint_t _fgetwchar(void)
1860 {
1861   return MSVCRT_fgetwc(MSVCRT_stdin);
1862 }
1863
1864 /*********************************************************************
1865  *              getwchar (MSVCRT.@)
1866  */
1867 MSVCRT_wint_t MSVCRT_getwchar(void)
1868 {
1869   return _fgetwchar();
1870 }
1871
1872 /*********************************************************************
1873  *              fgetws (MSVCRT.@)
1874  */
1875 MSVCRT_wchar_t *MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
1876 {
1877   int    cc = MSVCRT_WEOF;
1878   MSVCRT_wchar_t * buf_start = s;
1879
1880   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
1881         file,file->_file,s,size);
1882
1883   while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
1884     {
1885       *s++ = (char)cc;
1886       size --;
1887     }
1888   if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
1889   {
1890     TRACE(":nothing read\n");
1891     return NULL;
1892   }
1893   if ((cc != MSVCRT_WEOF) && (size > 1))
1894     *s++ = cc;
1895   *s = 0;
1896   TRACE(":got %s\n", debugstr_w(buf_start));
1897   return buf_start;
1898 }
1899
1900 /*********************************************************************
1901  *              fwrite (MSVCRT.@)
1902  */
1903 MSVCRT_size_t MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
1904 {
1905   MSVCRT_size_t wrcnt=size * nmemb;
1906   int written = 0;
1907   if (size == 0)
1908       return 0;
1909   if(file->_cnt) {
1910         int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
1911         memcpy(file->_ptr, ptr, pcnt);
1912         file->_cnt -= pcnt;
1913         file->_ptr += pcnt;
1914         written = pcnt;
1915         wrcnt -= pcnt;
1916        ptr = (char*)ptr + pcnt;
1917   } else if(!(file->_flag & MSVCRT__IOWRT)) {
1918         if(file->_flag & MSVCRT__IORW) {
1919                 file->_flag |= MSVCRT__IOWRT;
1920         } else
1921                 return 0;
1922   }
1923   if(wrcnt) {
1924         /* Flush buffer */
1925         int res=msvcrt_flush_buffer(file);
1926         if(!res) {
1927                 int pwritten = _write(file->_file, ptr, wrcnt);
1928                 if (pwritten <= 0) pwritten=0;
1929                 written += pwritten;
1930         }
1931   }
1932   return written / size;
1933 }
1934
1935 /*********************************************************************
1936  *              fputwc (MSVCRT.@)
1937  */
1938 MSVCRT_wint_t MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
1939 {
1940   MSVCRT_wchar_t mwc=wc;
1941   if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
1942     return MSVCRT_WEOF;
1943   return wc;
1944 }
1945
1946 /*********************************************************************
1947  *              _fputwchar (MSVCRT.@)
1948  */
1949 MSVCRT_wint_t _fputwchar(MSVCRT_wint_t wc)
1950 {
1951   return MSVCRT_fputwc(wc, MSVCRT_stdout);
1952 }
1953
1954 /*********************************************************************
1955  *              fopen (MSVCRT.@)
1956  */
1957 MSVCRT_FILE* MSVCRT_fopen(const char *path, const char *mode)
1958 {
1959   MSVCRT_FILE* file;
1960   int flags = 0, plus = 0, fd;
1961   const char* search = mode;
1962
1963   TRACE("(%s,%s)\n",path,mode);
1964
1965   while (*search)
1966     if (*search++ == '+')
1967       plus = 1;
1968
1969   /* map mode string to open() flags. "man fopen" for possibilities. */
1970   switch(*mode++)
1971   {
1972   case 'R': case 'r':
1973     flags = (plus ? _O_RDWR : _O_RDONLY);
1974     break;
1975   case 'W': case 'w':
1976     flags = _O_CREAT | _O_TRUNC | (plus  ? _O_RDWR : _O_WRONLY);
1977     break;
1978   case 'A': case 'a':
1979     flags = _O_CREAT | _O_APPEND | (plus  ? _O_RDWR : _O_WRONLY);
1980     break;
1981   default:
1982     return NULL;
1983   }
1984
1985   while (*mode)
1986     switch (*mode++)
1987     {
1988     case 'B': case 'b':
1989       flags |=  _O_BINARY;
1990       flags &= ~_O_TEXT;
1991       break;
1992     case 'T': case 't':
1993       flags |=  _O_TEXT;
1994       flags &= ~_O_BINARY;
1995       break;
1996     case '+':
1997       break;
1998     default:
1999       FIXME(":unknown flag %c not supported\n",mode[-1]);
2000     }
2001
2002   fd = _open(path, flags, _S_IREAD | _S_IWRITE);
2003
2004   if (fd < 0)
2005     return NULL;
2006
2007   file = msvcrt_alloc_fp(fd);
2008   TRACE(":got (%p)\n",file);
2009   if (!file)
2010     _close(fd);
2011
2012   return file;
2013 }
2014
2015 /*********************************************************************
2016  *              _wfopen (MSVCRT.@)
2017  */
2018 MSVCRT_FILE *MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
2019 {
2020   const unsigned int plen = strlenW(path), mlen = strlenW(mode);
2021   char *patha = MSVCRT_calloc(plen + 1, 1);
2022   char *modea = MSVCRT_calloc(mlen + 1, 1);
2023
2024   TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
2025
2026   if (patha && modea &&
2027       WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
2028       WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
2029   {
2030     MSVCRT_FILE *retval = MSVCRT_fopen(patha,modea);
2031     MSVCRT_free(patha);
2032     MSVCRT_free(modea);
2033     return retval;
2034   }
2035
2036   MSVCRT__set_errno(GetLastError());
2037   return NULL;
2038 }
2039
2040 /*********************************************************************
2041  *              _fsopen (MSVCRT.@)
2042  */
2043 MSVCRT_FILE*  _fsopen(const char *path, const char *mode, int share)
2044 {
2045   FIXME(":(%s,%s,%d),ignoring share mode!\n",path,mode,share);
2046   return MSVCRT_fopen(path,mode);
2047 }
2048
2049 /*********************************************************************
2050  *              _wfsopen (MSVCRT.@)
2051  */
2052 MSVCRT_FILE*  MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
2053 {
2054   FIXME(":(%s,%s,%d),ignoring share mode!\n",
2055         debugstr_w(path),debugstr_w(mode),share);
2056   return MSVCRT__wfopen(path,mode);
2057 }
2058
2059 /* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
2060 int MSVCRT__flsbuf(int c, MSVCRT_FILE* file);
2061
2062 /*********************************************************************
2063  *              fputc (MSVCRT.@)
2064  */
2065 int MSVCRT_fputc(int c, MSVCRT_FILE* file)
2066 {
2067   if(file->_cnt>0) {
2068         *file->_ptr++=c;
2069         file->_cnt--;
2070         return c;
2071   } else {
2072         return MSVCRT__flsbuf(c, file);
2073   }
2074 }
2075
2076 /*********************************************************************
2077  *              _flsbuf (MSVCRT.@)
2078  */
2079 int MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
2080 {
2081   /* Flush output buffer */
2082   if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2083         msvcrt_alloc_buffer(file);
2084   }
2085   if(!(file->_flag & MSVCRT__IOWRT)) {
2086         if(file->_flag & MSVCRT__IORW) {
2087                 file->_flag |= MSVCRT__IOWRT;
2088         } else {
2089                 return MSVCRT_EOF;
2090         }
2091   }
2092   if(file->_bufsiz) {
2093         int res=msvcrt_flush_buffer(file);
2094         return res?res : MSVCRT_fputc(c, file);
2095   } else {
2096         unsigned char cc=c;
2097         return _write(file->_file, &cc, 1) == 1? c : MSVCRT_EOF;
2098   }
2099 }
2100
2101 /*********************************************************************
2102  *              _fputchar (MSVCRT.@)
2103  */
2104 int _fputchar(int c)
2105 {
2106   return MSVCRT_fputc(c, MSVCRT_stdout);
2107 }
2108
2109 /*********************************************************************
2110  *              fread (MSVCRT.@)
2111  */
2112 MSVCRT_size_t MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2113 { MSVCRT_size_t rcnt=size * nmemb;
2114   MSVCRT_size_t read=0;
2115   int pread=0;
2116   /* first buffered data */
2117   if(file->_cnt>0) {
2118         int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
2119         memcpy(ptr, file->_ptr, pcnt);
2120         file->_cnt -= pcnt;
2121         file->_ptr += pcnt;
2122         read += pcnt ;
2123         rcnt -= pcnt ;
2124        ptr = (char*)ptr + pcnt;
2125   } else if(!(file->_flag & MSVCRT__IOREAD )) {
2126         if(file->_flag & MSVCRT__IORW) {
2127                 file->_flag |= MSVCRT__IOREAD;
2128         } else
2129                 return 0;
2130   }
2131   if(rcnt) pread = _read(file->_file,ptr, rcnt);
2132   if (MSVCRT_flags[file->_file] & MSVCRT__IOEOF)
2133      /* expose feof condition in the flags
2134         MFC tests file->_flag for feof, and doesn't not call feof())
2135     */
2136     file->_flag |= MSVCRT__IOEOF;
2137   if (pread <= 0)
2138     pread = 0;
2139   read+=pread;
2140   return read / size;
2141 }
2142
2143 /*********************************************************************
2144  *              freopen (MSVCRT.@)
2145  *
2146  */
2147 MSVCRT_FILE* MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
2148 {
2149   MSVCRT_FILE* newfile;
2150   int fd;
2151
2152   TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
2153   if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
2154     return NULL;
2155
2156   if (fd > 2)
2157   {
2158 #if 0
2159     FIXME(":reopen on user file not implemented!\n");
2160     MSVCRT__set_errno(ERROR_CALL_NOT_IMPLEMENTED);
2161     return NULL;
2162 #endif
2163     if(MSVCRT_fclose(file))
2164         return NULL;
2165     return MSVCRT_fopen(path, mode);
2166   }
2167
2168   /* first, create the new file */
2169   if ((newfile = MSVCRT_fopen(path,mode)) == NULL)
2170     return NULL;
2171
2172   if (fd < 3 && SetStdHandle(fd == 0 ? STD_INPUT_HANDLE :
2173      (fd == 1? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE),
2174       MSVCRT_handles[newfile->_file]))
2175   {
2176     /* Redirecting std handle to file , copy over.. */
2177     MSVCRT_handles[fd] = MSVCRT_handles[newfile->_file];
2178     MSVCRT_flags[fd] = MSVCRT_flags[newfile->_file];
2179     memcpy(&MSVCRT__iob[fd], newfile, sizeof (MSVCRT_FILE));
2180     MSVCRT__iob[fd]._file = fd;
2181     /* And free up the resources allocated by fopen, but
2182      * not the HANDLE we copied. */
2183     MSVCRT_free(MSVCRT_files[fd]);
2184     msvcrt_free_fd(newfile->_file);
2185     return &MSVCRT__iob[fd];
2186   }
2187
2188   WARN(":failed-last error (%ld)\n",GetLastError());
2189   MSVCRT_fclose(newfile);
2190   MSVCRT__set_errno(GetLastError());
2191   return NULL;
2192 }
2193
2194 /*********************************************************************
2195  *              fsetpos (MSVCRT.@)
2196  */
2197 int MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2198 {
2199   return _lseek(file->_file,*pos,SEEK_SET);
2200 }
2201
2202 /*********************************************************************
2203  *              ftell (MSVCRT.@)
2204  */
2205 LONG MSVCRT_ftell(MSVCRT_FILE* file)
2206 {
2207   int off=0;
2208   long pos;
2209   if(file->_bufsiz)  {
2210         if( file->_flag & MSVCRT__IOWRT ) {
2211                 off = file->_ptr - file->_base;
2212         } else {
2213                 off = -file->_cnt;
2214         }
2215   }
2216   pos = _tell(file->_file);
2217   if(pos == -1) return pos;
2218   return off + pos;
2219 }
2220
2221 /*********************************************************************
2222  *              fgetpos (MSVCRT.@)
2223  */
2224 int MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2225 {
2226   *pos = MSVCRT_ftell(file);
2227   return (*pos == -1? -1 : 0);
2228 }
2229
2230 /*********************************************************************
2231  *              fputs (MSVCRT.@)
2232  */
2233 int MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
2234 {
2235     size_t i, len = strlen(s);
2236     if (file->_flag & _O_BINARY)
2237       return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2238     for (i=0; i<len; i++)
2239       if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
2240         return MSVCRT_EOF;
2241     return 0;
2242 }
2243
2244 /*********************************************************************
2245  *              fputws (MSVCRT.@)
2246  */
2247 int MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
2248 {
2249     size_t i, len = strlenW(s);
2250     if (file->_flag & _O_BINARY)
2251       return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2252     for (i=0; i<len; i++)
2253       {
2254         if ((s[i] == L'\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
2255           return MSVCRT_WEOF;
2256         if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
2257           return MSVCRT_WEOF;
2258       }
2259     return 0;
2260 }
2261
2262 /*********************************************************************
2263  *              getchar (MSVCRT.@)
2264  */
2265 int MSVCRT_getchar(void)
2266 {
2267   return MSVCRT_fgetc(MSVCRT_stdin);
2268 }
2269
2270 /*********************************************************************
2271  *              getc (MSVCRT.@)
2272  */
2273 int MSVCRT_getc(MSVCRT_FILE* file)
2274 {
2275   return MSVCRT_fgetc(file);
2276 }
2277
2278 /*********************************************************************
2279  *              gets (MSVCRT.@)
2280  */
2281 char *MSVCRT_gets(char *buf)
2282 {
2283   int    cc;
2284   char * buf_start = buf;
2285
2286   for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
2287       cc = MSVCRT_fgetc(MSVCRT_stdin))
2288   if(cc != '\r') *buf++ = (char)cc;
2289
2290   *buf = '\0';
2291
2292   TRACE("got '%s'\n", buf_start);
2293   return buf_start;
2294 }
2295
2296 /*********************************************************************
2297  *              _getws (MSVCRT.@)
2298  */
2299 MSVCRT_wchar_t* MSVCRT__getws(MSVCRT_wchar_t* buf)
2300 {
2301     MSVCRT_wint_t cc;
2302     MSVCRT_wchar_t* ws = buf;
2303
2304     for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
2305          cc = MSVCRT_fgetwc(MSVCRT_stdin))
2306     {
2307         if (cc != '\r')
2308             *buf++ = (MSVCRT_wchar_t)cc;
2309     }
2310     *buf = '\0';
2311
2312     TRACE("got '%s'\n", debugstr_w(ws));
2313     return ws;
2314 }
2315
2316 /*********************************************************************
2317  *              putc (MSVCRT.@)
2318  */
2319 int MSVCRT_putc(int c, MSVCRT_FILE* file)
2320 {
2321   return MSVCRT_fputc(c, file);
2322 }
2323
2324 /*********************************************************************
2325  *              putchar (MSVCRT.@)
2326  */
2327 int MSVCRT_putchar(int c)
2328 {
2329   return MSVCRT_fputc(c, MSVCRT_stdout);
2330 }
2331
2332 /*********************************************************************
2333  *              puts (MSVCRT.@)
2334  */
2335 int MSVCRT_puts(const char *s)
2336 {
2337     size_t len = strlen(s);
2338     if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2339     return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2340 }
2341
2342 /*********************************************************************
2343  *              _putws (MSVCRT.@)
2344  */
2345 int _putws(const MSVCRT_wchar_t *s)
2346 {
2347     static const MSVCRT_wchar_t nl = '\n';
2348     size_t len = strlenW(s);
2349     if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2350     return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2351 }
2352
2353 /*********************************************************************
2354  *              remove (MSVCRT.@)
2355  */
2356 int MSVCRT_remove(const char *path)
2357 {
2358   TRACE("(%s)\n",path);
2359   if (DeleteFileA(path))
2360     return 0;
2361   TRACE(":failed (%ld)\n",GetLastError());
2362   MSVCRT__set_errno(GetLastError());
2363   return -1;
2364 }
2365
2366 /*********************************************************************
2367  *              _wremove (MSVCRT.@)
2368  */
2369 int _wremove(const MSVCRT_wchar_t *path)
2370 {
2371   TRACE("(%s)\n",debugstr_w(path));
2372   if (DeleteFileW(path))
2373     return 0;
2374   TRACE(":failed (%ld)\n",GetLastError());
2375   MSVCRT__set_errno(GetLastError());
2376   return -1;
2377 }
2378
2379 /*********************************************************************
2380  *              rename (MSVCRT.@)
2381  */
2382 int MSVCRT_rename(const char *oldpath,const char *newpath)
2383 {
2384   TRACE(":from %s to %s\n",oldpath,newpath);
2385   if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2386     return 0;
2387   TRACE(":failed (%ld)\n",GetLastError());
2388   MSVCRT__set_errno(GetLastError());
2389   return -1;
2390 }
2391
2392 /*********************************************************************
2393  *              _wrename (MSVCRT.@)
2394  */
2395 int _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
2396 {
2397   TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
2398   if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2399     return 0;
2400   TRACE(":failed (%ld)\n",GetLastError());
2401   MSVCRT__set_errno(GetLastError());
2402   return -1;
2403 }
2404
2405 /*********************************************************************
2406  *              setvbuf (MSVCRT.@)
2407  */
2408 int MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
2409 {
2410   /* TODO: Check if file busy */
2411   if(file->_bufsiz) {
2412         MSVCRT_free(file->_base);
2413         file->_bufsiz = 0;
2414         file->_cnt = 0;
2415   }
2416   if(mode == MSVCRT__IOFBF) {
2417         file->_flag &= ~MSVCRT__IONBF;
2418         file->_base = file->_ptr = buf;
2419         if(buf) {
2420                 file->_bufsiz = size;
2421         }
2422   } else {
2423         file->_flag |= MSVCRT__IONBF;
2424   }
2425   return 0;
2426 }
2427
2428 /*********************************************************************
2429  *              setbuf (MSVCRT.@)
2430  */
2431 void MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
2432 {
2433   MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
2434 }
2435
2436 /*********************************************************************
2437  *              tmpnam (MSVCRT.@)
2438  */
2439 char *MSVCRT_tmpnam(char *s)
2440 {
2441   static int unique;
2442   char tmpstr[16];
2443   char *p;
2444   int count;
2445   if (s == 0)
2446     s = MSVCRT_tmpname;
2447   msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
2448   p = s + sprintf(s, "\\s%s.", tmpstr);
2449   for (count = 0; count < MSVCRT_TMP_MAX; count++)
2450   {
2451     msvcrt_int_to_base32(unique++, tmpstr);
2452     strcpy(p, tmpstr);
2453     if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
2454         GetLastError() == ERROR_FILE_NOT_FOUND)
2455       break;
2456   }
2457   return s;
2458 }
2459
2460 /*********************************************************************
2461  *              tmpfile (MSVCRT.@)
2462  */
2463 MSVCRT_FILE* MSVCRT_tmpfile(void)
2464 {
2465   char *filename = MSVCRT_tmpnam(NULL);
2466   int fd;
2467   fd = _open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
2468   if (fd != -1)
2469     return msvcrt_alloc_fp(fd);
2470   return NULL;
2471 }
2472
2473 /*********************************************************************
2474  *              vfprintf (MSVCRT.@)
2475  */
2476 int MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
2477 {
2478   char buf[2048], *mem = buf;
2479   int written, resize = sizeof(buf), retval;
2480   /* There are two conventions for vsnprintf failing:
2481    * Return -1 if we truncated, or
2482    * Return the number of bytes that would have been written
2483    * The code below handles both cases
2484    */
2485   while ((written = vsnprintf(mem, resize, format, valist)) == -1 ||
2486           written > resize)
2487   {
2488     resize = (written == -1 ? resize * 2 : written + 1);
2489     if (mem != buf)
2490       MSVCRT_free (mem);
2491     if (!(mem = (char *)MSVCRT_malloc(resize)))
2492       return MSVCRT_EOF;
2493   }
2494   retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2495   if (mem != buf)
2496     MSVCRT_free (mem);
2497   return retval;
2498 }
2499
2500 /*********************************************************************
2501  *              vfwprintf (MSVCRT.@)
2502  * FIXME:
2503  * Is final char included in written (then resize is too big) or not
2504  * (then we must test for equality too)?
2505  */
2506 int MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
2507 {
2508   MSVCRT_wchar_t buf[2048], *mem = buf;
2509   int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
2510   /* See vfprintf comments */
2511   while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
2512           written > resize)
2513   {
2514     resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
2515     if (mem != buf)
2516       MSVCRT_free (mem);
2517     if (!(mem = (MSVCRT_wchar_t *)MSVCRT_malloc(resize*sizeof(*mem))))
2518       return MSVCRT_EOF;
2519   }
2520   retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2521   if (mem != buf)
2522     MSVCRT_free (mem);
2523   return retval;
2524 }
2525
2526 /*********************************************************************
2527  *              vprintf (MSVCRT.@)
2528  */
2529 int MSVCRT_vprintf(const char *format, va_list valist)
2530 {
2531   return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
2532 }
2533
2534 /*********************************************************************
2535  *              vwprintf (MSVCRT.@)
2536  */
2537 int MSVCRT_vwprintf(const MSVCRT_wchar_t *format, va_list valist)
2538 {
2539   return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
2540 }
2541
2542 /*********************************************************************
2543  *              fprintf (MSVCRT.@)
2544  */
2545 int MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
2546 {
2547     va_list valist;
2548     int res;
2549     va_start(valist, format);
2550     res = MSVCRT_vfprintf(file, format, valist);
2551     va_end(valist);
2552     return res;
2553 }
2554
2555 /*********************************************************************
2556  *              fwprintf (MSVCRT.@)
2557  */
2558 int MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
2559 {
2560     va_list valist;
2561     int res;
2562     va_start(valist, format);
2563     res = MSVCRT_vfwprintf(file, format, valist);
2564     va_end(valist);
2565     return res;
2566 }
2567
2568 /*********************************************************************
2569  *              printf (MSVCRT.@)
2570  */
2571 int MSVCRT_printf(const char *format, ...)
2572 {
2573     va_list valist;
2574     int res;
2575     va_start(valist, format);
2576     res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
2577     va_end(valist);
2578     return res;
2579 }
2580
2581 /*********************************************************************
2582  *              ungetc (MSVCRT.@)
2583  */
2584 int MSVCRT_ungetc(int c, MSVCRT_FILE * file)
2585 {
2586         if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2587                 msvcrt_alloc_buffer(file);
2588                 file->_ptr++;
2589         }
2590         if(file->_ptr>file->_base) {
2591                 file->_ptr--;
2592                 *file->_ptr=c;
2593                 file->_cnt++;
2594                 return c;
2595         }
2596         return MSVCRT_EOF;
2597 }
2598
2599 /*********************************************************************
2600  *              ungetwc (MSVCRT.@)
2601  */
2602 MSVCRT_wint_t MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
2603 {
2604         MSVCRT_wchar_t mwc = wc;
2605         char * pp = (char *)&mwc;
2606         int i;
2607         for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
2608                 if(pp[i] != MSVCRT_ungetc(pp[i],file))
2609                         return MSVCRT_WEOF;
2610         }
2611         return mwc;
2612 }
2613
2614 /*********************************************************************
2615  *              wprintf (MSVCRT.@)
2616  */
2617 int MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
2618 {
2619     va_list valist;
2620     int res;
2621     va_start(valist, format);
2622     res = MSVCRT_vwprintf(format, valist);
2623     va_end(valist);
2624     return res;
2625 }