fstream.tcc

00001 // File based streams -*- C++ -*-
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // You should have received a copy of the GNU General Public License along
00018 // with this library; see the file COPYING.  If not, write to the Free
00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00020 // USA.
00021 
00022 // As a special exception, you may use this file as part of a free software
00023 // library without restriction.  Specifically, if other files instantiate
00024 // templates or use macros or inline functions from this file, or you compile
00025 // this file and link it with other files to produce an executable, this
00026 // file does not by itself cause the resulting executable to be covered by
00027 // the GNU General Public License.  This exception does not however
00028 // invalidate any other reasons why the executable file might be covered by
00029 // the GNU General Public License.
00030 
00031 //
00032 // ISO C++ 14882: 27.8  File-based streams
00033 //
00034 
00035 #ifndef _CPP_BITS_FSTREAM_TCC
00036 #define _CPP_BITS_FSTREAM_TCC 1
00037 
00038 #pragma GCC system_header
00039 
00040 namespace std
00041 {
00042   template<typename _CharT, typename _Traits>
00043     void
00044     basic_filebuf<_CharT, _Traits>::
00045     _M_allocate_internal_buffer()
00046     {
00047       if (!_M_buf && _M_buf_size_opt)
00048     {
00049       _M_buf_size = _M_buf_size_opt;
00050 
00051       // Allocate internal buffer.
00052       _M_buf = new char_type[_M_buf_size]; 
00053       _M_buf_allocated = true;
00054     }
00055     }
00056 
00057   // Both close and setbuf need to deallocate internal buffers, if it exists.
00058   template<typename _CharT, typename _Traits>
00059     void
00060     basic_filebuf<_CharT, _Traits>::
00061     _M_destroy_internal_buffer() throw()
00062     {
00063       if (_M_buf_allocated)
00064     {
00065       delete [] _M_buf;
00066       _M_buf = NULL;
00067       _M_buf_allocated = false;
00068       this->setg(NULL, NULL, NULL);
00069       this->setp(NULL, NULL);
00070     }
00071     }
00072 
00073   template<typename _CharT, typename _Traits>
00074     basic_filebuf<_CharT, _Traits>::
00075     basic_filebuf() : __streambuf_type(), _M_file(&_M_lock), 
00076     _M_state_cur(__state_type()), _M_state_beg(__state_type()), 
00077     _M_buf_allocated(false), _M_last_overflowed(false)
00078     { _M_buf_unified = true; }
00079 
00080   template<typename _CharT, typename _Traits>
00081     typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 
00082     basic_filebuf<_CharT, _Traits>::
00083     open(const char* __s, ios_base::openmode __mode)
00084     {
00085       __filebuf_type *__ret = NULL;
00086       if (!this->is_open())
00087     {
00088       _M_file.open(__s, __mode);
00089       if (this->is_open())
00090         {
00091           _M_allocate_internal_buffer();
00092           _M_mode = __mode;
00093 
00094           // Setup initial position of buffer.
00095           _M_set_indeterminate();
00096 
00097           if ((__mode & ios_base::ate)
00098           && this->seekoff(0, ios_base::end, __mode) < 0)
00099         {
00100           // 27.8.1.3,4
00101           this->close();
00102           return __ret;
00103         }
00104 
00105           __ret = this;
00106         }
00107     }
00108       return __ret;
00109     }
00110 
00111   template<typename _CharT, typename _Traits>
00112     typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 
00113     basic_filebuf<_CharT, _Traits>::
00114     close() throw()
00115     {
00116       __filebuf_type* __ret = NULL;
00117       if (this->is_open())
00118     {
00119       bool __testfail = false;
00120       try
00121         {
00122           const int_type __eof = traits_type::eof();
00123           bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
00124           if (__testput 
00125           && traits_type::eq_int_type(_M_really_overflow(__eof), 
00126                           __eof))
00127         __testfail = true;
00128           
00129 #if 0
00130           // XXX not done
00131           if (_M_last_overflowed)
00132         {
00133           _M_output_unshift();
00134           _M_really_overflow(__eof);
00135         }
00136 #endif
00137         }
00138       catch(...)
00139         { __testfail = true; }
00140 
00141       // NB: Do this here so that re-opened filebufs will be cool...
00142       this->_M_mode = ios_base::openmode(0);
00143       _M_destroy_internal_buffer();
00144       _M_pback_destroy();
00145 
00146       if (!_M_file.close())
00147         __testfail = true;
00148 
00149       if (!__testfail)
00150         __ret = this;
00151     }
00152       _M_last_overflowed = false;   
00153       return __ret;
00154     }
00155 
00156   template<typename _CharT, typename _Traits>
00157     streamsize 
00158     basic_filebuf<_CharT, _Traits>::
00159     showmanyc()
00160     {
00161       streamsize __ret = -1;
00162       bool __testin = _M_mode & ios_base::in;
00163       const locale __loc = this->getloc();
00164       const __codecvt_type& __cvt = use_facet<__codecvt_type>(__loc);
00165 
00166       if (__testin && this->is_open())
00167     {
00168       __ret = _M_in_end - _M_in_cur;
00169       if (__cvt.always_noconv())
00170         __ret += _M_file.showmanyc_helper();
00171     }
00172 
00173       _M_last_overflowed = false;   
00174       return __ret;
00175     }
00176   
00177   template<typename _CharT, typename _Traits>
00178     typename basic_filebuf<_CharT, _Traits>::int_type 
00179     basic_filebuf<_CharT, _Traits>::
00180     pbackfail(int_type __i)
00181     {
00182       int_type __ret = traits_type::eof();
00183       bool __testin = _M_mode & ios_base::in;
00184 
00185       if (__testin)
00186     {
00187       bool __testpb = _M_in_beg < _M_in_cur;
00188       char_type __c = traits_type::to_char_type(__i);
00189       bool __testeof = traits_type::eq_int_type(__i, __ret);
00190 
00191       if (__testpb)
00192         {
00193           bool __testout = _M_mode & ios_base::out;
00194           bool __testeq = traits_type::eq(__c, this->gptr()[-1]);
00195 
00196           // Try to put back __c into input sequence in one of three ways.
00197           // Order these tests done in is unspecified by the standard.
00198           if (!__testeof && __testeq)
00199         {
00200           --_M_in_cur;
00201           if (__testout)
00202             --_M_out_cur;
00203           __ret = __i;
00204         }
00205           else if (__testeof)
00206         {
00207           --_M_in_cur;
00208           if (__testout)
00209             --_M_out_cur;
00210           __ret = traits_type::not_eof(__i);
00211         }
00212           else if (!__testeof)
00213         {
00214           --_M_in_cur;
00215           if (__testout)
00216             --_M_out_cur;
00217           _M_pback_create();
00218           *_M_in_cur = __c; 
00219           __ret = __i;
00220         }
00221         }
00222       else
00223         {    
00224           // At the beginning of the buffer, need to make a
00225           // putback position available.
00226           // But the seek may fail (f.i., at the beginning of
00227           // a file, see libstdc++/9439) and in that case
00228           // we return traits_type::eof()
00229           if (this->seekoff(-1, ios_base::cur) >= 0)
00230         {
00231           this->underflow();
00232           if (!__testeof)
00233             {
00234               if (!traits_type::eq(__c, *_M_in_cur))
00235             {
00236               _M_pback_create();
00237               *_M_in_cur = __c;
00238             }
00239               __ret = __i;
00240             }
00241           else
00242             __ret = traits_type::not_eof(__i);
00243         }
00244         }
00245     }
00246       _M_last_overflowed = false;   
00247       return __ret;
00248     }
00249 
00250   template<typename _CharT, typename _Traits>
00251     typename basic_filebuf<_CharT, _Traits>::int_type 
00252     basic_filebuf<_CharT, _Traits>::
00253     overflow(int_type __c)
00254     {
00255       int_type __ret = traits_type::eof();
00256       bool __testput = _M_out_cur && _M_out_cur < _M_buf + _M_buf_size;
00257       bool __testout = _M_mode & ios_base::out;
00258       
00259       if (__testout)
00260     {
00261       if (traits_type::eq_int_type(__c, traits_type::eof()))
00262         __ret = traits_type::not_eof(__c);
00263       else if (__testput)
00264         {
00265           *_M_out_cur = traits_type::to_char_type(__c);
00266           _M_out_cur_move(1);
00267           __ret = traits_type::not_eof(__c);
00268         }
00269       else 
00270         __ret = this->_M_really_overflow(__c);
00271     }
00272 
00273       _M_last_overflowed = false;    // Set in _M_really_overflow, below.
00274       return __ret;
00275     }
00276   
00277   template<typename _CharT, typename _Traits>
00278     void
00279     basic_filebuf<_CharT, _Traits>::
00280     _M_convert_to_external(_CharT* __ibuf, streamsize __ilen,
00281                streamsize& __elen, streamsize& __plen)
00282     {
00283       const locale __loc = this->getloc();
00284       const __codecvt_type& __cvt = use_facet<__codecvt_type>(__loc);
00285       
00286       if (__cvt.always_noconv() && __ilen)
00287     {
00288       __elen += _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
00289       __plen += __ilen;
00290     }
00291       else
00292     {
00293       // Worst-case number of external bytes needed.
00294       int __ext_multiplier = __cvt.encoding();
00295       if (__ext_multiplier ==  -1 || __ext_multiplier == 0)
00296         __ext_multiplier = sizeof(char_type);
00297       streamsize __blen = __ilen * __ext_multiplier;
00298       char* __buf = static_cast<char*>(__builtin_alloca(__blen));
00299       char* __bend;
00300       const char_type* __iend;
00301       codecvt_base::result __r;
00302       __r = __cvt.out(_M_state_cur, __ibuf, __ibuf + __ilen, 
00303               __iend, __buf, __buf + __blen, __bend);
00304 
00305       if (__r == codecvt_base::ok || __r == codecvt_base::partial)
00306         __blen = __bend - __buf;
00307       else if (__r == codecvt_base::noconv)
00308         {
00309           // Same as the always_noconv case above.
00310           __buf = reinterpret_cast<char*>(__ibuf);
00311           __blen = __ilen;
00312         }
00313       else
00314         {
00315           // Result == error 
00316           __blen = 0;
00317         }
00318       
00319       if (__blen)
00320         {
00321           __elen += _M_file.xsputn(__buf, __blen);
00322           __plen += __blen;
00323         }
00324 
00325       // Try once more for partial conversions.
00326       if (__r == codecvt_base::partial)
00327         {
00328           const char_type* __iresume = __iend;
00329           streamsize __rlen = _M_out_end - __iend;
00330           __r = __cvt.out(_M_state_cur, __iresume, __iresume + __rlen, 
00331                   __iend, __buf, __buf + __blen, __bend);
00332           if (__r != codecvt_base::error)
00333         {
00334           __rlen = __bend - __buf;
00335           __elen += _M_file.xsputn(__buf, __rlen);
00336           __plen += __rlen;
00337         }
00338         }
00339     }
00340     }
00341 
00342   template<typename _CharT, typename _Traits>
00343     typename basic_filebuf<_CharT, _Traits>::int_type 
00344     basic_filebuf<_CharT, _Traits>::
00345     _M_really_overflow(int_type __c)
00346     {
00347       int_type __ret = traits_type::eof();
00348       bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
00349       bool __testunbuffered = _M_file.is_open() && !_M_buf_size;
00350 
00351       if (__testput || __testunbuffered)
00352     {
00353       // Sizes of external and pending output.
00354       streamsize __elen = 0;
00355       streamsize __plen = 0;
00356 
00357       // Need to restore current position. The position of the external
00358       // byte sequence (_M_file) corresponds to _M_filepos, and we need
00359       // to move it to _M_out_beg for the write.
00360       if (_M_filepos && _M_filepos != _M_out_beg)
00361         {
00362           off_type __off = _M_out_beg - _M_filepos;
00363           _M_file.seekoff(__off, ios_base::cur);
00364         }
00365 
00366       // Convert internal buffer to external representation, output.
00367       // NB: In the unbuffered case, no internal buffer exists. 
00368       if (!__testunbuffered)
00369         _M_convert_to_external(_M_out_beg,  _M_out_end - _M_out_beg, 
00370                    __elen, __plen);
00371 
00372       // Checks for codecvt.out failures and _M_file.xsputn failures,
00373       // respectively, inside _M_convert_to_external.
00374       if (__testunbuffered || (__elen && __elen == __plen))
00375         {
00376           // Convert pending sequence to external representation, output.
00377           // If eof, then just attempt sync.
00378           if (!traits_type::eq_int_type(__c, traits_type::eof()))
00379         {
00380           char_type __pending = traits_type::to_char_type(__c);
00381           _M_convert_to_external(&__pending, 1, __elen, __plen);
00382   
00383           // User code must flush when switching modes (thus
00384           // don't sync).
00385           if (__elen == __plen && __elen)
00386             {
00387               _M_set_indeterminate();
00388               __ret = traits_type::not_eof(__c);
00389             }
00390         }
00391           else if (!_M_file.sync())
00392         {
00393           _M_set_indeterminate();
00394           __ret = traits_type::not_eof(__c);
00395         }
00396         }
00397     }
00398       _M_last_overflowed = true;    
00399       return __ret;
00400     }
00401 
00402   template<typename _CharT, typename _Traits>
00403     typename basic_filebuf<_CharT, _Traits>::__streambuf_type* 
00404     basic_filebuf<_CharT, _Traits>::
00405     setbuf(char_type* __s, streamsize __n)
00406     {
00407       if (!this->is_open() && __s == 0 && __n == 0)
00408     _M_buf_size_opt = 0;
00409       else if (__s && __n)
00410     {
00411       // This is implementation-defined behavior, and assumes
00412       // that an external char_type array of length (__s + __n)
00413       // exists and has been pre-allocated. If this is not the
00414       // case, things will quickly blow up.
00415       // Step 1: Destroy the current internal array.
00416       _M_destroy_internal_buffer();
00417       
00418       // Step 2: Use the external array.
00419       _M_buf = __s;
00420       _M_buf_size_opt = _M_buf_size = __n;
00421       _M_set_indeterminate();
00422     }
00423       _M_last_overflowed = false;   
00424       return this; 
00425     }
00426   
00427   template<typename _CharT, typename _Traits>
00428     typename basic_filebuf<_CharT, _Traits>::pos_type
00429     basic_filebuf<_CharT, _Traits>::
00430     seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
00431     {
00432       pos_type __ret =  pos_type(off_type(-1)); 
00433       bool __testin = (ios_base::in & _M_mode & __mode) != 0;
00434       bool __testout = (ios_base::out & _M_mode & __mode) != 0;
00435 
00436       int __width = 0;
00437       if (has_facet<__codecvt_type>(this->_M_buf_locale))
00438       __width = use_facet<__codecvt_type>(this->_M_buf_locale).encoding();
00439       if (__width < 0)
00440     __width = 0;
00441 
00442       bool __testfail = __off != 0 && __width <= 0;      
00443       if (this->is_open() && !__testfail && (__testin || __testout)) 
00444     {
00445       // Ditch any pback buffers to avoid confusion.
00446       _M_pback_destroy();
00447 
00448       if (__way != ios_base::cur || __off != 0)
00449         { 
00450           off_type __computed_off = __width * __off;
00451           
00452           bool __testget = _M_in_cur && _M_in_beg < _M_in_end;
00453           bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
00454           // Sync the internal and external streams.
00455           // out
00456           if (__testput || _M_last_overflowed)
00457         {
00458           // Part one: update the output sequence.
00459           this->sync();
00460           // Part two: output unshift sequence.
00461           _M_output_unshift();
00462         }
00463           //in
00464           else if (__testget && __way == ios_base::cur)
00465         __computed_off += _M_in_cur - _M_filepos;
00466 
00467           // Return pos_type(off_type(-1)) in case of failure.    
00468           __ret = _M_file.seekoff(__computed_off, __way, __mode);
00469           _M_set_indeterminate();
00470         }
00471       // NB: Need to do this in case _M_file in indeterminate
00472       // state, ie _M_file._offset == -1
00473       else
00474         {
00475           pos_type __tmp =
00476         _M_file.seekoff(__off, ios_base::cur, __mode);
00477           if (__tmp >= 0)
00478         {
00479           // Seek successful.
00480           __ret = __tmp;
00481           __ret += max(_M_out_cur, _M_in_cur) - _M_filepos;
00482         }
00483         }
00484     }
00485       _M_last_overflowed = false;   
00486       return __ret;
00487     }
00488 
00489   template<typename _CharT, typename _Traits>
00490     typename basic_filebuf<_CharT, _Traits>::pos_type
00491     basic_filebuf<_CharT, _Traits>::
00492     seekpos(pos_type __pos, ios_base::openmode __mode)
00493     {
00494 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00495 // 171. Strange seekpos() semantics due to joint position
00496       return this->seekoff(off_type(__pos), ios_base::beg, __mode);
00497 #endif
00498     }
00499 
00500   template<typename _CharT, typename _Traits>
00501     void 
00502     basic_filebuf<_CharT, _Traits>::
00503     _M_output_unshift()
00504     { }
00505 
00506   template<typename _CharT, typename _Traits>
00507     void
00508     basic_filebuf<_CharT, _Traits>::
00509     imbue(const locale&)
00510     { _M_last_overflowed = false; }
00511 
00512   // Inhibit implicit instantiations for required instantiations,
00513   // which are defined via explicit instantiations elsewhere.  
00514   // NB:  This syntax is a GNU extension.
00515 #if _GLIBCPP_EXTERN_TEMPLATE
00516   extern template class basic_filebuf<char>;
00517   extern template class basic_ifstream<char>;
00518   extern template class basic_ofstream<char>;
00519   extern template class basic_fstream<char>;
00520 
00521 #ifdef _GLIBCPP_USE_WCHAR_T
00522   extern template class basic_filebuf<wchar_t>;
00523   extern template class basic_ifstream<wchar_t>;
00524   extern template class basic_ofstream<wchar_t>;
00525   extern template class basic_fstream<wchar_t>;
00526 #endif
00527 #endif
00528 } // namespace std
00529 
00530 #endif 

Generated on Thu Feb 10 23:22:54 2005 for libstdc++-v3 Source by  doxygen 1.4.0