www.fifi.org     Documentation         Manpages         GNU Info         Debian document tree         Whole document tree     Trigance web page     Public services     User info     Mailing lists     Secure server     Multilingual usage   Copyright (C) 2000-2012 Philippe Troin <webmaster@fifi.org>. Validate HTML Validate CSS

Whole document tree                   fstream.tcc Go to the documentation of this file. // File based streams -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001 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 2, 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. // You should have received a copy of the GNU General Public License along // with this library; see the file COPYING. If not, write to the Free // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, // USA. // As a special exception, you may use this file as part of a free software // library without restriction. Specifically, if other files instantiate // templates or use macros or inline functions from this file, or you compile // this file and link it with other files to produce an executable, this // file does not by itself cause the resulting executable to be covered by // the GNU General Public License. This exception does not however // invalidate any other reasons why the executable file might be covered by // the GNU General Public License. // // ISO C++ 14882: 27.8 File-based streams // #ifndef _CPP_BITS_FSTREAM_TCC #define _CPP_BITS_FSTREAM_TCC 1 namespace std { template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: _M_allocate_file() { if (!_M_file) { _M_buf_unified = true; // Tie input to output for basic_filebuf. try { _M_file = new __file_type(&_M_lock); } catch(...) { delete _M_file; __throw_exception_again; } } } template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: _M_allocate_internal_buffer() { if (!_M_buf && _M_buf_size_opt) { _M_buf_size = _M_buf_size_opt; // Allocate internal buffer. try { _M_buf = new char_type[_M_buf_size]; } catch(...) { delete [] _M_buf; __throw_exception_again; } _M_buf_allocated = true; } } // Both close and setbuf need to deallocate internal buffers, if it exists. template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: _M_destroy_internal_buffer() { if (_M_buf_allocated) { delete [] _M_buf; _M_buf = NULL; _M_buf_allocated = false; this->setg(NULL, NULL, NULL); this->setp(NULL, NULL); } } template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: _M_allocate_pback_buffer() { if (!_M_pback && _M_pback_size) { // Allocate pback buffer. try { _M_pback = new char_type[_M_pback_size]; } catch(...) { delete [] _M_pback; __throw_exception_again; } } } template<typename _CharT, typename _Traits> basic_filebuf<_CharT, _Traits>:: basic_filebuf() : __streambuf_type(), _M_file(NULL), _M_state_cur(__state_type()), _M_state_beg(__state_type()), _M_buf_allocated(false), _M_last_overflowed(false) { } template<typename _CharT, typename _Traits> basic_filebuf<_CharT, _Traits>:: basic_filebuf(__c_file_type* __f, ios_base::openmode __mode, int_type __s) : __streambuf_type(), _M_file(NULL), _M_state_cur(__state_type()), _M_state_beg(__state_type()), _M_buf_allocated(false), _M_last_overflowed(false) { _M_allocate_file(); _M_file->sys_open(__f, __mode); if (this->is_open()) { _M_mode = __mode; if (__s) { _M_buf_size_opt = __s; _M_allocate_internal_buffer(); _M_set_indeterminate(); } _M_allocate_pback_buffer(); } } 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 = NULL; if (!this->is_open()) { _M_allocate_file(); _M_file->open(__s, __mode); if (this->is_open()) { _M_allocate_internal_buffer(); _M_allocate_pback_buffer(); _M_mode = __mode; // For time being, set both (in/out) sets of pointers. _M_set_indeterminate(); if (__mode & ios_base::ate && this->seekoff(0, ios_base::end, __mode) < 0) this->close(); __ret = this; } } return __ret; } template<typename _CharT, typename _Traits> typename basic_filebuf<_CharT, _Traits>::__filebuf_type* basic_filebuf<_CharT, _Traits>:: close() { __filebuf_type *__ret = NULL; if (this->is_open()) { bool __testput = _M_out_cur && _M_out_beg < _M_out_end; if (__testput) _M_really_overflow(traits_type::eof()); // NB: Do this here so that re-opened filebufs will be cool... _M_pback_destroy(); #if 0 // XXX not done if (_M_last_overflowed) { _M_output_unshift(); _M_really_overflow(traits_type::eof()); } #endif _M_mode = ios_base::openmode(0); _M_destroy_internal_buffer(); if (_M_pback) { delete [] _M_pback; _M_pback = NULL; } __ret = this; } // Can actually allocate this file as part of an open and never // have it be opened..... if (_M_file) { delete _M_file; _M_file = NULL; } _M_last_overflowed = false; return __ret; } template<typename _CharT, typename _Traits> streamsize basic_filebuf<_CharT, _Traits>:: showmanyc() { streamsize __ret = -1; bool __testin = _M_mode & ios_base::in; if (__testin) { bool __testeof = false; if (_M_in_cur >= _M_in_end) __testeof = this->underflow() == traits_type::eof(); if (!__testeof) __ret = _M_in_end - _M_in_cur; } _M_last_overflowed = false; 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(); bool __testin = _M_mode & ios_base::in; bool __testout = _M_mode & ios_base::out; // XXX Should re-enable codecvt bits disabled after 2.90.8. if (__testin) { // Check for pback madness, and if so swich back to the // normal buffers and jet outta here before expensive // fileops happen... if (_M_pback_init) { _M_pback_destroy(); if (_M_in_cur < _M_in_end) return traits_type::to_int_type(*_M_in_cur); } bool __testget = _M_in_cur && _M_in_beg < _M_in_cur; bool __testinit = _M_is_indeterminate(); // Sync internal and external buffers. // NB: __testget -> __testput as _M_buf_unified here. if (__testget) { if (__testout) _M_really_overflow(); #if _GLIBCPP_AVOID_FSEEK else if ((_M_in_cur - _M_in_beg) == 1) _M_file->sys_getc(); #endif else _M_file->seekoff(_M_in_cur - _M_in_beg, ios_base::cur, ios_base::in); } if (__testinit || __testget) { // Assume buffered case, need to refill internal buffers. streamsize __size = _M_file->xsgetn(_M_in_beg, _M_buf_size); if (0 < __size) { _M_set_determinate(__size); if (__testout) _M_out_cur = _M_in_cur; __ret = traits_type::to_int_type(*_M_in_cur); #if _GLIBCPP_AVOID_FSEEK if (__size == 1) _M_file->sys_ungetc(*_M_in_cur); else { #endif streamoff __p = _M_file->seekoff(0 - __size, ios_base::cur, ios_base::in); if (__p == -1) { // XXX Something is wrong, do error checking. } #if _GLIBCPP_AVOID_FSEEK } #endif } } } _M_last_overflowed = false; 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(); bool __testin = _M_mode & ios_base::in; if (__testin) { bool __testpb = _M_in_beg < _M_in_cur; char_type __c = traits_type::to_char_type(__i); bool __testeof = traits_type::eq_int_type(__i, __ret); if (__testpb) { bool __testout = _M_mode & ios_base::out; bool __testeq = traits_type::eq(__c, this->gptr()[-1]); // Try to put back __c into input sequence in one of three ways. // Order these tests done in is unspecified by the standard. if (!__testeof && __testeq) { --_M_in_cur; if (__testout) --_M_out_cur; __ret = __i; } else if (__testeof) { --_M_in_cur; if (__testout) --_M_out_cur; __ret = traits_type::not_eof(__i); } else if (!__testeof) { --_M_in_cur; if (__testout) --_M_out_cur; _M_pback_create(); *_M_in_cur = __c; __ret = __i; } } else { // At the beginning of the buffer, need to make a // putback position available. this->seekoff(-1, ios_base::cur); this->underflow(); if (!__testeof) { if (!traits_type::eq(__c, *_M_in_cur)) { _M_pback_create(); *_M_in_cur = __c; } __ret = __i; } else __ret = traits_type::not_eof(__i); } } _M_last_overflowed = false; 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(); bool __testput = _M_out_cur && _M_out_cur < _M_buf + _M_buf_size; bool __testout = _M_mode & ios_base::out; if (__testout) { if (__testput) { *_M_out_cur = traits_type::to_char_type(__c); _M_out_cur_move(1); __ret = traits_type::not_eof(__c); } else __ret = this->_M_really_overflow(__c); } _M_last_overflowed = false; // Set in _M_really_overflow, below. return __ret; } template<typename _CharT, typename _Traits> typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>:: _M_really_overflow(int_type __c) { int_type __ret = traits_type::eof(); bool __testput = _M_out_cur && _M_out_beg < _M_out_end; bool __testunbuffered = _M_file && !_M_buf_size; if (__testput || __testunbuffered) { #if 1 int __plen = _M_out_end - _M_out_beg; streamsize __len = 0; if (__plen) __len = _M_file->xsputn(_M_out_beg, __plen); if (__c !=traits_type::eof()) { char_type __pending = traits_type::to_char_type(__c); __len += _M_file->xsputn(&__pending, 1); ++__plen; } // NB: Need this so that external byte sequence reflects // internal buffer. _M_file->sync(); if (__len == __plen) { _M_set_indeterminate(); __ret = traits_type::not_eof(__c); } #else // Part one: Allocate temporary conversion buffer on // stack. Convert internal buffer plus __c (ie, // "pending sequence") to temporary conversion buffer. int __plen = _M_out_end - _M_out_beg; char_type* __pbuf = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen + 1)); traits_type::copy(__pbuf, this->pbase(), __plen); if (!__testeof) { __pbuf[__plen] = traits_type::to_char_type(__c); ++__plen; } char_type* __pend; char* __conv_buf = static_cast<char*>(__builtin_alloca(__plen)); char* __conv_end; _M_state_beg = _M_state_cur; __res_type __r = _M_fcvt->out(_M_state_cur, __pbuf, __pbuf + __plen, const_cast<const char_type*&>(__pend), __conv_buf, __conv_buf + __plen, __conv_end); // Part two: (Re)spill converted "pending sequence" // contents (now in temporary conversion buffer) to // external buffer (_M_file->_IO_*) using // _M_file->sys_write(), and do error (minimal) checking. if (__r != codecvt_base::error) { streamsize __len = _M_file->xsputn(__conv_buf, __plen); // NB: Need this so that external byte sequence reflects // internal buffer. _M_file->sync(); if (__len == __plen) { _M_set_indeterminate(); __ret = traits_type::not_eof(__c); } } #endif } _M_last_overflowed = true; 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() && __s == 0 && __n == 0) _M_buf_size_opt = 0; else if (__s && __n) { // This is implementation-defined behavior, and assumes // that an external char_type array of length (__s + __n) // exists and has been pre-allocated. If this is not the // case, things will quickly blow up. // Step 1: Destroy the current internal array. _M_destroy_internal_buffer(); // Step 2: Use the external array. _M_buf = __s; _M_buf_size_opt = _M_buf_size = __n; _M_set_indeterminate(); // Step 3: Make sure a pback buffer is allocated. _M_allocate_pback_buffer(); } _M_last_overflowed = false; return this; } 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 __mode) { pos_type __ret = pos_type(off_type(-1)); bool __testopen = this->is_open(); bool __testin = __mode & ios_base::in && _M_mode & ios_base::in; bool __testout = __mode & ios_base::out && _M_mode & ios_base::out; // Should probably do has_facet checks here. int __width = use_facet<__codecvt_type>(_M_buf_locale).encoding(); if (__width < 0) __width = 0; bool __testfail = __off != 0 && __width <= 0; if (__testopen && !__testfail && (__testin || __testout)) { // Ditch any pback buffers to avoid confusion. _M_pback_destroy(); if (__way != ios_base::cur || __off != 0) { off_type __computed_off = __width * __off; bool __testget = _M_in_cur && _M_in_beg < _M_in_end; bool __testput = _M_out_cur && _M_out_beg < _M_out_end; // Sync the internal and external streams. // out if (__testput || _M_last_overflowed) { // Part one: update the output sequence. this->sync(); // Part two: output unshift sequence. _M_output_unshift(); } //in // NB: underflow() rewinds the external buffer. else if (__testget && __way == ios_base::cur) __computed_off += _M_in_cur - _M_in_beg; __ret = _M_file->seekoff(__computed_off, __way, __mode); _M_set_indeterminate(); } // NB: Need to do this in case _M_file in indeterminate // state, ie _M_file->_offset == -1 else { __ret = _M_file->seekoff(__off, ios_base::cur, __mode); __ret += max(_M_out_cur, _M_in_cur) - _M_buf; } } _M_last_overflowed = false; return __ret; } template<typename _CharT, typename _Traits> typename basic_filebuf<_CharT, _Traits>::pos_type basic_filebuf<_CharT, _Traits>:: seekpos(pos_type __pos, ios_base::openmode __mode) { pos_type __ret; off_type __off = __pos; __ret = this->seekoff(__off, ios_base::beg, __mode); _M_last_overflowed = false; return __ret; } template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: _M_output_unshift() { } template<typename _CharT, typename _Traits> void basic_filebuf<_CharT, _Traits>:: imbue(const locale& __loc) { bool __testbeg = gptr() == eback() && pptr() == pbase(); if (__testbeg && _M_buf_locale != __loc) { _M_buf_locale = __loc; _M_buf_locale_init = true; } // NB this may require the reconversion of previously // converted chars. This in turn may cause the reconstruction // of the original file. YIKES!! // XXX The part in the above comment is not done. _M_last_overflowed = false; } } // namespace std #endif // _CPP_BITS_FSTREAM_TCC