diff -r e1b950c65cb4 -r 837f303aceeb epoc32/include/stdapis/stlport/stl/_fstream.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/epoc32/include/stdapis/stlport/stl/_fstream.c Wed Mar 31 12:33:34 2010 +0100 @@ -0,0 +1,891 @@ +/* + * © 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 +# 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 +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 +basic_filebuf<_CharT, _Traits>::~basic_filebuf() { + this->close(); + _M_deallocate_buffers(); +} + + +template +_STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type +basic_filebuf<_CharT, _Traits>::underflow() +{ + return _Underflow<_CharT, _Traits>::_M_doit(this); +} + +template +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 +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 +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 +__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 +__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 +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 +__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())))) { + // 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 +__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 +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 +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 +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 +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 +__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 +__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 +__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 +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 +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 +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 +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 +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 +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 + _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 + _STLP_EXP_DECLSPEC basic_fstream<_CharT, _Traits>::~basic_fstream(){} + +#ifdef __SYMBIAN32__ +template +int basic_filebuf<_CharT, _Traits>::save_read_buffer () + { + return _M_in_putback_mode ? _M_saved_egptr - _M_saved_gptr : 0; + } +template +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 */ +