/*

  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

  *

  * Copyright (c) 1996,1997

  * 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.

  *

  */

 #ifndef _STLP_FSTREAM_C

 #define _STLP_FSTREAM_C

 # ifndef _STLP_INTERNAL_FSTREAM_H

 #  include <stl/_fstream.h>

 # endif

 # if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)

 _STLP_BEGIN_NAMESPACE

 # if defined ( _STLP_NESTED_TYPE_PARAM_BUG )

 // no wchar_t is supported for this mode

 # define __BF_int_type__ int

 # define __BF_pos_type__ streampos

 # define __BF_off_type__ streamoff

 # else

 # define __BF_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type

 # define __BF_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::pos_type

 # define __BF_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::off_type

 # endif

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

 // Public basic_filebuf<> member functions

 template <class _CharT, class _Traits>

 basic_filebuf<_CharT, _Traits>::basic_filebuf()

      :  basic_streambuf<_CharT, _Traits>(), _M_base(),

     _M_constant_width(false), _M_always_noconv(false),

     _M_int_buf_dynamic(false),

     _M_in_input_mode(false), _M_in_output_mode(false),

     _M_in_error_mode(false), _M_in_putback_mode(false),

     _M_int_buf(0), _M_int_buf_EOS(0),

     _M_ext_buf(0), _M_ext_buf_EOS(0),

     _M_ext_buf_converted(0), _M_ext_buf_end(0),

     _M_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),

     _M_end_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),

     _M_mmap_base(0), _M_mmap_len(0),

     _M_saved_eback(0), _M_saved_gptr(0), _M_saved_egptr(0),

     _M_codecvt(0),

     _M_width(1), _M_max_width(1)

 {

   this->_M_setup_codecvt(locale());

 }

 template <class _CharT, class _Traits>

 basic_filebuf<_CharT, _Traits>::~basic_filebuf() {

   this->close();

   _M_deallocate_buffers();

 }

 template <class _CharT, class _Traits>

 _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type 

 basic_filebuf<_CharT, _Traits>::underflow() 

 {

   return _Underflow<_CharT, _Traits>::_M_doit(this);

 }

 template <class _CharT, class _Traits>

 basic_filebuf<_CharT, _Traits>* 

 basic_filebuf<_CharT, _Traits>::close()

 {

   bool __ok = this->is_open();

   if (_M_in_output_mode) {

     __ok = __ok && !_Traits::eq_int_type(this->overflow(traits_type::eof()),

                                          traits_type::eof());

     __ok == __ok && this->_M_unshift();

   }

   else if (_M_in_input_mode)

       this->_M_exit_input_mode();

   // Note order of arguments.  We close the file even if __ok is false.

   __ok = _M_base._M_close() && __ok;

   // Restore the initial state, except that we don't deallocate the buffer

   // or mess with the cached codecvt information.

   _M_state = _M_end_state = _State_type();

   _M_ext_buf_converted = _M_ext_buf_end = 0;

   _M_mmap_base = 0;

   _M_mmap_len = 0;

 #ifdef __SYMBIAN32__

   if (__ok) {

 #endif // __SYMBIAN32__

   this->setg(0, 0, 0);

   this->setp(0, 0);

 #ifdef __SYMBIAN32__  

   }

 #endif // __SYMBIAN32__

   _M_saved_eback = _M_saved_gptr = _M_saved_egptr = 0;

   _M_in_input_mode = _M_in_output_mode = _M_in_error_mode = _M_in_putback_mode

     = false;

   return __ok ? this : 0;

 }

 // This member function is called whenever we exit input mode.

 // It unmaps the memory-mapped file, if any, and sets

 // _M_in_input_mode to false.  

 template <class _CharT, class _Traits>

 void basic_filebuf<_CharT, _Traits>::_M_exit_input_mode()

 {

    if (_M_mmap_base != 0)

      _M_base._M_unmap(_M_mmap_base, _M_mmap_len); 

    _M_in_input_mode = false;

    _M_mmap_base = 0;

 }

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

 // basic_filebuf<> overridden protected virtual member functions

 template <class _CharT, class _Traits>

 streamsize basic_filebuf<_CharT, _Traits>::showmanyc()

 {

   // Is there any possibility that reads can succeed?

 #ifdef __SYMBIAN32__

   if (!this->is_open() || !(_M_base.__o_mode() & (int)ios_base::in) || _M_in_error_mode)

 #else

   if (!this->is_open() || _M_in_output_mode || _M_in_error_mode)

 #endif

     return -1;

   else if (_M_in_putback_mode)

     return this->egptr() - this->gptr();

   else if (_M_constant_width) {

     streamoff __pos  = _M_base._M_seek(0, ios_base::cur);

     streamoff __size = _M_base._M_file_size();

 #ifdef __SYMBIAN32__

     if(__size == 0)

         return 0;

 #endif

     return __pos >= 0 && __size > __pos ? __size - __pos : -1;

   }

   else 

     return 0;

 }

 // Make a putback position available, if necessary, by switching to a 

 // special internal buffer used only for putback.  The buffer is

 // [_M_pback_buf, _M_pback_buf + _S_pback_buf_size), but the base

 // class only sees a piece of it at a time.  (We want to make sure

 // that we don't try to read a character that hasn't been initialized.)

 // The end of the putback buffer is always _M_pback_buf + _S_pback_buf_size,

 // but the beginning is usually not _M_pback_buf.

 template <class _CharT, class _Traits>

 __BF_int_type__ 

 basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c)

 {

   const int_type __eof = traits_type::eof();

   // If we aren't already in input mode, pushback is impossible.

   if (!_M_in_input_mode)

     return __eof;

   // We can use the ordinary get buffer if there's enough space, and

   // if it's a buffer that we're allowed to write to.

   if (this->gptr() != this->eback() &&

       (traits_type::eq_int_type(__c, __eof) ||

        traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]) ||

        !_M_mmap_base)) {

     this->gbump(-1);

     if (traits_type::eq_int_type(__c, __eof) ||

         traits_type::eq(traits_type::to_char_type(__c), *this->gptr()))

       return traits_type::to_int_type(*this->gptr());

   }

   else if (!traits_type::eq_int_type(__c, __eof)) {

     // Are we in the putback buffer already?

     _CharT* __pback_end = _M_pback_buf + __STATIC_CAST(int,_S_pback_buf_size);

     if (_M_in_putback_mode) {

       // Do we have more room in the putback buffer?

       if (this->eback() != _M_pback_buf) 

         this->setg(this->egptr() - 1, this->egptr() - 1, __pback_end);

       else

         return __eof;           // No more room in the buffer, so fail.

     }

     else {                      // We're not yet in the putback buffer.

       _M_saved_eback = this->eback();

       _M_saved_gptr  = this->gptr();

       _M_saved_egptr = this->egptr();

       this->setg(__pback_end - 1, __pback_end - 1, __pback_end);

       _M_in_putback_mode = true;

     }

   }

   else

   {

 #ifdef __SYMBIAN32__

     if (traits_type::eq_int_type(__c, __eof) )

     {

         if(_M_in_putback_mode)

         {

             _M_in_putback_mode = false;

             // we are at putback mode

             if(_M_saved_eback != _M_saved_gptr)

             {

                 this->setg(_M_saved_eback, _M_saved_gptr - 1, _M_saved_egptr);

                 return *this->gptr();

             }

             else

                 this->setg(_M_saved_eback, _M_saved_gptr, _M_saved_egptr);

          }

          else

          {

             if(!this->eback())

             {

                 streamoff __pos  = _M_base._M_seek(0, ios_base::cur);

                 streamoff __size = _M_base._M_file_size();

                 if( __size > 0 && __pos > 0 && __pos == __size)

                     __pos  = _M_base._M_seek(__pos - 1, ios_base::beg);

                 this->underflow();

                 this->setg(this->eback(), this->gptr(), this->egptr());

                 return *this->gptr();

             }

             else

             {

                 this->setg(this->eback(), this->gptr() - 1, this->egptr());

                 return *this->gptr();

             }

          }

     }

 #endif

     return __eof;

   }

   // We have made a putback position available.  Assign to it, and return.

   *this->gptr() = traits_type::to_char_type(__c);

   return __c;

 }

 // This member function flushes the put area, and also outputs the

 // character __c (unless __c is eof).  Invariant: we always leave room

 // in the internal buffer for one character more than the base class knows

 // about.  We see the internal buffer as [_M_int_buf, _M_int_buf_EOS), but

 // the base class only sees [_M_int_buf, _M_int_buf_EOS - 1).

 template <class _CharT, class _Traits>

 __BF_int_type__

 basic_filebuf<_CharT, _Traits>::overflow(int_type __c)

 {

   // Switch to output mode, if necessary.

   bool putflag = false;

   if (!_M_in_output_mode)

   {

 #ifdef __SYMBIAN32__

     if(this->_M_int_buf)

         putflag = true;

 #endif

     if (!_M_switch_to_output_mode())

       return traits_type::eof();

   }

   _CharT* __ibegin = this->_M_int_buf;

   _CharT* __iend   = this->pptr();

   this->setp(_M_int_buf, _M_int_buf_EOS - 1);

   // Put __c at the end of the internal buffer.

   if (!traits_type::eq_int_type(__c, traits_type::eof()))

     *__iend++ = __c;

 #ifdef __SYMBIAN32__

   int current_pos = this->gptr() - this->eback();

   streamoff __size = _M_base._M_file_size();

   if(current_pos > 0 && current_pos < __size && _M_base.__is_open())

     _M_base._M_seek(current_pos, ios_base::beg);

 #endif

   // For variable-width encodings, output may take more than one pass.

   while (__ibegin != __iend) {

     const _CharT* __inext = __ibegin;

     char* __enext         = _M_ext_buf;

     typename _Codecvt::result __status

       = _M_codecvt->out(_M_state, __ibegin, __iend, __inext,

                                   _M_ext_buf, _M_ext_buf_EOS, __enext);

     if (__status == _Codecvt::noconv)

 #ifdef __SYMBIAN32__    

     {

       if(_Noconv_output<_Traits>::_M_doit(this, __ibegin, __iend))

       {

         if (this->eback())

             {

             *(this->gptr()) = __c;

             this->setg(this->eback(), this->gptr() + 1, this->egptr());

             }

         if(putflag && this->pptr()  < this->epptr())

             this->setp(this->pptr() + 1, this->epptr());

         return traits_type::not_eof(__c);

       }

       else

         return _M_output_error();

     }

 #else

       return _Noconv_output<_Traits>::_M_doit(this, __ibegin, __iend)

         ? traits_type::not_eof(__c)

         : _M_output_error();

 #endif

     // For a constant-width encoding we know that the external buffer

     // is large enough, so failure to consume the entire internal buffer

     // or to produce the correct number of external characters, is an error.

     // For a variable-width encoding, however, we require only that we 

     // consume at least one internal character

     else if (__status != _Codecvt::error && 

              ((__inext == __iend && (__enext - _M_ext_buf == 

                                      _M_width * (__iend - __ibegin))) ||

               (!_M_constant_width && __inext != __ibegin))) {

         // We successfully converted part or all of the internal buffer.

       ptrdiff_t __n = __enext - _M_ext_buf;

       if (_M_write(_M_ext_buf, __n))

         __ibegin += __inext - __ibegin;

       else

         return _M_output_error();

     }

     else

       return _M_output_error();

   }

   return traits_type::not_eof(__c);

 }

 // This member function must be called before any I/O has been

 // performed on the stream, otherwise it has no effect.

 //

 // __buf == 0 && __n == 0 means to make ths stream unbuffered.

 // __buf != 0 && __n > 0 means to use __buf as the stream's internal

 // buffer, rather than the buffer that would otherwise be allocated

 // automatically.  __buf must be a pointer to an array of _CharT whose

 // size is at least __n.

 template <class _CharT, class _Traits>

 basic_streambuf<_CharT, _Traits>*

 basic_filebuf<_CharT, _Traits>::setbuf(_CharT* __buf, streamsize __n)

 {

   if (!_M_in_input_mode &&! _M_in_output_mode && !_M_in_error_mode &&

       _M_int_buf == 0) {

     if (__buf == 0 && __n == 0)

       _M_allocate_buffers(0, 1);

     else if (__buf != 0 && __n > 0)

       _M_allocate_buffers(__buf, __n);

   }

   return this;

 }

 template <class _CharT, class _Traits>

 __BF_pos_type__

 basic_filebuf<_CharT, _Traits>::seekoff(off_type __off,

                                         ios_base::seekdir __whence,

                                         ios_base::openmode /* dummy */)

 {

   if (this->is_open() &&

       (__off == 0 || (_M_constant_width && this->_M_base._M_in_binary_mode()))) {

     if (!_M_seek_init(__off != 0 || __whence != ios_base::cur))

       return pos_type(-1);

     // Seek to beginning or end, regardless of whether we're in input mode.

     if (__whence == ios_base::beg || __whence == ios_base::end)

       return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),

                             _State_type());

     // Seek relative to current position.  Complicated if we're in input mode.

     else if (__whence == ios_base::cur) {

       if (!_M_in_input_mode)

         return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),

                               _State_type());

       else if (_M_mmap_base != 0) {

         // __off is relative to gptr().  We need to do a bit of arithmetic

         // to get an offset relative to the external file pointer.

         streamoff __adjust = _M_mmap_len - (this->gptr() - (_CharT*) _M_mmap_base);

         // if __off == 0, we do not need to exit input mode and to shift file pointer

         if (__off == 0) {

           return pos_type(_M_base._M_seek(0, ios_base::cur) - __adjust);

         }

         else

 #ifdef __SYMBIAN32__       

         return _M_seek_return(_M_base._M_seek(__off, ios_base::cur), _State_type());

 #else      

           return _M_seek_return(_M_base._M_seek(__off - __adjust, ios_base::cur), _State_type());

 #endif

       }

       else if (_M_constant_width) { // Get or set the position.  

         streamoff __iadj = _M_width * (this->gptr() - this->eback());

         // Compensate for offset relative to gptr versus offset relative

         // to external pointer.  For a text-oriented stream, where the 

         // compensation is more than just pointer arithmetic, we may get

         // but not set the current position.

         if (__iadj <= _M_ext_buf_end - _M_ext_buf) {

           streamoff __eadj =  _M_base._M_get_offset(_M_ext_buf + __iadj, _M_ext_buf_end);

           if (__off == 0) {

             return pos_type(_M_base._M_seek(0, ios_base::cur) - __eadj);

           }  else {

             return _M_seek_return(_M_base._M_seek(__off - __eadj, ios_base::cur), _State_type());

           }

         }

         else

           return pos_type(-1);

       }

       else {                    // Get the position.  Encoding is var width.

         // Get position in internal buffer.

         ptrdiff_t __ipos = this->gptr() - this->eback();

         // Get corresponding position in external buffer.

         _State_type __state = _M_state;

         int __epos = _M_codecvt->length(__state, _M_ext_buf, _M_ext_buf_end,

                                         __ipos);

         // Sanity check (expensive): make sure __epos is the right answer.

         _State_type __tmp_state = _M_state;

         _Filebuf_Tmp_Buf<_CharT> __buf(__ipos);

         _CharT* __ibegin = __buf._M_ptr;

         _CharT* __inext  = __ibegin;

         const char* __dummy;

         typename _Codecvt::result __status

           = _M_codecvt->in(__tmp_state,

                            _M_ext_buf, _M_ext_buf + __epos, __dummy,

                            __ibegin, __ibegin + __ipos, __inext);

         if (__status != _Codecvt::error &&

             (__status == _Codecvt::noconv ||

              (__inext == __ibegin + __ipos &&

               equal(this->gptr(), this->eback(), __ibegin,

                     _Eq_traits<traits_type>())))) {

           // Get the current position (at the end of the external buffer),

           // then adjust it.  Again, it might be a text-oriented stream.

           streamoff __cur = _M_base._M_seek(0, ios_base::cur);

           streamoff __adj =

             _M_base._M_get_offset(_M_ext_buf, _M_ext_buf + __epos) -

             _M_base._M_get_offset(_M_ext_buf, _M_ext_buf_end);

           if (__cur != -1 && __cur + __adj >= 0)

             return _M_seek_return(__cur + __adj, __state);

           else

             return pos_type(-1);

         }

         else                    // We failed the sanity check.

           return pos_type(-1);

       }

     }

     else                        // Unrecognized value for __whence.

       return pos_type(-1);

   }

   else

     return pos_type(-1);

 }

 template <class _CharT, class _Traits>

 __BF_pos_type__

 basic_filebuf<_CharT, _Traits>::seekpos(pos_type __pos,

                                         ios_base::openmode /* dummy */)

 {

   if (this->is_open()) {

     if (!_M_seek_init(true))

       return pos_type(-1);

     streamoff __off = off_type(__pos);

     if (__off != -1 && _M_base._M_seek(__off, ios_base::beg) != -1) {

       _M_state = __pos.state();

       return _M_seek_return(__off, __pos.state());

     }

     else

       return pos_type(-1);

   }

   else

     return pos_type(-1);

 }

 template <class _CharT, class _Traits>

 int basic_filebuf<_CharT, _Traits>::sync()

 {

   if (_M_in_output_mode)

     return traits_type::eq_int_type(this->overflow(traits_type::eof()),

                                     traits_type::eof())

       ? -1

       : 0;

   else

     return 0;

 }

 // Change the filebuf's locale.  This member function has no effect

 // unless it is called before any I/O is performed on the stream.

 template <class _CharT, class _Traits>

 void basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)

 {

   if (!_M_in_input_mode &&! _M_in_output_mode && !_M_in_error_mode) {

     this->_M_setup_codecvt(__loc);

   }

 }

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

 // basic_filebuf<> helper functions.

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

 // Helper functions for switching between modes.

 // This member function is called if we're performing the first I/O

 // operation on a filebuf, or if we're performing an input operation 

 // immediately after a seek.

 template <class _CharT, class _Traits>

 bool basic_filebuf<_CharT, _Traits>::_M_switch_to_input_mode()

 {

   if (this->is_open() && (((int)_M_base.__o_mode() & (int)ios_base::in) !=0)

 #ifndef __SYMBIAN32__

       && (_M_in_output_mode == 0) 

 #endif

       && (_M_in_error_mode == 0)) {

 #ifdef __STLP_NO_WRITE_SIDE_BUFFERING__

     // If file has been opened in input|output mode

     if ((((int)_M_base.__o_mode() & (int)ios_base::out) !=0) 

 #ifndef __SYMBIAN32__

         && sync()

 #endif

         && !_M_int_buf && !_M_allocate_buffers(0, 1))

 #else

     if (!_M_int_buf && !_M_allocate_buffers())

 #endif

       return false;

     _M_ext_buf_converted = _M_ext_buf;

     _M_ext_buf_end       = _M_ext_buf;

     _M_end_state    = _M_state;

     _M_in_input_mode = true;

     return true;

   }

   else

     return false;

 }

 // This member function is called if we're performing the first I/O

 // operation on a filebuf, or if we're performing an output operation 

 // immediately after a seek.

 template <class _CharT, class _Traits>

 bool basic_filebuf<_CharT, _Traits>::_M_switch_to_output_mode()

 {

   if (this->is_open() && (_M_base.__o_mode() & (int)ios_base::out) &&

 #ifdef __SYMBIAN32__  

       _M_in_error_mode == 0) {

 #else      

       _M_in_input_mode == 0 && _M_in_error_mode == 0) {

 #endif //__SYMBIAN32__      

 #ifdef __STLP_NO_WRITE_SIDE_BUFFERING__

     if (!_M_int_buf && !_M_allocate_buffers(0, 1))

 #else

     if (!_M_int_buf && !_M_allocate_buffers())

 #endif

       return false;

     // In append mode, every write does an implicit seek to the end

     // of the file.  Whenever leaving output mode, the end of file

     // get put in the initial shift state.

     if (_M_base.__o_mode() & ios_base::app)

       _M_state = _State_type();

     this->setp(_M_int_buf, _M_int_buf_EOS - 1);

     _M_in_output_mode = true;

     return true;

   }

   else

     return false;

 }

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

 // Helper functions for input

 // This member function is called if there is an error during input.

 // It puts the filebuf in error mode, clear the get area buffer, and

 // returns eof.

 // returns eof.  Error mode is sticky; it is cleared only by close or

 // seek.

 template <class _CharT, class _Traits>

 __BF_int_type__

 basic_filebuf<_CharT, _Traits>::_M_input_error()

 {

    this->_M_exit_input_mode();   

   _M_in_output_mode = false;

   _M_in_error_mode = true;

   this->setg(0, 0, 0);

   return traits_type::eof();

 }

 template <class _CharT, class _Traits>

 __BF_int_type__ 

 basic_filebuf<_CharT, _Traits>::_M_underflow_aux() 

 {

   // We have the state and file position from the end of the internal

   // buffer.  This round, they become the beginning of the internal buffer.

   _M_state    = _M_end_state;

   // Fill the external buffer.  Start with any leftover characters that

   // didn't get converted last time.

   if (_M_ext_buf_end > _M_ext_buf_converted)

     _M_ext_buf_end = copy(_M_ext_buf_converted, _M_ext_buf_end, _M_ext_buf);

     // boris : copy_backward did not work

     //_M_ext_buf_end = copy_backward(_M_ext_buf_converted, _M_ext_buf_end, 

     //_M_ext_buf+ (_M_ext_buf_end - _M_ext_buf_converted));

   else

     {

 #ifdef __SYMBIAN32__

      if(_M_ext_buf == NULL)

     _M_allocate_buffers(0, MMAP_CHUNK);

 #endif

     _M_ext_buf_end = _M_ext_buf;

     }

   // Now fill the external buffer with characters from the file.  This is

   // a loop because occasonally we don't get enough external characters

   // to make progress.

   while (true) {

     ptrdiff_t __n = _M_base._M_read(_M_ext_buf_end, _M_ext_buf_EOS - _M_ext_buf_end);

     // Don't enter error mode for a failed read.  Error mode is sticky,

     // and we might succeed if we try again.

 #ifdef __SYMBIAN32__    //plum hall bug 577

     int nn = (char*)_M_ext_buf_end-(char*)_M_ext_buf; //number of chars unconverted last time

     if ( (__n <= 0) && ( nn<=0 ) )

 #else

 	if (__n <= 0)

 #endif    

       return traits_type::eof();

     // Convert the external buffer to internal characters.  

     _M_ext_buf_end += __n;

     const char*   __enext;

     _CharT* __inext;

     typename _Codecvt::result __status

       = _M_codecvt->in(_M_end_state,

                        _M_ext_buf, _M_ext_buf_end, __enext,

                        _M_int_buf, _M_int_buf_EOS, __inext);

     // Error conditions: (1) Return value of error.  (2) Producing internal

     // characters without consuming external characters.  (3) In fixed-width

     // encodings, producing an internal sequence whose length is inconsistent

     // with that of the internal sequence.  (4) Failure to produce any 

     // characters if we have enough characters in the external buffer, where

     // "enough" means the largest possible width of a single character.

     if (__status == _Codecvt::noconv)

       return _Noconv_input<_Traits>::_M_doit(this);

     else if (__status == _Codecvt::error ||

              (__inext != _M_int_buf && __enext == _M_ext_buf) ||

              (_M_constant_width &&

               //         __inext - _M_int_buf != _M_width * (__enext - _M_ext_buf)) ||

               (__inext - _M_int_buf) *  _M_width != (__enext - _M_ext_buf)) ||

              (__inext == _M_int_buf && __enext - _M_ext_buf >= _M_max_width))

       return _M_input_error();

     else if (__inext != _M_int_buf) {

       _M_ext_buf_converted = _M_ext_buf + (__enext - _M_ext_buf);

       this->setg(_M_int_buf, _M_int_buf, __inext);

       return traits_type::to_int_type(*_M_int_buf);

     }

     // We need to go around the loop again to get more external characters.

   } 

 }

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

 // Helper functions for output

 // This member function is called if there is an error during output.

 // It puts the filebuf in error mode, clear the put area buffer, and

 // returns eof.  Error mode is sticky; it is cleared only by close or

 // seek.

 template <class _CharT, class _Traits>

 __BF_int_type__

 basic_filebuf<_CharT, _Traits>::_M_output_error()

 {

   _M_in_output_mode = false;

   _M_in_input_mode = false;

   _M_in_error_mode = true;

   this->setp(0, 0);

   return traits_type::eof();

 }

 // Write whatever sequence of characters is necessary to get back to

 // the initial shift state.  This function overwrites the external

 // buffer, changes the external file position, and changes the state.

 // Precondition: the internal buffer is empty.

 template <class _CharT, class _Traits>

 bool basic_filebuf<_CharT, _Traits>::_M_unshift()

 {

   if (_M_in_output_mode && !_M_constant_width) {

     typename _Codecvt::result __status;

     do {

       char* __enext = _M_ext_buf;

       __status = _M_codecvt->unshift(_M_state,

                                      _M_ext_buf, _M_ext_buf_EOS, __enext);

       if (__status == _Codecvt::noconv ||

           (__enext == _M_ext_buf && __status == _Codecvt::ok))

         return true;

       else if (__status == _Codecvt::error)

         return false;

       else if (!_M_write(_M_ext_buf, __enext - _M_ext_buf))

         return false;

     } while(__status == _Codecvt::partial);

   }

   return true;

 }

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

 // Helper functions for buffer allocation and deallocation

 // This member function is called when we're initializing a filebuf's

 // internal and external buffers.  The argument is the size of the

 // internal buffer; the external buffer is sized using the character

 // width in the current encoding.  Preconditions: the buffers are currently

 // null.  __n >= 1.  __buf is either a null pointer or a pointer to an 

 // array show size is at least __n.

 // We need __n >= 1 for two different reasons.  For input, the base

 // class always needs a buffer because of the sementics of underflow().

 // For output, we want to have an internal buffer that's larger by one

 // element than the buffer that the base class knows about.  (See 

 // basic_filebuf<>::overflow() for the reason.)

 template <class _CharT, class _Traits>

 bool 

 basic_filebuf<_CharT, _Traits>::_M_allocate_buffers(_CharT* __buf, streamsize __n)

 {

   if (__buf == 0) {

     _M_int_buf = __STATIC_CAST(_CharT*,malloc(__n * sizeof(_CharT)));

     if (! _M_int_buf)

       return false;

     _M_int_buf_dynamic = true;

   }

   else {

     _M_int_buf = __buf;

     _M_int_buf_dynamic = false;

   }

   size_t __ebufsiz = (max)(__n * (max)(_M_codecvt->encoding(), 1),

                       streamsize(_M_codecvt->max_length()));

   _M_ext_buf = __STATIC_CAST(char*,malloc(__ebufsiz));

   if (!_M_ext_buf) {

     _M_deallocate_buffers();

     return false;

   }

   _M_int_buf_EOS = _M_int_buf + __n;

   _M_ext_buf_EOS = _M_ext_buf + __ebufsiz;

   return true;

 }

 // Abbreviation for the most common case.

 template <class _CharT, class _Traits>

 bool basic_filebuf<_CharT, _Traits>::_M_allocate_buffers()

 {

   // Choose a buffer that's at least 4096 characters long and that's a

   // multiple of the page size.

   streamsize __default_bufsiz =

     ((_M_base.__page_size() + 4095UL) / _M_base.__page_size()) * _M_base.__page_size();

   return _M_allocate_buffers(0, __default_bufsiz);

 }

 template <class _CharT, class _Traits>

 void basic_filebuf<_CharT, _Traits>::_M_deallocate_buffers()

 {

   if (_M_int_buf_dynamic)

     free(_M_int_buf);

   free(_M_ext_buf);

   _M_int_buf     = 0;

   _M_int_buf_EOS = 0;

   _M_ext_buf     = 0;

   _M_ext_buf_EOS = 0;

 }

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

 // Helper functiosn for seek and imbue

 template <class _CharT, class _Traits>

 bool basic_filebuf<_CharT, _Traits>::_M_seek_init(bool __do_unshift) {

   // If we're in error mode, leave it.

    _M_in_error_mode = false;

   // Flush the output buffer if we're in output mode, and (conditionally)

   // emit an unshift sequence.

   if (_M_in_output_mode) {

     bool __ok = !traits_type::eq_int_type(this->overflow(traits_type::eof()),

                                           traits_type::eof());

     if (__do_unshift)

       __ok = __ok && this->_M_unshift();

     if (!__ok) {

       _M_in_output_mode = false;

       _M_in_error_mode = true;

       this->setp(0, 0);

       return false;

     }

   }

   // Discard putback characters, if any.

   if (_M_in_input_mode && _M_in_putback_mode)

     _M_exit_putback_mode();

   return true;

 }

 // Change the filebuf's locale.  This member function has no effect

 // unless it is called before any I/O is performed on the stream.

 template <class _CharT, class _Traits>

 void basic_filebuf<_CharT, _Traits>::_M_setup_codecvt(const locale& __loc)

 {

   _M_codecvt = &use_facet<_Codecvt>(__loc) ;

   int __encoding    = _M_codecvt->encoding();

   _M_width          = (max)(__encoding, 1);

   _M_max_width      = _M_codecvt->max_length();

   _M_constant_width = __encoding > 0;

   _M_always_noconv  = _M_codecvt->always_noconv();

 }

 template <class _CharT, class _Traits>

   _STLP_EXP_DECLSPEC basic_fstream<_CharT, _Traits>::basic_fstream()

     : basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {

       this->init(&_M_buf);

   }

 template <class _CharT, class _Traits>

   _STLP_EXP_DECLSPEC basic_fstream<_CharT, _Traits>::~basic_fstream(){}

 #ifdef __SYMBIAN32__

 template <class _CharT, class _Traits>

 int basic_filebuf<_CharT, _Traits>::save_read_buffer ()

     {

     return _M_in_putback_mode ? _M_saved_egptr - _M_saved_gptr : 0;

     }

 template <class _CharT, class _Traits>

 void basic_filebuf<_CharT, _Traits>::_change_input_mode ()

     {

     _M_in_input_mode = 1;

     }

 #endif

 _STLP_END_NAMESPACE

 # undef __BF_int_type__

 # undef __BF_pos_type__

 # undef __BF_off_type__

 # endif /* defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) */

 #endif /* _STLP_FSTREAM_C */