istream.tcc

00001 // istream classes -*- 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.6.2  Output streams
00033 //
00034 
00035 #pragma GCC system_header
00036 
00037 #include <locale>
00038 #include <ostream> // For flush()
00039 
00040 namespace std 
00041 {
00042   template<typename _CharT, typename _Traits>
00043     basic_istream<_CharT, _Traits>::sentry::
00044     sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
00045     {
00046       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00047       if (__in.good()) 
00048     {
00049       if (__in.tie())
00050         __in.tie()->flush();
00051       if (!__noskipws && (__in.flags() & ios_base::skipws))
00052         {     
00053           const __int_type __eof = traits_type::eof();
00054           __streambuf_type* __sb = __in.rdbuf();
00055           __int_type __c = __sb->sgetc();
00056 
00057           __in._M_check_facet(__in._M_fctype);
00058           const __ctype_type& __ct = *__in._M_fctype;
00059           while (!traits_type::eq_int_type(__c, __eof)
00060              && __ct.is(ctype_base::space, 
00061                 traits_type::to_char_type(__c)))
00062         __c = __sb->snextc();
00063 
00064           // _GLIBCXX_RESOLVE_LIB_DEFECTS
00065           // 195. Should basic_istream::sentry's constructor ever
00066           // set eofbit?
00067           if (traits_type::eq_int_type(__c, __eof))
00068         __err |= ios_base::eofbit;
00069         }
00070     }
00071 
00072       if (__in.good() && __err == ios_base::goodbit)
00073     _M_ok = true;
00074       else
00075     {
00076       _M_ok = false;
00077       __err |= ios_base::failbit;
00078       __in.setstate(__err);
00079     }
00080     }
00081 
00082   template<typename _CharT, typename _Traits>
00083     basic_istream<_CharT, _Traits>& 
00084     basic_istream<_CharT, _Traits>::
00085     operator>>(__istream_type& (*__pf)(__istream_type&))
00086     { return __pf(*this); }
00087 
00088   template<typename _CharT, typename _Traits>
00089     basic_istream<_CharT, _Traits>& 
00090     basic_istream<_CharT, _Traits>::
00091     operator>>(__ios_type& (*__pf)(__ios_type&))
00092     {
00093       __pf(*this);
00094       return *this;
00095     }
00096   
00097   template<typename _CharT, typename _Traits>
00098     basic_istream<_CharT, _Traits>& 
00099     basic_istream<_CharT, _Traits>::
00100     operator>>(ios_base& (*__pf)(ios_base&))
00101     {
00102       __pf(*this);
00103       return *this;
00104     }
00105   
00106   template<typename _CharT, typename _Traits>
00107     basic_istream<_CharT, _Traits>& 
00108     basic_istream<_CharT, _Traits>::
00109     operator>>(bool& __n)
00110     {
00111       sentry __cerb(*this, false);
00112       if (__cerb) 
00113     {
00114       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00115       try 
00116         {
00117           _M_check_facet(this->_M_fnumget);
00118           const __numget_type& __ng = *this->_M_fnumget;
00119           __ng.get(*this, 0, *this, __err, __n);
00120         }
00121       catch(...)
00122         { this->_M_setstate(ios_base::badbit); }
00123       if (__err)
00124         this->setstate(__err);
00125     }
00126       return *this;
00127     }
00128 
00129   template<typename _CharT, typename _Traits>
00130     basic_istream<_CharT, _Traits>& 
00131     basic_istream<_CharT, _Traits>::
00132     operator>>(short& __n)
00133     {
00134       sentry __cerb(*this, false);
00135       if (__cerb) 
00136     {
00137       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00138       try 
00139         {
00140           long __l;
00141           _M_check_facet(this->_M_fnumget);
00142           const __numget_type& __ng = *this->_M_fnumget;
00143           __ng.get(*this, 0, *this, __err, __l);
00144           // _GLIBCXX_RESOLVE_LIB_DEFECTS
00145           // 118. basic_istream uses nonexistent num_get member functions.
00146           if (!(__err & ios_base::failbit)
00147           && (numeric_limits<short>::min() <= __l 
00148               && __l <= numeric_limits<short>::max()))
00149         __n = __l;
00150           else
00151                 __err |= ios_base::failbit;
00152         }
00153       catch(...)
00154         { this->_M_setstate(ios_base::badbit); }
00155       if (__err)
00156         this->setstate(__err);
00157     }
00158       return *this;
00159     }
00160 
00161   template<typename _CharT, typename _Traits>
00162     basic_istream<_CharT, _Traits>& 
00163     basic_istream<_CharT, _Traits>::
00164     operator>>(unsigned short& __n)
00165     {
00166       sentry __cerb(*this, false);
00167       if (__cerb) 
00168     {
00169       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00170       try 
00171         {
00172           _M_check_facet(this->_M_fnumget);
00173           const __numget_type& __ng = *this->_M_fnumget;
00174           __ng.get(*this, 0, *this, __err, __n);
00175         }
00176       catch(...)
00177         { this->_M_setstate(ios_base::badbit); }
00178       if (__err)
00179         this->setstate(__err);
00180     }
00181       return *this;
00182     }
00183 
00184   template<typename _CharT, typename _Traits>
00185     basic_istream<_CharT, _Traits>& 
00186     basic_istream<_CharT, _Traits>::
00187     operator>>(int& __n)
00188     {
00189       sentry __cerb(*this, false);
00190       if (__cerb) 
00191     {
00192       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00193       try 
00194         {
00195           long __l;
00196           _M_check_facet(this->_M_fnumget);
00197           const __numget_type& __ng = *this->_M_fnumget;
00198           __ng.get(*this, 0, *this, __err, __l);
00199           // _GLIBCXX_RESOLVE_LIB_DEFECTS
00200           // 118. basic_istream uses nonexistent num_get member functions.
00201           if (!(__err & ios_base::failbit)
00202           && (numeric_limits<int>::min() <= __l 
00203               && __l <= numeric_limits<int>::max()))
00204         __n = __l;
00205           else
00206                 __err |= ios_base::failbit;
00207         }
00208       catch(...)
00209         { this->_M_setstate(ios_base::badbit); }
00210       if (__err)
00211         this->setstate(__err);
00212     }
00213       return *this;
00214     }
00215 
00216   template<typename _CharT, typename _Traits>
00217     basic_istream<_CharT, _Traits>& 
00218     basic_istream<_CharT, _Traits>::
00219     operator>>(unsigned int& __n)
00220     {
00221       sentry __cerb(*this, false);
00222       if (__cerb) 
00223     {
00224       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00225       try 
00226         {
00227           _M_check_facet(this->_M_fnumget);
00228           const __numget_type& __ng = *this->_M_fnumget;
00229           __ng.get(*this, 0, *this, __err, __n);
00230         }
00231       catch(...)
00232         { this->_M_setstate(ios_base::badbit); }
00233       if (__err)
00234         this->setstate(__err);
00235     }
00236       return *this;
00237     }
00238 
00239   template<typename _CharT, typename _Traits>
00240     basic_istream<_CharT, _Traits>& 
00241     basic_istream<_CharT, _Traits>::
00242     operator>>(long& __n)
00243     {
00244       sentry __cerb(*this, false);
00245       if (__cerb) 
00246     {
00247       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00248       try 
00249         {
00250           _M_check_facet(this->_M_fnumget);
00251           const __numget_type& __ng = *this->_M_fnumget;
00252           __ng.get(*this, 0, *this, __err, __n);
00253         }
00254       catch(...)
00255         { this->_M_setstate(ios_base::badbit); }
00256       if (__err)
00257         this->setstate(__err);
00258     }
00259       return *this;
00260     }
00261 
00262   template<typename _CharT, typename _Traits>
00263     basic_istream<_CharT, _Traits>& 
00264     basic_istream<_CharT, _Traits>::
00265     operator>>(unsigned long& __n)
00266     {
00267       sentry __cerb(*this, false);
00268       if (__cerb) 
00269     {
00270       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00271       try 
00272         {
00273           _M_check_facet(this->_M_fnumget);
00274           const __numget_type& __ng = *this->_M_fnumget;
00275           __ng.get(*this, 0, *this, __err, __n);
00276         }
00277       catch(...)
00278         { this->_M_setstate(ios_base::badbit); }
00279       if (__err)
00280         this->setstate(__err);
00281     }
00282       return *this;
00283     }
00284 
00285 #ifdef _GLIBCPP_USE_LONG_LONG
00286   template<typename _CharT, typename _Traits>
00287     basic_istream<_CharT, _Traits>& 
00288     basic_istream<_CharT, _Traits>::
00289     operator>>(long long& __n)
00290     {
00291       sentry __cerb(*this, false);
00292       if (__cerb) 
00293     {
00294       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00295       try 
00296         {
00297           _M_check_facet(this->_M_fnumget);
00298           const __numget_type& __ng = *this->_M_fnumget;
00299           __ng.get(*this, 0, *this, __err, __n);
00300         }
00301       catch(...)
00302         { this->_M_setstate(ios_base::badbit); }
00303       if (__err)
00304         this->setstate(__err);
00305     }
00306       return *this;
00307     }
00308 
00309   template<typename _CharT, typename _Traits>
00310     basic_istream<_CharT, _Traits>& 
00311     basic_istream<_CharT, _Traits>::
00312     operator>>(unsigned long long& __n)
00313     {
00314       sentry __cerb(*this, false);
00315       if (__cerb) 
00316     {
00317       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00318       try 
00319         {
00320           _M_check_facet(this->_M_fnumget);
00321           const __numget_type& __ng = *this->_M_fnumget;
00322           __ng.get(*this, 0, *this, __err, __n);
00323         }
00324       catch(...)
00325         { this->_M_setstate(ios_base::badbit); }
00326       if (__err)
00327         this->setstate(__err);
00328     }
00329       return *this;
00330     }
00331 #endif
00332 
00333   template<typename _CharT, typename _Traits>
00334     basic_istream<_CharT, _Traits>& 
00335     basic_istream<_CharT, _Traits>::
00336     operator>>(float& __n)
00337     {
00338       sentry __cerb(*this, false);
00339       if (__cerb) 
00340     {
00341       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00342       try 
00343         {
00344           _M_check_facet(this->_M_fnumget);
00345           const __numget_type& __ng = *this->_M_fnumget;
00346           __ng.get(*this, 0, *this, __err, __n);
00347         }
00348       catch(...)
00349         { this->_M_setstate(ios_base::badbit); }
00350       if (__err)
00351         this->setstate(__err);
00352     }
00353       return *this;
00354     }
00355 
00356   template<typename _CharT, typename _Traits>
00357     basic_istream<_CharT, _Traits>& 
00358     basic_istream<_CharT, _Traits>::
00359     operator>>(double& __n)
00360     {
00361       sentry __cerb(*this, false);
00362       if (__cerb) 
00363     {
00364       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00365       try 
00366         {
00367           _M_check_facet(this->_M_fnumget);
00368           const __numget_type& __ng = *this->_M_fnumget;
00369           __ng.get(*this, 0, *this, __err, __n);
00370         }
00371       catch(...)
00372         { this->_M_setstate(ios_base::badbit); }
00373       if (__err)
00374         this->setstate(__err);
00375     }
00376       return *this;
00377     }
00378 
00379   template<typename _CharT, typename _Traits>
00380     basic_istream<_CharT, _Traits>& 
00381     basic_istream<_CharT, _Traits>::
00382     operator>>(long double& __n)
00383     {
00384       sentry __cerb(*this, false);
00385       if (__cerb) 
00386     {
00387       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00388       try 
00389         {
00390           _M_check_facet(this->_M_fnumget);
00391           const __numget_type& __ng = *this->_M_fnumget;
00392           __ng.get(*this, 0, *this, __err, __n);
00393         }
00394       catch(...)
00395         { this->_M_setstate(ios_base::badbit); }
00396       if (__err)
00397         this->setstate(__err);
00398     }
00399       return *this;
00400     }
00401 
00402   template<typename _CharT, typename _Traits>
00403     basic_istream<_CharT, _Traits>& 
00404     basic_istream<_CharT, _Traits>::
00405     operator>>(void*& __n)
00406     {
00407       sentry __cerb(*this, false);
00408       if (__cerb) 
00409     {
00410       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00411       try 
00412         {
00413           _M_check_facet(this->_M_fnumget);
00414           const __numget_type& __ng = *this->_M_fnumget;
00415           __ng.get(*this, 0, *this, __err, __n);
00416         }
00417       catch(...)
00418         { this->_M_setstate(ios_base::badbit); }
00419       if (__err)
00420         this->setstate(__err);
00421     }
00422       return *this;
00423     }
00424 
00425   template<typename _CharT, typename _Traits>
00426     basic_istream<_CharT, _Traits>& 
00427     basic_istream<_CharT, _Traits>::
00428     operator>>(__streambuf_type* __sbout)
00429     {
00430       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00431       sentry __cerb(*this, false);
00432       if (__cerb && __sbout)
00433     {
00434       try
00435         {
00436           if (!__copy_streambufs(*this, this->rdbuf(), __sbout))
00437         __err |= ios_base::failbit;
00438         }
00439       catch(...)
00440         { this->_M_setstate(ios_base::failbit); }
00441     }
00442       else if (!__sbout)
00443     __err |= ios_base::failbit;
00444       if (__err)
00445     this->setstate(__err);
00446       return *this;
00447     }
00448 
00449   template<typename _CharT, typename _Traits>
00450     typename basic_istream<_CharT, _Traits>::int_type
00451     basic_istream<_CharT, _Traits>::
00452     get(void)
00453     {
00454       const int_type __eof = traits_type::eof();
00455       int_type __c = __eof;
00456       _M_gcount = 0;
00457       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00458       sentry __cerb(*this, true);
00459       if (__cerb) 
00460     {
00461       try 
00462         {
00463           __c = this->rdbuf()->sbumpc();
00464           // 27.6.1.1 paragraph 3
00465           if (!traits_type::eq_int_type(__c, __eof))
00466         _M_gcount = 1;
00467           else
00468         __err |= ios_base::eofbit;
00469         }
00470       catch(...)
00471         { this->_M_setstate(ios_base::badbit); }
00472     }
00473       if (!_M_gcount)
00474     __err |= ios_base::failbit;
00475       if (__err)
00476     this->setstate(__err);
00477       return __c;
00478     }
00479 
00480   template<typename _CharT, typename _Traits>
00481     basic_istream<_CharT, _Traits>&
00482     basic_istream<_CharT, _Traits>::
00483     get(char_type& __c)
00484     {
00485       _M_gcount = 0;
00486       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00487       sentry __cerb(*this, true);
00488       if (__cerb) 
00489     {
00490       try 
00491         {
00492           int_type __cb = this->rdbuf()->sbumpc();
00493           // 27.6.1.1 paragraph 3
00494           if (!traits_type::eq_int_type(__cb, traits_type::eof()))
00495         {
00496           _M_gcount = 1;
00497           __c = traits_type::to_char_type(__cb);
00498         }
00499           else
00500         __err |= ios_base::eofbit;
00501         }
00502       catch(...)
00503         { this->_M_setstate(ios_base::badbit); }
00504     }
00505       if (!_M_gcount)
00506     __err |= ios_base::failbit;
00507       if (__err)
00508     this->setstate(__err);
00509       return *this;
00510     }
00511 
00512   template<typename _CharT, typename _Traits>
00513     basic_istream<_CharT, _Traits>&
00514     basic_istream<_CharT, _Traits>::
00515     get(char_type* __s, streamsize __n, char_type __delim)
00516     {
00517       _M_gcount = 0;
00518       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00519       sentry __cerb(*this, true);
00520       if (__cerb) 
00521     {
00522       try 
00523         {
00524           const int_type __idelim = traits_type::to_int_type(__delim);
00525           const int_type __eof = traits_type::eof();
00526           __streambuf_type* __sb = this->rdbuf();
00527           int_type __c = __sb->sgetc(); 
00528           
00529           while (_M_gcount + 1 < __n 
00530              && !traits_type::eq_int_type(__c, __eof)
00531              && !traits_type::eq_int_type(__c, __idelim))
00532         {
00533           *__s++ = traits_type::to_char_type(__c);
00534           __c = __sb->snextc();
00535           ++_M_gcount;
00536         }
00537           if (traits_type::eq_int_type(__c, __eof))
00538         __err |= ios_base::eofbit;
00539         }
00540       catch(...)
00541         { this->_M_setstate(ios_base::badbit); }
00542     }
00543       *__s = char_type();
00544       if (!_M_gcount)
00545     __err |= ios_base::failbit;
00546       if (__err)
00547     this->setstate(__err);
00548       return *this;
00549     }
00550 
00551   template<typename _CharT, typename _Traits>
00552     basic_istream<_CharT, _Traits>&
00553     basic_istream<_CharT, _Traits>::
00554     get(__streambuf_type& __sb, char_type __delim)
00555     {
00556       _M_gcount = 0;
00557       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00558       sentry __cerb(*this, true);
00559       if (__cerb) 
00560     {
00561       try 
00562         {
00563           const int_type __idelim = traits_type::to_int_type(__delim);
00564           const int_type __eof = traits_type::eof();          
00565           __streambuf_type* __this_sb = this->rdbuf();
00566           int_type __c = __this_sb->sgetc();
00567           char_type __c2 = traits_type::to_char_type(__c);
00568           
00569           while (!traits_type::eq_int_type(__c, __eof) 
00570              && !traits_type::eq_int_type(__c, __idelim) 
00571              && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
00572         {
00573           ++_M_gcount;
00574           __c = __this_sb->snextc();
00575           __c2 = traits_type::to_char_type(__c);
00576         }
00577           if (traits_type::eq_int_type(__c, __eof))
00578         __err |= ios_base::eofbit;
00579         }
00580       catch(...)
00581         { this->_M_setstate(ios_base::badbit); }
00582     }
00583       if (!_M_gcount)
00584     __err |= ios_base::failbit;
00585       if (__err)
00586     this->setstate(__err);
00587       return *this;
00588     }
00589 
00590   template<typename _CharT, typename _Traits>
00591     basic_istream<_CharT, _Traits>&
00592     basic_istream<_CharT, _Traits>::
00593     getline(char_type* __s, streamsize __n, char_type __delim)
00594     {
00595       _M_gcount = 0;
00596       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00597       sentry __cerb(*this, true);
00598       if (__cerb) 
00599     {
00600           try 
00601         {
00602           const int_type __idelim = traits_type::to_int_type(__delim);
00603           const int_type __eof = traits_type::eof();
00604           __streambuf_type* __sb = this->rdbuf();
00605           int_type __c = __sb->sgetc();
00606         
00607           while (_M_gcount + 1 < __n 
00608              && !traits_type::eq_int_type(__c, __eof)
00609              && !traits_type::eq_int_type(__c, __idelim))
00610         {
00611           *__s++ = traits_type::to_char_type(__c);
00612           __c = __sb->snextc();
00613           ++_M_gcount;
00614         }
00615           if (traits_type::eq_int_type(__c, __eof))
00616         __err |= ios_base::eofbit;
00617           else
00618         {
00619           if (traits_type::eq_int_type(__c, __idelim))
00620             {
00621               __sb->sbumpc();
00622               ++_M_gcount;
00623             }
00624           else
00625             __err |= ios_base::failbit;
00626         }
00627         }
00628       catch(...)
00629         { this->_M_setstate(ios_base::badbit); }
00630     }
00631       *__s = char_type();
00632       if (!_M_gcount)
00633     __err |= ios_base::failbit;
00634       if (__err)
00635     this->setstate(__err);
00636       return *this;
00637     }
00638   
00639   template<typename _CharT, typename _Traits>
00640     basic_istream<_CharT, _Traits>&
00641     basic_istream<_CharT, _Traits>::
00642     ignore(streamsize __n, int_type __delim)
00643     {
00644       _M_gcount = 0;
00645       sentry __cerb(*this, true);
00646       if (__cerb && __n > 0) 
00647     {
00648       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00649       try 
00650         {
00651           const int_type __eof = traits_type::eof();
00652           __streambuf_type* __sb = this->rdbuf();
00653           int_type __c;
00654           
00655           __n = min(__n, numeric_limits<streamsize>::max());
00656           while (_M_gcount < __n  
00657              && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
00658         {
00659           ++_M_gcount;
00660           if (traits_type::eq_int_type(__c, __delim))
00661             break;
00662         }
00663           if (traits_type::eq_int_type(__c, __eof))
00664         __err |= ios_base::eofbit;
00665         }
00666       catch(...)
00667         { this->_M_setstate(ios_base::badbit); }
00668       if (__err)
00669         this->setstate(__err);
00670     }
00671       return *this;
00672     }
00673   
00674   template<typename _CharT, typename _Traits>
00675     typename basic_istream<_CharT, _Traits>::int_type
00676     basic_istream<_CharT, _Traits>::
00677     peek(void)
00678     {
00679       int_type __c = traits_type::eof();
00680       _M_gcount = 0;
00681       sentry __cerb(*this, true);
00682       if (__cerb)
00683     {
00684       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00685       try 
00686         {
00687           __c = this->rdbuf()->sgetc();
00688           if (traits_type::eq_int_type(__c, traits_type::eof()))
00689         __err |= ios_base::eofbit;
00690         }
00691       catch(...)
00692         { this->_M_setstate(ios_base::badbit); }
00693       if (__err)
00694         this->setstate(__err);
00695     } 
00696        return __c;
00697     }
00698 
00699   template<typename _CharT, typename _Traits>
00700     basic_istream<_CharT, _Traits>&
00701     basic_istream<_CharT, _Traits>::
00702     read(char_type* __s, streamsize __n)
00703     {
00704       _M_gcount = 0;
00705       sentry __cerb(*this, true);
00706       if (__cerb) 
00707     {
00708       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00709       try 
00710         {
00711           _M_gcount = this->rdbuf()->sgetn(__s, __n);
00712           if (_M_gcount != __n)
00713         __err |= (ios_base::eofbit | ios_base::failbit);
00714         }       
00715       catch(...)
00716         { this->_M_setstate(ios_base::badbit); }
00717       if (__err)
00718         this->setstate(__err);
00719     }
00720       return *this;
00721     }
00722   
00723   template<typename _CharT, typename _Traits>
00724     streamsize 
00725     basic_istream<_CharT, _Traits>::
00726     readsome(char_type* __s, streamsize __n)
00727     {
00728       _M_gcount = 0;
00729       sentry __cerb(*this, true);
00730       if (__cerb) 
00731     {
00732       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00733       try 
00734         {
00735           // Cannot compare int_type with streamsize generically.
00736           streamsize __num = this->rdbuf()->in_avail();
00737           if (__num >= 0)
00738         {
00739           __num = min(__num, __n);
00740           if (__num)
00741             _M_gcount = this->rdbuf()->sgetn(__s, __num);
00742         }
00743           else
00744         __err |= ios_base::eofbit;
00745         }
00746       catch(...)
00747         { this->_M_setstate(ios_base::badbit); }
00748       if (__err)
00749         this->setstate(__err);
00750     }
00751       return _M_gcount;
00752     }
00753       
00754   template<typename _CharT, typename _Traits>
00755     basic_istream<_CharT, _Traits>&
00756     basic_istream<_CharT, _Traits>::
00757     putback(char_type __c)
00758     {
00759 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00760 // 60. What is a formatted input function?
00761       _M_gcount = 0;
00762 #endif
00763       sentry __cerb(*this, true);
00764       if (__cerb) 
00765     {
00766       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00767       try 
00768         {
00769           const int_type __eof = traits_type::eof();
00770           __streambuf_type* __sb = this->rdbuf();
00771           if (!__sb 
00772           || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
00773         __err |= ios_base::badbit;
00774         }
00775       catch(...)
00776         { this->_M_setstate(ios_base::badbit); }
00777       if (__err)
00778         this->setstate(__err);
00779     }
00780       return *this;
00781     }
00782   
00783   template<typename _CharT, typename _Traits>
00784     basic_istream<_CharT, _Traits>&
00785     basic_istream<_CharT, _Traits>::
00786     unget(void)
00787     {
00788 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00789 // 60. What is a formatted input function?
00790       _M_gcount = 0;
00791 #endif
00792       sentry __cerb(*this, true);
00793       if (__cerb) 
00794     {
00795       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00796       try 
00797         {
00798           const int_type __eof = traits_type::eof();
00799           __streambuf_type* __sb = this->rdbuf();
00800           if (!__sb 
00801           || traits_type::eq_int_type(__sb->sungetc(), __eof))
00802         __err |= ios_base::badbit;
00803         }
00804       catch(...)
00805         { this->_M_setstate(ios_base::badbit); }
00806       if (__err)
00807         this->setstate(__err);
00808     }
00809       return *this;
00810     }
00811   
00812   template<typename _CharT, typename _Traits>
00813     int
00814     basic_istream<_CharT, _Traits>::
00815     sync(void)
00816     {
00817       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00818       // DR60.  Do not change _M_gcount.
00819       int __ret = -1;
00820       sentry __cerb(*this, true);
00821       if (__cerb) 
00822     {
00823       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00824       try 
00825         {
00826           __streambuf_type* __sb = this->rdbuf();
00827           if (__sb)
00828         {
00829           if (__sb->pubsync() == -1)
00830             __err |= ios_base::badbit;
00831           else 
00832             __ret = 0;
00833         }
00834         }
00835       catch(...)
00836         { this->_M_setstate(ios_base::badbit); }
00837       if (__err)
00838         this->setstate(__err);
00839     }
00840       return __ret;
00841     }
00842   
00843   template<typename _CharT, typename _Traits>
00844     typename basic_istream<_CharT, _Traits>::pos_type
00845     basic_istream<_CharT, _Traits>::
00846     tellg(void)
00847     {
00848       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00849       // DR60.  Do not change _M_gcount.
00850       pos_type __ret = pos_type(-1);
00851       try
00852     {
00853       if (!this->fail())
00854         __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
00855     }
00856       catch(...)
00857     { this->_M_setstate(ios_base::badbit); }
00858       return __ret;
00859     }
00860 
00861 
00862   template<typename _CharT, typename _Traits>
00863     basic_istream<_CharT, _Traits>&
00864     basic_istream<_CharT, _Traits>::
00865     seekg(pos_type __pos)
00866     {
00867       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00868       // DR60.  Do not change _M_gcount.
00869       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00870       try
00871     {
00872       if (!this->fail())
00873         {
00874           // 136.  seekp, seekg setting wrong streams?
00875           pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::in);
00876 
00877           // 129. Need error indication from seekp() and seekg()
00878           if (__p == pos_type(off_type(-1)))
00879         __err |= ios_base::failbit;
00880         }
00881     }
00882       catch(...)
00883     { this->_M_setstate(ios_base::badbit); }
00884       if (__err)
00885     this->setstate(__err);
00886       return *this;
00887     }
00888 
00889   template<typename _CharT, typename _Traits>
00890     basic_istream<_CharT, _Traits>&
00891     basic_istream<_CharT, _Traits>::
00892     seekg(off_type __off, ios_base::seekdir __dir)
00893     {
00894       // _GLIBCXX_RESOLVE_LIB_DEFECTS
00895       // DR60.  Do not change _M_gcount.
00896       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00897       try
00898     {
00899       if (!this->fail())
00900         {
00901           // 136.  seekp, seekg setting wrong streams?
00902           pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, 
00903                                ios_base::in);
00904           
00905           // 129. Need error indication from seekp() and seekg()
00906           if (__p == pos_type(off_type(-1)))
00907         __err |= ios_base::failbit;
00908         }
00909     }
00910       catch(...)
00911     { this->_M_setstate(ios_base::badbit); }
00912       if (__err)
00913     this->setstate(__err);
00914       return *this;
00915     }
00916 
00917   // 27.6.1.2.3 Character extraction templates
00918   template<typename _CharT, typename _Traits>
00919     basic_istream<_CharT, _Traits>&
00920     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
00921     {
00922       typedef basic_istream<_CharT, _Traits>        __istream_type;
00923       typename __istream_type::sentry __cerb(__in, false);
00924       if (__cerb)
00925     {
00926       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00927       try 
00928         {
00929           typename __istream_type::int_type __cb = __in.rdbuf()->sbumpc();
00930           if (!_Traits::eq_int_type(__cb, _Traits::eof()))
00931         __c = _Traits::to_char_type(__cb);
00932           else
00933         __err |= (ios_base::eofbit | ios_base::failbit);
00934         }
00935       catch(...)
00936         { __in._M_setstate(ios_base::badbit); }
00937       if (__err)
00938         __in.setstate(__err);
00939     }
00940       return __in;
00941     }
00942 
00943   template<typename _CharT, typename _Traits>
00944     basic_istream<_CharT, _Traits>&
00945     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
00946     {
00947       typedef basic_istream<_CharT, _Traits>        __istream_type;
00948       typedef typename __istream_type::__streambuf_type __streambuf_type;
00949       typedef typename _Traits::int_type        int_type;
00950       typedef _CharT                            char_type;
00951       typedef ctype<_CharT>                 __ctype_type;
00952 
00953       streamsize __extracted = 0;
00954       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00955       typename __istream_type::sentry __cerb(__in, false);
00956       if (__cerb)
00957     {
00958       try 
00959         {
00960           // Figure out how many characters to extract.
00961           streamsize __num = __in.width();
00962           if (__num <= 0)
00963         __num = numeric_limits<streamsize>::max();
00964           
00965           const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
00966           const int_type __eof = _Traits::eof();
00967           __streambuf_type* __sb = __in.rdbuf();
00968           int_type __c = __sb->sgetc();
00969           
00970           while (__extracted < __num - 1 
00971              && !_Traits::eq_int_type(__c, __eof)
00972              && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
00973         {
00974           *__s++ = _Traits::to_char_type(__c);
00975           ++__extracted;
00976           __c = __sb->snextc();
00977         }
00978           if (_Traits::eq_int_type(__c, __eof))
00979         __err |= ios_base::eofbit;
00980 
00981 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00982 //68.  Extractors for char* should store null at end
00983           *__s = char_type();
00984 #endif
00985           __in.width(0);
00986         }
00987       catch(...)
00988         { __in._M_setstate(ios_base::badbit); }
00989     }
00990       if (!__extracted)
00991     __err |= ios_base::failbit;
00992       if (__err)
00993     __in.setstate(__err);
00994       return __in;
00995     }
00996 
00997   // 27.6.1.4 Standard basic_istream manipulators
00998   template<typename _CharT, typename _Traits>
00999     basic_istream<_CharT,_Traits>& 
01000     ws(basic_istream<_CharT,_Traits>& __in)
01001     {
01002       typedef basic_istream<_CharT, _Traits>        __istream_type;
01003       typedef typename __istream_type::__streambuf_type __streambuf_type;
01004       typedef typename __istream_type::__ctype_type     __ctype_type;
01005       typedef typename __istream_type::int_type     __int_type;
01006 
01007       const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
01008       const __int_type __eof = _Traits::eof();        
01009       __streambuf_type* __sb = __in.rdbuf();
01010       __int_type __c = __sb->sgetc();
01011 
01012       while (!_Traits::eq_int_type(__c, __eof) 
01013          && __ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
01014     __c = __sb->snextc();
01015 
01016        if (_Traits::eq_int_type(__c, __eof))
01017      __in.setstate(ios_base::eofbit);
01018       return __in;
01019     }
01020 
01021   // 21.3.7.9 basic_string::getline and operators
01022   template<typename _CharT, typename _Traits, typename _Alloc>
01023     basic_istream<_CharT, _Traits>&
01024     operator>>(basic_istream<_CharT, _Traits>& __in,
01025            basic_string<_CharT, _Traits, _Alloc>& __str)
01026     {
01027       typedef basic_istream<_CharT, _Traits>        __istream_type;
01028       typedef typename __istream_type::int_type     __int_type;
01029       typedef typename __istream_type::__streambuf_type __streambuf_type;
01030       typedef typename __istream_type::__ctype_type     __ctype_type;
01031       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
01032       typedef typename __string_type::size_type     __size_type;
01033 
01034       __size_type __extracted = 0;
01035       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01036       typename __istream_type::sentry __cerb(__in, false);
01037       if (__cerb) 
01038     {
01039       try
01040         {
01041           __str.erase();
01042           streamsize __w = __in.width();
01043           __size_type __n;
01044           __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
01045           
01046           const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
01047           const __int_type __eof = _Traits::eof();
01048           __streambuf_type* __sb = __in.rdbuf();
01049           __int_type __c = __sb->sgetc();
01050           
01051           while (__extracted < __n 
01052              && !_Traits::eq_int_type(__c, __eof)
01053              && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
01054         {
01055           __str += _Traits::to_char_type(__c);
01056           ++__extracted;
01057           __c = __sb->snextc();
01058         }
01059           if (_Traits::eq_int_type(__c, __eof))
01060         __err |= ios_base::eofbit;
01061           __in.width(0);
01062         }
01063       catch(...)
01064         {
01065           // _GLIBCXX_RESOLVE_LIB_DEFECTS
01066           // 91. Description of operator>> and getline() for string<>
01067           // might cause endless loop
01068           __in._M_setstate(ios_base::badbit);
01069         }
01070     }
01071       // 211.  operator>>(istream&, string&) doesn't set failbit
01072       if (!__extracted)
01073     __err |= ios_base::failbit;
01074       if (__err)
01075     __in.setstate(__err);
01076       return __in;
01077     }
01078 
01079   template<typename _CharT, typename _Traits, typename _Alloc>
01080     basic_istream<_CharT, _Traits>&
01081     getline(basic_istream<_CharT, _Traits>& __in,
01082         basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
01083     {
01084       typedef basic_istream<_CharT, _Traits>        __istream_type;
01085       typedef typename __istream_type::int_type     __int_type;
01086       typedef typename __istream_type::__streambuf_type __streambuf_type;
01087       typedef typename __istream_type::__ctype_type     __ctype_type;
01088       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
01089       typedef typename __string_type::size_type     __size_type;
01090 
01091       __size_type __extracted = 0;
01092       const __size_type __n = __str.max_size();
01093       bool __testdelim = false;
01094       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01095       typename __istream_type::sentry __cerb(__in, true);
01096       if (__cerb) 
01097     {
01098       try
01099         {
01100           __str.erase();
01101           __int_type __idelim = _Traits::to_int_type(__delim);
01102           __streambuf_type* __sb = __in.rdbuf();
01103           __int_type __c = __sb->sbumpc();
01104           const __int_type __eof = _Traits::eof();
01105           __testdelim = _Traits::eq_int_type(__c, __idelim);
01106           
01107           while (!_Traits::eq_int_type(__c, __eof) && !__testdelim
01108              && __extracted < __n)
01109         {
01110           __str += _Traits::to_char_type(__c);
01111           ++__extracted;
01112           __c = __sb->sbumpc();
01113           __testdelim = _Traits::eq_int_type(__c, __idelim);
01114         }
01115           if (_Traits::eq_int_type(__c, __eof))
01116         __err |= ios_base::eofbit;
01117         }
01118       catch(...)
01119         {
01120           // _GLIBCXX_RESOLVE_LIB_DEFECTS
01121           // 91. Description of operator>> and getline() for string<>
01122           // might cause endless loop
01123           __in._M_setstate(ios_base::badbit);
01124         }
01125     }
01126       if ((!__extracted && !__testdelim) || __extracted == __n)
01127     __err |= ios_base::failbit;
01128       if (__err)
01129     __in.setstate(__err);
01130       return __in;
01131     }
01132 
01133   template<class _CharT, class _Traits, class _Alloc>
01134     inline basic_istream<_CharT,_Traits>&
01135     getline(basic_istream<_CharT, _Traits>& __in, 
01136         basic_string<_CharT,_Traits,_Alloc>& __str)
01137     { return getline(__in, __str, __in.widen('\n')); }
01138 
01139   // Inhibit implicit instantiations for required instantiations,
01140   // which are defined via explicit instantiations elsewhere.  
01141   // NB:  This syntax is a GNU extension.
01142 #if _GLIBCPP_EXTERN_TEMPLATE
01143   extern template class basic_istream<char>;
01144   extern template istream& ws(istream&);
01145   extern template istream& operator>>(istream&, char&);
01146   extern template istream& operator>>(istream&, char*);
01147   extern template istream& operator>>(istream&, unsigned char&);
01148   extern template istream& operator>>(istream&, signed char&);
01149   extern template istream& operator>>(istream&, unsigned char*);
01150   extern template istream& operator>>(istream&, signed char*);
01151 
01152 #ifdef _GLIBCPP_USE_WCHAR_T
01153   extern template class basic_istream<wchar_t>;
01154   extern template wistream& ws(wistream&);
01155   extern template wistream& operator>>(wistream&, wchar_t&);
01156   extern template wistream& operator>>(wistream&, wchar_t*);
01157 #endif
01158 #endif
01159 } // namespace std

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