+/*
+ * PROJECT: ReactOS CRT library
+ * LICENSE: LGPL - See COPYING in the top level directory
+ * FILE: lib/sdk/crt/stdio/file.c
+ * PURPOSE: File CRT functions
+ * PROGRAMMERS: Wine team
+ * Ported to ReactOS by Aleksey Bragin (aleksey@reactos.org)
+ */
+
/*
* msvcrt.dll file functions
*
#include <precomp.h>
#include "wine/unicode.h"
-#if 0
+#include <sys/utime.h>
+#include <direct.h>
+int *__p__fmode(void);
+int *__p___mb_cur_max(void);
+
+#ifdef feof
+#undef feof
+#endif
+#ifdef _fileno
+#undef _fileno
+#endif
+#ifdef ferror
+#undef ferror
+#endif
+#ifdef clearerr
+#undef clearerr
+#endif
+
+#undef getc
+#undef getwc
+#undef getchar
+#undef getwchar
+#undef putc
+#undef putwc
+#undef putchar
+#undef putwchar
+
+#undef vprintf
+#undef vwprintf
/* for stat mode, permissions apply to all,owner and group */
-#define ALL_S_IREAD (MSVCRT__S_IREAD | (MSVCRT__S_IREAD >> 3) | (MSVCRT__S_IREAD >> 6))
-#define ALL_S_IWRITE (MSVCRT__S_IWRITE | (MSVCRT__S_IWRITE >> 3) | (MSVCRT__S_IWRITE >> 6))
-#define ALL_S_IEXEC (MSVCRT__S_IEXEC | (MSVCRT__S_IEXEC >> 3) | (MSVCRT__S_IEXEC >> 6))
+#define ALL_S_IREAD (_S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6))
+#define ALL_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
+#define ALL_S_IEXEC (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6))
/* _access() bit flags FIXME: incomplete */
-#define MSVCRT_W_OK 0x02
+/* defined in crt/io.h */
/* values for wxflag in file descriptor */
#define WX_OPEN 0x01
#define WX_TEXT 0x80
/* FIXME: this should be allocated dynamically */
-#define MSVCRT_MAX_FILES 2048
+#define MAX_FILES 2048
+/* ReactOS: Use _FDINFO instead! */
typedef struct {
HANDLE handle;
unsigned char wxflag;
DWORD unkn[7]; /* critical section and init flag */
} ioinfo;
-static ioinfo MSVCRT_fdesc[MSVCRT_MAX_FILES];
+/*static */ioinfo fdesc[MAX_FILES];
-MSVCRT_FILE MSVCRT__iob[3];
+FILE _iob[3] = { { 0 } };
-static int MSVCRT_fdstart = 3; /* first unallocated fd */
-static int MSVCRT_fdend = 3; /* highest allocated fd */
+static int fdstart = 3; /* first unallocated fd */
+static int fdend = 3; /* highest allocated fd */
-static MSVCRT_FILE* MSVCRT_fstreams[2048];
-static int MSVCRT_stream_idx;
+static FILE* fstreams[2048];
+static int stream_idx;
/* INTERNAL: process umask */
static int MSVCRT_umask = 0;
/* INTERNAL: Static buffer for temp file name */
-static char MSVCRT_tmpname[MAX_PATH];
+static char tmpname[MAX_PATH];
static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
-/* This critical section protects the tables MSVCRT_fdesc and MSVCRT_fstreams,
- * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
- * and MSVCRT_stream_idx, from race conditions.
+/* This critical section protects the tables fdesc and fstreams,
+ * and their related indexes, fdstart, fdend,
+ * and stream_idx, from race conditions.
* It doesn't protect against race conditions manipulating the underlying files
* or flags; doing so would probably be better accomplished with per-file
* protection, rather than locking the whole table for every change.
*/
-static CRITICAL_SECTION MSVCRT_file_cs;
-#define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
-#define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
+static CRITICAL_SECTION FILE_cs;
+#define LOCK_FILES() do { EnterCriticalSection(&FILE_cs); } while (0)
+#define UNLOCK_FILES() do { LeaveCriticalSection(&FILE_cs); } while (0)
-static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
+static void stat64_to_stat(const struct __stat64 *buf64, struct _stat *buf)
{
buf->st_dev = buf64->st_dev;
buf->st_ino = buf64->st_ino;
buf->st_ctime = buf64->st_ctime;
}
-static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
+static void stat64_to_stati64(const struct __stat64 *buf64, struct _stati64 *buf)
{
buf->st_dev = buf64->st_dev;
buf->st_ino = buf64->st_ino;
buf->st_ctime = buf64->st_ctime;
}
-static inline BOOL msvcrt_is_valid_fd(int fd)
+static inline BOOL is_valid_fd(int fd)
{
- return fd >= 0 && fd < MSVCRT_fdend && (MSVCRT_fdesc[fd].wxflag & WX_OPEN);
+ return fd >= 0 && fd < fdend && (fdesc[fd].wxflag & WX_OPEN);
}
/* INTERNAL: Get the HANDLE for a fd
* it returns a valid handle which is about to be closed, a subsequent call
* will fail, most likely in a sane way.
*/
-static HANDLE msvcrt_fdtoh(int fd)
+static HANDLE fdtoh(int fd)
{
- if (!msvcrt_is_valid_fd(fd))
+ if (!is_valid_fd(fd))
{
WARN(":fd (%d) - no handle!\n",fd);
- *MSVCRT___doserrno() = 0;
- *MSVCRT__errno() = MSVCRT_EBADF;
+ *__doserrno() = 0;
+ *_errno() = EBADF;
return INVALID_HANDLE_VALUE;
}
- if (MSVCRT_fdesc[fd].handle == INVALID_HANDLE_VALUE) FIXME("wtf\n");
- return MSVCRT_fdesc[fd].handle;
+ //if (fdesc[fd].handle == INVALID_HANDLE_VALUE) FIXME("wtf\n");
+ return fdesc[fd].handle;
}
/* INTERNAL: free a file entry fd */
-static void msvcrt_free_fd(int fd)
+static void free_fd(int fd)
{
LOCK_FILES();
- MSVCRT_fdesc[fd].handle = INVALID_HANDLE_VALUE;
- MSVCRT_fdesc[fd].wxflag = 0;
+ fdesc[fd].handle = INVALID_HANDLE_VALUE;
+ fdesc[fd].wxflag = 0;
TRACE(":fd (%d) freed\n",fd);
if (fd < 3) /* don't use 0,1,2 for user files */
{
}
else
{
- if (fd == MSVCRT_fdend - 1)
- MSVCRT_fdend--;
- if (fd < MSVCRT_fdstart)
- MSVCRT_fdstart = fd;
+ if (fd == fdend - 1)
+ fdend--;
+ if (fd < fdstart)
+ fdstart = fd;
}
UNLOCK_FILES();
}
/* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
/* caller must hold the files lock */
-static int msvcrt_alloc_fd_from(HANDLE hand, int flag, int fd)
+static int alloc_fd_from(HANDLE hand, int flag, int fd)
{
- if (fd >= MSVCRT_MAX_FILES)
+ if (fd >= MAX_FILES)
{
WARN(":files exhausted!\n");
return -1;
}
- MSVCRT_fdesc[fd].handle = hand;
- MSVCRT_fdesc[fd].wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT));
+ fdesc[fd].handle = hand;
+ fdesc[fd].wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT));
/* locate next free slot */
- if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
- MSVCRT_fdstart = MSVCRT_fdend + 1;
+ if (fd == fdstart && fd == fdend)
+ fdstart = fdend + 1;
else
- while (MSVCRT_fdstart < MSVCRT_fdend &&
- MSVCRT_fdesc[MSVCRT_fdstart].handle != INVALID_HANDLE_VALUE)
- MSVCRT_fdstart++;
+ while (fdstart < fdend &&
+ fdesc[fdstart].handle != INVALID_HANDLE_VALUE)
+ fdstart++;
/* update last fd in use */
- if (fd >= MSVCRT_fdend)
- MSVCRT_fdend = fd + 1;
- TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
+ if (fd >= fdend)
+ fdend = fd + 1;
+ TRACE("fdstart is %d, fdend is %d\n", fdstart, fdend);
switch (fd)
{
}
/* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
-static int msvcrt_alloc_fd(HANDLE hand, int flag)
+/*static */int alloc_fd(HANDLE hand, int flag)
{
int ret;
LOCK_FILES();
- TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
- ret = msvcrt_alloc_fd_from(hand, flag, MSVCRT_fdstart);
+ TRACE(":handle (%p) allocating fd (%d)\n",hand,fdstart);
+ ret = alloc_fd_from(hand, flag, fdstart);
UNLOCK_FILES();
return ret;
}
/* INTERNAL: Allocate a FILE* for an fd slot */
/* caller must hold the files lock */
-static MSVCRT_FILE* msvcrt_alloc_fp(void)
+static FILE* alloc_fp(void)
{
unsigned int i;
- for (i = 3; i < sizeof(MSVCRT_fstreams) / sizeof(MSVCRT_fstreams[0]); i++)
+ for (i = 3; i < sizeof(fstreams) / sizeof(fstreams[0]); i++)
{
- if (!MSVCRT_fstreams[i] || MSVCRT_fstreams[i]->_flag == 0)
+ if (!fstreams[i] || fstreams[i]->_flag == 0)
{
- if (!MSVCRT_fstreams[i])
+ if (!fstreams[i])
{
- if (!(MSVCRT_fstreams[i] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
+ if (!(fstreams[i] = calloc(sizeof(FILE),1)))
return NULL;
- if (i == MSVCRT_stream_idx) MSVCRT_stream_idx++;
+ if (i == stream_idx) stream_idx++;
}
- return MSVCRT_fstreams[i];
+ return fstreams[i];
}
}
return NULL;
}
/* INTERNAL: initialize a FILE* from an open fd */
-static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
+static int init_fp(FILE* file, int fd, unsigned stream_flags)
{
TRACE(":fd (%d) allocating FILE*\n",fd);
- if (!msvcrt_is_valid_fd(fd))
+ if (!is_valid_fd(fd))
{
WARN(":invalid fd %d\n",fd);
- *MSVCRT___doserrno() = 0;
- *MSVCRT__errno() = MSVCRT_EBADF;
+ *__doserrno() = 0;
+ *_errno() = EBADF;
return -1;
}
memset(file, 0, sizeof(*file));
* 04 char file flags (wxflag): repeated for each fd
* 4+NBFD HANDLE file handle: repeated for each fd
*/
-unsigned msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
+unsigned create_io_inherit_block(WORD *size, BYTE **block)
{
int fd;
char* wxflag_ptr;
HANDLE* handle_ptr;
- *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
- *block = MSVCRT_calloc(*size, 1);
+ *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * fdend;
+ *block = calloc(*size, 1);
if (!*block)
{
*size = 0;
return FALSE;
}
wxflag_ptr = (char*)*block + sizeof(unsigned);
- handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
+ handle_ptr = (HANDLE*)(wxflag_ptr + fdend * sizeof(char));
- *(unsigned*)*block = MSVCRT_fdend;
- for (fd = 0; fd < MSVCRT_fdend; fd++)
+ *(unsigned*)*block = fdend;
+ for (fd = 0; fd < fdend; fd++)
{
/* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
- if ((MSVCRT_fdesc[fd].wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
+ if ((fdesc[fd].wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
{
- *wxflag_ptr = MSVCRT_fdesc[fd].wxflag;
- *handle_ptr = MSVCRT_fdesc[fd].handle;
+ *wxflag_ptr = fdesc[fd].wxflag;
+ *handle_ptr = fdesc[fd].handle;
}
else
{
STARTUPINFOA si;
int i;
- InitializeCriticalSection(&MSVCRT_file_cs);
- MSVCRT_file_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs");
+ InitializeCriticalSection(&FILE_cs);
+ FILE_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FILE_cs");
GetStartupInfoA(&si);
if (si.cbReserved2 != 0 && si.lpReserved2 != NULL)
{
char* wxflag_ptr;
HANDLE* handle_ptr;
- MSVCRT_fdend = *(unsigned*)si.lpReserved2;
+ fdend = *(unsigned*)si.lpReserved2;
wxflag_ptr = (char*)(si.lpReserved2 + sizeof(unsigned));
- handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
+ handle_ptr = (HANDLE*)(wxflag_ptr + fdend * sizeof(char));
- MSVCRT_fdend = min(MSVCRT_fdend, sizeof(MSVCRT_fdesc) / sizeof(MSVCRT_fdesc[0]));
- for (i = 0; i < MSVCRT_fdend; i++)
+ fdend = min(fdend, sizeof(fdesc) / sizeof(fdesc[0]));
+ for (i = 0; i < fdend; i++)
{
if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
{
- MSVCRT_fdesc[i].wxflag = *wxflag_ptr;
- MSVCRT_fdesc[i].handle = *handle_ptr;
+ fdesc[i].wxflag = *wxflag_ptr;
+ fdesc[i].handle = *handle_ptr;
}
else
{
- MSVCRT_fdesc[i].wxflag = 0;
- MSVCRT_fdesc[i].handle = INVALID_HANDLE_VALUE;
+ fdesc[i].wxflag = 0;
+ fdesc[i].handle = INVALID_HANDLE_VALUE;
}
wxflag_ptr++; handle_ptr++;
}
- for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
- if (MSVCRT_fdesc[MSVCRT_fdstart].handle == INVALID_HANDLE_VALUE) break;
+ for (fdstart = 3; fdstart < fdend; fdstart++)
+ if (fdesc[fdstart].handle == INVALID_HANDLE_VALUE) break;
}
- if (!(MSVCRT_fdesc[0].wxflag & WX_OPEN) || MSVCRT_fdesc[0].handle == INVALID_HANDLE_VALUE)
+ if (!(fdesc[0].wxflag & WX_OPEN) || fdesc[0].handle == INVALID_HANDLE_VALUE)
{
+#ifndef __REACTOS__
DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
- GetCurrentProcess(), &MSVCRT_fdesc[0].handle, 0, TRUE,
+ GetCurrentProcess(), &fdesc[0].handle, 0, TRUE,
DUPLICATE_SAME_ACCESS);
- MSVCRT_fdesc[0].wxflag = WX_OPEN | WX_TEXT;
+#else
+ fdesc[0].handle = GetStdHandle(STD_INPUT_HANDLE);
+ if (fdesc[0].handle == NULL)
+ fdesc[0].handle = INVALID_HANDLE_VALUE;
+#endif
+ fdesc[0].wxflag = WX_OPEN | WX_TEXT;
}
- if (!(MSVCRT_fdesc[1].wxflag & WX_OPEN) || MSVCRT_fdesc[1].handle == INVALID_HANDLE_VALUE)
+ if (!(fdesc[1].wxflag & WX_OPEN) || fdesc[1].handle == INVALID_HANDLE_VALUE)
{
- DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
- GetCurrentProcess(), &MSVCRT_fdesc[1].handle, 0, TRUE,
+#ifndef __REACTOS__
+ DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
+ GetCurrentProcess(), &fdesc[1].handle, 0, TRUE,
DUPLICATE_SAME_ACCESS);
- MSVCRT_fdesc[1].wxflag = WX_OPEN | WX_TEXT;
+#else
+ fdesc[1].handle = GetStdHandle(STD_OUTPUT_HANDLE);
+ if (fdesc[1].handle == NULL)
+ fdesc[1].handle = INVALID_HANDLE_VALUE;
+#endif
+ fdesc[1].wxflag = WX_OPEN | WX_TEXT;
}
- if (!(MSVCRT_fdesc[2].wxflag & WX_OPEN) || MSVCRT_fdesc[2].handle == INVALID_HANDLE_VALUE)
+ if (!(fdesc[2].wxflag & WX_OPEN) || fdesc[2].handle == INVALID_HANDLE_VALUE)
{
- DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
- GetCurrentProcess(), &MSVCRT_fdesc[2].handle, 0, TRUE,
+#ifndef __REACTOS__
+ DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
+ GetCurrentProcess(), &fdesc[2].handle, 0, TRUE,
DUPLICATE_SAME_ACCESS);
- MSVCRT_fdesc[2].wxflag = WX_OPEN | WX_TEXT;
+#else
+ fdesc[2].handle = GetStdHandle(STD_ERROR_HANDLE);
+ if (fdesc[2].handle == NULL)
+ fdesc[2].handle = INVALID_HANDLE_VALUE;
+#endif
+ fdesc[2].wxflag = WX_OPEN | WX_TEXT;
}
- TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_fdesc[0].handle,
- MSVCRT_fdesc[1].handle,MSVCRT_fdesc[2].handle);
+ TRACE(":handles (%p)(%p)(%p)\n",fdesc[0].handle,
+ fdesc[1].handle,fdesc[2].handle);
- memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
+ memset(_iob,0,3*sizeof(FILE));
for (i = 0; i < 3; i++)
{
/* FILE structs for stdin/out/err are static and never deleted */
- MSVCRT_fstreams[i] = &MSVCRT__iob[i];
- MSVCRT__iob[i]._file = i;
- MSVCRT__iob[i]._tmpfname = NULL;
- MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
+ fstreams[i] = &_iob[i];
+ _iob[i]._file = i;
+ _iob[i]._tmpfname = NULL;
+ _iob[i]._flag = (i == 0) ? _IOREAD : _IOWRT;
}
- MSVCRT_stream_idx = 3;
+ stream_idx = 3;
}
/* INTERNAL: Flush stdio file buffer */
-static int msvcrt_flush_buffer(MSVCRT_FILE* file)
+static int flush_buffer(FILE* file)
{
if(file->_bufsiz) {
int cnt=file->_ptr-file->_base;
- if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
- file->_flag |= MSVCRT__IOERR;
- return MSVCRT_EOF;
+ if(cnt>0 && _write(file->_file, file->_base, cnt) != cnt) {
+ file->_flag |= _IOERR;
+ return EOF;
}
file->_ptr=file->_base;
file->_cnt=file->_bufsiz;
}
/* INTERNAL: Allocate stdio file buffer */
-static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
+static void alloc_buffer(FILE* file)
{
- file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
+ file->_base = calloc(BUFSIZ,1);
if(file->_base) {
- file->_bufsiz = MSVCRT_BUFSIZ;
- file->_flag |= MSVCRT__IOMYBUF;
+ file->_bufsiz = BUFSIZ;
+ file->_flag |= _IOMYBUF;
} else {
file->_base = (char*)(&file->_charbuf);
/* put here 2 ??? */
}
/* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
-static void msvcrt_int_to_base32(int num, char *str)
+static void int_to_base32(int num, char *str)
{
char *p;
int n = num;
/*********************************************************************
* __p__iob(MSVCRT.@)
*/
-MSVCRT_FILE * CDECL __p__iob(void)
+FILE * CDECL __p__iob(void)
{
- return &MSVCRT__iob[0];
+ return &_iob[0];
}
/*********************************************************************
* _access (MSVCRT.@)
*/
-int CDECL MSVCRT__access(const char *filename, int mode)
+int CDECL _access(const char *filename, int mode)
{
DWORD attr = GetFileAttributesA(filename);
if (!filename || attr == INVALID_FILE_ATTRIBUTES)
{
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
- if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
+ if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
{
- msvcrt_set_errno(ERROR_ACCESS_DENIED);
+ __set_errno(ERROR_ACCESS_DENIED);
return -1;
}
return 0;
/*********************************************************************
* _waccess (MSVCRT.@)
*/
-int CDECL _waccess(const MSVCRT_wchar_t *filename, int mode)
+int CDECL _waccess(const wchar_t *filename, int mode)
{
DWORD attr = GetFileAttributesW(filename);
if (!filename || attr == INVALID_FILE_ATTRIBUTES)
{
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
- if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
+ if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
{
- msvcrt_set_errno(ERROR_ACCESS_DENIED);
+ __set_errno(ERROR_ACCESS_DENIED);
return -1;
}
return 0;
/*********************************************************************
* _chmod (MSVCRT.@)
*/
-int CDECL MSVCRT__chmod(const char *path, int flags)
+int CDECL _chmod(const char *path, int flags)
{
DWORD oldFlags = GetFileAttributesA(path);
if (oldFlags != INVALID_FILE_ATTRIBUTES)
{
- DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
+ DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
oldFlags | FILE_ATTRIBUTE_READONLY;
if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
return 0;
}
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _wchmod (MSVCRT.@)
*/
-int CDECL _wchmod(const MSVCRT_wchar_t *path, int flags)
+int CDECL _wchmod(const wchar_t *path, int flags)
{
DWORD oldFlags = GetFileAttributesW(path);
if (oldFlags != INVALID_FILE_ATTRIBUTES)
{
- DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
+ DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
oldFlags | FILE_ATTRIBUTE_READONLY;
if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
return 0;
}
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _unlink (MSVCRT.@)
*/
-int CDECL MSVCRT__unlink(const char *path)
+int CDECL _unlink(const char *path)
{
TRACE("%s\n",debugstr_a(path));
if(DeleteFileA(path))
return 0;
TRACE("failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _wunlink (MSVCRT.@)
*/
-int CDECL _wunlink(const MSVCRT_wchar_t *path)
+int CDECL _wunlink(const wchar_t *path)
{
TRACE("(%s)\n",debugstr_w(path));
if(DeleteFileW(path))
return 0;
TRACE("failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
-/* _flushall calls MSVCRT_fflush which calls _flushall */
-int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
+/* _flushall calls fflush which calls _flushall */
+int CDECL fflush(FILE* file);
/*********************************************************************
* _flushall (MSVCRT.@)
int i, num_flushed = 0;
LOCK_FILES();
- for (i = 3; i < MSVCRT_stream_idx; i++)
- if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag)
+ for (i = 3; i < stream_idx; i++)
+ if (fstreams[i] && fstreams[i]->_flag)
{
#if 0
/* FIXME: flush, do not commit */
if (_commit(i) == -1)
- if (MSVCRT_fstreams[i])
- MSVCRT_fstreams[i]->_flag |= MSVCRT__IOERR;
+ if (fstreams[i])
+ fstreams[i]->_flag |= _IOERR;
#endif
- if(MSVCRT_fstreams[i]->_flag & MSVCRT__IOWRT) {
- MSVCRT_fflush(MSVCRT_fstreams[i]);
+ if(fstreams[i]->_flag & _IOWRT) {
+ fflush(fstreams[i]);
num_flushed++;
}
}
/*********************************************************************
* fflush (MSVCRT.@)
*/
-int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
+int CDECL fflush(FILE* file)
{
if(!file) {
_flushall();
- } else if(file->_flag & MSVCRT__IOWRT) {
- int res=msvcrt_flush_buffer(file);
+ } else if(file->_flag & _IOWRT) {
+ int res=flush_buffer(file);
return res;
}
return 0;
/*********************************************************************
* _close (MSVCRT.@)
*/
-int CDECL MSVCRT__close(int fd)
+int CDECL _close(int fd)
{
HANDLE hand;
int ret;
LOCK_FILES();
- hand = msvcrt_fdtoh(fd);
+ hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (hand == INVALID_HANDLE_VALUE)
ret = -1;
else if (!CloseHandle(hand))
{
WARN(":failed-last error (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
ret = -1;
}
else
{
- msvcrt_free_fd(fd);
+ free_fd(fd);
ret = 0;
}
UNLOCK_FILES();
*/
int CDECL _commit(int fd)
{
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (hand == INVALID_HANDLE_VALUE)
return 0;
}
TRACE(":failed-last error (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
TRACE(":ok\n");
* indicate file descriptors duplicated with _dup and _dup2 are always
* inheritable.
*/
-int CDECL MSVCRT__dup2(int od, int nd)
+int CDECL _dup2(int od, int nd)
{
int ret;
TRACE("(od=%d, nd=%d)\n", od, nd);
LOCK_FILES();
- if (nd < MSVCRT_MAX_FILES && msvcrt_is_valid_fd(od))
+ if (nd < MAX_FILES && is_valid_fd(od))
{
HANDLE handle;
- if (DuplicateHandle(GetCurrentProcess(), MSVCRT_fdesc[od].handle,
+ if (DuplicateHandle(GetCurrentProcess(), fdesc[od].handle,
GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
{
- int wxflag = MSVCRT_fdesc[od].wxflag & ~MSVCRT__O_NOINHERIT;
+ int wxflag = fdesc[od].wxflag & ~_O_NOINHERIT;
- if (msvcrt_is_valid_fd(nd))
- MSVCRT__close(nd);
- ret = msvcrt_alloc_fd_from(handle, wxflag, nd);
+ if (is_valid_fd(nd))
+ _close(nd);
+ ret = alloc_fd_from(handle, wxflag, nd);
if (ret == -1)
{
CloseHandle(handle);
- *MSVCRT__errno() = MSVCRT_EMFILE;
+ *_errno() = EMFILE;
}
else
{
else
{
ret = -1;
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
}
}
else
{
- *MSVCRT__errno() = MSVCRT_EBADF;
+ *_errno() = EBADF;
ret = -1;
}
UNLOCK_FILES();
/*********************************************************************
* _dup (MSVCRT.@)
*/
-int CDECL MSVCRT__dup(int od)
+int CDECL _dup(int od)
{
int fd, ret;
LOCK_FILES();
- fd = MSVCRT_fdstart;
- if (MSVCRT__dup2(od, fd) == 0)
+ fd = fdstart;
+ if (_dup2(od, fd) == 0)
ret = fd;
else
ret = -1;
{
DWORD curpos,endpos;
LONG hcurpos,hendpos;
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (hand == INVALID_HANDLE_VALUE)
return -1;
- if (MSVCRT_fdesc[fd].wxflag & WX_ATEOF) return TRUE;
+ if (fdesc[fd].wxflag & WX_ATEOF) return TRUE;
/* Otherwise we do it the hard way */
hcurpos = hendpos = 0;
/*********************************************************************
* _fcloseall (MSVCRT.@)
*/
-int CDECL MSVCRT__fcloseall(void)
+int CDECL _fcloseall(void)
{
int num_closed = 0, i;
LOCK_FILES();
- for (i = 3; i < MSVCRT_stream_idx; i++)
- if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag &&
- !MSVCRT_fclose(MSVCRT_fstreams[i]))
+ for (i = 3; i < stream_idx; i++)
+ if (fstreams[i] && fstreams[i]->_flag &&
+ !fclose(fstreams[i]))
num_closed++;
UNLOCK_FILES();
/* free everything on process exit */
void msvcrt_free_io(void)
{
- MSVCRT__fcloseall();
+ _fcloseall();
/* The Win32 _fcloseall() function explicitly doesn't close stdin,
* stdout, and stderr (unlike GNU), so we need to fclose() them here
* or they won't get flushed.
*/
- MSVCRT_fclose(&MSVCRT__iob[0]);
- MSVCRT_fclose(&MSVCRT__iob[1]);
- MSVCRT_fclose(&MSVCRT__iob[2]);
- MSVCRT_file_cs.DebugInfo->Spare[0] = 0;
- DeleteCriticalSection(&MSVCRT_file_cs);
+ fclose(&_iob[0]);
+ fclose(&_iob[1]);
+ fclose(&_iob[2]);
+ FILE_cs.DebugInfo->Spare[0] = 0;
+ DeleteCriticalSection(&FILE_cs);
}
/*********************************************************************
* _lseeki64 (MSVCRT.@)
*/
-__int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
+__int64 CDECL _lseeki64(int fd, __int64 offset, int whence)
{
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
LARGE_INTEGER ofs, ret;
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (whence < 0 || whence > 2)
{
- *MSVCRT__errno() = MSVCRT_EINVAL;
+ *_errno() = EINVAL;
return -1;
}
ofs.QuadPart = offset;
if (SetFilePointerEx(hand, ofs, &ret, whence))
{
- MSVCRT_fdesc[fd].wxflag &= ~(WX_ATEOF|WX_READEOF);
+ fdesc[fd].wxflag &= ~(WX_ATEOF|WX_READEOF);
/* FIXME: What if we seek _to_ EOF - is EOF set? */
return ret.QuadPart;
}
TRACE(":error-last error (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _lseek (MSVCRT.@)
*/
-LONG CDECL MSVCRT__lseek(int fd, LONG offset, int whence)
+LONG CDECL _lseek(int fd, LONG offset, int whence)
{
- return MSVCRT__lseeki64(fd, offset, whence);
+ return _lseeki64(fd, offset, whence);
}
/*********************************************************************
*
* This is untested; the underlying LockFile doesn't work yet.
*/
-int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
+int CDECL _locking(int fd, int mode, LONG nbytes)
{
BOOL ret;
DWORD cur_locn;
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (hand == INVALID_HANDLE_VALUE)
if (mode < 0 || mode > 4)
{
- *MSVCRT__errno() = MSVCRT_EINVAL;
+ *_errno() = EINVAL;
return -1;
}
TRACE(":fd (%d) by 0x%08x mode %s\n",
- fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
- (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
- (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
- (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
- (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
+ fd,nbytes,(mode==_LK_UNLCK)?"_LK_UNLCK":
+ (mode==_LK_LOCK)?"_LK_LOCK":
+ (mode==_LK_NBLCK)?"_LK_NBLCK":
+ (mode==_LK_RLCK)?"_LK_RLCK":
+ (mode==_LK_NBRLCK)?"_LK_NBRLCK":
"UNKNOWN");
if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
{
FIXME ("Seek failed\n");
- *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
+ *_errno() = EINVAL; /* FIXME */
return -1;
}
- if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
+ if (mode == _LK_LOCK || mode == _LK_RLCK)
{
int nretry = 10;
ret = 1; /* just to satisfy gcc */
Sleep(1);
}
}
- else if (mode == MSVCRT__LK_UNLCK)
+ else if (mode == _LK_UNLCK)
ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
else
ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
/*********************************************************************
* fseek (MSVCRT.@)
*/
-int CDECL MSVCRT_fseek(MSVCRT_FILE* file, long offset, int whence)
+int CDECL fseek(FILE* file, long offset, int whence)
{
/* Flush output if needed */
- if(file->_flag & MSVCRT__IOWRT)
- msvcrt_flush_buffer(file);
+ if(file->_flag & _IOWRT)
+ flush_buffer(file);
- if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
+ if(whence == SEEK_CUR && file->_flag & _IOREAD ) {
offset -= file->_cnt;
}
/* Discard buffered input */
file->_cnt = 0;
file->_ptr = file->_base;
/* Reset direction of i/o */
- if(file->_flag & MSVCRT__IORW) {
- file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
+ if(file->_flag & _IORW) {
+ file->_flag &= ~(_IOREAD|_IOWRT);
}
/* Clear end of file flag */
- file->_flag &= ~MSVCRT__IOEOF;
- return (MSVCRT__lseek(file->_file,offset,whence) == -1)?-1:0;
+ file->_flag &= ~_IOEOF;
+ return (_lseek(file->_file,offset,whence) == -1)?-1:0;
}
/*********************************************************************
LOCK_FILES();
- handle = msvcrt_fdtoh(fd);
+ handle = fdtoh(fd);
if (handle != INVALID_HANDLE_VALUE)
{
/* save the current file pointer */
- cur = MSVCRT__lseek(fd, 0, SEEK_CUR);
+ cur = _lseek(fd, 0, SEEK_CUR);
if (cur >= 0)
{
- pos = MSVCRT__lseek(fd, size, SEEK_SET);
+ pos = _lseek(fd, size, SEEK_SET);
if (pos >= 0)
{
ret = SetEndOfFile(handle);
- if (!ret) msvcrt_set_errno(GetLastError());
+ if (!ret) __set_errno(GetLastError());
}
/* restore the file pointer */
- MSVCRT__lseek(fd, cur, SEEK_SET);
+ _lseek(fd, cur, SEEK_SET);
}
}
/*********************************************************************
* clearerr (MSVCRT.@)
*/
-void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
+void CDECL clearerr(FILE* file)
{
TRACE(":file (%p) fd (%d)\n",file,file->_file);
- file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
+ file->_flag &= ~(_IOERR | _IOEOF);
}
/*********************************************************************
* rewind (MSVCRT.@)
*/
-void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
+void CDECL rewind(FILE* file)
{
TRACE(":file (%p) fd (%d)\n",file,file->_file);
- MSVCRT_fseek(file, 0L, SEEK_SET);
- MSVCRT_clearerr(file);
+ fseek(file, 0L, SEEK_SET);
+ clearerr(file);
}
-static int msvcrt_get_flags(const char* mode, int *open_flags, int* stream_flags)
+static int get_flags(const char* mode, int *open_flags, int* stream_flags)
{
int plus = strchr(mode, '+') != NULL;
switch(*mode++)
{
case 'R': case 'r':
- *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
- *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
+ *open_flags = plus ? _O_RDWR : _O_RDONLY;
+ *stream_flags = plus ? _IORW : _IOREAD;
break;
case 'W': case 'w':
- *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
- *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
+ *open_flags = _O_CREAT | _O_TRUNC | (plus ? _O_RDWR : _O_WRONLY);
+ *stream_flags = plus ? _IORW : _IOWRT;
break;
case 'A': case 'a':
- *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
- *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
+ *open_flags = _O_CREAT | _O_APPEND | (plus ? _O_RDWR : _O_WRONLY);
+ *stream_flags = plus ? _IORW : _IOWRT;
break;
default:
return -1;
switch (*mode++)
{
case 'B': case 'b':
- *open_flags |= MSVCRT__O_BINARY;
- *open_flags &= ~MSVCRT__O_TEXT;
+ *open_flags |= _O_BINARY;
+ *open_flags &= ~_O_TEXT;
break;
case 'T': case 't':
- *open_flags |= MSVCRT__O_TEXT;
- *open_flags &= ~MSVCRT__O_BINARY;
+ *open_flags |= _O_TEXT;
+ *open_flags &= ~_O_BINARY;
break;
case '+':
break;
/*********************************************************************
* _fdopen (MSVCRT.@)
*/
-MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
+FILE* CDECL _fdopen(int fd, const char *mode)
{
int open_flags, stream_flags;
- MSVCRT_FILE* file;
+ FILE* file;
- if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
+ if (get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
LOCK_FILES();
- if (!(file = msvcrt_alloc_fp()))
+ if (!(file = alloc_fp()))
file = NULL;
- else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
+ else if (init_fp(file, fd, stream_flags) == -1)
{
file->_flag = 0;
file = NULL;
/*********************************************************************
* _wfdopen (MSVCRT.@)
*/
-MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
+FILE* CDECL _wfdopen(int fd, const wchar_t *mode)
{
unsigned mlen = strlenW(mode);
- char *modea = MSVCRT_calloc(mlen + 1, 1);
- MSVCRT_FILE* file = NULL;
+ char *modea = calloc(mlen + 1, 1);
+ FILE* file = NULL;
int open_flags, stream_flags;
if (modea &&
WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
{
- if (msvcrt_get_flags(modea, &open_flags, &stream_flags) == -1) return NULL;
+ if (get_flags(modea, &open_flags, &stream_flags) == -1) return NULL;
LOCK_FILES();
- if (!(file = msvcrt_alloc_fp()))
+ if (!(file = alloc_fp()))
file = NULL;
- else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
+ else if (init_fp(file, fd, stream_flags) == -1)
{
file->_flag = 0;
file = NULL;
else
{
if (file)
- MSVCRT_rewind(file); /* FIXME: is this needed ??? */
+ rewind(file); /* FIXME: is this needed ??? */
TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
}
UNLOCK_FILES();
/*********************************************************************
* _filelength (MSVCRT.@)
*/
-LONG CDECL MSVCRT__filelength(int fd)
+LONG CDECL _filelength(int fd)
{
- LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
+ LONG curPos = _lseek(fd, 0, SEEK_CUR);
if (curPos != -1)
{
- LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
+ LONG endPos = _lseek(fd, 0, SEEK_END);
if (endPos != -1)
{
if (endPos != curPos)
- MSVCRT__lseek(fd, curPos, SEEK_SET);
+ _lseek(fd, curPos, SEEK_SET);
return endPos;
}
}
/*********************************************************************
* _filelengthi64 (MSVCRT.@)
*/
-__int64 CDECL MSVCRT__filelengthi64(int fd)
+__int64 CDECL _filelengthi64(int fd)
{
- __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
+ __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
if (curPos != -1)
{
- __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
+ __int64 endPos = _lseeki64(fd, 0, SEEK_END);
if (endPos != -1)
{
if (endPos != curPos)
- MSVCRT__lseeki64(fd, curPos, SEEK_SET);
+ _lseeki64(fd, curPos, SEEK_SET);
return endPos;
}
}
/*********************************************************************
* _fileno (MSVCRT.@)
*/
-int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
+int CDECL _fileno(FILE* file)
{
TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
return file->_file;
/*********************************************************************
* _fstat64 (MSVCRT.@)
*/
-int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
+int CDECL _fstat64(int fd, struct __stat64* buf)
{
DWORD dw;
DWORD type;
BY_HANDLE_FILE_INFORMATION hfi;
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) stat (%p)\n",fd,buf);
if (hand == INVALID_HANDLE_VALUE)
if (!buf)
{
WARN(":failed-NULL buf\n");
- msvcrt_set_errno(ERROR_INVALID_PARAMETER);
+ __set_errno(ERROR_INVALID_PARAMETER);
return -1;
}
memset(&hfi, 0, sizeof(hfi));
- memset(buf, 0, sizeof(struct MSVCRT__stat64));
+ memset(buf, 0, sizeof(struct __stat64));
type = GetFileType(hand);
if (type == FILE_TYPE_PIPE)
{
if (!GetFileInformationByHandle(hand, &hfi))
{
WARN(":failed-last error (%d)\n",GetLastError());
- msvcrt_set_errno(ERROR_INVALID_PARAMETER);
+ __set_errno(ERROR_INVALID_PARAMETER);
return -1;
}
buf->st_mode = S_IFREG | S_IREAD;
/*********************************************************************
* _fstati64 (MSVCRT.@)
*/
-int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
+int CDECL _fstati64(int fd, struct _stati64* buf)
{
int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__fstat64(fd, &buf64);
+ ret = _fstat64(fd, &buf64);
if (!ret)
- msvcrt_stat64_to_stati64(&buf64, buf);
+ stat64_to_stati64(&buf64, buf);
return ret;
}
/*********************************************************************
* _fstat (MSVCRT.@)
*/
-int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
+int CDECL _fstat(int fd, struct _stat* buf)
{ int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__fstat64(fd, &buf64);
+ ret = _fstat64(fd, &buf64);
if (!ret)
- msvcrt_stat64_to_stat(&buf64, buf);
+ stat64_to_stat(&buf64, buf);
return ret;
}
/*********************************************************************
* _futime (MSVCRT.@)
*/
-int CDECL _futime(int fd, struct MSVCRT__utimbuf *t)
+int CDECL _futime(int fd, struct _utimbuf *t)
{
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
FILETIME at, wt;
+ if (hand == INVALID_HANDLE_VALUE)
+ return -1;
+
if (!t)
{
- MSVCRT_time_t currTime;
- MSVCRT_time(&currTime);
+ time_t currTime;
+ time(&currTime);
RtlSecondsSince1970ToTime(currTime, (LARGE_INTEGER *)&at);
wt = at;
}
if (!SetFileTime(hand, NULL, &at, &wt))
{
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1 ;
}
return 0;
*/
long CDECL _get_osfhandle(int fd)
{
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
- return (long)hand;
+ return (long)(LONG_PTR)hand;
}
/*********************************************************************
*/
int CDECL _isatty(int fd)
{
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
TRACE(":fd (%d) handle (%p)\n",fd,hand);
if (hand == INVALID_HANDLE_VALUE)
/*********************************************************************
* _wmktemp (MSVCRT.@)
*/
-MSVCRT_wchar_t * CDECL _wmktemp(MSVCRT_wchar_t *pattern)
+wchar_t * CDECL _wmktemp(wchar_t *pattern)
{
int numX = 0;
- MSVCRT_wchar_t *retVal = pattern;
+ wchar_t *retVal = pattern;
int id;
- MSVCRT_wchar_t letter = 'a';
+ wchar_t letter = 'a';
while(*pattern)
numX = (*pattern++ == 'X')? numX + 1 : 0;
return NULL;
}
-static unsigned split_oflags(unsigned oflags)
+/*static */unsigned split_oflags(unsigned oflags)
{
int wxflags = 0;
unsigned unsupp; /* until we support everything */
- if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
- if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
- else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
- else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
+ if (oflags & _O_APPEND) wxflags |= WX_APPEND;
+ if (oflags & _O_BINARY) {/* Nothing to do */}
+ else if (oflags & _O_TEXT) wxflags |= WX_TEXT;
+ else if (*__p__fmode() & _O_BINARY) {/* Nothing to do */}
else wxflags |= WX_TEXT; /* default to TEXT*/
- if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
+ if (oflags & _O_NOINHERIT) wxflags |= WX_DONTINHERIT;
if ((unsupp = oflags & ~(
- MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
- MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
- MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
- MSVCRT__O_NOINHERIT|
- MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED
+ _O_BINARY|_O_TEXT|_O_APPEND|
+ _O_TRUNC|_O_EXCL|_O_CREAT|
+ _O_RDWR|_O_WRONLY|_O_TEMPORARY|
+ _O_NOINHERIT|
+ _O_SEQUENTIAL|_O_RANDOM|_O_SHORT_LIVED
)))
ERR(":unsupported oflags 0x%04x\n",unsupp);
/*********************************************************************
* _pipe (MSVCRT.@)
*/
-int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
+int CDECL _pipe(int *pfds, unsigned int psize, int textmode)
{
int ret = -1;
SECURITY_ATTRIBUTES sa;
if (!pfds)
{
- *MSVCRT__errno() = MSVCRT_EINVAL;
+ *_errno() = EINVAL;
return -1;
}
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
- sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
+ sa.bInheritHandle = !(textmode & _O_NOINHERIT);
sa.lpSecurityDescriptor = NULL;
if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
{
int fd;
LOCK_FILES();
- fd = msvcrt_alloc_fd(readHandle, wxflags);
+ fd = alloc_fd(readHandle, wxflags);
if (fd != -1)
{
pfds[0] = fd;
- fd = msvcrt_alloc_fd(writeHandle, wxflags);
+ fd = alloc_fd(writeHandle, wxflags);
if (fd != -1)
{
pfds[1] = fd;
}
else
{
- MSVCRT__close(pfds[0]);
+ _close(pfds[0]);
CloseHandle(writeHandle);
- *MSVCRT__errno() = MSVCRT_EMFILE;
+ *_errno() = EMFILE;
}
}
else
{
CloseHandle(readHandle);
CloseHandle(writeHandle);
- *MSVCRT__errno() = MSVCRT_EMFILE;
+ *_errno() = EMFILE;
}
UNLOCK_FILES();
}
else
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return ret;
}
/*********************************************************************
* _sopen (MSVCRT.@)
*/
-int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
+int CDECL _sopen( const char *path, int oflags, int shflags, ... )
{
va_list ap;
int pmode;
path, oflags, shflags);
wxflag = split_oflags(oflags);
- switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
+ switch (oflags & (_O_RDONLY | _O_WRONLY | _O_RDWR))
{
- case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
- case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
- case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
+ case _O_RDONLY: access |= GENERIC_READ; break;
+ case _O_WRONLY: access |= GENERIC_WRITE; break;
+ case _O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
}
- if (oflags & MSVCRT__O_CREAT)
+ if (oflags & _O_CREAT)
{
va_start(ap, shflags);
pmode = va_arg(ap, int);
va_end(ap);
- if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
+ if(pmode & ~(_S_IREAD | _S_IWRITE))
FIXME(": pmode 0x%04x ignored\n", pmode);
else
WARN(": pmode 0x%04x ignored\n", pmode);
- if (oflags & MSVCRT__O_EXCL)
+ if (oflags & _O_EXCL)
creation = CREATE_NEW;
- else if (oflags & MSVCRT__O_TRUNC)
+ else if (oflags & _O_TRUNC)
creation = CREATE_ALWAYS;
else
creation = OPEN_ALWAYS;
}
- else /* no MSVCRT__O_CREAT */
+ else /* no _O_CREAT */
{
- if (oflags & MSVCRT__O_TRUNC)
+ if (oflags & _O_TRUNC)
creation = TRUNCATE_EXISTING;
else
creation = OPEN_EXISTING;
switch( shflags )
{
- case MSVCRT__SH_DENYRW:
+ case _SH_DENYRW:
sharing = 0L;
break;
- case MSVCRT__SH_DENYWR:
+ case _SH_DENYWR:
sharing = FILE_SHARE_READ;
break;
- case MSVCRT__SH_DENYRD:
+ case _SH_DENYRD:
sharing = FILE_SHARE_WRITE;
break;
- case MSVCRT__SH_DENYNO:
+ case _SH_DENYNO:
sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
break;
default:
}
attrib = FILE_ATTRIBUTE_NORMAL;
- if (oflags & MSVCRT__O_TEMPORARY)
+ if (oflags & _O_TEMPORARY)
{
attrib |= FILE_FLAG_DELETE_ON_CLOSE;
access |= DELETE;
sa.nLength = sizeof( SECURITY_ATTRIBUTES );
sa.lpSecurityDescriptor = NULL;
- sa.bInheritHandle = (oflags & MSVCRT__O_NOINHERIT) ? FALSE : TRUE;
+ sa.bInheritHandle = (oflags & _O_NOINHERIT) ? FALSE : TRUE;
hand = CreateFileA(path, access, sharing, &sa, creation, attrib, 0);
if (hand == INVALID_HANDLE_VALUE) {
WARN(":failed-last error (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
- fd = msvcrt_alloc_fd(hand, wxflag);
+ fd = alloc_fd(hand, wxflag);
TRACE(":fd (%d) handle (%p)\n",fd, hand);
return fd;
/*********************************************************************
* _wsopen (MSVCRT.@)
*/
-int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
+int CDECL _wsopen( const wchar_t* path, int oflags, int shflags, ... )
{
const unsigned int len = strlenW(path);
- char *patha = MSVCRT_calloc(len + 1,1);
+ char *patha = calloc(len + 1,1);
va_list ap;
int pmode;
if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
{
- int retval = MSVCRT__sopen(patha,oflags,shflags,pmode);
- MSVCRT_free(patha);
+ int retval = _sopen(patha,oflags,shflags,pmode);
+ free(patha);
return retval;
}
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _open (MSVCRT.@)
*/
-int CDECL MSVCRT__open( const char *path, int flags, ... )
+int CDECL _open( const char *path, int flags, ... )
{
va_list ap;
- if (flags & MSVCRT__O_CREAT)
+ if (flags & _O_CREAT)
{
int pmode;
va_start(ap, flags);
pmode = va_arg(ap, int);
va_end(ap);
- return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
+ return _sopen( path, flags, _SH_DENYNO, pmode );
}
else
- return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
+ return _sopen( path, flags, _SH_DENYNO);
}
/*********************************************************************
* _wopen (MSVCRT.@)
*/
-int CDECL _wopen(const MSVCRT_wchar_t *path,int flags,...)
+int CDECL _wopen(const wchar_t *path,int flags,...)
{
const unsigned int len = strlenW(path);
- char *patha = MSVCRT_calloc(len + 1,1);
+ char *patha = calloc(len + 1,1);
va_list ap;
int pmode;
if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
{
- int retval = MSVCRT__open(patha,flags,pmode);
- MSVCRT_free(patha);
+ int retval = _open(patha,flags,pmode);
+ free(patha);
return retval;
}
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _creat (MSVCRT.@)
*/
-int CDECL MSVCRT__creat(const char *path, int flags)
+int CDECL _creat(const char *path, int flags)
{
- int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
- return MSVCRT__open(path, usedFlags);
+ int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
+ return _open(path, usedFlags);
}
/*********************************************************************
* _wcreat (MSVCRT.@)
*/
-int CDECL _wcreat(const MSVCRT_wchar_t *path, int flags)
+int CDECL _wcreat(const wchar_t *path, int flags)
{
- int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
+ int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
return _wopen(path, usedFlags);
}
{
int fd;
- /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
+ /* _O_RDONLY (0) always matches, so set the read flag
* MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
- * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
- * text - it never sets MSVCRT__O_BINARY.
+ * file, so set the write flag. It also only sets _O_TEXT if it wants
+ * text - it never sets _O_BINARY.
*/
/* don't let split_oflags() decide the mode if no mode is passed */
- if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
- oflags |= MSVCRT__O_BINARY;
+ if (!(oflags & (_O_BINARY | _O_TEXT)))
+ oflags |= _O_BINARY;
- fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
+ fd = alloc_fd((HANDLE)(LONG_PTR)handle, split_oflags(oflags));
TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
return fd;
}
int num_removed = 0, i;
LOCK_FILES();
- for (i = 3; i < MSVCRT_stream_idx; i++)
- if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_tmpfname)
+ for (i = 3; i < stream_idx; i++)
+ if (fstreams[i] && fstreams[i]->_tmpfname)
{
- MSVCRT_fclose(MSVCRT_fstreams[i]);
+ fclose(fstreams[i]);
num_removed++;
}
UNLOCK_FILES();
{
DWORD num_read;
char *bufstart = buf;
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
- if (MSVCRT_fdesc[fd].wxflag & WX_READEOF) {
- MSVCRT_fdesc[fd].wxflag |= WX_ATEOF;
+ if (fdesc[fd].wxflag & WX_READEOF) {
+ fdesc[fd].wxflag |= WX_ATEOF;
TRACE("already at EOF, returning 0\n");
return 0;
}
*/
if (ReadFile(hand, bufstart, count, &num_read, NULL))
{
- if (MSVCRT_fdesc[fd].wxflag & WX_TEXT)
+ if (fdesc[fd].wxflag & WX_TEXT)
{
int i;
/* in text mode, a ctrl-z signals EOF */
if (bufstart[i] == 0x1a)
{
num_read = i;
- MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
+ fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
break;
}
}
if (count != 0 && num_read == 0)
{
- MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
+ fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
TRACE(":EOF %s\n",debugstr_an(buf,num_read));
}
}
if (GetLastError() == ERROR_BROKEN_PIPE)
{
TRACE(":end-of-pipe\n");
- MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
+ fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
return 0;
}
else
/*********************************************************************
* _read (MSVCRT.@)
*/
-int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
+int CDECL _read(int fd, void *buf, unsigned int count)
{
int num_read;
num_read = read_i(fd, buf, count);
- if (num_read>0 && MSVCRT_fdesc[fd].wxflag & WX_TEXT)
+ if (num_read>0 && fdesc[fd].wxflag & WX_TEXT)
{
num_read -= remove_cr(buf,num_read);
}
*/
int CDECL _setmode(int fd,int mode)
{
- int ret = MSVCRT_fdesc[fd].wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
- if (mode & (~(MSVCRT__O_TEXT|MSVCRT__O_BINARY)))
+ int ret = fdesc[fd].wxflag & WX_TEXT ? _O_TEXT : _O_BINARY;
+ if (mode & (~(_O_TEXT|_O_BINARY)))
FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
- if ((mode & MSVCRT__O_TEXT) == MSVCRT__O_TEXT)
- MSVCRT_fdesc[fd].wxflag |= WX_TEXT;
+ if ((mode & _O_TEXT) == _O_TEXT)
+ fdesc[fd].wxflag |= WX_TEXT;
else
- MSVCRT_fdesc[fd].wxflag &= ~WX_TEXT;
+ fdesc[fd].wxflag &= ~WX_TEXT;
return ret;
}
/*********************************************************************
* _stat64 (MSVCRT.@)
*/
-int CDECL MSVCRT__stat64(const char* path, struct MSVCRT__stat64 * buf)
+int CDECL _stat64(const char* path, struct __stat64 * buf)
{
DWORD dw;
WIN32_FILE_ATTRIBUTE_DATA hfi;
if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
{
TRACE("failed (%d)\n",GetLastError());
- msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
+ __set_errno(ERROR_FILE_NOT_FOUND);
return -1;
}
- memset(buf,0,sizeof(struct MSVCRT__stat64));
+ memset(buf,0,sizeof(struct __stat64));
/* FIXME: rdev isn't drive num, despite what the docs say-what is it?
Bon 011120: This FIXME seems incorrect
/* Dir, or regular file? */
if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
(path[plen-1] == '\\'))
- mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
+ mode |= (_S_IFDIR | ALL_S_IEXEC);
else
{
- mode |= MSVCRT__S_IFREG;
+ mode |= _S_IFREG;
/* executable? */
if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
{
/*********************************************************************
* _stati64 (MSVCRT.@)
*/
-int CDECL MSVCRT__stati64(const char* path, struct MSVCRT__stati64 * buf)
+int CDECL _stati64(const char* path, struct _stati64 * buf)
{
int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__stat64(path, &buf64);
+ ret = _stat64(path, &buf64);
if (!ret)
- msvcrt_stat64_to_stati64(&buf64, buf);
+ stat64_to_stati64(&buf64, buf);
return ret;
}
/*********************************************************************
* _stat (MSVCRT.@)
*/
-int CDECL MSVCRT__stat(const char* path, struct MSVCRT__stat * buf)
+int CDECL _stat(const char* path, struct _stat * buf)
{ int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__stat64( path, &buf64);
+ ret = _stat64( path, &buf64);
if (!ret)
- msvcrt_stat64_to_stat(&buf64, buf);
+ stat64_to_stat(&buf64, buf);
return ret;
}
/*********************************************************************
* _wstat64 (MSVCRT.@)
*/
-int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
+int CDECL _wstat64(const wchar_t* path, struct __stat64 * buf)
{
DWORD dw;
WIN32_FILE_ATTRIBUTE_DATA hfi;
if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
{
TRACE("failed (%d)\n",GetLastError());
- msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
+ __set_errno(ERROR_FILE_NOT_FOUND);
return -1;
}
- memset(buf,0,sizeof(struct MSVCRT__stat64));
+ memset(buf,0,sizeof(struct __stat64));
/* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
- if (MSVCRT_iswalpha(*path))
+ if (iswalpha(*path))
buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
else
buf->st_dev = buf->st_rdev = _getdrive() - 1;
/* Dir, or regular file? */
if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
(path[plen-1] == '\\'))
- mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
+ mode |= (_S_IFDIR | ALL_S_IEXEC);
else
{
- mode |= MSVCRT__S_IFREG;
+ mode |= _S_IFREG;
/* executable? */
if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
{
/*********************************************************************
* _wstati64 (MSVCRT.@)
*/
-int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
+int CDECL _wstati64(const wchar_t* path, struct _stati64 * buf)
{
int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__wstat64(path, &buf64);
+ ret = _wstat64(path, &buf64);
if (!ret)
- msvcrt_stat64_to_stati64(&buf64, buf);
+ stat64_to_stati64(&buf64, buf);
return ret;
}
/*********************************************************************
* _wstat (MSVCRT.@)
*/
-int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
+int CDECL _wstat(const wchar_t* path, struct _stat * buf)
{
int ret;
- struct MSVCRT__stat64 buf64;
+ struct __stat64 buf64;
- ret = MSVCRT__wstat64( path, &buf64 );
- if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
+ ret = _wstat64( path, &buf64 );
+ if (!ret) stat64_to_stat(&buf64, buf);
return ret;
}
*/
long CDECL _tell(int fd)
{
- return MSVCRT__lseek(fd, 0, SEEK_CUR);
+ return _lseek(fd, 0, SEEK_CUR);
}
/*********************************************************************
*/
__int64 CDECL _telli64(int fd)
{
- return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
+ return _lseeki64(fd, 0, SEEK_CUR);
}
/*********************************************************************
char * CDECL _tempnam(const char *dir, const char *prefix)
{
char tmpbuf[MAX_PATH];
- const char *tmp_dir = MSVCRT_getenv("TMP");
+ const char *tmp_dir = getenv("TMP");
if (tmp_dir) dir = tmp_dir;
/*********************************************************************
* _wtempnam (MSVCRT.@)
*/
-MSVCRT_wchar_t * CDECL _wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
+wchar_t * CDECL _wtempnam(const wchar_t *dir, const wchar_t *prefix)
{
- MSVCRT_wchar_t tmpbuf[MAX_PATH];
+ wchar_t tmpbuf[MAX_PATH];
TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
if (GetTempFileNameW(dir,prefix,0,tmpbuf))
/*********************************************************************
* _umask (MSVCRT.@)
*/
-int CDECL MSVCRT__umask(int umask)
+int CDECL _umask(int umask)
{
- int old_umask = MSVCRT_umask;
+ int old_umask = umask;
TRACE("(%d)\n",umask);
MSVCRT_umask = umask;
return old_umask;
/*********************************************************************
* _utime (MSVCRT.@)
*/
-int CDECL _utime(const char* path, struct MSVCRT__utimbuf *t)
+int CDECL _utime(const char* path, struct _utimbuf *t)
{
- int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
+ int fd = _open(path, _O_WRONLY | _O_BINARY);
if (fd > 0)
{
int retVal = _futime(fd, t);
- MSVCRT__close(fd);
+ _close(fd);
return retVal;
}
return -1;
/*********************************************************************
* _wutime (MSVCRT.@)
*/
-int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT__utimbuf *t)
+int CDECL _wutime(const wchar_t* path, struct _utimbuf *t)
{
- int fd = _wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
+ int fd = _wopen(path, _O_WRONLY | _O_BINARY);
if (fd > 0)
{
int retVal = _futime(fd, t);
- MSVCRT__close(fd);
+ _close(fd);
return retVal;
}
return -1;
/*********************************************************************
* _write (MSVCRT.@)
*/
-int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
+int CDECL _write(int fd, const void* buf, unsigned int count)
{
DWORD num_written;
- HANDLE hand = msvcrt_fdtoh(fd);
+ HANDLE hand = fdtoh(fd);
/* Don't trace small writes, it gets *very* annoying */
#if 0
#endif
if (hand == INVALID_HANDLE_VALUE)
{
- *MSVCRT__errno() = MSVCRT_EBADF;
+ *_errno() = EBADF;
return -1;
}
/* If appending, go to EOF */
- if (MSVCRT_fdesc[fd].wxflag & WX_APPEND)
- MSVCRT__lseek(fd, 0, FILE_END);
+ if (fdesc[fd].wxflag & WX_APPEND)
+ _lseek(fd, 0, FILE_END);
- if (!(MSVCRT_fdesc[fd].wxflag & WX_TEXT))
+ if (!(fdesc[fd].wxflag & WX_TEXT))
{
if (WriteFile(hand, buf, count, &num_written, NULL)
&& (num_written == count))
return num_written;
TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
hand, GetLastError());
- *MSVCRT__errno() = MSVCRT_ENOSPC;
+ *_errno() = ENOSPC;
}
else
{
}
if (nr_lf)
{
- if ((q = p = MSVCRT_malloc(count + nr_lf)))
+ if ((q = p = malloc(count + nr_lf)))
{
for (s = (const char *)buf, i = 0, j = 0; i < count; i++)
{
{
TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
fd, hand, GetLastError(), num_written);
- *MSVCRT__errno() = MSVCRT_ENOSPC;
+ *_errno() = ENOSPC;
if(nr_lf)
- MSVCRT_free(p);
+ free(p);
return s - buf_start;
}
else
{
if(nr_lf)
- MSVCRT_free(p);
+ free(p);
return count;
}
}
/*********************************************************************
* _putw (MSVCRT.@)
*/
-int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
+int CDECL _putw(int val, FILE* file)
{
int len;
- len = MSVCRT__write(file->_file, &val, sizeof(val));
+ len = _write(file->_file, &val, sizeof(val));
if (len == sizeof(val)) return val;
- file->_flag |= MSVCRT__IOERR;
- return MSVCRT_EOF;
+ file->_flag |= _IOERR;
+ return EOF;
}
/*********************************************************************
* fclose (MSVCRT.@)
*/
-int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
+int CDECL fclose(FILE* file)
{
int r, flag;
flag = file->_flag;
- MSVCRT_free(file->_tmpfname);
+ free(file->_tmpfname);
file->_tmpfname = NULL;
/* flush stdio buffers */
- if(file->_flag & MSVCRT__IOWRT)
- MSVCRT_fflush(file);
- if(file->_flag & MSVCRT__IOMYBUF)
- MSVCRT_free(file->_base);
+ if(file->_flag & _IOWRT)
+ fflush(file);
+ if(file->_flag & _IOMYBUF)
+ free(file->_base);
- r=MSVCRT__close(file->_file);
+ r=_close(file->_file);
file->_flag = 0;
- return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
+ return ((r == -1) || (flag & _IOERR) ? EOF : 0);
}
/*********************************************************************
* feof (MSVCRT.@)
*/
-int CDECL MSVCRT_feof(MSVCRT_FILE* file)
+int CDECL feof(FILE* file)
{
- return file->_flag & MSVCRT__IOEOF;
+ return file->_flag & _IOEOF;
}
/*********************************************************************
* ferror (MSVCRT.@)
*/
-int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
+int CDECL ferror(FILE* file)
{
- return file->_flag & MSVCRT__IOERR;
+ return file->_flag & _IOERR;
}
/*********************************************************************
* _filbuf (MSVCRT.@)
*/
-int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
+int CDECL _filbuf(FILE* file)
{
/* Allocate buffer if needed */
- if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
- msvcrt_alloc_buffer(file);
+ if(file->_bufsiz == 0 && !(file->_flag & _IONBF) ) {
+ alloc_buffer(file);
}
- if(!(file->_flag & MSVCRT__IOREAD)) {
- if(file->_flag & MSVCRT__IORW) {
- file->_flag |= MSVCRT__IOREAD;
+ if(!(file->_flag & _IOREAD)) {
+ if(file->_flag & _IORW) {
+ file->_flag |= _IOREAD;
} else {
- return MSVCRT_EOF;
+ return EOF;
}
}
- if(file->_flag & MSVCRT__IONBF) {
+ if(file->_flag & _IONBF) {
unsigned char c;
int r;
if ((r = read_i(file->_file,&c,1)) != 1) {
- file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
- return MSVCRT_EOF;
+ file->_flag |= (r == 0) ? _IOEOF : _IOERR;
+ return EOF;
}
return c;
} else {
file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
if(file->_cnt<=0) {
- file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
+ file->_flag |= (file->_cnt == 0) ? _IOEOF : _IOERR;
file->_cnt = 0;
- return MSVCRT_EOF;
+ return EOF;
}
file->_cnt--;
file->_ptr = file->_base+1;
/*********************************************************************
* fgetc (MSVCRT.@)
*/
-int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
+int CDECL fgetc(FILE* file)
{
unsigned char *i;
unsigned int j;
i = (unsigned char *)file->_ptr++;
j = *i;
} else
- j = MSVCRT__filbuf(file);
- if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT)
+ j = _filbuf(file);
+ if (!(fdesc[file->_file].wxflag & WX_TEXT)
|| ((j != '\r') || (file->_cnt && file->_ptr[0] != '\n')))
return j;
} while(1);
*/
int CDECL _fgetchar(void)
{
- return MSVCRT_fgetc(MSVCRT_stdin);
+ return fgetc(stdin);
}
/*********************************************************************
* fgets (MSVCRT.@)
*/
-char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
+char * CDECL fgets(char *s, int size, FILE* file)
{
- int cc = MSVCRT_EOF;
+ int cc = EOF;
char * buf_start = s;
TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
file,file->_file,s,size);
- while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
+ while ((size >1) && (cc = fgetc(file)) != EOF && cc != '\n')
{
*s++ = (char)cc;
size --;
}
- if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
+ if ((cc == EOF) && (s == buf_start)) /* If nothing read, return 0*/
{
TRACE(":nothing read\n");
return NULL;
}
- if ((cc != MSVCRT_EOF) && (size > 1))
+ if ((cc != EOF) && (size > 1))
*s++ = cc;
*s = '\0';
TRACE(":got %s\n", debugstr_a(buf_start));
/*********************************************************************
* fgetwc (MSVCRT.@)
*
- * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
+ * In _O_TEXT mode, multibyte characters are read from the file, dropping
* the CR from CR/LF combinations
*/
-MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
+wint_t CDECL fgetwc(FILE* file)
{
char c;
- if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
+ if (!(fdesc[file->_file].wxflag & WX_TEXT))
{
- MSVCRT_wchar_t wc;
+ wchar_t wc;
int i,j;
char *chp, *wcp;
wcp = (char *)&wc;
}
else
{
- j = MSVCRT__filbuf(file);
+ j = _filbuf(file);
if(file->_cnt<=0)
{
- file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
+ file->_flag |= (file->_cnt == 0) ? _IOEOF : _IOERR;
file->_cnt = 0;
- return MSVCRT_WEOF;
+ return WEOF;
}
wcp[i] = j;
}
return wc;
}
- c = MSVCRT_fgetc(file);
- if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c))
+ c = fgetc(file);
+ if ((*__p___mb_cur_max() > 1) && isleadbyte(c))
{
FIXME("Treat Multibyte characters\n");
}
- if (c == MSVCRT_EOF)
- return MSVCRT_WEOF;
+ if (c == EOF)
+ return WEOF;
else
- return (MSVCRT_wint_t)c;
+ return (wint_t)c;
}
/*********************************************************************
* _getw (MSVCRT.@)
*/
-int CDECL MSVCRT__getw(MSVCRT_FILE* file)
+int CDECL _getw(FILE* file)
{
char *ch;
int i, j, k;
ch = (char *)&i;
for (j=0; j<sizeof(int); j++) {
- k = MSVCRT_fgetc(file);
- if (k == MSVCRT_EOF) {
- file->_flag |= MSVCRT__IOEOF;
+ k = fgetc(file);
+ if (k == EOF) {
+ file->_flag |= _IOEOF;
return EOF;
}
ch[j] = k;
/*********************************************************************
* getwc (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
+wint_t CDECL getwc(FILE* file)
{
- return MSVCRT_fgetwc(file);
+ return fgetwc(file);
}
/*********************************************************************
* _fgetwchar (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL _fgetwchar(void)
+wint_t CDECL _fgetwchar(void)
{
- return MSVCRT_fgetwc(MSVCRT_stdin);
+ return fgetwc(stdin);
}
/*********************************************************************
* getwchar (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
+wint_t CDECL getwchar(void)
{
return _fgetwchar();
}
/*********************************************************************
* fgetws (MSVCRT.@)
*/
-MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
+wchar_t * CDECL fgetws(wchar_t *s, int size, FILE* file)
{
- int cc = MSVCRT_WEOF;
- MSVCRT_wchar_t * buf_start = s;
+ int cc = WEOF;
+ wchar_t * buf_start = s;
TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
file,file->_file,s,size);
- while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
+ while ((size >1) && (cc = fgetwc(file)) != WEOF && cc != '\n')
{
*s++ = (char)cc;
size --;
}
- if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
+ if ((cc == WEOF) && (s == buf_start)) /* If nothing read, return 0*/
{
TRACE(":nothing read\n");
return NULL;
}
- if ((cc != MSVCRT_WEOF) && (size > 1))
+ if ((cc != WEOF) && (size > 1))
*s++ = cc;
*s = 0;
TRACE(":got %s\n", debugstr_w(buf_start));
/*********************************************************************
* fwrite (MSVCRT.@)
*/
-MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
+size_t CDECL fwrite(const void *ptr, size_t size, size_t nmemb, FILE* file)
{
- MSVCRT_size_t wrcnt=size * nmemb;
+ size_t wrcnt=size * nmemb;
int written = 0;
if (size == 0)
return 0;
written = pcnt;
wrcnt -= pcnt;
ptr = (const char*)ptr + pcnt;
- } else if(!(file->_flag & MSVCRT__IOWRT)) {
- if(file->_flag & MSVCRT__IORW) {
- file->_flag |= MSVCRT__IOWRT;
+ } else if(!(file->_flag & _IOWRT)) {
+ if(file->_flag & _IORW) {
+ file->_flag |= _IOWRT;
} else
return 0;
}
if(wrcnt) {
/* Flush buffer */
- int res=msvcrt_flush_buffer(file);
+ int res=flush_buffer(file);
if(!res) {
- int pwritten = MSVCRT__write(file->_file, ptr, wrcnt);
+ int pwritten = _write(file->_file, ptr, wrcnt);
if (pwritten <= 0)
{
- file->_flag |= MSVCRT__IOERR;
+ file->_flag |= _IOERR;
pwritten=0;
}
written += pwritten;
/*********************************************************************
* fputwc (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
+wint_t CDECL fputwc(wint_t wc, FILE* file)
{
- MSVCRT_wchar_t mwc=wc;
- if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
- return MSVCRT_WEOF;
- return wc;
+ if (file->_flag & _IOBINARY)
+ {
+ if (fwrite(&wc, sizeof(wc), 1, file) != 1)
+ return WEOF;
+ }
+ else
+ {
+ /* Convert to multibyte in text mode */
+ char mbc[MB_LEN_MAX];
+ int mb_return;
+
+ mb_return = wctomb(mbc, wc);
+
+ if(mb_return == -1)
+ return WEOF;
+
+ /* Output all characters */
+ if (fwrite(mbc, mb_return, 1, file) != 1)
+ return WEOF;
+ }
+
+ return wc;
}
/*********************************************************************
* _fputwchar (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL _fputwchar(MSVCRT_wint_t wc)
+wint_t CDECL _fputwchar(wint_t wc)
{
- return MSVCRT_fputwc(wc, MSVCRT_stdout);
+ return fputwc(wc, stdout);
}
/*********************************************************************
* _fsopen (MSVCRT.@)
*/
-MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
+FILE * CDECL _fsopen(const char *path, const char *mode, int share)
{
- MSVCRT_FILE* file;
+ FILE* file;
int open_flags, stream_flags, fd;
TRACE("(%s,%s)\n",path,mode);
/* map mode string to open() flags. "man fopen" for possibilities. */
- if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
+ if (get_flags(mode, &open_flags, &stream_flags) == -1)
return NULL;
LOCK_FILES();
- fd = MSVCRT__sopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
+ fd = _sopen(path, open_flags, share, _S_IREAD | _S_IWRITE);
if (fd < 0)
file = NULL;
- else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
+ else if ((file = alloc_fp()) && init_fp(file, fd, stream_flags)
!= -1)
TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
else if (file)
TRACE(":got (%p)\n",file);
if (fd >= 0 && !file)
- MSVCRT__close(fd);
+ _close(fd);
UNLOCK_FILES();
return file;
}
/*********************************************************************
* _wfsopen (MSVCRT.@)
*/
-MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
+FILE * CDECL _wfsopen(const wchar_t *path, const wchar_t *mode, int share)
{
const unsigned int plen = strlenW(path), mlen = strlenW(mode);
- char *patha = MSVCRT_calloc(plen + 1, 1);
- char *modea = MSVCRT_calloc(mlen + 1, 1);
+ char *patha = calloc(plen + 1, 1);
+ char *modea = calloc(mlen + 1, 1);
TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
{
- MSVCRT_FILE *retval = MSVCRT__fsopen(patha,modea,share);
- MSVCRT_free(patha);
- MSVCRT_free(modea);
+ FILE *retval = _fsopen(patha,modea,share);
+ free(patha);
+ free(modea);
return retval;
}
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return NULL;
}
/*********************************************************************
* fopen (MSVCRT.@)
*/
-MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
+FILE * CDECL fopen(const char *path, const char *mode)
{
- return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
+ return _fsopen( path, mode, _SH_DENYNO );
}
/*********************************************************************
* _wfopen (MSVCRT.@)
*/
-MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
+FILE * CDECL _wfopen(const wchar_t *path, const wchar_t *mode)
{
- return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
+ return _wfsopen( path, mode, _SH_DENYNO );
}
-/* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
-int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file);
+/* fputc calls _flsbuf which calls fputc */
+int CDECL _flsbuf(int c, FILE* file);
/*********************************************************************
* fputc (MSVCRT.@)
*/
-int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
+int CDECL fputc(int c, FILE* file)
{
if(file->_cnt>0) {
*file->_ptr++=c;
file->_cnt--;
if (c == '\n')
{
- int res = msvcrt_flush_buffer(file);
+ int res = flush_buffer(file);
return res ? res : c;
}
else
return c;
} else {
- return MSVCRT__flsbuf(c, file);
+ return _flsbuf(c, file);
}
}
/*********************************************************************
* _flsbuf (MSVCRT.@)
*/
-int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
+int CDECL _flsbuf(int c, FILE* file)
{
/* Flush output buffer */
- if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
- msvcrt_alloc_buffer(file);
+ if(file->_bufsiz == 0 && !(file->_flag & _IONBF)) {
+ alloc_buffer(file);
}
- if(!(file->_flag & MSVCRT__IOWRT)) {
- if(file->_flag & MSVCRT__IORW) {
- file->_flag |= MSVCRT__IOWRT;
+ if(!(file->_flag & _IOWRT)) {
+ if(file->_flag & _IORW) {
+ file->_flag |= _IOWRT;
} else {
- return MSVCRT_EOF;
+ return EOF;
}
}
if(file->_bufsiz) {
- int res=msvcrt_flush_buffer(file);
- return res?res : MSVCRT_fputc(c, file);
+ int res=flush_buffer(file);
+ return res?res : fputc(c, file);
} else {
unsigned char cc=c;
int len;
- len = MSVCRT__write(file->_file, &cc, 1);
+ len = _write(file->_file, &cc, 1);
if (len == 1) return c;
- file->_flag |= MSVCRT__IOERR;
- return MSVCRT_EOF;
+ file->_flag |= _IOERR;
+ return EOF;
}
}
*/
int CDECL _fputchar(int c)
{
- return MSVCRT_fputc(c, MSVCRT_stdout);
+ return fputc(c, stdout);
}
/*********************************************************************
* fread (MSVCRT.@)
*/
-MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
-{ MSVCRT_size_t rcnt=size * nmemb;
- MSVCRT_size_t read=0;
+size_t CDECL fread(void *ptr, size_t size, size_t nmemb, FILE* file)
+{ size_t rcnt=size * nmemb;
+ size_t read=0;
int pread=0;
if(!rcnt)
memcpy(ptr, file->_ptr, pcnt);
file->_cnt -= pcnt;
file->_ptr += pcnt;
- if (MSVCRT_fdesc[file->_file].wxflag & WX_TEXT)
+ if (fdesc[file->_file].wxflag & WX_TEXT)
pcnt -= remove_cr(ptr,pcnt);
read += pcnt ;
rcnt -= pcnt ;
ptr = (char*)ptr + pcnt;
- } else if(!(file->_flag & MSVCRT__IOREAD )) {
- if(file->_flag & MSVCRT__IORW) {
- file->_flag |= MSVCRT__IOREAD;
+ } else if(!(file->_flag & _IOREAD )) {
+ if(file->_flag & _IORW) {
+ file->_flag |= _IOREAD;
} else
return 0;
}
/* Fill the buffer on small reads.
* TODO: Use a better buffering strategy.
*/
- if (!file->_cnt && size*nmemb <= MSVCRT_BUFSIZ/2 && !(file->_flag & MSVCRT__IONBF)) {
+ if (!file->_cnt && size*nmemb <= BUFSIZ/2 && !(file->_flag & _IONBF)) {
if (file->_bufsiz == 0) {
- msvcrt_alloc_buffer(file);
+ alloc_buffer(file);
}
- file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
+ file->_cnt = _read(file->_file, file->_base, file->_bufsiz);
file->_ptr = file->_base;
i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
/* If the buffer fill reaches eof but fread wouldn't, clear eof. */
if (i > 0 && i < file->_cnt) {
- MSVCRT_fdesc[file->_file].wxflag &= ~WX_ATEOF;
- file->_flag &= ~MSVCRT__IOEOF;
+ fdesc[file->_file].wxflag &= ~WX_ATEOF;
+ file->_flag &= ~_IOEOF;
}
if (i > 0) {
memcpy(ptr, file->_ptr, i);
file->_ptr += i;
}
} else {
- i = MSVCRT__read(file->_file,ptr, rcnt);
+ i = _read(file->_file,ptr, rcnt);
}
pread += i;
rcnt -= i;
/* expose feof condition in the flags
* MFC tests file->_flag for feof, and doesn't call feof())
*/
- if ( MSVCRT_fdesc[file->_file].wxflag & WX_ATEOF)
- file->_flag |= MSVCRT__IOEOF;
+ if ( fdesc[file->_file].wxflag & WX_ATEOF)
+ file->_flag |= _IOEOF;
else if (i == -1)
{
- file->_flag |= MSVCRT__IOERR;
+ file->_flag |= _IOERR;
pread = 0;
rcnt = 0;
}
* freopen (MSVCRT.@)
*
*/
-MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
+FILE* CDECL freopen(const char *path, const char *mode,FILE* file)
{
int open_flags, stream_flags, fd;
TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
LOCK_FILES();
- if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
+ if (!file || ((fd = file->_file) < 0) || fd > fdend)
file = NULL;
else
{
- MSVCRT_fclose(file);
+ fclose(file);
/* map mode string to open() flags. "man fopen" for possibilities. */
- if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
+ if (get_flags(mode, &open_flags, &stream_flags) == -1)
file = NULL;
else
{
- fd = MSVCRT__open(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
+ fd = _open(path, open_flags, _S_IREAD | _S_IWRITE);
if (fd < 0)
file = NULL;
- else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
+ else if (init_fp(file, fd, stream_flags) == -1)
{
file->_flag = 0;
WARN(":failed-last error (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
file = NULL;
}
}
return file;
}
+/*********************************************************************
+ * wfreopen (MSVCRT.@)
+ *
+ */
+FILE* CDECL _wfreopen(const wchar_t *path, const wchar_t *mode,FILE* file)
+{
+ FIXME("UNIMPLEMENTED stub!\n");
+ return NULL;
+}
+
/*********************************************************************
* fsetpos (MSVCRT.@)
*/
-int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
+int CDECL fsetpos(FILE* file, const fpos_t *pos)
{
/* Note that all this has been lifted 'as is' from fseek */
- if(file->_flag & MSVCRT__IOWRT)
- msvcrt_flush_buffer(file);
+ if(file->_flag & _IOWRT)
+ flush_buffer(file);
/* Discard buffered input */
file->_cnt = 0;
file->_ptr = file->_base;
/* Reset direction of i/o */
- if(file->_flag & MSVCRT__IORW) {
- file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
+ if(file->_flag & _IORW) {
+ file->_flag &= ~(_IOREAD|_IOWRT);
}
- return (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
+ return (_lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
}
/*********************************************************************
* ftell (MSVCRT.@)
*/
-LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
+LONG CDECL ftell(FILE* file)
{
int off=0;
long pos;
if(file->_bufsiz) {
- if( file->_flag & MSVCRT__IOWRT ) {
+ if( file->_flag & _IOWRT ) {
off = file->_ptr - file->_base;
} else {
off = -file->_cnt;
/*********************************************************************
* fgetpos (MSVCRT.@)
*/
-int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
+int CDECL fgetpos(FILE* file, fpos_t *pos)
{
- /* This code has been lifted form the MSVCRT_ftell function */
+ /* This code has been lifted form the ftell function */
int off=0;
- *pos = MSVCRT__lseeki64(file->_file,0,SEEK_CUR);
+ *pos = _lseeki64(file->_file,0,SEEK_CUR);
if (*pos == -1) return -1;
if(file->_bufsiz) {
- if( file->_flag & MSVCRT__IOWRT ) {
+ if( file->_flag & _IOWRT ) {
off = file->_ptr - file->_base;
} else {
off = -file->_cnt;
/*********************************************************************
* fputs (MSVCRT.@)
*/
-int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
+int CDECL fputs(const char *s, FILE* file)
{
size_t i, len = strlen(s);
- if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
- return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
+ if (!(fdesc[file->_file].wxflag & WX_TEXT))
+ return fwrite(s,sizeof(*s),len,file) == len ? 0 : EOF;
for (i=0; i<len; i++)
- if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
- return MSVCRT_EOF;
+ if (fputc(s[i], file) == EOF)
+ return EOF;
return 0;
}
/*********************************************************************
* fputws (MSVCRT.@)
*/
-int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
+int CDECL fputws(const wchar_t *s, FILE* file)
{
size_t i, len = strlenW(s);
- if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
- return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
+ if (!(fdesc[file->_file].wxflag & WX_TEXT))
+ return fwrite(s,sizeof(*s),len,file) == len ? 0 : EOF;
for (i=0; i<len; i++)
{
- if ((s[i] == '\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
- return MSVCRT_WEOF;
- if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
- return MSVCRT_WEOF;
+ if ((s[i] == '\n') && (fputc('\r', file) == EOF))
+ return WEOF;
+ if (fputwc(s[i], file) == WEOF)
+ return WEOF;
}
return 0;
}
/*********************************************************************
* getchar (MSVCRT.@)
*/
-int CDECL MSVCRT_getchar(void)
+int CDECL getchar(void)
{
- return MSVCRT_fgetc(MSVCRT_stdin);
+ return fgetc(stdin);
}
/*********************************************************************
* getc (MSVCRT.@)
*/
-int CDECL MSVCRT_getc(MSVCRT_FILE* file)
+int CDECL getc(FILE* file)
{
- return MSVCRT_fgetc(file);
+ return fgetc(file);
}
/*********************************************************************
* gets (MSVCRT.@)
*/
-char * CDECL MSVCRT_gets(char *buf)
+char * CDECL gets(char *buf)
{
int cc;
char * buf_start = buf;
- for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
- cc = MSVCRT_fgetc(MSVCRT_stdin))
+ for(cc = fgetc(stdin); cc != EOF && cc != '\n';
+ cc = fgetc(stdin))
if(cc != '\r') *buf++ = (char)cc;
*buf = '\0';
/*********************************************************************
* _getws (MSVCRT.@)
*/
-MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
+wchar_t* CDECL _getws(wchar_t* buf)
{
- MSVCRT_wint_t cc;
- MSVCRT_wchar_t* ws = buf;
+ wint_t cc;
+ wchar_t* ws = buf;
- for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
- cc = MSVCRT_fgetwc(MSVCRT_stdin))
+ for (cc = fgetwc(stdin); cc != WEOF && cc != '\n';
+ cc = fgetwc(stdin))
{
if (cc != '\r')
- *buf++ = (MSVCRT_wchar_t)cc;
+ *buf++ = (wchar_t)cc;
}
*buf = '\0';
/*********************************************************************
* putc (MSVCRT.@)
*/
-int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
+int CDECL putc(int c, FILE* file)
{
- return MSVCRT_fputc(c, file);
+ return fputc(c, file);
}
/*********************************************************************
* putchar (MSVCRT.@)
*/
-int CDECL MSVCRT_putchar(int c)
+int CDECL putchar(int c)
{
- return MSVCRT_fputc(c, MSVCRT_stdout);
+ return fputc(c, stdout);
}
/*********************************************************************
* puts (MSVCRT.@)
*/
-int CDECL MSVCRT_puts(const char *s)
+int CDECL puts(const char *s)
{
size_t len = strlen(s);
- if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
- return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
+ if (fwrite(s,sizeof(*s),len,stdout) != len) return EOF;
+ return fwrite("\n",1,1,stdout) == 1 ? 0 : EOF;
}
/*********************************************************************
* _putws (MSVCRT.@)
*/
-int CDECL _putws(const MSVCRT_wchar_t *s)
+int CDECL _putws(const wchar_t *s)
{
- static const MSVCRT_wchar_t nl = '\n';
+ static const wchar_t nl = '\n';
size_t len = strlenW(s);
- if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
- return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
+ if (fwrite(s,sizeof(*s),len,stdout) != len) return EOF;
+ return fwrite(&nl,sizeof(nl),1,stdout) == 1 ? 0 : EOF;
}
/*********************************************************************
* remove (MSVCRT.@)
*/
-int CDECL MSVCRT_remove(const char *path)
+int CDECL remove(const char *path)
{
TRACE("(%s)\n",path);
if (DeleteFileA(path))
return 0;
TRACE(":failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _wremove (MSVCRT.@)
*/
-int CDECL _wremove(const MSVCRT_wchar_t *path)
+int CDECL _wremove(const wchar_t *path)
{
TRACE("(%s)\n",debugstr_w(path));
if (DeleteFileW(path))
return 0;
TRACE(":failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* rename (MSVCRT.@)
*/
-int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
+int CDECL rename(const char *oldpath,const char *newpath)
{
TRACE(":from %s to %s\n",oldpath,newpath);
if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
return 0;
TRACE(":failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* _wrename (MSVCRT.@)
*/
-int CDECL _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
+int CDECL _wrename(const wchar_t *oldpath,const wchar_t *newpath)
{
TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
return 0;
TRACE(":failed (%d)\n",GetLastError());
- msvcrt_set_errno(GetLastError());
+ __set_errno(GetLastError());
return -1;
}
/*********************************************************************
* setvbuf (MSVCRT.@)
*/
-int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
+int CDECL setvbuf(FILE* file, char *buf, int mode, size_t size)
{
/* TODO: Check if file busy */
if(file->_bufsiz) {
- MSVCRT_free(file->_base);
+ free(file->_base);
file->_bufsiz = 0;
file->_cnt = 0;
}
- if(mode == MSVCRT__IOFBF) {
- file->_flag &= ~MSVCRT__IONBF;
+ if(mode == _IOFBF) {
+ file->_flag &= ~_IONBF;
file->_base = file->_ptr = buf;
if(buf) {
file->_bufsiz = size;
}
} else {
- file->_flag |= MSVCRT__IONBF;
+ file->_flag |= _IONBF;
}
return 0;
}
/*********************************************************************
* setbuf (MSVCRT.@)
*/
-void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
+void CDECL setbuf(FILE* file, char *buf)
{
- MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
+ setvbuf(file, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
}
/*********************************************************************
* tmpnam (MSVCRT.@)
*/
-char * CDECL MSVCRT_tmpnam(char *s)
+char * CDECL tmpnam(char *s)
{
static int unique;
char tmpstr[16];
char *p;
int count;
if (s == 0)
- s = MSVCRT_tmpname;
- msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
+ s = tmpname;
+ int_to_base32(GetCurrentProcessId(), tmpstr);
p = s + sprintf(s, "\\s%s.", tmpstr);
- for (count = 0; count < MSVCRT_TMP_MAX; count++)
+ for (count = 0; count < TMP_MAX; count++)
{
- msvcrt_int_to_base32(unique++, tmpstr);
+ int_to_base32(unique++, tmpstr);
strcpy(p, tmpstr);
if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
GetLastError() == ERROR_FILE_NOT_FOUND)
return s;
}
+/*********************************************************************
+ * wtmpnam (MSVCRT.@)
+ */
+wchar_t * CDECL _wtmpnam(wchar_t *s)
+{
+ ERR("UNIMPLEMENTED!\n");
+ return NULL;
+}
+
/*********************************************************************
* tmpfile (MSVCRT.@)
*/
-MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
+FILE* CDECL tmpfile(void)
{
- char *filename = MSVCRT_tmpnam(NULL);
+ char *filename = tmpnam(NULL);
int fd;
- MSVCRT_FILE* file = NULL;
+ FILE* file = NULL;
LOCK_FILES();
- fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY);
- if (fd != -1 && (file = msvcrt_alloc_fp()))
+ fd = _open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
+ if (fd != -1 && (file = alloc_fp()))
{
- if (msvcrt_init_fp(file, fd, MSVCRT__O_RDWR) == -1)
+ if (init_fp(file, fd, _O_RDWR) == -1)
{
file->_flag = 0;
file = NULL;
/*********************************************************************
* vfprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
+int CDECL vfprintf(FILE* file, const char *format, va_list valist)
{
char buf[2048], *mem = buf;
int written, resize = sizeof(buf), retval;
* Return the number of bytes that would have been written
* The code below handles both cases
*/
- while ((written = MSVCRT_vsnprintf(mem, resize, format, valist)) == -1 ||
+ while ((written = _vsnprintf(mem, resize, format, valist)) == -1 ||
written > resize)
{
resize = (written == -1 ? resize * 2 : written + 1);
if (mem != buf)
- MSVCRT_free (mem);
- if (!(mem = MSVCRT_malloc(resize)))
- return MSVCRT_EOF;
+ free (mem);
+ if (!(mem = malloc(resize)))
+ return EOF;
}
- retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
+ retval = fwrite(mem, sizeof(*mem), written, file);
if (mem != buf)
- MSVCRT_free (mem);
+ free (mem);
return retval;
}
* Is final char included in written (then resize is too big) or not
* (then we must test for equality too)?
*/
-int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
+int CDECL vfwprintf(FILE* file, const wchar_t *format, va_list valist)
{
- MSVCRT_wchar_t buf[2048], *mem = buf;
- int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
+ wchar_t buf[2048], *mem = buf;
+ int written, resize = sizeof(buf) / sizeof(wchar_t), retval;
/* See vfprintf comments */
- while ((written = MSVCRT_vsnwprintf(mem, resize, format, valist)) == -1 ||
+ while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
written > resize)
{
- resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
+ resize = (written == -1 ? resize * 2 : written + sizeof(wchar_t));
if (mem != buf)
- MSVCRT_free (mem);
- if (!(mem = MSVCRT_malloc(resize*sizeof(*mem))))
- return MSVCRT_EOF;
+ free (mem);
+ if (!(mem = malloc(resize*sizeof(*mem))))
+ return EOF;
+ }
+
+ /* Check if outputting to a text-file */
+ if (fdesc[file->_file].wxflag & WX_TEXT)
+ {
+ /* Convert each character and stop at the first invalid character. Behavior verified by tests under WinXP SP2 */
+ char chMultiByte[MB_LEN_MAX];
+ int nReturn;
+ wchar_t *p;
+
+ retval = 0;
+
+ for (p = mem; *p; p++)
+ {
+ nReturn = wctomb(chMultiByte, *p);
+
+ if(nReturn == -1)
+ break;
+
+ retval += fwrite(chMultiByte, 1, nReturn, file);
+ }
+ }
+ else
+ {
+ retval = fwrite(mem, sizeof(*mem), written, file);
}
- retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
+
if (mem != buf)
- MSVCRT_free (mem);
+ free (mem);
+
return retval;
}
/*********************************************************************
* vprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_vprintf(const char *format, va_list valist)
+int CDECL vprintf(const char *format, va_list valist)
{
- return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
+ return vfprintf(stdout,format,valist);
}
/*********************************************************************
* vwprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, va_list valist)
+int CDECL vwprintf(const wchar_t *format, va_list valist)
{
- return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
+ return vfwprintf(stdout,format,valist);
}
/*********************************************************************
* fprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
+int CDECL fprintf(FILE* file, const char *format, ...)
{
va_list valist;
int res;
va_start(valist, format);
- res = MSVCRT_vfprintf(file, format, valist);
+ res = vfprintf(file, format, valist);
va_end(valist);
return res;
}
/*********************************************************************
* fwprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
+int CDECL fwprintf(FILE* file, const wchar_t *format, ...)
{
va_list valist;
int res;
va_start(valist, format);
- res = MSVCRT_vfwprintf(file, format, valist);
+ res = vfwprintf(file, format, valist);
va_end(valist);
return res;
}
/*********************************************************************
* printf (MSVCRT.@)
*/
-int CDECL MSVCRT_printf(const char *format, ...)
+int CDECL printf(const char *format, ...)
{
va_list valist;
int res;
va_start(valist, format);
- res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
+ res = vfprintf(stdout, format, valist);
va_end(valist);
return res;
}
/*********************************************************************
* ungetc (MSVCRT.@)
*/
-int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
+int CDECL ungetc(int c, FILE * file)
{
- if (c == MSVCRT_EOF)
- return MSVCRT_EOF;
- if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
- msvcrt_alloc_buffer(file);
+ if (c == EOF)
+ return EOF;
+ if(file->_bufsiz == 0 && !(file->_flag & _IONBF)) {
+ alloc_buffer(file);
file->_ptr++;
}
if(file->_ptr>file->_base) {
file->_ptr--;
*file->_ptr=c;
file->_cnt++;
- MSVCRT_clearerr(file);
+ clearerr(file);
return c;
}
- return MSVCRT_EOF;
+ return EOF;
}
/*********************************************************************
* ungetwc (MSVCRT.@)
*/
-MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
+wint_t CDECL ungetwc(wint_t wc, FILE * file)
{
- MSVCRT_wchar_t mwc = wc;
+ wchar_t mwc = wc;
char * pp = (char *)&mwc;
int i;
- for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
- if(pp[i] != MSVCRT_ungetc(pp[i],file))
- return MSVCRT_WEOF;
+ for(i=sizeof(wchar_t)-1;i>=0;i--) {
+ if(pp[i] != ungetc(pp[i],file))
+ return WEOF;
}
return mwc;
}
/*********************************************************************
* wprintf (MSVCRT.@)
*/
-int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
+int CDECL wprintf(const wchar_t *format, ...)
{
va_list valist;
int res;
va_start(valist, format);
- res = MSVCRT_vwprintf(format, valist);
+ res = vwprintf(format, valist);
va_end(valist);
return res;
}
/*********************************************************************
* __pioinfo (MSVCRT.@)
- * FIXME: see MSVCRT_MAX_FILES define.
- */
-ioinfo * MSVCRT___pioinfo[] = { /* array of pointers to ioinfo arrays [64] */
- &MSVCRT_fdesc[0 * 64], &MSVCRT_fdesc[1 * 64], &MSVCRT_fdesc[2 * 64],
- &MSVCRT_fdesc[3 * 64], &MSVCRT_fdesc[4 * 64], &MSVCRT_fdesc[5 * 64],
- &MSVCRT_fdesc[6 * 64], &MSVCRT_fdesc[7 * 64], &MSVCRT_fdesc[8 * 64],
- &MSVCRT_fdesc[9 * 64], &MSVCRT_fdesc[10 * 64], &MSVCRT_fdesc[11 * 64],
- &MSVCRT_fdesc[12 * 64], &MSVCRT_fdesc[13 * 64], &MSVCRT_fdesc[14 * 64],
- &MSVCRT_fdesc[15 * 64], &MSVCRT_fdesc[16 * 64], &MSVCRT_fdesc[17 * 64],
- &MSVCRT_fdesc[18 * 64], &MSVCRT_fdesc[19 * 64], &MSVCRT_fdesc[20 * 64],
- &MSVCRT_fdesc[21 * 64], &MSVCRT_fdesc[22 * 64], &MSVCRT_fdesc[23 * 64],
- &MSVCRT_fdesc[24 * 64], &MSVCRT_fdesc[25 * 64], &MSVCRT_fdesc[26 * 64],
- &MSVCRT_fdesc[27 * 64], &MSVCRT_fdesc[28 * 64], &MSVCRT_fdesc[29 * 64],
- &MSVCRT_fdesc[30 * 64], &MSVCRT_fdesc[31 * 64]
+ * FIXME: see MAX_FILES define.
+ */
+ioinfo * __pioinfo[] = { /* array of pointers to ioinfo arrays [64] */
+ &fdesc[0 * 64], &fdesc[1 * 64], &fdesc[2 * 64],
+ &fdesc[3 * 64], &fdesc[4 * 64], &fdesc[5 * 64],
+ &fdesc[6 * 64], &fdesc[7 * 64], &fdesc[8 * 64],
+ &fdesc[9 * 64], &fdesc[10 * 64], &fdesc[11 * 64],
+ &fdesc[12 * 64], &fdesc[13 * 64], &fdesc[14 * 64],
+ &fdesc[15 * 64], &fdesc[16 * 64], &fdesc[17 * 64],
+ &fdesc[18 * 64], &fdesc[19 * 64], &fdesc[20 * 64],
+ &fdesc[21 * 64], &fdesc[22 * 64], &fdesc[23 * 64],
+ &fdesc[24 * 64], &fdesc[25 * 64], &fdesc[26 * 64],
+ &fdesc[27 * 64], &fdesc[28 * 64], &fdesc[29 * 64],
+ &fdesc[30 * 64], &fdesc[31 * 64]
} ;
/*********************************************************************
* __badioinfo (MSVCRT.@)
*/
-ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
-#endif
+ioinfo __badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
projects / reactos.git / blobdiff