fstream.cc

Go to the documentation of this file.

// -*- C++ -*-
 
_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