blob: c1e0dc036190198008868deae513d7db6cb95079 [file] [log] [blame]
// -*- C++ -*-
/***************************************************************************
*
* fstream.cc - Definition for the Standard Library file streams
*
* $Id$
*
***************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
* Copyright 1997-2008 Rogue Wave Software, Inc.
*
**************************************************************************/
_RWSTD_NAMESPACE (std) {
template<class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::
open (const char *__name, ios_base::openmode __mode, long __prot)
{
_RWSTD_ASSERT (this->_C_is_valid ());
// fail if `mode' has invalid bits set or if the file is already open
if ((__mode & ~_RWSTD_IOS_OPENMODE_MASK) || is_open ())
return 0;
_C_file = _RW::__rw_fopen (__name, __mode, __prot);
if (!_C_file)
return 0;
pos_type __pos = pos_type ();
if (__mode & ios_base::ate) {
// the end of a file is assumed to be in the initial shift state
// this assumption is safe as long as the file has been properly
// closed (or unshifted) after the last write operation on it
__pos = _RW::__rw_fseek (_C_file, 0, 0, ios_base::end);
if (-1L == __pos) {
_RW::__rw_fclose (_C_file, 0);
_C_file = 0;
return 0;
}
}
_C_beg_pos = _C_cur_pos = __pos;
this->_C_state &= ~_RWSTD_IOS_OPENMODE_MASK;
this->_C_state |= __mode;
return this;
}
template<class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::
close (bool __close_file /* = true */)
{
// close_file is false when close() is called from detach()
_RWSTD_ASSERT (this->_C_is_valid ());
if (!is_open ())
return 0; // failure
// close() returns this on success, 0 on failure
basic_filebuf *__retval = this;
_TRY {
// avoid expensive call to overflow() unless necessary
if (this->pptr () != this->pbase () && this->_C_is_eof (overflow ()))
__retval = 0; // failure
// write out any unshift sequence if necessary
// (applies to multibyte, state dependent encodings only)
if (__retval && this->_C_out_last () && !_C_unshift ())
__retval = 0; // failure
}
_CATCH (...) {
// either overflow() or codecvt::unshift() threw
if (__close_file) {
_RW::__rw_fclose (_C_file, this->_C_state);
// zero out the file pointer except when detaching fd
_C_file = 0;
_C_cur_pos = _C_beg_pos = pos_type (off_type (-1));
// reset input/output sequences to prevent any
// subsequent I/O attempts on closed file
this->setg (0, 0, 0);
this->setp (0, 0);
}
// rethrow the caught exception
_RETHROW;
}
if (__close_file) {
if (_RW::__rw_fclose (_C_file, this->_C_state))
__retval = 0;
// zero out the file pointer except when detaching fd
_C_file = 0;
_C_cur_pos = _C_beg_pos = pos_type (off_type (-1));
// reset input/output sequences to prevent any
// subsequent I/O attempts on closed file
this->setg (0, 0, 0);
this->setp (0, 0);
}
return __retval;
}
template<class _CharT, class _Traits>
streamsize
basic_filebuf<_CharT, _Traits>::
showmanyc ()
{
_RWSTD_ASSERT (this->_C_is_valid ());
if ( !this->_C_is_in () || !is_open ()
|| _C_cur_pos == pos_type (off_type (-1)))
return -1;
// start with the number of chars in get area
_RWSTD_STREAMSIZE __retval = this->egptr () - this->gptr ();
// no prob if this fails for non-seekable devices
const pos_type __end_pos =
_RW::__rw_fseek (_C_file, this->_C_state, 0, ios_base::end);
if (__end_pos != pos_type (off_type (-1))) {
// restore position within file only if seek succeeded
_RW::__rw_fseek (_C_file, this->_C_state, _C_cur_pos, ios_base::beg);
typedef typename traits_type::state_type _StateT;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const _Codecvt &__cvt = _USE_FACET (_Codecvt, this->getloc ());
if (__cvt.always_noconv ())
__retval += __end_pos - _C_cur_pos;
else
// make most pessimistic conversion estimate
__retval += (__end_pos - _C_cur_pos) / __cvt.max_length ();
}
return __retval > 0 ? __retval : 0;
}
template<class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::
underflow ()
{
_RWSTD_ASSERT (this->_C_is_valid ());
this->setp (0, 0); // invalidate put area
this->_C_out_last (false); // needed by close ()
if (!this->_C_is_in () || !is_open())
return traits_type::eof ();
char_type* const __to_end = this->_C_buffer + this->_C_bufsize;
typedef typename traits_type::int_type _IntType;
_IntType __ret = _IntType ();
// fill the buffer if it's empty
if (this->gptr () == this->egptr()) { // N.B.: gptr() could be null here
// determine the maximum possible size of putback area (if any)
// make sure putback area isn't too big - try to honor
// _RWSTD_PBACK_SIZE if possible, otherwise shrink
const _RWSTD_SIZE_T __pbackavail = this->_C_putback_avail ();
_C_pbacksize = __pbackavail < _RWSTD_PBACK_SIZE ?
__pbackavail : _RWSTD_PBACK_SIZE;
_RWSTD_ASSERT (0 != this->_C_bufsize);
if (_C_pbacksize == this->_C_bufsize)
_C_pbacksize = this->_C_bufsize - 1;
traits_type::move (this->eback(), this->gptr () - _C_pbacksize,
_C_pbacksize);
// fill the get area from the file, performing code conversion if
// necessary
_RWSTD_STREAMSIZE __nread = 0; // number of bytes read from file
_C_beg_pos = _C_cur_pos;
typedef typename traits_type::state_type _StateT;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const _Codecvt &__cvt = _USE_FACET (_Codecvt, this->getloc ());
if (__cvt.always_noconv ()) {
// no conversion required
__nread = (__to_end - this->_C_buffer) - _C_pbacksize;
__nread = _RW::__rw_fread (_C_file, this->_C_state,
this->_C_buffer + _C_pbacksize,
sizeof (char_type) * __nread);
if (__nread < 0)
return traits_type::eof (); // error while reading
this->setg (this->_C_buffer,
this->_C_buffer + _C_pbacksize,
this->_C_buffer + _C_pbacksize + __nread);
// adjust the current position in the file,
// taking into account CR/LF conversion on windows
__nread += _C_crlf_intern_count (this->gptr (),
this->gptr () + __nread);
}
else { // conversion required
char __xbuf [_RWSTD_DEFAULT_BUFSIZE];
char* __from_base = __xbuf;
const char* __from_next = 0;
char_type* __to_base = this->_C_buffer + _C_pbacksize;
char_type* __to_next = __to_base;
_StateT __state = _C_cur_pos.state ();
codecvt_base::result __res = codecvt_base::ok;
const ctype<char_type> &__ctp =
_USE_FACET (ctype<char_type>, this->getloc ());
while (__to_next != __to_end && codecvt_base::error != __res) {
// read only as many characters as we have positions left in
// internal buffer - guarantees we won't read more characters
// than we can put into the internal buffer after conversion
// and ending file position isn't in the middle of a shift
// sequence
// N.B.: area between __xbuf and __from_base contains partially
// converted sequences left from previous read
_RWSTD_STREAMSIZE __n = __to_end - __to_next;
if (_RWSTD_DEFAULT_BUFSIZE - (__from_base - __xbuf) < __n)
__n = _RWSTD_DEFAULT_BUFSIZE - (__from_base - __xbuf);
__n = _RW::__rw_fread (_C_file, this->_C_state,
__from_base, __n);
if (0 > __n)
return traits_type::eof (); // error while reading
if (0 == __n)
break; // reached eof
// take into account CR/LF conversion on Win32
__nread += __n +
_C_crlf_extern_count (__from_base, __from_base + __n);
// adjust 'n' to hold the number of external chars in buffer
__n += __from_base - __xbuf;
// convert any partially converted sequence from the previous
// iteration (possibly empty) plus what we just read in
__res = __cvt.in (__state, __xbuf, __xbuf + __n, __from_next,
__to_base, __to_end, __to_next);
switch (__res) {
case codecvt_base::ok:
// there may be yet unconverted elements at the end
// of the source sequence, fall through and treat
// as partial (`n' below may be 0)
case codecvt_base::partial:
// compute the length of partially converted sequence
__n -= __from_next - __xbuf;
typedef char_traits<char> CharTraits;
// copy the sequence to beginning of xbuf
CharTraits::move (__xbuf, __from_next, __n);
// will append external chars to end of the sequence
__from_base = __xbuf + __n;
break;
case codecvt_base::noconv:
// note that according to lwg issue 19, codecvt<wchar_t,
// char>::in() may not return noconv since internT and
// externT are not the same type
// since codecvt<char, char>::always_noconv() is required
// to return true, this branch only executes for a user-
// defined codecvt<T, T> facet with internT and externT
// being the same type
// FIXME: do not widen external buffer just memcpy it
// to internal buffer (externT == internT)
__ctp.widen (__xbuf, __xbuf + __n, __to_base);
__to_next = __to_base + __n;
break;
case codecvt_base::error:
// failed to convert part of the buffer
// retain the part that has been successfully
// converted, and disregard the rest
__ret = traits_type::eof ();
break;
default:
// bad return value from codecvt
return traits_type::eof ();
}
__to_base = __to_next; // continue at end of converted seq
}
_C_cur_pos.state (__state);
this->setg (this->_C_buffer, this->_C_buffer + _C_pbacksize,
__to_next);
} // end conversion block
if (__nread == 0)
return traits_type::eof ();
_C_cur_pos += __nread;
}
return traits_type::eq_int_type (__ret, _IntType ()) ?
traits_type::to_int_type (*this->gptr ()) : __ret;
}
template<class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::
overflow (int_type __c /* = eof () */)
{
_RWSTD_ASSERT (this->_C_is_valid ());
if (!this->_C_is_out () || !is_open ())
return traits_type::eof ();
this->setg (0, 0, 0); // invalidate the get area
const bool __unbuf = this->_C_is_unbuffered ();
const char_type __c_to_char = traits_type::to_char_type (__c);
if (this->pptr () == 0 && !__unbuf) {
// put area not valid yet - just need to initialize it
this->setp (this->_C_buffer, this->_C_buf_end ());
}
else if ( this->pptr () == this->epptr ()
|| this->_C_is_eof (__c)
|| __unbuf) {
const char_type* __buf;
_RWSTD_STREAMSIZE __nchars;
if (__unbuf) {
if (this->_C_is_eof (__c)){
__buf = 0;
__nchars = 0;
}
else {
__buf = &__c_to_char;
__nchars = 1;
}
}
else {
// call xsputn() with a special value to have it flush
// the controlled sequence to the file
__buf = _RWSTD_REINTERPRET_CAST (char_type*, this);
__nchars = this->pptr () - this->pbase ();
}
// typedef helps HP aCC 3.27
typedef basic_filebuf _FileBuf;
if (__nchars != _FileBuf::xsputn (__buf, __nchars))
return traits_type::eof (); // error while writing
}
// now that there's room in the buffer, call sputc() recursively
// to actually place the character in the buffer (unless we're
// in unbuffered mode because we just wrote it out)
if (!this->_C_is_eof (__c) && !__unbuf)
this->sputc (__c_to_char);
this->_C_out_last (true); // needed by close ()
return traits_type::not_eof (__c);
}
template <class _CharT, class _Traits>
_RWSTD_STREAMSIZE
basic_filebuf<_CharT, _Traits>::
xsputn (const char_type* __buf, _RWSTD_STREAMSIZE __nchars)
{
_RWSTD_ASSERT (0 != __buf || 0 == __nchars);
_RWSTD_ASSERT (this->_C_is_valid ());
if (0 == __nchars)
return 0; // not an error
if (__nchars < 0 || !this->_C_is_out () || !is_open ())
return -1; // error
if (0 == this->pptr () && !this->_C_is_unbuffered ())
// put area not valid yet - just need to initialize it
this->setp (this->_C_buffer, this->_C_buf_end ());
const _RWSTD_STREAMSIZE __navail = this->epptr () - this->pptr ();
const char_type* const __special =
_RWSTD_REINTERPRET_CAST (char_type*, this);
if (__buf == __special) {
__buf = this->pbase ();
}
else if (__nchars <= __navail) {
// the amount of available space is big enough
// append the contents of the buffer to the controlled sequence
traits_type::copy (this->pptr (), __buf, __nchars);
this->pbump (__nchars);
return __nchars;
}
else {
// call self recursively to flush the controlled sequence first
const _RWSTD_STREAMSIZE __nwrite = this->pptr () - this->pbase ();
// typedef helps HP aCC 3.27
typedef basic_filebuf _FileBuf;
// return -1 on error to flush the controlled sequence
if (__nwrite != _FileBuf::xsputn (__special, __nwrite))
return -1;
}
// flush buffer to file, performing code conversion if necessary
_RWSTD_ASSERT (this->_C_is_valid ());
_RWSTD_ASSERT (this->_C_is_out ());
_RWSTD_ASSERT (is_open ());
const char_type* const __end = __buf + __nchars;
typedef typename traits_type::state_type _StateT;
_RWSTD_STREAMSIZE __nwrote = 0; // num chars to write
_StateT __state = _C_cur_pos.state (); // state of stream
_C_beg_pos = _C_cur_pos;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const _Codecvt &__cvt = _USE_FACET (_Codecvt, this->getloc ());
if (__cvt.always_noconv ()) {
// no conversion
__nwrote = __end - __buf;
const _RWSTD_STREAMSIZE __nbytes = sizeof (char_type) * __nwrote;
if (__nbytes != _RW::__rw_fwrite (_C_file, this->_C_state,
__buf, __nbytes))
return -1; // error while writing
}
else {
// perform codeset conversion in chunks to avoid dynamic
// memory allocation
char __xbuf [_RWSTD_DEFAULT_BUFSIZE];
char* __xbuf_end = __xbuf + sizeof __xbuf;
char* __to_next = 0;
const char_type* __from_next = 0;
for (const char_type* __base = __buf; __from_next != __end;
__base = __from_next) {
// avoid using const codecvt_base::result here
// to prevent HP aCC 3.27 errors
const int __res =
__cvt.out (__state, __base, __end, __from_next,
__xbuf, __xbuf_end, __to_next);
_RWSTD_STREAMSIZE __nbytes =
sizeof (char_type) * (__end - __base);
switch (__res) {
case codecvt_base::error:
// write out the sequence successfully converted up
// to the point of the error in the internal sequence
// and fail
_RW::__rw_fwrite (_C_file, this->_C_state, __base, __nbytes);
return traits_type::eof ();
case codecvt_base::noconv:
// write the entire sequence
if (__nbytes != _RW::__rw_fwrite (_C_file, this->_C_state,
__base, __nbytes))
return traits_type::eof ();
__nwrote += __end - __base
+ _C_crlf_intern_count (__base, __end);
__from_next = __end; // effectively 'break'
break;
default:
_RWSTD_ASSERT ( codecvt_base::ok == __res
|| codecvt_base::partial == __res);
// partial conversion will result if there isn't enough
// space in the conversion buffer to hold the converted
// sequence, but we're O.K. since we'll be passing any
// remaining unconverted characters (starting at
// __from_next) in the next iteration
__nbytes = __to_next - __xbuf;
if (__nbytes != _RW::__rw_fwrite (_C_file, this->_C_state,
__xbuf, __nbytes))
return -1;
__nwrote += __nbytes
+ _C_crlf_extern_count (__xbuf, __to_next);
}
}
}
// adjust the current position in the file
_C_cur_pos += __nwrote;
_C_cur_pos.state (__state);
// reset the put area
if (!this->_C_is_unbuffered ())
this->setp (this->_C_buffer, this->_C_buf_end ());
this->_C_out_last (true); // needed by close ()
// return the number of characters (not bytes) in the buffer
// successfully written to the file
return __nchars;
}
template<class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::int_type
basic_filebuf<_CharT, _Traits>::
pbackfail (int_type __c)
{
_RWSTD_ASSERT (this->_C_is_valid ());
if (!is_open ())
return traits_type::eof ();
// we could get here if gptr = eback or if __c != *(gptr-1)
if (!this->_C_putback_avail ()) {
// try to make a putback area available
if (this->seekoff (-1, ios_base::cur) == pos_type (off_type (-1)))
return traits_type::eof ();
if (this->_C_is_eof (underflow ()))
return traits_type::eof ();
this->gbump (1);
}
if (traits_type::eq (traits_type::to_char_type (__c), *(this->gptr () - 1))
|| this->_C_is_eof (__c)) {
// "put back" original value
this->gbump (-1);
return traits_type::not_eof (__c);
}
else if (this->_C_is_out ()) {
// overwrite existing value with new value
this->gbump (-1);
*this->gptr () = traits_type::to_char_type (__c);
return __c;
}
else
return traits_type::eof ();
}
template<class _CharT, class _Traits>
basic_streambuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::
setbuf (char_type *__buf, streamsize __ssize)
{
_RWSTD_ASSERT (this->_C_is_valid ());
if (__ssize < 0)
return 0;
const _RWSTD_SIZE_T __bufsize =
_RWSTD_STATIC_CAST (_RWSTD_SIZE_T, __ssize);
// sync the buffer to the external file so it can be deallocated
if ((this->gptr () || this->pptr ()) && is_open () && sync () != 0)
return 0;
bool __reset = true;
if (0 < __bufsize) {
if (!__buf && (this->_C_bufsize < __bufsize || !this->_C_buffer)) {
// if `buf' is 0 and the requested size is greater than
// the size of the object's buffer, or of the object's
// buffer is 0, try to allocate a new buffer of the
// specified size
__buf = new char_type [__bufsize];
// delete old buffer if the object owns it
if (this->_C_own_buf ())
delete [] this->_C_buffer;
// take ownership of the newly allocated buffer
this->_C_own_buf (true);
}
else if (!__buf && __bufsize <= this->_C_bufsize) {
// if `buf' is 0 and the requested size is less than
// the size of the object's buffer, simply reuse the
// object's buffer
__buf = this->_C_buffer;
__reset = false;
}
else if (__buf && __buf != this->_C_buffer) {
// if `buf' is non-0 and different from the existing
// buffer, use it
// delete old buffer if the object owns it
if (this->_C_own_buf ())
delete [] this->_C_buffer;
// the object does not own of the new buffer
this->_C_own_buf (false);
}
this->_C_buffer = __buf;
this->_C_bufsize = __bufsize;
this->_C_set_unbuffered (false);
}
else {
// unbuffer this stream object
// character buffer is preserved (used as get area only),
// streambuf object unbuffered for writing
// to put a streambuf object into an unbuffered mode (see 27.8.1.4,
// p10) and affect the size of the get area, setbuf() should first
// be called with the desired (non-zero) size and then again with
// both arguments being 0
this->_C_set_unbuffered (true);
}
if (__reset) {
this->setg (0, 0, 0);
this->setp (0, 0);
}
// a character buffer of nonzero size must exist even in unbuffered mode
_RWSTD_ASSERT (0 != this->_C_buffer);
_RWSTD_ASSERT (0 != this->_C_bufsize);
return this;
}
// 27.8.1.4, p 11
template<class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
basic_filebuf<_CharT, _Traits>::
seekoff (off_type __off, ios_base::seekdir __way, ios_base::openmode)
{
_RWSTD_ASSERT (this->_C_is_valid ());
if (!is_open ())
return pos_type (off_type (-1));
typedef typename traits_type::state_type _StateT;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const int __width = _USE_FACET (_Codecvt, this->getloc ()).encoding ();
// offset must be zero with state-dependent encoding
if (0 != __off && __width <= 0)
return pos_type (off_type (-1));
// sync the buffer... (this also invalidates the get/put area)
if (sync () != 0)
return pos_type (off_type (-1));
// ...and, if last operation was output, append an unshift sequence
if (this->_C_out_last ())
_C_unshift ();
if (__width > 1)
__off *= __width;
// perform the seek and save the result
pos_type __pos = _RW::__rw_fseek (_C_file, this->_C_state, __off, __way);
if (__pos != pos_type (off_type (-1))) {
// preserve the current state if not changing position
// (only matters for state-dependent encodings for which
// the offset is required and guaranteed to be 0)
if (__way == ios_base::cur)
__pos.state (_C_cur_pos.state ());
_C_beg_pos = _C_cur_pos = __pos;
}
this->_C_out_last (false); // needed by close()
return __pos;
}
template<class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
basic_filebuf<_CharT, _Traits>::
seekpos (pos_type __pos, ios_base::openmode)
{
_RWSTD_ASSERT (this->_C_is_valid ());
if (!is_open ())
return pos_type (off_type (-1));
// flush the output area if it exists
if (this->pptr () != 0) {
if (this->_C_is_eof (this->overflow (traits_type::eof ())))
return pos_type (off_type (-1));
}
if ( _RW::__rw_fseek (_C_file, this->_C_state, __pos, ios_base::beg)
== pos_type (off_type (-1)))
return pos_type (off_type (-1));
_C_cur_pos = _C_beg_pos = __pos;
this->setg (0, 0, 0);
this->setp (0, 0);
this->_C_out_last (false); // needed by close()
return __pos;
}
template<class _CharT, class _Traits>
int
basic_filebuf<_CharT, _Traits>::
sync ()
{
_RWSTD_ASSERT (this->_C_is_valid ());
// put area active
if (this->pptr () != 0) {
// flush the buffer to the file
if (this->_C_is_eof (overflow (traits_type::eof ())))
return -1;
if (this->_C_state & _RWSTD_IOS_STDIO)
_RW::__rw_fflush (_C_file, this->_C_state);
}
// get area active
if (this->gptr () != 0) {
// pbacksize may need to be adjusted if it's greater than
// the available putback area (e.g., after calling putback()
// at the end of the buffer)
const _RWSTD_SIZE_T __pbackavail = this->_C_putback_avail ();
if (__pbackavail < _C_pbacksize)
_C_pbacksize = __pbackavail;
_RWSTD_ASSERT (0 != this->_C_bufsize);
if (_C_pbacksize == this->_C_bufsize)
_C_pbacksize = this->_C_bufsize - 1;
typedef typename traits_type::state_type _StateT;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const _Codecvt &__cvt = _USE_FACET (_Codecvt, this->getloc ());
int __width = __cvt.encoding ();
if (__width > 0) {
// get the number of chars consumed in the buffer
const off_type __consumed =
this->gptr () - this->eback () - _C_pbacksize;
// constant width conversion:
// adjust the current position/state in the file,
// taking into account CR/LF conversion on Win32
_C_cur_pos = _C_beg_pos;
_C_cur_pos += (__width * __consumed)
+ _C_crlf_intern_count (this->eback () + _C_pbacksize,
this->gptr());
}
else {
// This gets a bit tricky here because we don't know the external
// file position corresponding to the position in the
// internal buffer. To figure this out, we'll use the known
// file position/state corresponding to the start of the buffer
// (which we have carefully saved in _C_beg_pos) and
// convert the characters up to the current position in the
// buffer, counting how many external chars result. We can
// then use the offset from _C_beg_pos and the state
// returned from codecvt::out() to construct the current file
// position
off_type __ext_chars = 0; // converted external chars
char __xbuf [_RWSTD_DEFAULT_BUFSIZE];
char* __xbuf_end = __xbuf + sizeof __xbuf;
char* __to_next = 0;
const char_type* __from_next = 0;
const char_type* __from_end = this->gptr ();
_StateT __state = _C_beg_pos.state ();
const char_type* __base = this->eback () + _C_pbacksize;
while (__from_next != __from_end) {
const int __res =
__cvt.out (__state, __base, __from_end, __from_next,
__xbuf, __xbuf_end, __to_next);
switch (__res) {
case codecvt_base::error:
return -1;
case codecvt_base::noconv:
__ext_chars += __from_end - __base
+ _C_crlf_intern_count (__base, __from_end);
__from_next = __from_end; // break out of the loop
break;
default: // __res = ok or partial
// take into account CR/LF conversion on Win32
__ext_chars += __to_next - __xbuf
+ _C_crlf_extern_count (__xbuf, __to_next);
}
// repeat with next chunk
__base = __from_next;
}
_C_cur_pos = _C_beg_pos;
_C_cur_pos += __ext_chars;
_C_cur_pos.state (__state);
}
// seek within the external file to the position
// corresponding to the future beginning of the buffer
const off_type __off =
_RW::__rw_fseek (_C_file, this->_C_state,
_C_cur_pos, ios_base::beg);
if (-1L == __off)
return -1;
traits_type::move (this->eback (), this->gptr () - _C_pbacksize,
_C_pbacksize);
this->setg (this->eback (), this->eback () + _C_pbacksize,
this->eback () + _C_pbacksize);
}
_C_beg_pos = _C_cur_pos;
this->setp (0, 0);
return 0;
}
template<class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>*
basic_filebuf<_CharT, _Traits>::
_C_open (int __fd, void *__file, char_type *__buf, streamsize __n)
{
if (is_open () || !__file && -1 == __fd || !setbuf (__buf, __n))
return 0;
if (__file) {
_RWSTD_ASSERT (-1 == __fd);
_C_file = __file;
this->_C_state |= this->_C_stdio;
}
else {
_RWSTD_ASSERT (!__file);
_C_file = _RW::__rw_fdopen (__fd);
if (!_C_file)
return 0;
this->_C_state &= ~this->_C_stdio;
}
this->_C_state |= _RW::__rw_fmode (_C_file, this->_C_state);
this->setg (0, 0, 0);
this->setp (0, 0);
_C_cur_pos = _C_beg_pos = pos_type ();
return this;
}
// write out an unshift sequence if not in initial shift state
template<class _CharT, class _Traits>
bool
basic_filebuf<_CharT, _Traits>::
_C_unshift ()
{
typedef typename traits_type::state_type _StateT;
typedef codecvt<char_type, char, _StateT> _Codecvt;
const _Codecvt &__cvt = _USE_FACET (_Codecvt, this->getloc ());
// unshifting isn't necessary if encoding isn't state dependent
// or if the state is equivalent to initial state (determined
// by codecvt::unshift())
if (__cvt.encoding () >= 0)
return true;
// buf to hold unshift sequence - assumes that the shift
// sequence will be less than 64 chars (we can't safely
// use dynamic allocation because this function could be
// called as a result of memory allocation exception)
char __useq [64];
char* __useq_end = 0;
_StateT __state = _C_cur_pos.state ();
const int __res =
__cvt.unshift (__state, __useq, __useq + sizeof __useq, __useq_end);
const _RWSTD_STREAMSIZE __nbytes = __useq_end - __useq;
// in the unlikely event that the buffer isn't big enough, assert
_RWSTD_ASSERT (__res != codecvt_base::partial);
if (__res == codecvt_base::error)
return false;
if (__res == codecvt_base::noconv)
return true;
const off_type __nwrote =
_RW::__rw_fwrite (_C_file, this->_C_state, __useq, __nbytes);
if (__nwrote < 0)
return false;
_C_cur_pos += __nwrote; // CR/LF conversion not an issue here
return __nwrote == __nbytes;
}
} // namespace std