diff -r 000000000000 -r e4d67989cc36 stdcpp/src/fstream.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/src/fstream.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1201 @@
+/*
+ * © 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:
+