/*

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

#include <stdio_streambuf>

#ifdef _STLP_UNIX

#include <sys/types.h>

#include <sys/stat.h>

#endif /* __unix */

#include <stl/_fstream.h>

#include "fstream_impl.h"

# if defined (_STLP_USE_WIN32_IO) && !defined(_STLP_WINCE)

# if defined (__BORLANDC__)

// #  include <cio.h>

#  include <cfcntl.h>

# else

#  include <io.h>

#  include <fcntl.h>

# endif

#  include <sys/stat.h>

# endif

__SGI_BEGIN_NAMESPACE

//----------------------------------------------------------------------

// Class stdio_streambuf_base

stdio_streambuf_base::stdio_streambuf_base(FILE* file)

  : _STLP_STD::basic_streambuf<char, _STLP_STD::char_traits<char> >(file, 0),

    _M_file(file)

{}

stdio_streambuf_base::~stdio_streambuf_base()

{

  _STLP_VENDOR_CSTD::fflush(_M_file);

}

_STLP_STD::streambuf* stdio_streambuf_base::setbuf(char* s, streamsize n)

{

  _STLP_VENDOR_CSTD::setvbuf(_M_file, s, (s == 0 && n == 0) ? _IONBF : _IOFBF, n);

  return this;

}

stdio_streambuf_base::pos_type

stdio_streambuf_base::seekoff(off_type off, ios_base::seekdir dir,

                              ios_base::openmode /* mode */)

{

  int whence;

  switch(dir) {

  case ios_base::beg:

    whence = SEEK_SET;

    break;

  case ios_base::cur:

    whence = SEEK_CUR;

    break;

  case ios_base::end:

    whence = SEEK_END;

    break;

  default:

    return pos_type(-1);

  }

  if (_STLP_VENDOR_CSTD::fseek(_M_file, off, whence) == 0) {

    fpos_t pos;

    _STLP_VENDOR_CSTD::fgetpos(_M_file, &pos);

    // added 21 june 00 mdb,rjf,wjs: glibc 2.2 changed fpos_t to be a struct instead

    // of a primitive type

#if (defined(__GLIBC__) && ( (__GLIBC__ > 2) || ( (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 2) ) ) )

    return pos_type((streamoff)pos.__pos);

#elif defined(__ISCPP__) || defined(__MVS__) || (__OS400__)

     return pos_type(pos.__fpos_elem[ 0 ]);

#elif defined (__EMX__)

     return pos_type((streamoff)pos._pos);

#else

    return pos_type(pos);

#endif

  }

  else

    return pos_type(-1);

}

stdio_streambuf_base::pos_type

stdio_streambuf_base::seekpos(pos_type pos, ios_base::openmode /* mode */)   // dwa 4/27/00 - suppress unused parameter warning

{

  // added 21 june 00 mdb,rjf,wjs: glibc 2.2 changed fpos_t to be a struct instead

  // of a primitive type

#if (defined(__GLIBC__) && ( (__GLIBC__ > 2) || ( (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 2) ) ) )

  fpos_t p;

  p.__pos = pos;

  memset( &(p.__state), 0, sizeof(p.__state) );

#elif defined(__MVS__) || (__OS400__)

  fpos_t p;

  p.__fpos_elem[0] = pos;

#elif defined(__EMX__)

  fpos_t p;

  p._pos = pos;

  memset( &(p._mbstate), 0, sizeof(p._mbstate) );

#else

  fpos_t p(pos);

#endif

  if (_STLP_VENDOR_CSTD::fsetpos(_M_file, &p) == 0)

    return pos;

  else

    return pos_type(-1);

}

int stdio_streambuf_base::sync()

{

  return _STLP_VENDOR_CSTD::fflush(_M_file) == 0 ? 0 : -1;

}

//----------------------------------------------------------------------

// Class stdio_istreambuf

stdio_istreambuf::~stdio_istreambuf() {}

_STLP_EXP_DECLSPEC streamsize stdio_istreambuf::showmanyc()

{

  if (feof(_M_file)) 

    return -1;

  else {

    int fd = _FILE_fd(_M_file);

# ifdef _STLP_USE_WIN32_IO

    // in this case, __file_size works with Win32 fh , not libc one

    streamoff size;

    struct stat buf;

# ifdef __BORLANDC__

    if(fstat(fd, &buf) == 0 && S_ISREG( buf.st_mode ) )

# else

    if(fstat(fd, &buf) == 0 && ( _S_IFREG & buf.st_mode ) )

# endif

      size = ( buf.st_size > 0  ? buf.st_size : 0);

    else

      size = 0;

# else

    streamoff size = _SgI::__file_size(fd);

# endif

    // fbp : we can use ftell as this flavour always use stdio.

    long pos = _STLP_VENDOR_CSTD::ftell(_M_file);

    return pos >= 0 && size > pos ? size - pos : 0;

  }

}

stdio_istreambuf::int_type stdio_istreambuf::underflow()

{

  int c = getc(_M_file);

  if (c != EOF) {

    _STLP_VENDOR_CSTD::ungetc(c, _M_file);

    return c;

  }

  else

    return traits_type::eof();

}

stdio_istreambuf::int_type stdio_istreambuf::uflow()

{

#ifdef __SYMBIAN32__

  const int_type eof = traits_type::eof();

  return this->underflow() == eof 

    ? eof

    : traits_type::to_int_type(_FILE_I_postincr(_M_file));

#else

  int c = getc(_M_file);

  return c != EOF ? c : traits_type::eof();

#endif    

}

stdio_istreambuf::int_type stdio_istreambuf::pbackfail(int_type c)

{

  if (c != traits_type::eof()) {

    int result = _STLP_VENDOR_CSTD::ungetc(c, _M_file);

    return result != EOF ? result : traits_type::eof();

  }

  else{

    if (this->eback() < this->gptr()) {

      this->gbump(-1);

      return traits_type::not_eof(c);

    }

    else

      return traits_type::eof();

  }

}

//----------------------------------------------------------------------

// Class stdio_ostreambuf

stdio_ostreambuf::~stdio_ostreambuf() {}

_STLP_EXP_DECLSPEC streamsize stdio_ostreambuf::showmanyc()

{

  return -1;

}

stdio_ostreambuf::int_type stdio_ostreambuf::overflow(int_type c)

{

  // Write the existing buffer, without writing any additional character.

  if (c == traits_type::eof()) {

    // Do we have a buffer to write?

    ptrdiff_t unwritten = this->pptr() - this->pbase();

    if (unwritten != 0) {

      _STLP_VENDOR_CSTD::fflush(_M_file);

      // Test if the write succeeded.

      if (this->pptr() - this->pbase() < unwritten)

        return traits_type::not_eof(c);

      else

        return traits_type::eof();

    }

    // We always succeed if we don't have to do anything.

    else

      return traits_type::not_eof(c);

  }

  // Write the character c, and whatever else might be in the buffer.

  else {

    int result = putc(c, _M_file);

    return result != EOF ? result : traits_type::eof();

  }

}

__SGI_END_NAMESPACE

// Local Variables:

// mode:C++

// End: