| // File based streams -*- C++ -*- |
| |
| // Copyright (C) 1997-2013 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the |
| // terms of the GNU General Public License as published by the |
| // Free Software Foundation; either version 3, or (at your option) |
| // any later version. |
| |
| // This library is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // Under Section 7 of GPL version 3, you are granted additional |
| // permissions described in the GCC Runtime Library Exception, version |
| // 3.1, as published by the Free Software Foundation. |
| |
| // You should have received a copy of the GNU General Public License and |
| // a copy of the GCC Runtime Library Exception along with this program; |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| // <http://www.gnu.org/licenses/>. |
| |
| /** @file bits/fstream.tcc |
| * This is an internal header file, included by other library headers. |
| * Do not attempt to use it directly. @headername{fstream} |
| */ |
| |
| // |
| // ISO C++ 14882: 27.8 File-based streams |
| // |
| |
| #ifndef _FSTREAM_TCC |
| #define _FSTREAM_TCC 1 |
| |
| #pragma GCC system_header |
| |
| #include <bits/cxxabi_forced.h> |
| |
| namespace std _GLIBCXX_VISIBILITY(default) |
| { |
| _GLIBCXX_BEGIN_NAMESPACE_VERSION |
| |
| template<typename _CharT, typename _Traits> |
| void |
| basic_filebuf<_CharT, _Traits>:: |
| _M_allocate_internal_buffer() |
| { |
| // Allocate internal buffer only if one doesn't already exist |
| // (either allocated or provided by the user via setbuf). |
| if (!_M_buf_allocated && !_M_buf) |
| { |
| _M_buf = new char_type[_M_buf_size]; |
| _M_buf_allocated = true; |
| } |
| } |
| |
| template<typename _CharT, typename _Traits> |
| void |
| basic_filebuf<_CharT, _Traits>:: |
| _M_destroy_internal_buffer() throw() |
| { |
| if (_M_buf_allocated) |
| { |
| delete [] _M_buf; |
| _M_buf = 0; |
| _M_buf_allocated = false; |
| } |
| delete [] _M_ext_buf; |
| _M_ext_buf = 0; |
| _M_ext_buf_size = 0; |
| _M_ext_next = 0; |
| _M_ext_end = 0; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| basic_filebuf<_CharT, _Traits>:: |
| basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), |
| _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), |
| _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ), |
| _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), |
| _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), |
| _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), |
| _M_ext_end(0) |
| { |
| if (has_facet<__codecvt_type>(this->_M_buf_locale)) |
| _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale); |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::__filebuf_type* |
| basic_filebuf<_CharT, _Traits>:: |
| open(const char* __s, ios_base::openmode __mode) |
| { |
| __filebuf_type *__ret = 0; |
| if (!this->is_open()) |
| { |
| _M_file.open(__s, __mode); |
| if (this->is_open()) |
| { |
| _M_allocate_internal_buffer(); |
| _M_mode = __mode; |
| |
| // Setup initial buffer to 'uncommitted' mode. |
| _M_reading = false; |
| _M_writing = false; |
| _M_set_buffer(-1); |
| |
| // Reset to initial state. |
| _M_state_last = _M_state_cur = _M_state_beg; |
| |
| // 27.8.1.3,4 |
| if ((__mode & ios_base::ate) |
| && this->seekoff(0, ios_base::end, __mode) |
| == pos_type(off_type(-1))) |
| this->close(); |
| else |
| __ret = this; |
| } |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::__filebuf_type* |
| basic_filebuf<_CharT, _Traits>:: |
| close() |
| { |
| if (!this->is_open()) |
| return 0; |
| |
| bool __testfail = false; |
| { |
| // NB: Do this here so that re-opened filebufs will be cool... |
| struct __close_sentry |
| { |
| basic_filebuf *__fb; |
| __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { } |
| ~__close_sentry () |
| { |
| __fb->_M_mode = ios_base::openmode(0); |
| __fb->_M_pback_init = false; |
| __fb->_M_destroy_internal_buffer(); |
| __fb->_M_reading = false; |
| __fb->_M_writing = false; |
| __fb->_M_set_buffer(-1); |
| __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg; |
| } |
| } __cs (this); |
| |
| __try |
| { |
| if (!_M_terminate_output()) |
| __testfail = true; |
| } |
| __catch(__cxxabiv1::__forced_unwind&) |
| { |
| _M_file.close(); |
| __throw_exception_again; |
| } |
| __catch(...) |
| { __testfail = true; } |
| } |
| |
| if (!_M_file.close()) |
| __testfail = true; |
| |
| if (__testfail) |
| return 0; |
| else |
| return this; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| streamsize |
| basic_filebuf<_CharT, _Traits>:: |
| showmanyc() |
| { |
| streamsize __ret = -1; |
| const bool __testin = _M_mode & ios_base::in; |
| if (__testin && this->is_open()) |
| { |
| // For a stateful encoding (-1) the pending sequence might be just |
| // shift and unshift prefixes with no actual character. |
| __ret = this->egptr() - this->gptr(); |
| |
| #if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM |
| // About this workaround, see libstdc++/20806. |
| const bool __testbinary = _M_mode & ios_base::binary; |
| if (__check_facet(_M_codecvt).encoding() >= 0 |
| && __testbinary) |
| #else |
| if (__check_facet(_M_codecvt).encoding() >= 0) |
| #endif |
| __ret += _M_file.showmanyc() / _M_codecvt->max_length(); |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::int_type |
| basic_filebuf<_CharT, _Traits>:: |
| underflow() |
| { |
| int_type __ret = traits_type::eof(); |
| const bool __testin = _M_mode & ios_base::in; |
| if (__testin) |
| { |
| if (_M_writing) |
| { |
| if (overflow() == traits_type::eof()) |
| return __ret; |
| _M_set_buffer(-1); |
| _M_writing = false; |
| } |
| // Check for pback madness, and if so switch back to the |
| // normal buffers and jet outta here before expensive |
| // fileops happen... |
| _M_destroy_pback(); |
| |
| if (this->gptr() < this->egptr()) |
| return traits_type::to_int_type(*this->gptr()); |
| |
| // Get and convert input sequence. |
| const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; |
| |
| // Will be set to true if ::read() returns 0 indicating EOF. |
| bool __got_eof = false; |
| // Number of internal characters produced. |
| streamsize __ilen = 0; |
| codecvt_base::result __r = codecvt_base::ok; |
| if (__check_facet(_M_codecvt).always_noconv()) |
| { |
| __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()), |
| __buflen); |
| if (__ilen == 0) |
| __got_eof = true; |
| } |
| else |
| { |
| // Worst-case number of external bytes. |
| // XXX Not done encoding() == -1. |
| const int __enc = _M_codecvt->encoding(); |
| streamsize __blen; // Minimum buffer size. |
| streamsize __rlen; // Number of chars to read. |
| if (__enc > 0) |
| __blen = __rlen = __buflen * __enc; |
| else |
| { |
| __blen = __buflen + _M_codecvt->max_length() - 1; |
| __rlen = __buflen; |
| } |
| const streamsize __remainder = _M_ext_end - _M_ext_next; |
| __rlen = __rlen > __remainder ? __rlen - __remainder : 0; |
| |
| // An imbue in 'read' mode implies first converting the external |
| // chars already present. |
| if (_M_reading && this->egptr() == this->eback() && __remainder) |
| __rlen = 0; |
| |
| // Allocate buffer if necessary and move unconverted |
| // bytes to front. |
| if (_M_ext_buf_size < __blen) |
| { |
| char* __buf = new char[__blen]; |
| if (__remainder) |
| __builtin_memcpy(__buf, _M_ext_next, __remainder); |
| |
| delete [] _M_ext_buf; |
| _M_ext_buf = __buf; |
| _M_ext_buf_size = __blen; |
| } |
| else if (__remainder) |
| __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); |
| |
| _M_ext_next = _M_ext_buf; |
| _M_ext_end = _M_ext_buf + __remainder; |
| _M_state_last = _M_state_cur; |
| |
| do |
| { |
| if (__rlen > 0) |
| { |
| // Sanity check! |
| // This may fail if the return value of |
| // codecvt::max_length() is bogus. |
| if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size) |
| { |
| __throw_ios_failure(__N("basic_filebuf::underflow " |
| "codecvt::max_length() " |
| "is not valid")); |
| } |
| streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen); |
| if (__elen == 0) |
| __got_eof = true; |
| else if (__elen == -1) |
| break; |
| _M_ext_end += __elen; |
| } |
| |
| char_type* __iend = this->eback(); |
| if (_M_ext_next < _M_ext_end) |
| __r = _M_codecvt->in(_M_state_cur, _M_ext_next, |
| _M_ext_end, _M_ext_next, |
| this->eback(), |
| this->eback() + __buflen, __iend); |
| if (__r == codecvt_base::noconv) |
| { |
| size_t __avail = _M_ext_end - _M_ext_buf; |
| __ilen = std::min(__avail, __buflen); |
| traits_type::copy(this->eback(), |
| reinterpret_cast<char_type*> |
| (_M_ext_buf), __ilen); |
| _M_ext_next = _M_ext_buf + __ilen; |
| } |
| else |
| __ilen = __iend - this->eback(); |
| |
| // _M_codecvt->in may return error while __ilen > 0: this is |
| // ok, and actually occurs in case of mixed encodings (e.g., |
| // XML files). |
| if (__r == codecvt_base::error) |
| break; |
| |
| __rlen = 1; |
| } |
| while (__ilen == 0 && !__got_eof); |
| } |
| |
| if (__ilen > 0) |
| { |
| _M_set_buffer(__ilen); |
| _M_reading = true; |
| __ret = traits_type::to_int_type(*this->gptr()); |
| } |
| else if (__got_eof) |
| { |
| // If the actual end of file is reached, set 'uncommitted' |
| // mode, thus allowing an immediate write without an |
| // intervening seek. |
| _M_set_buffer(-1); |
| _M_reading = false; |
| // However, reaching it while looping on partial means that |
| // the file has got an incomplete character. |
| if (__r == codecvt_base::partial) |
| __throw_ios_failure(__N("basic_filebuf::underflow " |
| "incomplete character in file")); |
| } |
| else if (__r == codecvt_base::error) |
| __throw_ios_failure(__N("basic_filebuf::underflow " |
| "invalid byte sequence in file")); |
| else |
| __throw_ios_failure(__N("basic_filebuf::underflow " |
| "error reading the file")); |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::int_type |
| basic_filebuf<_CharT, _Traits>:: |
| pbackfail(int_type __i) |
| { |
| int_type __ret = traits_type::eof(); |
| const bool __testin = _M_mode & ios_base::in; |
| if (__testin) |
| { |
| if (_M_writing) |
| { |
| if (overflow() == traits_type::eof()) |
| return __ret; |
| _M_set_buffer(-1); |
| _M_writing = false; |
| } |
| // Remember whether the pback buffer is active, otherwise below |
| // we may try to store in it a second char (libstdc++/9761). |
| const bool __testpb = _M_pback_init; |
| const bool __testeof = traits_type::eq_int_type(__i, __ret); |
| int_type __tmp; |
| if (this->eback() < this->gptr()) |
| { |
| this->gbump(-1); |
| __tmp = traits_type::to_int_type(*this->gptr()); |
| } |
| else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1))) |
| { |
| __tmp = this->underflow(); |
| if (traits_type::eq_int_type(__tmp, __ret)) |
| return __ret; |
| } |
| else |
| { |
| // At the beginning of the buffer, need to make a |
| // putback position available. But the seek may fail |
| // (f.i., at the beginning of a file, see |
| // libstdc++/9439) and in that case we return |
| // traits_type::eof(). |
| return __ret; |
| } |
| |
| // Try to put back __i into input sequence in one of three ways. |
| // Order these tests done in is unspecified by the standard. |
| if (!__testeof && traits_type::eq_int_type(__i, __tmp)) |
| __ret = __i; |
| else if (__testeof) |
| __ret = traits_type::not_eof(__i); |
| else if (!__testpb) |
| { |
| _M_create_pback(); |
| _M_reading = true; |
| *this->gptr() = traits_type::to_char_type(__i); |
| __ret = __i; |
| } |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::int_type |
| basic_filebuf<_CharT, _Traits>:: |
| overflow(int_type __c) |
| { |
| int_type __ret = traits_type::eof(); |
| const bool __testeof = traits_type::eq_int_type(__c, __ret); |
| const bool __testout = _M_mode & ios_base::out; |
| if (__testout) |
| { |
| if (_M_reading) |
| { |
| _M_destroy_pback(); |
| const int __gptr_off = _M_get_ext_pos(_M_state_last); |
| if (_M_seek(__gptr_off, ios_base::cur, _M_state_last) |
| == pos_type(off_type(-1))) |
| return __ret; |
| } |
| if (this->pbase() < this->pptr()) |
| { |
| // If appropriate, append the overflow char. |
| if (!__testeof) |
| { |
| *this->pptr() = traits_type::to_char_type(__c); |
| this->pbump(1); |
| } |
| |
| // Convert pending sequence to external representation, |
| // and output. |
| if (_M_convert_to_external(this->pbase(), |
| this->pptr() - this->pbase())) |
| { |
| _M_set_buffer(0); |
| __ret = traits_type::not_eof(__c); |
| } |
| } |
| else if (_M_buf_size > 1) |
| { |
| // Overflow in 'uncommitted' mode: set _M_writing, set |
| // the buffer to the initial 'write' mode, and put __c |
| // into the buffer. |
| _M_set_buffer(0); |
| _M_writing = true; |
| if (!__testeof) |
| { |
| *this->pptr() = traits_type::to_char_type(__c); |
| this->pbump(1); |
| } |
| __ret = traits_type::not_eof(__c); |
| } |
| else |
| { |
| // Unbuffered. |
| char_type __conv = traits_type::to_char_type(__c); |
| if (__testeof || _M_convert_to_external(&__conv, 1)) |
| { |
| _M_writing = true; |
| __ret = traits_type::not_eof(__c); |
| } |
| } |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| bool |
| basic_filebuf<_CharT, _Traits>:: |
| _M_convert_to_external(_CharT* __ibuf, streamsize __ilen) |
| { |
| // Sizes of external and pending output. |
| streamsize __elen; |
| streamsize __plen; |
| if (__check_facet(_M_codecvt).always_noconv()) |
| { |
| __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen); |
| __plen = __ilen; |
| } |
| else |
| { |
| // Worst-case number of external bytes needed. |
| // XXX Not done encoding() == -1. |
| streamsize __blen = __ilen * _M_codecvt->max_length(); |
| char* __buf = static_cast<char*>(__builtin_alloca(__blen)); |
| |
| char* __bend; |
| const char_type* __iend; |
| codecvt_base::result __r; |
| __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen, |
| __iend, __buf, __buf + __blen, __bend); |
| |
| if (__r == codecvt_base::ok || __r == codecvt_base::partial) |
| __blen = __bend - __buf; |
| else if (__r == codecvt_base::noconv) |
| { |
| // Same as the always_noconv case above. |
| __buf = reinterpret_cast<char*>(__ibuf); |
| __blen = __ilen; |
| } |
| else |
| __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " |
| "conversion error")); |
| |
| __elen = _M_file.xsputn(__buf, __blen); |
| __plen = __blen; |
| |
| // Try once more for partial conversions. |
| if (__r == codecvt_base::partial && __elen == __plen) |
| { |
| const char_type* __iresume = __iend; |
| streamsize __rlen = this->pptr() - __iend; |
| __r = _M_codecvt->out(_M_state_cur, __iresume, |
| __iresume + __rlen, __iend, __buf, |
| __buf + __blen, __bend); |
| if (__r != codecvt_base::error) |
| { |
| __rlen = __bend - __buf; |
| __elen = _M_file.xsputn(__buf, __rlen); |
| __plen = __rlen; |
| } |
| else |
| __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " |
| "conversion error")); |
| } |
| } |
| return __elen == __plen; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| streamsize |
| basic_filebuf<_CharT, _Traits>:: |
| xsgetn(_CharT* __s, streamsize __n) |
| { |
| // Clear out pback buffer before going on to the real deal... |
| streamsize __ret = 0; |
| if (_M_pback_init) |
| { |
| if (__n > 0 && this->gptr() == this->eback()) |
| { |
| *__s++ = *this->gptr(); // emulate non-underflowing sbumpc |
| this->gbump(1); |
| __ret = 1; |
| --__n; |
| } |
| _M_destroy_pback(); |
| } |
| else if (_M_writing) |
| { |
| if (overflow() == traits_type::eof()) |
| return __ret; |
| _M_set_buffer(-1); |
| _M_writing = false; |
| } |
| |
| // Optimization in the always_noconv() case, to be generalized in the |
| // future: when __n > __buflen we read directly instead of using the |
| // buffer repeatedly. |
| const bool __testin = _M_mode & ios_base::in; |
| const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; |
| |
| if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() |
| && __testin) |
| { |
| // First, copy the chars already present in the buffer. |
| const streamsize __avail = this->egptr() - this->gptr(); |
| if (__avail != 0) |
| { |
| traits_type::copy(__s, this->gptr(), __avail); |
| __s += __avail; |
| this->setg(this->eback(), this->gptr() + __avail, |
| this->egptr()); |
| __ret += __avail; |
| __n -= __avail; |
| } |
| |
| // Need to loop in case of short reads (relatively common |
| // with pipes). |
| streamsize __len; |
| for (;;) |
| { |
| __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), |
| __n); |
| if (__len == -1) |
| __throw_ios_failure(__N("basic_filebuf::xsgetn " |
| "error reading the file")); |
| if (__len == 0) |
| break; |
| |
| __n -= __len; |
| __ret += __len; |
| if (__n == 0) |
| break; |
| |
| __s += __len; |
| } |
| |
| if (__n == 0) |
| { |
| _M_set_buffer(0); |
| _M_reading = true; |
| } |
| else if (__len == 0) |
| { |
| // If end of file is reached, set 'uncommitted' |
| // mode, thus allowing an immediate write without |
| // an intervening seek. |
| _M_set_buffer(-1); |
| _M_reading = false; |
| } |
| } |
| else |
| __ret += __streambuf_type::xsgetn(__s, __n); |
| |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| streamsize |
| basic_filebuf<_CharT, _Traits>:: |
| xsputn(const _CharT* __s, streamsize __n) |
| { |
| streamsize __ret = 0; |
| // Optimization in the always_noconv() case, to be generalized in the |
| // future: when __n is sufficiently large we write directly instead of |
| // using the buffer. |
| const bool __testout = _M_mode & ios_base::out; |
| if (__check_facet(_M_codecvt).always_noconv() |
| && __testout && !_M_reading) |
| { |
| // Measurement would reveal the best choice. |
| const streamsize __chunk = 1ul << 10; |
| streamsize __bufavail = this->epptr() - this->pptr(); |
| |
| // Don't mistake 'uncommitted' mode buffered with unbuffered. |
| if (!_M_writing && _M_buf_size > 1) |
| __bufavail = _M_buf_size - 1; |
| |
| const streamsize __limit = std::min(__chunk, __bufavail); |
| if (__n >= __limit) |
| { |
| const streamsize __buffill = this->pptr() - this->pbase(); |
| const char* __buf = reinterpret_cast<const char*>(this->pbase()); |
| __ret = _M_file.xsputn_2(__buf, __buffill, |
| reinterpret_cast<const char*>(__s), |
| __n); |
| if (__ret == __buffill + __n) |
| { |
| _M_set_buffer(0); |
| _M_writing = true; |
| } |
| if (__ret > __buffill) |
| __ret -= __buffill; |
| else |
| __ret = 0; |
| } |
| else |
| __ret = __streambuf_type::xsputn(__s, __n); |
| } |
| else |
| __ret = __streambuf_type::xsputn(__s, __n); |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::__streambuf_type* |
| basic_filebuf<_CharT, _Traits>:: |
| setbuf(char_type* __s, streamsize __n) |
| { |
| if (!this->is_open()) |
| { |
| if (__s == 0 && __n == 0) |
| _M_buf_size = 1; |
| else if (__s && __n > 0) |
| { |
| // This is implementation-defined behavior, and assumes that |
| // an external char_type array of length __n exists and has |
| // been pre-allocated. If this is not the case, things will |
| // quickly blow up. When __n > 1, __n - 1 positions will be |
| // used for the get area, __n - 1 for the put area and 1 |
| // position to host the overflow char of a full put area. |
| // When __n == 1, 1 position will be used for the get area |
| // and 0 for the put area, as in the unbuffered case above. |
| _M_buf = __s; |
| _M_buf_size = __n; |
| } |
| } |
| return this; |
| } |
| |
| |
| // According to 27.8.1.4 p11 - 13, seekoff should ignore the last |
| // argument (of type openmode). |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::pos_type |
| basic_filebuf<_CharT, _Traits>:: |
| seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) |
| { |
| int __width = 0; |
| if (_M_codecvt) |
| __width = _M_codecvt->encoding(); |
| if (__width < 0) |
| __width = 0; |
| |
| pos_type __ret = pos_type(off_type(-1)); |
| const bool __testfail = __off != 0 && __width <= 0; |
| if (this->is_open() && !__testfail) |
| { |
| // tellg and tellp queries do not affect any state, unless |
| // ! always_noconv and the put sequence is not empty. |
| // In that case, determining the position requires converting the |
| // put sequence. That doesn't use ext_buf, so requires a flush. |
| bool __no_movement = __way == ios_base::cur && __off == 0 |
| && (!_M_writing || _M_codecvt->always_noconv()); |
| |
| // Ditch any pback buffers to avoid confusion. |
| if (!__no_movement) |
| _M_destroy_pback(); |
| |
| // Correct state at destination. Note that this is the correct |
| // state for the current position during output, because |
| // codecvt::unshift() returns the state to the initial state. |
| // This is also the correct state at the end of the file because |
| // an unshift sequence should have been written at the end. |
| __state_type __state = _M_state_beg; |
| off_type __computed_off = __off * __width; |
| if (_M_reading && __way == ios_base::cur) |
| { |
| __state = _M_state_last; |
| __computed_off += _M_get_ext_pos(__state); |
| } |
| if (!__no_movement) |
| __ret = _M_seek(__computed_off, __way, __state); |
| else |
| { |
| if (_M_writing) |
| __computed_off = this->pptr() - this->pbase(); |
| |
| off_type __file_off = _M_file.seekoff(0, ios_base::cur); |
| if (__file_off != off_type(-1)) |
| { |
| __ret = __file_off + __computed_off; |
| __ret.state(__state); |
| } |
| } |
| } |
| return __ret; |
| } |
| |
| // _GLIBCXX_RESOLVE_LIB_DEFECTS |
| // 171. Strange seekpos() semantics due to joint position |
| // According to the resolution of DR 171, seekpos should ignore the last |
| // argument (of type openmode). |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::pos_type |
| basic_filebuf<_CharT, _Traits>:: |
| seekpos(pos_type __pos, ios_base::openmode) |
| { |
| pos_type __ret = pos_type(off_type(-1)); |
| if (this->is_open()) |
| { |
| // Ditch any pback buffers to avoid confusion. |
| _M_destroy_pback(); |
| __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state()); |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| typename basic_filebuf<_CharT, _Traits>::pos_type |
| basic_filebuf<_CharT, _Traits>:: |
| _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state) |
| { |
| pos_type __ret = pos_type(off_type(-1)); |
| if (_M_terminate_output()) |
| { |
| off_type __file_off = _M_file.seekoff(__off, __way); |
| if (__file_off != off_type(-1)) |
| { |
| _M_reading = false; |
| _M_writing = false; |
| _M_ext_next = _M_ext_end = _M_ext_buf; |
| _M_set_buffer(-1); |
| _M_state_cur = __state; |
| __ret = __file_off; |
| __ret.state(_M_state_cur); |
| } |
| } |
| return __ret; |
| } |
| |
| // Returns the distance from the end of the ext buffer to the point |
| // corresponding to gptr(). This is a negative value. Updates __state |
| // from eback() correspondence to gptr(). |
| template<typename _CharT, typename _Traits> |
| int basic_filebuf<_CharT, _Traits>:: |
| _M_get_ext_pos(__state_type& __state) |
| { |
| if (_M_codecvt->always_noconv()) |
| return this->gptr() - this->egptr(); |
| else |
| { |
| // Calculate offset from _M_ext_buf that corresponds to |
| // gptr(). Precondition: __state == _M_state_last, which |
| // corresponds to eback(). |
| const int __gptr_off = |
| _M_codecvt->length(__state, _M_ext_buf, _M_ext_next, |
| this->gptr() - this->eback()); |
| return _M_ext_buf + __gptr_off - _M_ext_end; |
| } |
| } |
| |
| template<typename _CharT, typename _Traits> |
| bool |
| basic_filebuf<_CharT, _Traits>:: |
| _M_terminate_output() |
| { |
| // Part one: update the output sequence. |
| bool __testvalid = true; |
| if (this->pbase() < this->pptr()) |
| { |
| const int_type __tmp = this->overflow(); |
| if (traits_type::eq_int_type(__tmp, traits_type::eof())) |
| __testvalid = false; |
| } |
| |
| // Part two: output unshift sequence. |
| if (_M_writing && !__check_facet(_M_codecvt).always_noconv() |
| && __testvalid) |
| { |
| // Note: this value is arbitrary, since there is no way to |
| // get the length of the unshift sequence from codecvt, |
| // without calling unshift. |
| const size_t __blen = 128; |
| char __buf[__blen]; |
| codecvt_base::result __r; |
| streamsize __ilen = 0; |
| |
| do |
| { |
| char* __next; |
| __r = _M_codecvt->unshift(_M_state_cur, __buf, |
| __buf + __blen, __next); |
| if (__r == codecvt_base::error) |
| __testvalid = false; |
| else if (__r == codecvt_base::ok || |
| __r == codecvt_base::partial) |
| { |
| __ilen = __next - __buf; |
| if (__ilen > 0) |
| { |
| const streamsize __elen = _M_file.xsputn(__buf, __ilen); |
| if (__elen != __ilen) |
| __testvalid = false; |
| } |
| } |
| } |
| while (__r == codecvt_base::partial && __ilen > 0 && __testvalid); |
| |
| if (__testvalid) |
| { |
| // This second call to overflow() is required by the standard, |
| // but it's not clear why it's needed, since the output buffer |
| // should be empty by this point (it should have been emptied |
| // in the first call to overflow()). |
| const int_type __tmp = this->overflow(); |
| if (traits_type::eq_int_type(__tmp, traits_type::eof())) |
| __testvalid = false; |
| } |
| } |
| return __testvalid; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| int |
| basic_filebuf<_CharT, _Traits>:: |
| sync() |
| { |
| // Make sure that the internal buffer resyncs its idea of |
| // the file position with the external file. |
| int __ret = 0; |
| if (this->pbase() < this->pptr()) |
| { |
| const int_type __tmp = this->overflow(); |
| if (traits_type::eq_int_type(__tmp, traits_type::eof())) |
| __ret = -1; |
| } |
| return __ret; |
| } |
| |
| template<typename _CharT, typename _Traits> |
| void |
| basic_filebuf<_CharT, _Traits>:: |
| imbue(const locale& __loc) |
| { |
| bool __testvalid = true; |
| |
| const __codecvt_type* _M_codecvt_tmp = 0; |
| if (__builtin_expect(has_facet<__codecvt_type>(__loc), true)) |
| _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc); |
| |
| if (this->is_open()) |
| { |
| // encoding() == -1 is ok only at the beginning. |
| if ((_M_reading || _M_writing) |
| && __check_facet(_M_codecvt).encoding() == -1) |
| __testvalid = false; |
| else |
| { |
| if (_M_reading) |
| { |
| if (__check_facet(_M_codecvt).always_noconv()) |
| { |
| if (_M_codecvt_tmp |
| && !__check_facet(_M_codecvt_tmp).always_noconv()) |
| __testvalid = this->seekoff(0, ios_base::cur, _M_mode) |
| != pos_type(off_type(-1)); |
| } |
| else |
| { |
| // External position corresponding to gptr(). |
| _M_ext_next = _M_ext_buf |
| + _M_codecvt->length(_M_state_last, _M_ext_buf, |
| _M_ext_next, |
| this->gptr() - this->eback()); |
| const streamsize __remainder = _M_ext_end - _M_ext_next; |
| if (__remainder) |
| __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); |
| |
| _M_ext_next = _M_ext_buf; |
| _M_ext_end = _M_ext_buf + __remainder; |
| _M_set_buffer(-1); |
| _M_state_last = _M_state_cur = _M_state_beg; |
| } |
| } |
| else if (_M_writing && (__testvalid = _M_terminate_output())) |
| _M_set_buffer(-1); |
| } |
| } |
| |
| if (__testvalid) |
| _M_codecvt = _M_codecvt_tmp; |
| else |
| _M_codecvt = 0; |
| } |
| |
| // Inhibit implicit instantiations for required instantiations, |
| // which are defined via explicit instantiations elsewhere. |
| #if _GLIBCXX_EXTERN_TEMPLATE |
| extern template class basic_filebuf<char>; |
| extern template class basic_ifstream<char>; |
| extern template class basic_ofstream<char>; |
| extern template class basic_fstream<char>; |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| extern template class basic_filebuf<wchar_t>; |
| extern template class basic_ifstream<wchar_t>; |
| extern template class basic_ofstream<wchar_t>; |
| extern template class basic_fstream<wchar_t>; |
| #endif |
| #endif |
| |
| _GLIBCXX_END_NAMESPACE_VERSION |
| } // namespace std |
| |
| #endif |
