/*

 * © 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)