Whole document tree
istream.tcc
Go to the documentation of this file.00001 // Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. 00002 // 00003 // This file is part of the GNU ISO C++ Library. This library is free 00004 // software; you can redistribute it and/or modify it under the 00005 // terms of the GNU General Public License as published by the 00006 // Free Software Foundation; either version 2, or (at your option) 00007 // any later version. 00008 00009 // This library is distributed in the hope that it will be useful, 00010 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00012 // GNU General Public License for more details. 00013 00014 // You should have received a copy of the GNU General Public License along 00015 // with this library; see the file COPYING. If not, write to the Free 00016 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 00017 // USA. 00018 00019 // As a special exception, you may use this file as part of a free software 00020 // library without restriction. Specifically, if other files instantiate 00021 // templates or use macros or inline functions from this file, or you compile 00022 // this file and link it with other files to produce an executable, this 00023 // file does not by itself cause the resulting executable to be covered by 00024 // the GNU General Public License. This exception does not however 00025 // invalidate any other reasons why the executable file might be covered by 00026 // the GNU General Public License. 00027 00028 // 00029 // ISO C++ 14882: 27.6.2 Output streams 00030 // 00031 00032 #include <bits/std_locale.h> 00033 #include <bits/std_ostream.h> // for flush() 00034 00035 namespace std 00036 { 00037 template<typename _CharT, typename _Traits> 00038 basic_istream<_CharT, _Traits>::sentry:: 00039 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws) 00040 { 00041 if (__in.good()) 00042 { 00043 if (__in.tie()) 00044 __in.tie()->flush(); 00045 if (!__noskipws && (__in.flags() & ios_base::skipws)) 00046 { 00047 const __int_type __eof = traits_type::eof(); 00048 const __ctype_type* __ctype = __in._M_get_fctype_ios(); 00049 __streambuf_type* __sb = __in.rdbuf(); 00050 __int_type __c = __sb->sgetc(); 00051 00052 while (__c != __eof && __ctype->is(ctype_base::space, __c)) 00053 __c = __sb->snextc(); 00054 00055 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 00056 //195. Should basic_istream::sentry's constructor ever set eofbit? 00057 if (__c == __eof) 00058 __in.setstate(ios_base::eofbit); 00059 #endif 00060 } 00061 } 00062 00063 if (__in.good()) 00064 _M_ok = true; 00065 else 00066 { 00067 _M_ok = false; 00068 __in.setstate(ios_base::failbit); 00069 } 00070 } 00071 00072 template<typename _CharT, typename _Traits> 00073 basic_istream<_CharT, _Traits>& 00074 basic_istream<_CharT, _Traits>:: 00075 operator>>(__istream_type& (*__pf)(__istream_type&)) 00076 { 00077 __pf(*this); 00078 return *this; 00079 } 00080 00081 template<typename _CharT, typename _Traits> 00082 basic_istream<_CharT, _Traits>& 00083 basic_istream<_CharT, _Traits>:: 00084 operator>>(__ios_type& (*__pf)(__ios_type&)) 00085 { 00086 __pf(*this); 00087 return *this; 00088 } 00089 00090 template<typename _CharT, typename _Traits> 00091 basic_istream<_CharT, _Traits>& 00092 basic_istream<_CharT, _Traits>:: 00093 operator>>(ios_base& (*__pf)(ios_base&)) 00094 { 00095 __pf(*this); 00096 return *this; 00097 } 00098 00099 template<typename _CharT, typename _Traits> 00100 basic_istream<_CharT, _Traits>& 00101 basic_istream<_CharT, _Traits>:: 00102 operator>>(bool& __n) 00103 { 00104 sentry __cerb(*this, false); 00105 if (__cerb) 00106 { 00107 try 00108 { 00109 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00110 if (_M_check_facet(_M_fnumget)) 00111 _M_fnumget->get(*this, 0, *this, __err, __n); 00112 this->setstate(__err); 00113 } 00114 catch(exception& __fail) 00115 { 00116 // 27.6.1.2.1 Common requirements. 00117 // Turn this on without causing an ios::failure to be thrown. 00118 this->setstate(ios_base::badbit); 00119 if ((this->exceptions() & ios_base::badbit) != 0) 00120 __throw_exception_again; 00121 } 00122 } 00123 return *this; 00124 } 00125 00126 template<typename _CharT, typename _Traits> 00127 basic_istream<_CharT, _Traits>& 00128 basic_istream<_CharT, _Traits>:: 00129 operator>>(short& __n) 00130 { 00131 sentry __cerb(*this, false); 00132 if (__cerb) 00133 { 00134 try 00135 { 00136 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00137 if (_M_check_facet(_M_fnumget)) 00138 _M_fnumget->get(*this, 0, *this, __err, __n); 00139 this->setstate(__err); 00140 } 00141 catch(exception& __fail) 00142 { 00143 // 27.6.1.2.1 Common requirements. 00144 // Turn this on without causing an ios::failure to be thrown. 00145 this->setstate(ios_base::badbit); 00146 if ((this->exceptions() & ios_base::badbit) != 0) 00147 __throw_exception_again; 00148 } 00149 } 00150 return *this; 00151 } 00152 00153 template<typename _CharT, typename _Traits> 00154 basic_istream<_CharT, _Traits>& 00155 basic_istream<_CharT, _Traits>:: 00156 operator>>(unsigned short& __n) 00157 { 00158 sentry __cerb(*this, false); 00159 if (__cerb) 00160 { 00161 try 00162 { 00163 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00164 if (_M_check_facet(_M_fnumget)) 00165 _M_fnumget->get(*this, 0, *this, __err, __n); 00166 this->setstate(__err); 00167 } 00168 catch(exception& __fail) 00169 { 00170 // 27.6.1.2.1 Common requirements. 00171 // Turn this on without causing an ios::failure to be thrown. 00172 this->setstate(ios_base::badbit); 00173 if ((this->exceptions() & ios_base::badbit) != 0) 00174 __throw_exception_again; 00175 } 00176 } 00177 return *this; 00178 } 00179 00180 template<typename _CharT, typename _Traits> 00181 basic_istream<_CharT, _Traits>& 00182 basic_istream<_CharT, _Traits>:: 00183 operator>>(int& __n) 00184 { 00185 sentry __cerb(*this, false); 00186 if (__cerb) 00187 { 00188 try 00189 { 00190 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00191 if (_M_check_facet(_M_fnumget)) 00192 _M_fnumget->get(*this, 0, *this, __err, __n); 00193 this->setstate(__err); 00194 } 00195 catch(exception& __fail) 00196 { 00197 // 27.6.1.2.1 Common requirements. 00198 // Turn this on without causing an ios::failure to be thrown. 00199 this->setstate(ios_base::badbit); 00200 if ((this->exceptions() & ios_base::badbit) != 0) 00201 __throw_exception_again; 00202 } 00203 } 00204 return *this; 00205 } 00206 00207 template<typename _CharT, typename _Traits> 00208 basic_istream<_CharT, _Traits>& 00209 basic_istream<_CharT, _Traits>:: 00210 operator>>(unsigned int& __n) 00211 { 00212 sentry __cerb(*this, false); 00213 if (__cerb) 00214 { 00215 try 00216 { 00217 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00218 if (_M_check_facet(_M_fnumget)) 00219 _M_fnumget->get(*this, 0, *this, __err, __n); 00220 this->setstate(__err); 00221 } 00222 catch(exception& __fail) 00223 { 00224 // 27.6.1.2.1 Common requirements. 00225 // Turn this on without causing an ios::failure to be thrown. 00226 this->setstate(ios_base::badbit); 00227 if ((this->exceptions() & ios_base::badbit) != 0) 00228 __throw_exception_again; 00229 } 00230 } 00231 return *this; 00232 } 00233 00234 template<typename _CharT, typename _Traits> 00235 basic_istream<_CharT, _Traits>& 00236 basic_istream<_CharT, _Traits>:: 00237 operator>>(long& __n) 00238 { 00239 sentry __cerb(*this, false); 00240 if (__cerb) 00241 { 00242 try 00243 { 00244 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00245 if (_M_check_facet(_M_fnumget)) 00246 _M_fnumget->get(*this, 0, *this, __err, __n); 00247 this->setstate(__err); 00248 } 00249 catch(exception& __fail) 00250 { 00251 // 27.6.1.2.1 Common requirements. 00252 // Turn this on without causing an ios::failure to be thrown. 00253 this->setstate(ios_base::badbit); 00254 if ((this->exceptions() & ios_base::badbit) != 0) 00255 __throw_exception_again; 00256 } 00257 } 00258 return *this; 00259 } 00260 00261 template<typename _CharT, typename _Traits> 00262 basic_istream<_CharT, _Traits>& 00263 basic_istream<_CharT, _Traits>:: 00264 operator>>(unsigned long& __n) 00265 { 00266 sentry __cerb(*this, false); 00267 if (__cerb) 00268 { 00269 try 00270 { 00271 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00272 if (_M_check_facet(_M_fnumget)) 00273 _M_fnumget->get(*this, 0, *this, __err, __n); 00274 this->setstate(__err); 00275 } 00276 catch(exception& __fail) 00277 { 00278 // 27.6.1.2.1 Common requirements. 00279 // Turn this on without causing an ios::failure to be thrown. 00280 this->setstate(ios_base::badbit); 00281 if ((this->exceptions() & ios_base::badbit) != 0) 00282 __throw_exception_again; 00283 } 00284 } 00285 return *this; 00286 } 00287 00288 #ifdef _GLIBCPP_USE_LONG_LONG 00289 template<typename _CharT, typename _Traits> 00290 basic_istream<_CharT, _Traits>& 00291 basic_istream<_CharT, _Traits>:: 00292 operator>>(long long& __n) 00293 { 00294 sentry __cerb(*this, false); 00295 if (__cerb) 00296 { 00297 try 00298 { 00299 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00300 if (_M_check_facet(_M_fnumget)) 00301 _M_fnumget->get(*this, 0, *this, __err, __n); 00302 this->setstate(__err); 00303 } 00304 catch(exception& __fail) 00305 { 00306 // 27.6.1.2.1 Common requirements. 00307 // Turn this on without causing an ios::failure to be thrown. 00308 this->setstate(ios_base::badbit); 00309 if ((this->exceptions() & ios_base::badbit) != 0) 00310 __throw_exception_again; 00311 } 00312 } 00313 return *this; 00314 } 00315 00316 template<typename _CharT, typename _Traits> 00317 basic_istream<_CharT, _Traits>& 00318 basic_istream<_CharT, _Traits>:: 00319 operator>>(unsigned long long& __n) 00320 { 00321 sentry __cerb(*this, false); 00322 if (__cerb) 00323 { 00324 try 00325 { 00326 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00327 if (_M_check_facet(_M_fnumget)) 00328 _M_fnumget->get(*this, 0, *this, __err, __n); 00329 this->setstate(__err); 00330 } 00331 catch(exception& __fail) 00332 { 00333 // 27.6.1.2.1 Common requirements. 00334 // Turn this on without causing an ios::failure to be thrown. 00335 this->setstate(ios_base::badbit); 00336 if ((this->exceptions() & ios_base::badbit) != 0) 00337 __throw_exception_again; 00338 } 00339 } 00340 return *this; 00341 } 00342 #endif 00343 00344 template<typename _CharT, typename _Traits> 00345 basic_istream<_CharT, _Traits>& 00346 basic_istream<_CharT, _Traits>:: 00347 operator>>(float& __n) 00348 { 00349 sentry __cerb(*this, false); 00350 if (__cerb) 00351 { 00352 try 00353 { 00354 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00355 if (_M_check_facet(_M_fnumget)) 00356 _M_fnumget->get(*this, 0, *this, __err, __n); 00357 this->setstate(__err); 00358 } 00359 catch(exception& __fail) 00360 { 00361 // 27.6.1.2.1 Common requirements. 00362 // Turn this on without causing an ios::failure to be thrown. 00363 this->setstate(ios_base::badbit); 00364 if ((this->exceptions() & ios_base::badbit) != 0) 00365 __throw_exception_again; 00366 } 00367 } 00368 return *this; 00369 } 00370 00371 template<typename _CharT, typename _Traits> 00372 basic_istream<_CharT, _Traits>& 00373 basic_istream<_CharT, _Traits>:: 00374 operator>>(double& __n) 00375 { 00376 sentry __cerb(*this, false); 00377 if (__cerb) 00378 { 00379 try 00380 { 00381 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00382 if (_M_check_facet(_M_fnumget)) 00383 _M_fnumget->get(*this, 0, *this, __err, __n); 00384 this->setstate(__err); 00385 } 00386 catch(exception& __fail) 00387 { 00388 // 27.6.1.2.1 Common requirements. 00389 // Turn this on without causing an ios::failure to be thrown. 00390 this->setstate(ios_base::badbit); 00391 if ((this->exceptions() & ios_base::badbit) != 0) 00392 __throw_exception_again; 00393 } 00394 } 00395 return *this; 00396 } 00397 00398 template<typename _CharT, typename _Traits> 00399 basic_istream<_CharT, _Traits>& 00400 basic_istream<_CharT, _Traits>:: 00401 operator>>(long double& __n) 00402 { 00403 sentry __cerb(*this, false); 00404 if (__cerb) 00405 { 00406 try 00407 { 00408 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00409 if (_M_check_facet(_M_fnumget)) 00410 _M_fnumget->get(*this, 0, *this, __err, __n); 00411 this->setstate(__err); 00412 } 00413 catch(exception& __fail) 00414 { 00415 // 27.6.1.2.1 Common requirements. 00416 // Turn this on without causing an ios::failure to be thrown. 00417 this->setstate(ios_base::badbit); 00418 if ((this->exceptions() & ios_base::badbit) != 0) 00419 __throw_exception_again; 00420 } 00421 } 00422 return *this; 00423 } 00424 00425 template<typename _CharT, typename _Traits> 00426 basic_istream<_CharT, _Traits>& 00427 basic_istream<_CharT, _Traits>:: 00428 operator>>(void*& __n) 00429 { 00430 sentry __cerb(*this, false); 00431 if (__cerb) 00432 { 00433 try 00434 { 00435 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 00436 if (_M_check_facet(_M_fnumget)) 00437 _M_fnumget->get(*this, 0, *this, __err, __n); 00438 this->setstate(__err); 00439 } 00440 catch(exception& __fail) 00441 { 00442 // 27.6.1.2.1 Common requirements. 00443 // Turn this on without causing an ios::failure to be thrown. 00444 this->setstate(ios_base::badbit); 00445 if ((this->exceptions() & ios_base::badbit) != 0) 00446 __throw_exception_again; 00447 } 00448 } 00449 return *this; 00450 } 00451 00452 template<typename _CharT, typename _Traits> 00453 basic_istream<_CharT, _Traits>& 00454 basic_istream<_CharT, _Traits>:: 00455 operator>>(__streambuf_type* __sbout) 00456 { 00457 streamsize __xtrct = 0; 00458 __streambuf_type* __sbin = this->rdbuf(); 00459 sentry __cerb(*this, false); 00460 if (__sbout && __cerb) 00461 __xtrct = __copy_streambufs(*this, __sbin, __sbout); 00462 if (!__sbout || !__xtrct) 00463 this->setstate(ios_base::failbit); 00464 return *this; 00465 } 00466 00467 template<typename _CharT, typename _Traits> 00468 typename basic_istream<_CharT, _Traits>::int_type 00469 basic_istream<_CharT, _Traits>:: 00470 get(void) 00471 { 00472 const int_type __eof = traits_type::eof(); 00473 int_type __c = __eof; 00474 _M_gcount = 0; 00475 sentry __cerb(*this, true); 00476 if (__cerb) 00477 { 00478 try 00479 { 00480 __c = this->rdbuf()->sbumpc(); 00481 // 27.6.1.1 paragraph 3 00482 if (__c != __eof) 00483 _M_gcount = 1; 00484 else 00485 this->setstate(ios_base::eofbit | ios_base::failbit); 00486 } 00487 catch(exception& __fail) 00488 { 00489 // 27.6.1.3 paragraph 1 00490 // Turn this on without causing an ios::failure to be thrown. 00491 this->setstate(ios_base::badbit); 00492 if ((this->exceptions() & ios_base::badbit) != 0) 00493 __throw_exception_again; 00494 } 00495 } 00496 return __c; 00497 } 00498 00499 template<typename _CharT, typename _Traits> 00500 basic_istream<_CharT, _Traits>& 00501 basic_istream<_CharT, _Traits>:: 00502 get(char_type& __c) 00503 { 00504 _M_gcount = 0; 00505 sentry __cerb(*this, true); 00506 if (__cerb) 00507 { 00508 try 00509 { 00510 const int_type __eof = traits_type::eof(); 00511 int_type __bufval = this->rdbuf()->sbumpc(); 00512 // 27.6.1.1 paragraph 3 00513 if (__bufval != __eof) 00514 { 00515 _M_gcount = 1; 00516 __c = traits_type::to_char_type(__bufval); 00517 } 00518 else 00519 this->setstate(ios_base::eofbit | ios_base::failbit); 00520 } 00521 catch(exception& __fail) 00522 { 00523 // 27.6.1.3 paragraph 1 00524 // Turn this on without causing an ios::failure to be thrown. 00525 this->setstate(ios_base::badbit); 00526 if ((this->exceptions() & ios_base::badbit) != 0) 00527 __throw_exception_again; 00528 } 00529 } 00530 return *this; 00531 } 00532 00533 template<typename _CharT, typename _Traits> 00534 basic_istream<_CharT, _Traits>& 00535 basic_istream<_CharT, _Traits>:: 00536 get(char_type* __s, streamsize __n, char_type __delim) 00537 { 00538 _M_gcount = 0; 00539 sentry __cerb(*this, true); 00540 if (__cerb && __n > 1) 00541 { 00542 try 00543 { 00544 const int_type __idelim = traits_type::to_int_type(__delim); 00545 const int_type __eof = traits_type::eof(); 00546 __streambuf_type* __sb = this->rdbuf(); 00547 int_type __c = __sb->sbumpc(); 00548 bool __testdelim = __c == __idelim; 00549 bool __testeof = __c == __eof; 00550 00551 while (_M_gcount < __n - 1 && !__testeof && !__testdelim) 00552 { 00553 *__s++ = traits_type::to_char_type(__c); 00554 ++_M_gcount; 00555 __c = __sb->sbumpc(); 00556 __testeof = __c == __eof; 00557 __testdelim = __c == __idelim; 00558 } 00559 if (__testdelim || _M_gcount == __n - 1) 00560 __sb->sputbackc(__c); 00561 if (__testeof) 00562 this->setstate(ios_base::eofbit); 00563 } 00564 catch(exception& __fail) 00565 { 00566 // 27.6.1.3 paragraph 1 00567 // Turn this on without causing an ios::failure to be thrown. 00568 this->setstate(ios_base::badbit); 00569 if ((this->exceptions() & ios_base::badbit) != 0) 00570 __throw_exception_again; 00571 } 00572 } 00573 *__s = char_type(); 00574 if (!_M_gcount) 00575 this->setstate(ios_base::failbit); 00576 return *this; 00577 } 00578 00579 template<typename _CharT, typename _Traits> 00580 basic_istream<_CharT, _Traits>& 00581 basic_istream<_CharT, _Traits>:: 00582 get(__streambuf_type& __sb, char_type __delim) 00583 { 00584 _M_gcount = 0; 00585 sentry __cerb(*this, true); 00586 if (__cerb) 00587 { 00588 int_type __c; 00589 __streambuf_type* __this_sb = this->rdbuf(); 00590 try 00591 { 00592 const int_type __idelim = traits_type::to_int_type(__delim); 00593 const int_type __eof = traits_type::eof(); 00594 __c = __this_sb->sbumpc(); 00595 bool __testdelim = __c == __idelim; 00596 bool __testeof = __c == __eof; 00597 bool __testput = true; 00598 00599 while (!__testeof && !__testdelim 00600 && (__testput = __sb.sputc(traits_type::to_char_type(__c)) 00601 != __eof)) 00602 { 00603 ++_M_gcount; 00604 __c = __this_sb->sbumpc(); 00605 __testeof = __c == __eof; 00606 __testdelim = __c == __idelim; 00607 } 00608 if (__testdelim || !__testput) 00609 __this_sb->sputbackc(traits_type::to_char_type(__c)); 00610 if (__testeof) 00611 this->setstate(ios_base::eofbit); 00612 } 00613 catch(exception& __fail) 00614 { 00615 // Exception may result from sputc->overflow. 00616 __this_sb->sputbackc(traits_type::to_char_type(__c)); 00617 } 00618 } 00619 if (!_M_gcount) 00620 this->setstate(ios_base::failbit); 00621 return *this; 00622 } 00623 00624 template<typename _CharT, typename _Traits> 00625 basic_istream<_CharT, _Traits>& 00626 basic_istream<_CharT, _Traits>:: 00627 getline(char_type* __s, streamsize __n, char_type __delim) 00628 { 00629 _M_gcount = 0; 00630 sentry __cerb(*this, true); 00631 if (__cerb) 00632 { 00633 try 00634 { 00635 __streambuf_type* __sb = this->rdbuf(); 00636 int_type __c = __sb->sbumpc(); 00637 ++_M_gcount; 00638 const int_type __idelim = traits_type::to_int_type(__delim); 00639 const int_type __eof = traits_type::eof(); 00640 bool __testdelim = __c == __idelim; 00641 bool __testeof = __c == __eof; 00642 00643 while (_M_gcount < __n && !__testeof && !__testdelim) 00644 { 00645 *__s++ = traits_type::to_char_type(__c); 00646 __c = __sb->sbumpc(); 00647 ++_M_gcount; 00648 __testeof = __c == __eof; 00649 __testdelim = __c == __idelim; 00650 } 00651 00652 if (__testeof) 00653 { 00654 --_M_gcount; 00655 this->setstate(ios_base::eofbit); 00656 } 00657 else if (!__testdelim) 00658 { 00659 --_M_gcount; 00660 __sb->sputbackc(traits_type::to_char_type(__c)); 00661 this->setstate(ios_base::failbit); 00662 } 00663 } 00664 catch(exception& __fail) 00665 { 00666 // 27.6.1.3 paragraph 1 00667 // Turn this on without causing an ios::failure to be thrown. 00668 this->setstate(ios_base::badbit); 00669 if ((this->exceptions() & ios_base::badbit) != 0) 00670 __throw_exception_again; 00671 } 00672 } 00673 *__s = char_type(); 00674 if (!_M_gcount) 00675 this->setstate(ios_base::failbit); 00676 return *this; 00677 } 00678 00679 template<typename _CharT, typename _Traits> 00680 basic_istream<_CharT, _Traits>& 00681 basic_istream<_CharT, _Traits>:: 00682 ignore(streamsize __n, int_type __delim) 00683 { 00684 _M_gcount = 0; 00685 sentry __cerb(*this, true); 00686 if (__cerb && __n > 0) 00687 { 00688 try 00689 { 00690 const int_type __idelim = traits_type::to_int_type(__delim); 00691 const int_type __eof = traits_type::eof(); 00692 __streambuf_type* __sb = this->rdbuf(); 00693 int_type __c = __sb->sbumpc(); 00694 bool __testdelim = __c == __idelim; 00695 bool __testeof = __c == __eof; 00696 00697 __n = min(__n, numeric_limits<streamsize>::max()); 00698 while (_M_gcount < __n - 1 && !__testeof && !__testdelim) 00699 { 00700 ++_M_gcount; 00701 __c = __sb->sbumpc(); 00702 __testeof = __c == __eof; 00703 __testdelim = __c == __idelim; 00704 } 00705 if ((_M_gcount == __n - 1 && !__testeof) || __testdelim) 00706 ++_M_gcount; 00707 if (__testeof) 00708 this->setstate(ios_base::eofbit); 00709 } 00710 catch(exception& __fail) 00711 { 00712 // 27.6.1.3 paragraph 1 00713 // Turn this on without causing an ios::failure to be thrown. 00714 this->setstate(ios_base::badbit); 00715 if ((this->exceptions() & ios_base::badbit) != 0) 00716 __throw_exception_again; 00717 } 00718 } 00719 return *this; 00720 } 00721 00722 template<typename _CharT, typename _Traits> 00723 typename basic_istream<_CharT, _Traits>::int_type 00724 basic_istream<_CharT, _Traits>:: 00725 peek(void) 00726 { 00727 int_type __c = traits_type::eof(); 00728 _M_gcount = 0; 00729 sentry __cerb(*this, true); 00730 if (__cerb) 00731 { 00732 try 00733 { __c = this->rdbuf()->sgetc(); } 00734 catch(exception& __fail) 00735 { 00736 // 27.6.1.3 paragraph 1 00737 // Turn this on without causing an ios::failure to be thrown. 00738 this->setstate(ios_base::badbit); 00739 if ((this->exceptions() & ios_base::badbit) != 0) 00740 __throw_exception_again; 00741 } 00742 } 00743 return __c; 00744 } 00745 00746 template<typename _CharT, typename _Traits> 00747 basic_istream<_CharT, _Traits>& 00748 basic_istream<_CharT, _Traits>:: 00749 read(char_type* __s, streamsize __n) 00750 { 00751 _M_gcount = 0; 00752 sentry __cerb(*this, true); 00753 if (__cerb) 00754 { 00755 if (__n > 0) 00756 { 00757 try 00758 { 00759 const int_type __eof = traits_type::eof(); 00760 __streambuf_type* __sb = this->rdbuf(); 00761 int_type __c = __sb->sbumpc(); 00762 bool __testeof = __c == __eof; 00763 00764 while (_M_gcount < __n - 1 && !__testeof) 00765 { 00766 *__s++ = traits_type::to_char_type(__c); 00767 ++_M_gcount; 00768 __c = __sb->sbumpc(); 00769 __testeof = __c == __eof; 00770 } 00771 if (__testeof) 00772 this->setstate(ios_base::eofbit | ios_base::failbit); 00773 else 00774 { 00775 // _M_gcount == __n - 1 00776 *__s++ = traits_type::to_char_type(__c); 00777 ++_M_gcount; 00778 } 00779 } 00780 catch(exception& __fail) 00781 { 00782 // 27.6.1.3 paragraph 1 00783 // Turn this on without causing an ios::failure to be thrown. 00784 this->setstate(ios_base::badbit); 00785 if ((this->exceptions() & ios_base::badbit) != 0) 00786 __throw_exception_again; 00787 } 00788 } 00789 } 00790 else 00791 this->setstate(ios_base::failbit); 00792 return *this; 00793 } 00794 00795 template<typename _CharT, typename _Traits> 00796 streamsize 00797 basic_istream<_CharT, _Traits>:: 00798 readsome(char_type* __s, streamsize __n) 00799 { 00800 const int_type __eof = traits_type::eof(); 00801 _M_gcount = 0; 00802 sentry __cerb(*this, true); 00803 if (__cerb) 00804 { 00805 if (__n > 0) 00806 { 00807 try 00808 { 00809 streamsize __num = this->rdbuf()->in_avail(); 00810 if (__num != static_cast<streamsize>(__eof)) 00811 { 00812 __num = min(__num, __n); 00813 _M_gcount = this->rdbuf()->sgetn(__s, __num); 00814 } 00815 else 00816 this->setstate(ios_base::eofbit); 00817 } 00818 catch(exception& __fail) 00819 { 00820 // 27.6.1.3 paragraph 1 00821 // Turn this on without causing an ios::failure to be thrown. 00822 this->setstate(ios_base::badbit); 00823 if ((this->exceptions() & ios_base::badbit) != 0) 00824 __throw_exception_again; 00825 } 00826 } 00827 } 00828 else 00829 this->setstate(ios_base::failbit); 00830 return _M_gcount; 00831 } 00832 00833 template<typename _CharT, typename _Traits> 00834 basic_istream<_CharT, _Traits>& 00835 basic_istream<_CharT, _Traits>:: 00836 putback(char_type __c) 00837 { 00838 sentry __cerb(*this, true); 00839 if (__cerb) 00840 { 00841 try 00842 { 00843 const int_type __eof = traits_type::eof(); 00844 __streambuf_type* __sb = this->rdbuf(); 00845 if (!__sb || __sb->sputbackc(__c) == __eof) 00846 this->setstate(ios_base::badbit); 00847 } 00848 catch(exception& __fail) 00849 { 00850 // 27.6.1.3 paragraph 1 00851 // Turn this on without causing an ios::failure to be thrown. 00852 this->setstate(ios_base::badbit); 00853 if ((this->exceptions() & ios_base::badbit) != 0) 00854 __throw_exception_again; 00855 } 00856 } 00857 else 00858 this->setstate(ios_base::failbit); 00859 return *this; 00860 } 00861 00862 template<typename _CharT, typename _Traits> 00863 basic_istream<_CharT, _Traits>& 00864 basic_istream<_CharT, _Traits>:: 00865 unget(void) 00866 { 00867 _M_gcount = 0; 00868 sentry __cerb(*this, true); 00869 if (__cerb) 00870 { 00871 try 00872 { 00873 const int_type __eof = traits_type::eof(); 00874 __streambuf_type* __sb = this->rdbuf(); 00875 if (!__sb || __eof == __sb->sungetc()) 00876 this->setstate(ios_base::badbit); 00877 } 00878 catch(exception& __fail) 00879 { 00880 // 27.6.1.3 paragraph 1 00881 // Turn this on without causing an ios::failure to be thrown. 00882 this->setstate(ios_base::badbit); 00883 if ((this->exceptions() & ios_base::badbit) != 0) 00884 __throw_exception_again; 00885 } 00886 } 00887 else 00888 this->setstate(ios_base::failbit); 00889 return *this; 00890 } 00891 00892 template<typename _CharT, typename _Traits> 00893 int 00894 basic_istream<_CharT, _Traits>:: 00895 sync(void) 00896 { 00897 int __ret = traits_type::eof(); 00898 _M_gcount = 0; 00899 sentry __cerb(*this, true); 00900 if (__cerb) 00901 { 00902 try 00903 { 00904 __streambuf_type* __sb = this->rdbuf(); 00905 if (!__sb || __ret == __sb->pubsync()) 00906 this->setstate(ios_base::badbit); 00907 else 00908 __ret = 0; 00909 } 00910 catch(exception& __fail) 00911 { 00912 // 27.6.1.3 paragraph 1 00913 // Turn this on without causing an ios::failure to be thrown. 00914 this->setstate(ios_base::badbit); 00915 if ((this->exceptions() & ios_base::badbit) != 0) 00916 __throw_exception_again; 00917 } 00918 } 00919 return __ret; 00920 } 00921 00922 template<typename _CharT, typename _Traits> 00923 typename basic_istream<_CharT, _Traits>::pos_type 00924 basic_istream<_CharT, _Traits>:: 00925 tellg(void) 00926 { 00927 pos_type __ret = pos_type(-1); 00928 _M_gcount = 0; 00929 sentry __cerb(*this, true); 00930 if (__cerb) 00931 { 00932 try 00933 { 00934 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); 00935 } 00936 catch(exception& __fail) 00937 { 00938 // 27.6.1.3 paragraph 1 00939 // Turn this on without causing an ios::failure to be thrown. 00940 this->setstate(ios_base::badbit); 00941 if ((this->exceptions() & ios_base::badbit) != 0) 00942 __throw_exception_again; 00943 } 00944 } 00945 return __ret; 00946 } 00947 00948 00949 template<typename _CharT, typename _Traits> 00950 basic_istream<_CharT, _Traits>& 00951 basic_istream<_CharT, _Traits>:: 00952 seekg(pos_type __pos) 00953 { 00954 _M_gcount = 0; 00955 sentry __cerb(*this, true); 00956 if (__cerb) 00957 { 00958 try 00959 { 00960 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 00961 // 136. seekp, seekg setting wrong streams? 00962 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in); 00963 00964 // 129. Need error indication from seekp() and seekg() 00965 if (__err == pos_type(off_type(-1))) 00966 this->setstate(failbit); 00967 #endif 00968 } 00969 catch(exception& __fail) 00970 { 00971 // 27.6.1.3 paragraph 1 00972 // Turn this on without causing an ios::failure to be thrown. 00973 this->setstate(ios_base::badbit); 00974 if ((this->exceptions() & ios_base::badbit) != 0) 00975 __throw_exception_again; 00976 } 00977 } 00978 return *this; 00979 } 00980 00981 template<typename _CharT, typename _Traits> 00982 basic_istream<_CharT, _Traits>& 00983 basic_istream<_CharT, _Traits>:: 00984 seekg(off_type __off, ios_base::seekdir __dir) 00985 { 00986 _M_gcount = 0; 00987 sentry __cerb(*this, true); 00988 if (__cerb) 00989 { 00990 try 00991 { 00992 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 00993 // 136. seekp, seekg setting wrong streams? 00994 pos_type __err = this->rdbuf()->pubseekoff(__off, __dir, 00995 ios_base::in); 00996 00997 // 129. Need error indication from seekp() and seekg() 00998 if (__err == pos_type(off_type(-1))) 00999 this->setstate(failbit); 01000 #endif 01001 } 01002 catch(exception& __fail) 01003 { 01004 // 27.6.1.3 paragraph 1 01005 // Turn this on without causing an ios::failure to be thrown. 01006 this->setstate(ios_base::badbit); 01007 if ((this->exceptions() & ios_base::badbit) != 0) 01008 __throw_exception_again; 01009 } 01010 } 01011 return *this; 01012 } 01013 01014 // 27.6.1.2.3 Character extraction templates 01015 template<typename _CharT, typename _Traits> 01016 basic_istream<_CharT, _Traits>& 01017 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) 01018 { 01019 typedef basic_istream<_CharT, _Traits> __istream_type; 01020 typename __istream_type::sentry __cerb(__in, false); 01021 if (__cerb) 01022 { 01023 try 01024 { __in.get(__c); } 01025 catch(exception& __fail) 01026 { 01027 // 27.6.1.2.1 Common requirements. 01028 // Turn this on without causing an ios::failure to be thrown. 01029 __in.setstate(ios_base::badbit); 01030 if ((__in.exceptions() & ios_base::badbit) != 0) 01031 __throw_exception_again; 01032 } 01033 } 01034 else 01035 __in.setstate(ios_base::failbit); 01036 return __in; 01037 } 01038 01039 template<typename _CharT, typename _Traits> 01040 basic_istream<_CharT, _Traits>& 01041 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) 01042 { 01043 typedef basic_istream<_CharT, _Traits> __istream_type; 01044 typedef typename __istream_type::__streambuf_type __streambuf_type; 01045 typedef typename _Traits::int_type int_type; 01046 typedef _CharT char_type; 01047 typedef ctype<_CharT> __ctype_type; 01048 streamsize __extracted = 0; 01049 01050 typename __istream_type::sentry __cerb(__in, false); 01051 if (__cerb) 01052 { 01053 try 01054 { 01055 // Figure out how many characters to extract. 01056 streamsize __num = __in.width(); 01057 if (__num == 0) 01058 __num = numeric_limits<streamsize>::max(); 01059 01060 __streambuf_type* __sb = __in.rdbuf(); 01061 const __ctype_type* __ctype = __in._M_get_fctype_ios(); 01062 int_type __c = __sb->sbumpc(); 01063 const int_type __eof = _Traits::eof(); 01064 bool __testsp = __ctype->is(ctype_base::space, __c); 01065 bool __testeof = __c == __eof; 01066 01067 while (__extracted < __num - 1 && !__testeof && !__testsp) 01068 { 01069 *__s++ = __c; 01070 ++__extracted; 01071 __c = __sb->sbumpc(); 01072 __testeof = __c == __eof; 01073 __testsp = __ctype->is(ctype_base::space, __c); 01074 } 01075 01076 if (!__testeof) 01077 __sb->sputbackc(__c); 01078 else 01079 __in.setstate(ios_base::eofbit); 01080 01081 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 01082 //68. Extractors for char* should store null at end 01083 *__s = char_type(); 01084 #endif 01085 __in.width(0); 01086 } 01087 catch(exception& __fail) 01088 { 01089 // 27.6.1.2.1 Common requirements. 01090 // Turn this on without causing an ios::failure to be thrown. 01091 __in.setstate(ios_base::badbit); 01092 if ((__in.exceptions() & ios_base::badbit) != 0) 01093 __throw_exception_again; 01094 } 01095 } 01096 if (!__extracted) 01097 __in.setstate(ios_base::failbit); 01098 return __in; 01099 } 01100 01101 // 27.6.1.4 Standard basic_istream manipulators 01102 template<typename _CharT, typename _Traits> 01103 basic_istream<_CharT,_Traits>& 01104 ws(basic_istream<_CharT,_Traits>& __in) 01105 { 01106 typedef basic_istream<_CharT, _Traits> __istream_type; 01107 typedef typename __istream_type::__streambuf_type __streambuf_type; 01108 typedef typename __istream_type::__ctype_type __ctype_type; 01109 typedef typename __istream_type::int_type __int_type; 01110 typedef typename __istream_type::char_type __char_type; 01111 01112 __streambuf_type* __sb = __in.rdbuf(); 01113 const __ctype_type* __ctype = __in._M_get_fctype_ios(); 01114 const __int_type __eof = _Traits::eof(); 01115 __int_type __c; 01116 bool __testeof; 01117 bool __testsp; 01118 01119 do 01120 { 01121 __c = __sb->sbumpc(); 01122 __testeof = __c == __eof; 01123 __testsp = __ctype->is(ctype_base::space, __c); 01124 } 01125 while (!__testeof && __testsp); 01126 01127 if (!__testeof && !__testsp) 01128 __sb->sputbackc(__c); 01129 else 01130 __in.setstate(ios_base::eofbit); 01131 01132 return __in; 01133 } 01134 01135 // 21.3.7.9 basic_string::getline and operators 01136 template<typename _CharT, typename _Traits, typename _Alloc> 01137 basic_istream<_CharT, _Traits>& 01138 operator>>(basic_istream<_CharT, _Traits>& __in, 01139 basic_string<_CharT, _Traits, _Alloc>& __str) 01140 { 01141 typedef basic_istream<_CharT, _Traits> __istream_type; 01142 typedef typename __istream_type::int_type __int_type; 01143 typedef typename __istream_type::__streambuf_type __streambuf_type; 01144 typedef typename __istream_type::__ctype_type __ctype_type; 01145 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 01146 typedef typename __string_type::size_type __size_type; 01147 __size_type __extracted = 0; 01148 01149 typename __istream_type::sentry __cerb(__in, false); 01150 if (__cerb) 01151 { 01152 __str.erase(); 01153 streamsize __w = __in.width(); 01154 __size_type __n; 01155 __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size(); 01156 01157 __streambuf_type* __sb = __in.rdbuf(); 01158 const __ctype_type* __ctype = __in._M_get_fctype_ios(); 01159 __int_type __c = __sb->sbumpc(); 01160 const __int_type __eof = _Traits::eof(); 01161 bool __testsp = __ctype->is(ctype_base::space, __c); 01162 bool __testeof = __c == __eof; 01163 01164 while (__extracted < __n && !__testeof && !__testsp) 01165 { 01166 __str += _Traits::to_char_type(__c); 01167 ++__extracted; 01168 __c = __sb->sbumpc(); 01169 __testeof = __c == __eof; 01170 __testsp = __ctype->is(ctype_base::space, __c); 01171 } 01172 if (!__testeof) 01173 __sb->sputbackc(__c); 01174 else 01175 __in.setstate(ios_base::eofbit); 01176 __in.width(0); 01177 } 01178 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 01179 // 2000-02-01 Number to be determined 01180 if (!__extracted) 01181 __in.setstate (ios_base::failbit); 01182 #endif 01183 return __in; 01184 } 01185 01186 template<typename _CharT, typename _Traits, typename _Alloc> 01187 basic_istream<_CharT, _Traits>& 01188 getline(basic_istream<_CharT, _Traits>& __in, 01189 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) 01190 { 01191 typedef basic_istream<_CharT, _Traits> __istream_type; 01192 typedef typename __istream_type::int_type __int_type; 01193 typedef typename __istream_type::__streambuf_type __streambuf_type; 01194 typedef typename __istream_type::__ctype_type __ctype_type; 01195 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 01196 typedef typename __string_type::size_type __size_type; 01197 01198 __size_type __extracted = 0; 01199 bool __testdelim = false; 01200 typename __istream_type::sentry __cerb(__in, true); 01201 if (__cerb) 01202 { 01203 __str.erase(); 01204 __size_type __n = __str.max_size(); 01205 01206 __int_type __idelim = _Traits::to_int_type(__delim); 01207 __streambuf_type* __sb = __in.rdbuf(); 01208 __int_type __c = __sb->sbumpc(); 01209 const __int_type __eof = _Traits::eof(); 01210 __testdelim = __c == __idelim; 01211 bool __testeof = __c == __eof; 01212 01213 while (__extracted <= __n && !__testeof && !__testdelim) 01214 { 01215 __str += _Traits::to_char_type(__c); 01216 ++__extracted; 01217 __c = __sb->sbumpc(); 01218 __testeof = __c == __eof; 01219 __testdelim = __c == __idelim; 01220 } 01221 if (__testeof) 01222 __in.setstate(ios_base::eofbit); 01223 } 01224 if (!__extracted && !__testdelim) 01225 __in.setstate(ios_base::failbit); 01226 return __in; 01227 } 01228 01229 template<class _CharT, class _Traits, class _Alloc> 01230 inline basic_istream<_CharT,_Traits>& 01231 getline(basic_istream<_CharT, _Traits>& __in, 01232 basic_string<_CharT,_Traits,_Alloc>& __str) 01233 { return getline(__in, __str, __in.widen('\n')); } 01234 } // namespace std 01235 01236 // Local Variables: 01237 // mode:C++ 01238 // End: 01239
Generated on Mon Apr 8 03:11:27 2002 for libstdc++-v3 Source by
1.2.15