/*
* © Portions copyright (c) 2006-2007 Nokia Corporation. All rights reserved.
*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
# include "stlport_prefix.h"
# if defined (__SUNPPRO_CC) && !defined (_STLP_NO_NEW_C_HEADERS)
# include <time.h>
// For sunpro, it chokes if time.h is included through stat.h
# endif
#include <fstream>
#ifdef __CYGWIN__
# define __int64 long long
#endif
#if defined (_STLP_USE_UNIX_IO)
extern "C" {
// open/close/read/write
# include <sys/stat.h> // For stat
#if !defined (_CRAY) && ! defined (__EMX__)
# include <sys/mman.h> // For mmap
#endif
// on HP-UX 11, this one contradicts with pthread.h on pthread_atfork, unless we unset this
# if defined (__hpux) && defined (__GNUC__)
# undef _INCLUDE_POSIX1C_SOURCE
# endif
# include <unistd.h>
# include <fcntl.h>
}
# ifdef __APPLE__
# include <sys/sysctl.h>
# endif
#elif defined (_STLP_USE_WIN32_IO)
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# ifdef __BORLANDC__
# if (__BORLANDC__ > 0x530)
# include <cfcntl.h> // For _O_RDONLY, etc
# else
# include <fcntl.h> // For _O_RDONLY, etc
# endif
# include <sys/stat.h> // For _fstat
# elif !defined(_STLP_WINCE)
# include <io.h> // For _get_osfhandle
# include <fcntl.h> // For _O_RDONLY, etc
# include <sys/stat.h> // For _fstat
# endif
# define _TEXTBUF_SIZE 0x1000
#elif defined (_STLP_USE_UNIX_EMULATION_IO)
# if defined( __MSL__ )
# include <unistd.h>
# else
# include <io.h>
# endif
# include <fcntl.h>
# include <sys/stat.h>
#elif defined (_STLP_USE_STDIO_IO)
# include <cstdio>
# if !(defined(__MRC__) || defined(__SC__) || defined(__ISCPP__) )
extern "C" {
# include <sys/stat.h>
}
# endif
# if defined( __MSL__ )
# include <unix.h>
# endif
# if defined(__ISCPP__)
# include <c_locale_is/filestat.h>
# endif
# if (defined(__BEOS__) && defined(__INTEL__)) || defined(__SYMBIAN32__)
# include <fcntl.h>
# include <sys/stat.h> // For _fstat
# define _S_IREAD S_IREAD
# define _S_IWRITE S_IWRITE
# define _S_IFREG S_IFREG
# endif
#else
#error "Configure i/o !"
#endif
// map permission masks
#if defined (_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO)
# ifndef S_IRUSR
# define S_IRUSR _S_IREAD
# define S_IWUSR _S_IWRITE
# define S_IRGRP _S_IREAD
# define S_IWGRP _S_IWRITE
# define S_IROTH _S_IREAD
# define S_IWOTH _S_IWRITE
# endif
# ifndef O_RDONLY
# define O_RDONLY _O_RDONLY
# define O_WRONLY _O_WRONLY
# define O_RDWR _O_RDWR
# define O_APPEND _O_APPEND
# define O_CREAT _O_CREAT
# define O_TRUNC _O_TRUNC
# define O_TEXT _O_TEXT
# define O_BINARY _O_BINARY
# endif
# ifdef __MSL__
# define _O_TEXT 0x0
# if !defined( O_TEXT )
# define O_TEXT _O_TEXT
# endif
# define _S_IFREG S_IFREG
# define S_IREAD S_IRUSR
# define S_IWRITE S_IWUSR
# define S_IEXEC S_IXUSR
# define _S_IWRITE S_IWRITE
# define _S_IREAD S_IREAD
# define _open open
# define _lseek lseek
# define _close close
# define _read read
# define _write write
# endif
#endif
#ifndef O_ACCMODE
# define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
#endif
#include "fstream_impl.h"
# ifdef _STLP_LONG_LONG
# define ULL(x) ((unsigned _STLP_LONG_LONG)x)
// # elif defined (_MSC_VER) || defined (__BORLANDC__)
// # define ULL(x) ((__int64)x)
# elif defined(__MRC__) || defined(__SC__) //*TY 02/25/2000 - added support for MPW compilers
# include <Math64.h>
# define ULL(x) (U64SetU(x))
# elif defined(__ISCPP__)
# include "uint64.h"
# else
# error "there should be some long long type on the system!"
# endif
__SGI_BEGIN_NAMESPACE
#if !defined(__MSL__) && !defined(__MRC__) && !defined(__SC__) && !defined(_STLP_WINCE) //*TY 04/15/2000 - exclude mpw compilers also
ios_base::openmode flag_to_openmode(int mode)
{
ios_base::openmode ret = ios_base::in;
switch(mode & O_ACCMODE) {
case O_RDONLY:
ret = ios_base::in; break;
case O_WRONLY:
ret = ios_base::out; break;
case O_RDWR:
ret = ios_base::in | ios_base::out; break;
}
if (mode & O_APPEND)
ret |= ios_base::app;
# ifdef _STLP_USE_WIN32_IO
if (mode & O_BINARY)
ret |= ios_base::binary;
# endif // _MSC_VER
return ret;
}
# endif /* MSL */
// Helper functions for _Filebuf_base.
bool __is_regular_file(_STLP_fd fd) {
#if defined (_STLP_UNIX)
struct stat buf;
return fstat(fd, &buf) == 0 && S_ISREG(buf.st_mode);
#elif defined(__MRC__) || defined(__SC__) //*TY 02/25/2000 - added support for MPW compilers
#pragma unused(fd)
return true; // each file is a regular file under mac os, isn't it? (we don't have fstat())
#elif defined(_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO)
struct stat buf;
return fstat(fd, &buf) == 0 && (buf.st_mode & _S_IFREG) != 0 ;
# elif defined (_STLP_USE_WIN32_IO) && !defined(_STLP_WINCE)
return (GetFileType(fd) & ~FILE_TYPE_REMOTE) == FILE_TYPE_DISK;
#else
(void)fd; // dwa 4/27/00 - suppress unused parameter warning
return false;
#endif
}
// Number of characters in the file.
streamoff __file_size(_STLP_fd fd) {
streamoff ret = 0;
#if defined (_STLP_UNIX)
struct stat buf;
if(fstat(fd, &buf) == 0 && S_ISREG(buf.st_mode))
ret = buf.st_size > 0 ? buf.st_size : 0;
#elif defined(__MRC__) || defined(__SC__) //*TY 02/25/2000 - added support for MPW compilers
#pragma unused(fd)
#elif defined(_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO)
struct stat buf;
if(fstat(fd, &buf) == 0 && (buf.st_mode & _S_IFREG) != 0)
ret = buf.st_size > 0 ? buf.st_size : 0;
# elif defined (_STLP_USE_WIN32_IO)
LARGE_INTEGER li;
li.LowPart = GetFileSize(fd, (unsigned long*) &li.HighPart);
if (li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR )
{
ret = 0;
} else
ret = li.QuadPart;
# else
(void)fd; // dwa 4/27/00 - suppress unused parameter warning
# endif
return ret;
}
// Visual C++ and Intel use this, but not Metrowerks
// Also MinGW, msvcrt.dll (but not crtdll.dll) dependent version
#if (!defined(__MSL__) && !defined(_STLP_WINCE) && defined( _MSC_VER ) && defined(_WIN32)) || \
(defined(__MINGW32__) && defined(__MSVCRT__) && !defined (__SYMBIAN32__))
// fcntl(fileno, F_GETFL) for Microsoft library
// 'semi-documented' defines:
#define IOINFO_L2E 5
#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
#define _pioinfo(i) ( __pioinfo[(i) >> IOINFO_L2E] + \
((i) & (IOINFO_ARRAY_ELTS - 1)) )
#define FAPPEND 0x20 // O_APPEND flag
#define FTEXT 0x80 // O_TEXT flag
// end of 'semi-documented' defines
// fbp : empirical
#define F_WRITABLE 0x04
// 'semi-documented' internal structure
extern "C" {
struct ioinfo {
long osfhnd; // the real os HANDLE
char osfile; // file handle flags
char pipech; // pipe buffer
# ifdef _MT
// multi-threaded locking
int lockinitflag;
CRITICAL_SECTION lock;
# endif /* _MT */
};
#ifdef __MINGW32__
__MINGW_IMPORT ioinfo * __pioinfo[];
#else
extern _CRTIMP ioinfo * __pioinfo[];
#endif
} // extern "C"
// end of 'semi-documented' declarations
ios_base::openmode _get_osfflags(int fd, HANDLE oshandle) {
char dosflags = 0;
dosflags = _pioinfo(fd)->osfile;
// end of 'semi-documented' stuff
int mode = 0;
if (dosflags & FAPPEND)
mode |= O_APPEND;
if (dosflags & FTEXT)
mode |= O_TEXT;
else
mode |= O_BINARY;
// we have to guess
# ifdef __macintosh
DWORD dummy, dummy2;
if (WriteFile(oshandle, &dummy2, 0, &dummy, 0))
mode |= O_RDWR;
else
mode |= O_RDONLY;
# else
// on Windows, this seems to work...
if (dosflags & F_WRITABLE)
mode |= O_RDWR;
else
mode |= O_RDONLY;
# endif
return flag_to_openmode(mode);
}
#elif defined(__DMC__)
#define FHND_APPEND 0x04
#define FHND_DEVICE 0x08
#define FHND_TEXT 0x10
extern "C" unsigned char __fhnd_info[_NFILE];
ios_base::openmode _get_osfflags(int fd, HANDLE oshandle) {
int mode = 0;
if (__fhnd_info[fd] & FHND_APPEND)
mode |= O_APPEND;
if (__fhnd_info[fd] & FHND_TEXT == 0)
mode |= O_BINARY;
for (FILE *fp = &_iob[0]; fp < &_iob[_NFILE]; fp++)
{
if ((fileno(fp) == fd) && (fp->_flag & (_IOREAD | _IOWRT | _IORW)))
{
const int osflags = fp->_flag;
if ((osflags & _IOREAD) && !(osflags & _IOWRT) && !(osflags & _IORW))
mode |= O_RDONLY;
else if ((osflags & _IOWRT) && !(osflags & _IOREAD) && !(osflags & _IORW))
mode |= O_WRONLY;
else
mode |= O_RDWR;
break;
}
}
return flag_to_openmode(mode);
}
#endif // _MSC_VER
__SGI_END_NAMESPACE
// All version of Unix have mmap and lseek system calls. Some also have
// longer versions of thos system calls to accommodate 64-bit offsets.
// If we're on a Unix system, define some macros to encapsulate those
// differences.
#ifdef _STLP_USE_UNIX_IO
# ifdef __sgi /* IRIX */
# define LSEEK lseek64
# define MMAP mmap64
# else
# define LSEEK lseek
# define MMAP mmap
# endif
#ifndef MAP_FAILED /* MMAP failure return code */
# define MAP_FAILED -1
#endif
#elif defined (_STLP_USE_UNIX_EMULATION_IO)
# define LSEEK _lseek
#endif
#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)
#include "libstdcppwsd.h"
# endif
_STLP_BEGIN_NAMESPACE
#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)
void filebuf_page_size_init()
{
get_fstream_Filebuf_Base_GetPageSize() = 4096;
}
#else
size_t
_Filebuf_base::_M_page_size = 4096;
#endif //__LIBSTD_CPP_SYMBIAN32_WSD__
_STLP_EXP_DECLSPEC _Filebuf_base::_Filebuf_base()
: _M_file_id((_STLP_fd)-1),
_M_openmode(0),
_M_is_open(false),
_M_should_close(false)
{
#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)
if (!get_fstream_Filebuf_Base_GetPageSize())
#else
if (!_M_page_size)
#endif //__SYMBIAN32__
#if defined (_STLP_UNIX) && !defined(__DJGPP) && !defined(_CRAY)
# if defined (__APPLE__)
{
int mib[2];
size_t pagesize, len;
mib[0] = CTL_HW;
mib[1] = HW_PAGESIZE;
len = sizeof(pagesize);
sysctl(mib, 2, &pagesize, &len, NULL, 0);
_M_page_size = pagesize;
}
# elif defined(__DJGPP) && defined(_CRAY)
_M_page_size = BUFSIZ;
# else
#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)
get_fstream_Filebuf_Base_GetPageSize() = sysconf(_SC_PAGESIZE);
#else
_M_page_size = sysconf(_SC_PAGESIZE);
#endif
# endif
# elif defined (_STLP_USE_WIN32_IO)
{
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);
_M_page_size = SystemInfo.dwPageSize;
// might be .dwAllocationGranularity
}
// _M_CRLF_trans_buf = 0,
// _M_trans_buf_end=0,
_M_view_id = 0;
#endif
#if defined(__LIBSTD_CPP_SYMBIAN32_WSD__) || defined(_STLP_LIBSTD_CPP_NO_STATIC_VAR_)
if (get_fstream_Filebuf_Base_GetPageSize() <= 0 )
get_fstream_Filebuf_Base_GetPageSize() = 4096;
#else
if (_M_page_size <=0 )
_M_page_size = 4096;
#endif //__LIBSTD_CPP_SYMBIAN32_WSD__
}
// Return the size of the file. This is a wrapper for stat.
// Returns zero if the size cannot be determined or is ill-defined.
_STLP_EXP_DECLSPEC streamoff
_Filebuf_base::_M_file_size()
{
return _SgI::__file_size(_M_file_id);
}
_STLP_EXP_DECLSPEC bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
long permission)
{
_STLP_fd file_no;
if (_M_is_open)
return false;
#if defined (_STLP_USE_UNIX_IO) || defined (_STLP_USE_UNIX_EMULATION_IO)
int flags = 0;
// Unix makes no distinction between text and binary files.
switch(openmode & (~ios_base::ate & ~ios_base::binary)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
flags = O_WRONLY | O_CREAT | O_TRUNC;
break;
case ios_base::out | ios_base::app:
flags = O_WRONLY | O_CREAT | O_APPEND;
break;
case ios_base::in:
flags = O_RDONLY;
permission = 0; // Irrelevant unless we're writing.
break;
case ios_base::in | ios_base::out:
flags = O_RDWR;
break;
case ios_base::in | ios_base::out | ios_base::trunc:
flags = O_RDWR | O_CREAT | O_TRUNC;
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
# if defined (_STLP_USE_UNIX_EMULATION_IO)
if (openmode & ios_base::binary)
flags |= O_BINARY;
else
flags |= O_TEXT;
file_no = _open(name, flags, permission);
# else
file_no = open(name, flags, permission);
# endif /* _STLP_USE_UNIX_EMULATION_IO */
if (file_no < 0)
return false;
_M_is_open = true;
if (openmode & ios_base::ate)
if (LSEEK(file_no, 0, SEEK_END) == -1)
_M_is_open = false;
#elif defined (_STLP_USE_STDIO_IO)
// use FILE-based i/o
const char* flags;
switch(openmode & (~ios_base::ate)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
flags = "w";
break;
case ios_base::out | ios_base::binary:
case ios_base::out | ios_base::trunc | ios_base::binary:
flags = "wb";
break;
case ios_base::out | ios_base::app:
flags = "a";
break;
case ios_base::out | ios_base::app | ios_base::binary:
flags = "ab";
break;
case ios_base::in:
flags = "r";
break;
case ios_base::in | ios_base::binary:
flags = "rb";
break;
case ios_base::in | ios_base::out:
flags = "r+";
break;
case ios_base::in | ios_base::out | ios_base::binary:
flags = "r+b";
break;
case ios_base::in | ios_base::out | ios_base::trunc:
flags = "w+";
break;
case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
flags = "w+b";
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
// fbp : TODO : set permissions !
(void)permission; // currently unused //*TY 02/26/2000 - added to suppress warning message
_M_file = fopen(name, flags);
if (_M_file) {
file_no = fileno(_M_file);
}
else
return false;
// unset buffering immediately
setbuf(_M_file, 0);
_M_is_open = true;
if (openmode & ios_base::ate)
if (fseek(_M_file, 0, SEEK_END) == -1)
_M_is_open = false;
# elif defined (_STLP_USE_WIN32_IO)
DWORD dwDesiredAccess, dwShareMode, dwCreationDisposition;
bool doTruncate = false;
switch(openmode & (~ios_base::ate & ~ios_base::binary)) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
dwDesiredAccess = GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
// boris : even though it is very non-intuitive, standard
// requires them both to behave same.
doTruncate = true;
break;
case ios_base::out | ios_base::app:
dwDesiredAccess = GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
break;
case ios_base::in:
dwDesiredAccess = GENERIC_READ;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_EXISTING;
permission = 0; // Irrelevant unless we're writing.
break;
case ios_base::in | ios_base::out:
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_EXISTING;
break;
case ios_base::in | ios_base::out | ios_base::trunc:
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
dwCreationDisposition = OPEN_ALWAYS;
doTruncate = true;
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
#if defined(_STLP_WINCE)
file_no = CreateFile(__ASCIIToWide(name).c_str(),
#else
file_no = CreateFileA(name,
#endif
dwDesiredAccess, dwShareMode, 0,
dwCreationDisposition, permission, 0);
if ( file_no == INVALID_HANDLE_VALUE )
return false;
if ((doTruncate && SetEndOfFile(file_no) == 0) ||
((openmode & ios_base::ate) && SetFilePointer(file_no, 0, NULL, FILE_END) == -1)) {
CloseHandle(file_no);
return false;
}
_M_is_open = true;
#else
# error "Port!"
#endif /* __unix */
_M_file_id = file_no;
_M_should_close = _M_is_open;
_M_openmode = openmode;
if (_M_is_open)
_M_regular_file = _SgI::__is_regular_file(_M_file_id);
return _M_is_open;
}
_STLP_EXP_DECLSPEC bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode)
{
// This doesn't really grant everyone in the world read/write
// access. On Unix, file-creation system calls always clear
// bits that are set in the umask from the permissions flag.
# ifdef _STLP_USE_WIN32_IO
return this->_M_open(name, openmode, FILE_ATTRIBUTE_NORMAL);
# elif defined(__MRC__) || defined(__SC__) //*TY 02/26/2000 - added support for MPW compilers
return this->_M_open(name, openmode, 0);
# else
return this->_M_open(name, openmode, S_IRUSR | S_IWUSR | S_IRGRP |
S_IWGRP | S_IROTH | S_IWOTH);
# endif
}
// Associated the filebuf with a file descriptor pointing to an already-
// open file. Mode is set to be consistent with the way that the file
// was opened.
bool _Filebuf_base::_M_open(int file_no, ios_base::openmode init_mode) {
if (_M_is_open || file_no < 0)
return false;
# if defined (_STLP_UNIX)
(void)init_mode; // dwa 4/27/00 - suppress unused parameter warning
int mode ;
mode = fcntl(file_no, F_GETFL);
if (mode == -1)
return false;
_M_openmode = _SgI::flag_to_openmode(mode);
# elif defined(__MRC__) || defined(__SC__) //*TY 02/26/2000 - added support for MPW compilers
(void)init_mode; // dwa 4/27/00 - suppress unused parameter warning
switch( _iob[file_no]._flag & (_IOREAD|_IOWRT|_IORW) )
{
case _IOREAD:
_M_openmode = ios_base::in; break;
case _IOWRT:
_M_openmode = ios_base::out; break;
case _IORW:
_M_openmode = ios_base::in | ios_base::out; break;
default:
return false;
}
# elif defined (_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO)
(void)init_mode; // dwa 4/27/00 - suppress unused parameter warning
int mode ;
struct stat buf;
if (fstat(file_no, &buf) != 0)
return false;
mode = buf.st_mode;
switch(mode & (_S_IWRITE | _S_IREAD) ) {
case _S_IREAD:
_M_openmode = ios_base::in; break;
case _S_IWRITE:
_M_openmode = ios_base::out; break;
case (_S_IWRITE | _S_IREAD):
_M_openmode = ios_base::in | ios_base::out; break;
default:
return false;
}
# elif (defined(_STLP_USE_WIN32_IO) && defined (_MSC_VER) && !defined(_STLP_WINCE)) || \
(defined(__MINGW32__) && defined(__MSVCRT__)) || defined(__DMC__)
if (_M_is_open || file_no == -1)
return false;
HANDLE oshandle = (HANDLE)_get_osfhandle(file_no);
if ((long)oshandle != -1)
file_no = (int)oshandle;
else
return false;
if (init_mode != ios_base::__default_mode)
_M_openmode = init_mode;
else
_M_openmode = _SgI::_get_osfflags(file_no, oshandle);
# else
(void)init_mode; // dwa 4/27/00 - suppress unused parameter warning
// not available for the API
return false;
# endif
_M_is_open = true;
_M_file_id = (_STLP_fd)file_no;
_M_should_close = false;
_M_regular_file = _SgI::__is_regular_file(_M_file_id);
return true;
}
_STLP_EXP_DECLSPEC bool _Filebuf_base::_M_close() {
if (!_M_is_open)
return false;
bool ok;
if (!_M_should_close)
ok = true;
else {
# if defined (_STLP_USE_UNIX_IO)
ok = (close(_M_file_id) == 0);
# elif defined (_STLP_USE_UNIX_EMULATION_IO)
ok = (_close(_M_file_id) == 0);
# elif defined (_STLP_USE_STDIO_IO)
ok = (fclose(_M_file) == 0);
# elif defined (_STLP_USE_WIN32_IO)
if ( _M_file_id != INVALID_HANDLE_VALUE ) {
ok = (CloseHandle(_M_file_id) != 0);
}
else {
ok = false;
}
# else
ok = false;
# endif /* _STLP_USE_UNIX_IO */
}
_M_is_open = _M_should_close = false;
_M_openmode = 0;
return ok;
}
# define _STLP_LF 10
# define _STLP_CR 13
# define _STLP_CTRLZ 26
// Read up to n characters into a buffer. Return value is number of
// characters read.
_STLP_EXP_DECLSPEC ptrdiff_t _Filebuf_base::_M_read(char* buf, ptrdiff_t n) {
# if defined (_STLP_USE_UNIX_IO)
return read(_M_file_id, buf, n);
# elif defined (_STLP_USE_UNIX_EMULATION_IO)
return _read(_M_file_id, buf, n);
# elif defined (_STLP_USE_WIN32_IO)
DWORD NumberOfBytesRead;
ReadFile(_M_file_id, (LPVOID)buf, (DWORD)n,
&NumberOfBytesRead, 0);
if ((! (_M_openmode & ios_base::binary)) && NumberOfBytesRead) {
// translate CR-LFs to LFs in the buffer
char * to = buf, * last = buf + NumberOfBytesRead - 1;
char * from;
for (from = buf; from <= last && * from != _STLP_CTRLZ; ++ from ) {
if (* from != _STLP_CR)
* to ++ = * from;
else { // found CR
if (from < last) { // not at buffer end
if (* (from + 1) != _STLP_LF)
* to ++ = _STLP_CR;
}
else { // last char is CR, peek for LF
char peek = ' ';
DWORD NumberOfBytesPeeked;
ReadFile(_M_file_id, (LPVOID)&peek,
1, &NumberOfBytesPeeked, 0);
if (NumberOfBytesPeeked) {
if (peek != _STLP_LF) { //not a <CR><LF> combination
* to ++ = _STLP_CR;
SetFilePointer(_M_file_id,(LONG)-1,0,SEEK_CUR);
}
else {
//We ignore the complete combinaison:
SetFilePointer(_M_file_id,(LONG)-2,0,SEEK_CUR);
}
}
}
} // found CR
} // for
// seek back to TEXT end of file if hit CTRL-Z
if (from <= last) // terminated due to CTRLZ
SetFilePointer(_M_file_id,(LONG)((last+1) - from),0,SEEK_CUR);
NumberOfBytesRead = to - buf;
}
return (ptrdiff_t)NumberOfBytesRead;
# elif defined (_STLP_USE_STDIO_IO)
return fread(buf, 1, n, _M_file);
# else
# error "Port!"
# endif /* __unix */
}
// Write n characters from a buffer. Return value: true if we managed
// to write the entire buffer, false if we didn't.
_STLP_EXP_DECLSPEC bool _Filebuf_base::_M_write(char* buf, ptrdiff_t n) {
while (true) {
ptrdiff_t written;
# if defined (_STLP_USE_UNIX_IO)
written = write(_M_file_id, buf, n);
# elif defined (_STLP_USE_UNIX_EMULATION_IO)
written = _write(_M_file_id, buf, n);
# elif defined (_STLP_USE_WIN32_IO)
// In append mode, every write does an implicit seek to the end
// of the file.
if (_M_openmode & ios_base::app)
_M_seek( 0, ios_base::end);
if (_M_openmode & ios_base::binary) {
// binary mode
DWORD NumberOfBytesWritten;
WriteFile(_M_file_id, (LPVOID)buf, (DWORD)n,
&NumberOfBytesWritten, 0);
written = (ptrdiff_t)NumberOfBytesWritten;
}
else {
char textbuf[_TEXTBUF_SIZE + 1]; // extra 1 in case LF at end
char * nextblock = buf, * ptrtextbuf = textbuf;
char * endtextbuf = textbuf + _TEXTBUF_SIZE;
char * endblock = buf + n;
ptrdiff_t nextblocksize = (min) (n, (ptrdiff_t)_TEXTBUF_SIZE);
char * nextlf;
while ( (nextblocksize > 0) &&
(nextlf = (char *)memchr(nextblock, _STLP_LF, nextblocksize)) != 0) {
ptrdiff_t linelength = nextlf - nextblock;
memcpy(ptrtextbuf, nextblock, linelength);
ptrtextbuf += linelength;
nextblock += (linelength + 1);
* ptrtextbuf ++ = _STLP_CR;
* ptrtextbuf ++ = _STLP_LF;
nextblocksize = (min) (ptrdiff_t(endblock - nextblock),
(max) (ptrdiff_t(0), ptrdiff_t(endtextbuf - ptrtextbuf)));
}
// write out what's left, > condition is here since for LF at the end ,
// endtextbuf may get < ptrtextbuf ...
if (nextblocksize > 0) {
memcpy(ptrtextbuf, nextblock, nextblocksize);
ptrtextbuf += nextblocksize;
nextblock += nextblocksize;
}
// now write out the translated buffer
char * writetextbuf = textbuf;
for (ptrdiff_t NumberOfBytesToWrite = ptrtextbuf - textbuf;
NumberOfBytesToWrite;) {
DWORD NumberOfBytesWritten;
WriteFile((HANDLE)_M_file_id, (LPVOID)writetextbuf,
NumberOfBytesToWrite, &NumberOfBytesWritten, 0);
if (NumberOfBytesWritten == NumberOfBytesToWrite)
break;
if (!NumberOfBytesWritten) // write shortfall
return false;
writetextbuf += NumberOfBytesWritten;
NumberOfBytesToWrite -= NumberOfBytesWritten;
}
// count non-translated characters
written = (nextblock - buf);
}
# elif defined (_STLP_USE_STDIO_IO)
written = fwrite(buf, 1, n, _M_file);
# else
# error "Port!"
# endif /* __unix */
if (n == written)
return true;
else if (written > 0 && written < n) {
n -= written;
buf += written;
}
else
return false;
}
}
#ifdef _STLP_USE_WIN32_IO
# define STL_SEEK_SET FILE_BEGIN
# define STL_SEEK_CUR FILE_CURRENT
# define STL_SEEK_END FILE_END
#else
# define STL_SEEK_SET SEEK_SET
# define STL_SEEK_CUR SEEK_CUR
# define STL_SEEK_END SEEK_END
#endif
// Wrapper for lseek or the like.
_STLP_EXP_DECLSPEC streamoff _Filebuf_base::_M_seek(streamoff offset, ios_base::seekdir dir)
{
streamoff result = -1;
int whence;
switch(dir) {
case ios_base::beg:
if (offset < 0 /* || offset > _M_file_size() */ )
return streamoff(-1);
whence = STL_SEEK_SET;
break;
case ios_base::cur:
whence = STL_SEEK_CUR;
break;
case ios_base::end:
if (/* offset > 0 || */ -offset > _M_file_size() )
return streamoff(-1);
whence = STL_SEEK_END;
break;
default:
return streamoff(-1);
}
#if defined (_STLP_USE_UNIX_IO) || defined (_STLP_USE_UNIX_EMULATION_IO)
result = LSEEK(_M_file_id, offset, whence);
#elif defined (_STLP_USE_STDIO_IO)
result = fseek(_M_file, offset, whence);
#elif defined (_STLP_USE_WIN32_IO)
LARGE_INTEGER li;
li.QuadPart = offset;
li.LowPart = SetFilePointer(_M_file_id, li.LowPart, &li.HighPart, whence);
if (li.LowPart == 0xFFFFFFFF && GetLastError() != NO_ERROR)
result = -1; // Error
else
result = li.QuadPart;
#else
# error "Port!"
#endif
return result;
}
// Attempts to memory-map len bytes of the current file, starting
// at position offset. Precondition: offset is a multiple of the
// page size. Postcondition: return value is a null pointer if the
// memory mapping failed. Otherwise the return value is a pointer to
// the memory-mapped file and the file position is set to offset.
_STLP_EXP_DECLSPEC void* _Filebuf_base::_M_mmap(streamoff offset, streamoff len) {
void* base;
#if defined (_STLP_UNIX) && !defined(__DJGPP) && !defined(_CRAY)
base = MMAP(0, len, PROT_READ, MAP_PRIVATE, _M_file_id, offset);
if (base != (void*)MAP_FAILED) {
if (LSEEK(_M_file_id, offset + len, SEEK_SET) < 0) {
this->_M_unmap(base, len);
base = 0;
}
} else
base =0;
#elif defined (_STLP_USE_WIN32_IO)
_M_view_id = CreateFileMapping(_M_file_id, (PSECURITY_ATTRIBUTES)0 ,
PAGE_READONLY, 0 /* len >> 32 */ ,
0 /* len & 0xFFFFFFFF */ , // low-order DWORD of size
0);
if (_M_view_id) {
# if 0
printf("view %x created from file %x, error = %d, size = %d, map_offset = %d map_len = %d\n",
_M_view_id, _M_file_id, GetLastError(),
(int)cur_filesize, ULL(offset) & 0xffffffff, len);
# endif
base = MapViewOfFile(_M_view_id, FILE_MAP_READ, ULL(offset)>>32,
ULL(offset) & 0xffffffff, len);
// check if mapping succeded and is usable
if (base ==0 || _M_seek(offset+len, ios_base::beg) < 0) {
this->_M_unmap(base, len);
base = 0;
}
} else
base = 0;
#else
(void)len; //*TY 02/26/2000 - unused variables
(void)offset; //*TY 02/26/2000 -
base = 0;
#endif
return base;
}
_STLP_EXP_DECLSPEC void _Filebuf_base::_M_unmap(void* base, streamoff len) {
// precondition : there is a valid mapping at the moment
#if defined (_STLP_UNIX) && !defined(__DJGPP) && !defined(_CRAY)
munmap((char*)base, len);
#elif defined (_STLP_USE_WIN32_IO)
if ( base != NULL )
UnmapViewOfFile(base);
// destroy view handle as well
if ( _M_view_id != NULL )
CloseHandle(_M_view_id);
_M_view_id = 0;
base = 0;
#else
(void)len; //*TY 02/26/2000 - unused variables
(void)base; //*TY 02/26/2000 -
#endif
}
_STLP_EXP_DECLSPEC int _STLP_CALL
_Underflow<char, char_traits<char> >::_M_doit (basic_filebuf<char, char_traits<char> >* __this)
{
if (!__this->_M_in_input_mode) {
if (!__this->_M_switch_to_input_mode())
return traits_type::eof();
}
else if (__this->_M_in_putback_mode) {
__this->_M_exit_putback_mode();
if (__this->gptr() != __this->egptr()) {
int_type __c = traits_type::to_int_type(*__this->gptr());
return __c;
}
}
// If it's a disk file, and if the internal and external character
// sequences are guaranteed to be identical, then try to use memory
// mapped I/O. Otherwise, revert to ordinary read.
if (__this->_M_base.__regular_file()
&& __this->_M_always_noconv
&& __this->_M_base._M_in_binary_mode()) {
// If we've mmapped part of the file already, then unmap it.
if (__this->_M_mmap_base)
__this->_M_base._M_unmap(__this->_M_mmap_base, __this->_M_mmap_len);
__this->_M_mmap_base = 0;
__this->_M_mmap_len = 0;
// Determine the position where we start mapping. It has to be
// a multiple of the page size.
streamoff __cur = __this->_M_base._M_seek(0, ios_base::cur);
streamoff __size = __this->_M_base._M_file_size();
if (__size > 0 && __cur >= 0 && __cur < __size) {
streamoff __offset = (__cur / __this->_M_base.__page_size())
* __this->_M_base.__page_size();
streamoff __remainder = __cur - __offset;
__this->_M_mmap_len = __size - __offset;
if (__this->_M_mmap_len > MMAP_CHUNK)
__this->_M_mmap_len = MMAP_CHUNK;
if ((__this->_M_mmap_base =
__this->_M_base._M_mmap(__offset, __this->_M_mmap_len)) != 0) {
__this->setg((char*) __this->_M_mmap_base,
(char*) __this->_M_mmap_base + __remainder,
(char*) __this->_M_mmap_base + __this->_M_mmap_len);
return traits_type::to_int_type(*__this->gptr());
}
} else /* size > 0 ... */ {
// There is nothing to map. We unmapped the file above, now zap pointers.
__this->_M_mmap_base = 0;
__this->_M_mmap_len = 0;
}
}
return __this->_M_underflow_aux();
}
//----------------------------------------------------------------------
// Force instantiation of filebuf and fstream classes.
#if !defined(_STLP_NO_FORCE_INSTANTIATE)
template class basic_filebuf<char, char_traits<char> >;
template class basic_ifstream<char, char_traits<char> >;
template class basic_ofstream<char, char_traits<char> >;
template class basic_fstream<char, char_traits<char> >;
# ifndef _STLP_NO_WCHAR_T
template class _Underflow<wchar_t, char_traits<wchar_t> >;
template class basic_filebuf<wchar_t, char_traits<wchar_t> >;
template class basic_ifstream<wchar_t, char_traits<wchar_t> >;
template class basic_ofstream<wchar_t, char_traits<wchar_t> >;
template class basic_fstream<wchar_t, char_traits<wchar_t> >;
# endif /* _STLP_NO_WCHAR_T */
#endif
_STLP_END_NAMESPACE
// Local Variables:
// mode:C++
// End: