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 Sun Sep 19 16:33:51 2004 for libstdc++-v3 Source by doxygen 1.3.8