libstdc++
|
00001 // istream classes -*- C++ -*- 00002 00003 // Copyright (C) 1997-2013 Free Software Foundation, Inc. 00004 // 00005 // This file is part of the GNU ISO C++ Library. This library is free 00006 // software; you can redistribute it and/or modify it under the 00007 // terms of the GNU General Public License as published by the 00008 // Free Software Foundation; either version 3, or (at your option) 00009 // any later version. 00010 00011 // This library is distributed in the hope that it will be useful, 00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 // GNU General Public License for more details. 00015 00016 // Under Section 7 of GPL version 3, you are granted additional 00017 // permissions described in the GCC Runtime Library Exception, version 00018 // 3.1, as published by the Free Software Foundation. 00019 00020 // You should have received a copy of the GNU General Public License and 00021 // a copy of the GCC Runtime Library Exception along with this program; 00022 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 00023 // <http://www.gnu.org/licenses/>. 00024 00025 /** @file bits/istream.tcc 00026 * This is an internal header file, included by other library headers. 00027 * Do not attempt to use it directly. @headername{istream} 00028 */ 00029 00030 // 00031 // ISO C++ 14882: 27.6.1 Input streams 00032 // 00033 00034 #ifndef _ISTREAM_TCC 00035 #define _ISTREAM_TCC 1 00036 00037 #pragma GCC system_header 00038 00039 #include <bits/cxxabi_forced.h> 00040 00041 namespace std _GLIBCXX_VISIBILITY(default) 00042 { 00043 _GLIBCXX_BEGIN_NAMESPACE_VERSION 00044 00045 template<typename _CharT, typename _Traits> 00046 basic_istream<_CharT, _Traits>::sentry:: 00047 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) 00048 { 00049 ios_base::iostate __err = ios_base::goodbit; 00050 if (__in.good()) 00051 { 00052 if (__in.tie()) 00053 __in.tie()->flush(); 00054 if (!__noskip && bool(__in.flags() & ios_base::skipws)) 00055 { 00056 const __int_type __eof = traits_type::eof(); 00057 __streambuf_type* __sb = __in.rdbuf(); 00058 __int_type __c = __sb->sgetc(); 00059 00060 const __ctype_type& __ct = __check_facet(__in._M_ctype); 00061 while (!traits_type::eq_int_type(__c, __eof) 00062 && __ct.is(ctype_base::space, 00063 traits_type::to_char_type(__c))) 00064 __c = __sb->snextc(); 00065 00066 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00067 // 195. Should basic_istream::sentry's constructor ever 00068 // set eofbit? 00069 if (traits_type::eq_int_type(__c, __eof)) 00070 __err |= ios_base::eofbit; 00071 } 00072 } 00073 00074 if (__in.good() && __err == ios_base::goodbit) 00075 _M_ok = true; 00076 else 00077 { 00078 __err |= ios_base::failbit; 00079 __in.setstate(__err); 00080 } 00081 } 00082 00083 template<typename _CharT, typename _Traits> 00084 template<typename _ValueT> 00085 basic_istream<_CharT, _Traits>& 00086 basic_istream<_CharT, _Traits>:: 00087 _M_extract(_ValueT& __v) 00088 { 00089 sentry __cerb(*this, false); 00090 if (__cerb) 00091 { 00092 ios_base::iostate __err = ios_base::goodbit; 00093 __try 00094 { 00095 const __num_get_type& __ng = __check_facet(this->_M_num_get); 00096 __ng.get(*this, 0, *this, __err, __v); 00097 } 00098 __catch(__cxxabiv1::__forced_unwind&) 00099 { 00100 this->_M_setstate(ios_base::badbit); 00101 __throw_exception_again; 00102 } 00103 __catch(...) 00104 { this->_M_setstate(ios_base::badbit); } 00105 if (__err) 00106 this->setstate(__err); 00107 } 00108 return *this; 00109 } 00110 00111 template<typename _CharT, typename _Traits> 00112 basic_istream<_CharT, _Traits>& 00113 basic_istream<_CharT, _Traits>:: 00114 operator>>(short& __n) 00115 { 00116 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00117 // 118. basic_istream uses nonexistent num_get member functions. 00118 sentry __cerb(*this, false); 00119 if (__cerb) 00120 { 00121 ios_base::iostate __err = ios_base::goodbit; 00122 __try 00123 { 00124 long __l; 00125 const __num_get_type& __ng = __check_facet(this->_M_num_get); 00126 __ng.get(*this, 0, *this, __err, __l); 00127 00128 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00129 // 696. istream::operator>>(int&) broken. 00130 if (__l < __gnu_cxx::__numeric_traits<short>::__min) 00131 { 00132 __err |= ios_base::failbit; 00133 __n = __gnu_cxx::__numeric_traits<short>::__min; 00134 } 00135 else if (__l > __gnu_cxx::__numeric_traits<short>::__max) 00136 { 00137 __err |= ios_base::failbit; 00138 __n = __gnu_cxx::__numeric_traits<short>::__max; 00139 } 00140 else 00141 __n = short(__l); 00142 } 00143 __catch(__cxxabiv1::__forced_unwind&) 00144 { 00145 this->_M_setstate(ios_base::badbit); 00146 __throw_exception_again; 00147 } 00148 __catch(...) 00149 { this->_M_setstate(ios_base::badbit); } 00150 if (__err) 00151 this->setstate(__err); 00152 } 00153 return *this; 00154 } 00155 00156 template<typename _CharT, typename _Traits> 00157 basic_istream<_CharT, _Traits>& 00158 basic_istream<_CharT, _Traits>:: 00159 operator>>(int& __n) 00160 { 00161 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00162 // 118. basic_istream uses nonexistent num_get member functions. 00163 sentry __cerb(*this, false); 00164 if (__cerb) 00165 { 00166 ios_base::iostate __err = ios_base::goodbit; 00167 __try 00168 { 00169 long __l; 00170 const __num_get_type& __ng = __check_facet(this->_M_num_get); 00171 __ng.get(*this, 0, *this, __err, __l); 00172 00173 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00174 // 696. istream::operator>>(int&) broken. 00175 if (__l < __gnu_cxx::__numeric_traits<int>::__min) 00176 { 00177 __err |= ios_base::failbit; 00178 __n = __gnu_cxx::__numeric_traits<int>::__min; 00179 } 00180 else if (__l > __gnu_cxx::__numeric_traits<int>::__max) 00181 { 00182 __err |= ios_base::failbit; 00183 __n = __gnu_cxx::__numeric_traits<int>::__max; 00184 } 00185 else 00186 __n = int(__l); 00187 } 00188 __catch(__cxxabiv1::__forced_unwind&) 00189 { 00190 this->_M_setstate(ios_base::badbit); 00191 __throw_exception_again; 00192 } 00193 __catch(...) 00194 { this->_M_setstate(ios_base::badbit); } 00195 if (__err) 00196 this->setstate(__err); 00197 } 00198 return *this; 00199 } 00200 00201 template<typename _CharT, typename _Traits> 00202 basic_istream<_CharT, _Traits>& 00203 basic_istream<_CharT, _Traits>:: 00204 operator>>(__streambuf_type* __sbout) 00205 { 00206 ios_base::iostate __err = ios_base::goodbit; 00207 sentry __cerb(*this, false); 00208 if (__cerb && __sbout) 00209 { 00210 __try 00211 { 00212 bool __ineof; 00213 if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) 00214 __err |= ios_base::failbit; 00215 if (__ineof) 00216 __err |= ios_base::eofbit; 00217 } 00218 __catch(__cxxabiv1::__forced_unwind&) 00219 { 00220 this->_M_setstate(ios_base::failbit); 00221 __throw_exception_again; 00222 } 00223 __catch(...) 00224 { this->_M_setstate(ios_base::failbit); } 00225 } 00226 else if (!__sbout) 00227 __err |= ios_base::failbit; 00228 if (__err) 00229 this->setstate(__err); 00230 return *this; 00231 } 00232 00233 template<typename _CharT, typename _Traits> 00234 typename basic_istream<_CharT, _Traits>::int_type 00235 basic_istream<_CharT, _Traits>:: 00236 get(void) 00237 { 00238 const int_type __eof = traits_type::eof(); 00239 int_type __c = __eof; 00240 _M_gcount = 0; 00241 ios_base::iostate __err = ios_base::goodbit; 00242 sentry __cerb(*this, true); 00243 if (__cerb) 00244 { 00245 __try 00246 { 00247 __c = this->rdbuf()->sbumpc(); 00248 // 27.6.1.1 paragraph 3 00249 if (!traits_type::eq_int_type(__c, __eof)) 00250 _M_gcount = 1; 00251 else 00252 __err |= ios_base::eofbit; 00253 } 00254 __catch(__cxxabiv1::__forced_unwind&) 00255 { 00256 this->_M_setstate(ios_base::badbit); 00257 __throw_exception_again; 00258 } 00259 __catch(...) 00260 { this->_M_setstate(ios_base::badbit); } 00261 } 00262 if (!_M_gcount) 00263 __err |= ios_base::failbit; 00264 if (__err) 00265 this->setstate(__err); 00266 return __c; 00267 } 00268 00269 template<typename _CharT, typename _Traits> 00270 basic_istream<_CharT, _Traits>& 00271 basic_istream<_CharT, _Traits>:: 00272 get(char_type& __c) 00273 { 00274 _M_gcount = 0; 00275 ios_base::iostate __err = ios_base::goodbit; 00276 sentry __cerb(*this, true); 00277 if (__cerb) 00278 { 00279 __try 00280 { 00281 const int_type __cb = this->rdbuf()->sbumpc(); 00282 // 27.6.1.1 paragraph 3 00283 if (!traits_type::eq_int_type(__cb, traits_type::eof())) 00284 { 00285 _M_gcount = 1; 00286 __c = traits_type::to_char_type(__cb); 00287 } 00288 else 00289 __err |= ios_base::eofbit; 00290 } 00291 __catch(__cxxabiv1::__forced_unwind&) 00292 { 00293 this->_M_setstate(ios_base::badbit); 00294 __throw_exception_again; 00295 } 00296 __catch(...) 00297 { this->_M_setstate(ios_base::badbit); } 00298 } 00299 if (!_M_gcount) 00300 __err |= ios_base::failbit; 00301 if (__err) 00302 this->setstate(__err); 00303 return *this; 00304 } 00305 00306 template<typename _CharT, typename _Traits> 00307 basic_istream<_CharT, _Traits>& 00308 basic_istream<_CharT, _Traits>:: 00309 get(char_type* __s, streamsize __n, char_type __delim) 00310 { 00311 _M_gcount = 0; 00312 ios_base::iostate __err = ios_base::goodbit; 00313 sentry __cerb(*this, true); 00314 if (__cerb) 00315 { 00316 __try 00317 { 00318 const int_type __idelim = traits_type::to_int_type(__delim); 00319 const int_type __eof = traits_type::eof(); 00320 __streambuf_type* __sb = this->rdbuf(); 00321 int_type __c = __sb->sgetc(); 00322 00323 while (_M_gcount + 1 < __n 00324 && !traits_type::eq_int_type(__c, __eof) 00325 && !traits_type::eq_int_type(__c, __idelim)) 00326 { 00327 *__s++ = traits_type::to_char_type(__c); 00328 ++_M_gcount; 00329 __c = __sb->snextc(); 00330 } 00331 if (traits_type::eq_int_type(__c, __eof)) 00332 __err |= ios_base::eofbit; 00333 } 00334 __catch(__cxxabiv1::__forced_unwind&) 00335 { 00336 this->_M_setstate(ios_base::badbit); 00337 __throw_exception_again; 00338 } 00339 __catch(...) 00340 { this->_M_setstate(ios_base::badbit); } 00341 } 00342 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00343 // 243. get and getline when sentry reports failure. 00344 if (__n > 0) 00345 *__s = char_type(); 00346 if (!_M_gcount) 00347 __err |= ios_base::failbit; 00348 if (__err) 00349 this->setstate(__err); 00350 return *this; 00351 } 00352 00353 template<typename _CharT, typename _Traits> 00354 basic_istream<_CharT, _Traits>& 00355 basic_istream<_CharT, _Traits>:: 00356 get(__streambuf_type& __sb, char_type __delim) 00357 { 00358 _M_gcount = 0; 00359 ios_base::iostate __err = ios_base::goodbit; 00360 sentry __cerb(*this, true); 00361 if (__cerb) 00362 { 00363 __try 00364 { 00365 const int_type __idelim = traits_type::to_int_type(__delim); 00366 const int_type __eof = traits_type::eof(); 00367 __streambuf_type* __this_sb = this->rdbuf(); 00368 int_type __c = __this_sb->sgetc(); 00369 char_type __c2 = traits_type::to_char_type(__c); 00370 00371 while (!traits_type::eq_int_type(__c, __eof) 00372 && !traits_type::eq_int_type(__c, __idelim) 00373 && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) 00374 { 00375 ++_M_gcount; 00376 __c = __this_sb->snextc(); 00377 __c2 = traits_type::to_char_type(__c); 00378 } 00379 if (traits_type::eq_int_type(__c, __eof)) 00380 __err |= ios_base::eofbit; 00381 } 00382 __catch(__cxxabiv1::__forced_unwind&) 00383 { 00384 this->_M_setstate(ios_base::badbit); 00385 __throw_exception_again; 00386 } 00387 __catch(...) 00388 { this->_M_setstate(ios_base::badbit); } 00389 } 00390 if (!_M_gcount) 00391 __err |= ios_base::failbit; 00392 if (__err) 00393 this->setstate(__err); 00394 return *this; 00395 } 00396 00397 template<typename _CharT, typename _Traits> 00398 basic_istream<_CharT, _Traits>& 00399 basic_istream<_CharT, _Traits>:: 00400 getline(char_type* __s, streamsize __n, char_type __delim) 00401 { 00402 _M_gcount = 0; 00403 ios_base::iostate __err = ios_base::goodbit; 00404 sentry __cerb(*this, true); 00405 if (__cerb) 00406 { 00407 __try 00408 { 00409 const int_type __idelim = traits_type::to_int_type(__delim); 00410 const int_type __eof = traits_type::eof(); 00411 __streambuf_type* __sb = this->rdbuf(); 00412 int_type __c = __sb->sgetc(); 00413 00414 while (_M_gcount + 1 < __n 00415 && !traits_type::eq_int_type(__c, __eof) 00416 && !traits_type::eq_int_type(__c, __idelim)) 00417 { 00418 *__s++ = traits_type::to_char_type(__c); 00419 __c = __sb->snextc(); 00420 ++_M_gcount; 00421 } 00422 if (traits_type::eq_int_type(__c, __eof)) 00423 __err |= ios_base::eofbit; 00424 else 00425 { 00426 if (traits_type::eq_int_type(__c, __idelim)) 00427 { 00428 __sb->sbumpc(); 00429 ++_M_gcount; 00430 } 00431 else 00432 __err |= ios_base::failbit; 00433 } 00434 } 00435 __catch(__cxxabiv1::__forced_unwind&) 00436 { 00437 this->_M_setstate(ios_base::badbit); 00438 __throw_exception_again; 00439 } 00440 __catch(...) 00441 { this->_M_setstate(ios_base::badbit); } 00442 } 00443 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00444 // 243. get and getline when sentry reports failure. 00445 if (__n > 0) 00446 *__s = char_type(); 00447 if (!_M_gcount) 00448 __err |= ios_base::failbit; 00449 if (__err) 00450 this->setstate(__err); 00451 return *this; 00452 } 00453 00454 // We provide three overloads, since the first two are much simpler 00455 // than the general case. Also, the latter two can thus adopt the 00456 // same "batchy" strategy used by getline above. 00457 template<typename _CharT, typename _Traits> 00458 basic_istream<_CharT, _Traits>& 00459 basic_istream<_CharT, _Traits>:: 00460 ignore(void) 00461 { 00462 _M_gcount = 0; 00463 sentry __cerb(*this, true); 00464 if (__cerb) 00465 { 00466 ios_base::iostate __err = ios_base::goodbit; 00467 __try 00468 { 00469 const int_type __eof = traits_type::eof(); 00470 __streambuf_type* __sb = this->rdbuf(); 00471 00472 if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) 00473 __err |= ios_base::eofbit; 00474 else 00475 _M_gcount = 1; 00476 } 00477 __catch(__cxxabiv1::__forced_unwind&) 00478 { 00479 this->_M_setstate(ios_base::badbit); 00480 __throw_exception_again; 00481 } 00482 __catch(...) 00483 { this->_M_setstate(ios_base::badbit); } 00484 if (__err) 00485 this->setstate(__err); 00486 } 00487 return *this; 00488 } 00489 00490 template<typename _CharT, typename _Traits> 00491 basic_istream<_CharT, _Traits>& 00492 basic_istream<_CharT, _Traits>:: 00493 ignore(streamsize __n) 00494 { 00495 _M_gcount = 0; 00496 sentry __cerb(*this, true); 00497 if (__cerb && __n > 0) 00498 { 00499 ios_base::iostate __err = ios_base::goodbit; 00500 __try 00501 { 00502 const int_type __eof = traits_type::eof(); 00503 __streambuf_type* __sb = this->rdbuf(); 00504 int_type __c = __sb->sgetc(); 00505 00506 // N.B. On LFS-enabled platforms streamsize is still 32 bits 00507 // wide: if we want to implement the standard mandated behavior 00508 // for n == max() (see 27.6.1.3/24) we are at risk of signed 00509 // integer overflow: thus these contortions. Also note that, 00510 // by definition, when more than 2G chars are actually ignored, 00511 // _M_gcount (the return value of gcount, that is) cannot be 00512 // really correct, being unavoidably too small. 00513 bool __large_ignore = false; 00514 while (true) 00515 { 00516 while (_M_gcount < __n 00517 && !traits_type::eq_int_type(__c, __eof)) 00518 { 00519 ++_M_gcount; 00520 __c = __sb->snextc(); 00521 } 00522 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 00523 && !traits_type::eq_int_type(__c, __eof)) 00524 { 00525 _M_gcount = 00526 __gnu_cxx::__numeric_traits<streamsize>::__min; 00527 __large_ignore = true; 00528 } 00529 else 00530 break; 00531 } 00532 00533 if (__large_ignore) 00534 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 00535 00536 if (traits_type::eq_int_type(__c, __eof)) 00537 __err |= ios_base::eofbit; 00538 } 00539 __catch(__cxxabiv1::__forced_unwind&) 00540 { 00541 this->_M_setstate(ios_base::badbit); 00542 __throw_exception_again; 00543 } 00544 __catch(...) 00545 { this->_M_setstate(ios_base::badbit); } 00546 if (__err) 00547 this->setstate(__err); 00548 } 00549 return *this; 00550 } 00551 00552 template<typename _CharT, typename _Traits> 00553 basic_istream<_CharT, _Traits>& 00554 basic_istream<_CharT, _Traits>:: 00555 ignore(streamsize __n, int_type __delim) 00556 { 00557 _M_gcount = 0; 00558 sentry __cerb(*this, true); 00559 if (__cerb && __n > 0) 00560 { 00561 ios_base::iostate __err = ios_base::goodbit; 00562 __try 00563 { 00564 const int_type __eof = traits_type::eof(); 00565 __streambuf_type* __sb = this->rdbuf(); 00566 int_type __c = __sb->sgetc(); 00567 00568 // See comment above. 00569 bool __large_ignore = false; 00570 while (true) 00571 { 00572 while (_M_gcount < __n 00573 && !traits_type::eq_int_type(__c, __eof) 00574 && !traits_type::eq_int_type(__c, __delim)) 00575 { 00576 ++_M_gcount; 00577 __c = __sb->snextc(); 00578 } 00579 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 00580 && !traits_type::eq_int_type(__c, __eof) 00581 && !traits_type::eq_int_type(__c, __delim)) 00582 { 00583 _M_gcount = 00584 __gnu_cxx::__numeric_traits<streamsize>::__min; 00585 __large_ignore = true; 00586 } 00587 else 00588 break; 00589 } 00590 00591 if (__large_ignore) 00592 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 00593 00594 if (traits_type::eq_int_type(__c, __eof)) 00595 __err |= ios_base::eofbit; 00596 else if (traits_type::eq_int_type(__c, __delim)) 00597 { 00598 if (_M_gcount 00599 < __gnu_cxx::__numeric_traits<streamsize>::__max) 00600 ++_M_gcount; 00601 __sb->sbumpc(); 00602 } 00603 } 00604 __catch(__cxxabiv1::__forced_unwind&) 00605 { 00606 this->_M_setstate(ios_base::badbit); 00607 __throw_exception_again; 00608 } 00609 __catch(...) 00610 { this->_M_setstate(ios_base::badbit); } 00611 if (__err) 00612 this->setstate(__err); 00613 } 00614 return *this; 00615 } 00616 00617 template<typename _CharT, typename _Traits> 00618 typename basic_istream<_CharT, _Traits>::int_type 00619 basic_istream<_CharT, _Traits>:: 00620 peek(void) 00621 { 00622 int_type __c = traits_type::eof(); 00623 _M_gcount = 0; 00624 sentry __cerb(*this, true); 00625 if (__cerb) 00626 { 00627 ios_base::iostate __err = ios_base::goodbit; 00628 __try 00629 { 00630 __c = this->rdbuf()->sgetc(); 00631 if (traits_type::eq_int_type(__c, traits_type::eof())) 00632 __err |= ios_base::eofbit; 00633 } 00634 __catch(__cxxabiv1::__forced_unwind&) 00635 { 00636 this->_M_setstate(ios_base::badbit); 00637 __throw_exception_again; 00638 } 00639 __catch(...) 00640 { this->_M_setstate(ios_base::badbit); } 00641 if (__err) 00642 this->setstate(__err); 00643 } 00644 return __c; 00645 } 00646 00647 template<typename _CharT, typename _Traits> 00648 basic_istream<_CharT, _Traits>& 00649 basic_istream<_CharT, _Traits>:: 00650 read(char_type* __s, streamsize __n) 00651 { 00652 _M_gcount = 0; 00653 sentry __cerb(*this, true); 00654 if (__cerb) 00655 { 00656 ios_base::iostate __err = ios_base::goodbit; 00657 __try 00658 { 00659 _M_gcount = this->rdbuf()->sgetn(__s, __n); 00660 if (_M_gcount != __n) 00661 __err |= (ios_base::eofbit | ios_base::failbit); 00662 } 00663 __catch(__cxxabiv1::__forced_unwind&) 00664 { 00665 this->_M_setstate(ios_base::badbit); 00666 __throw_exception_again; 00667 } 00668 __catch(...) 00669 { this->_M_setstate(ios_base::badbit); } 00670 if (__err) 00671 this->setstate(__err); 00672 } 00673 return *this; 00674 } 00675 00676 template<typename _CharT, typename _Traits> 00677 streamsize 00678 basic_istream<_CharT, _Traits>:: 00679 readsome(char_type* __s, streamsize __n) 00680 { 00681 _M_gcount = 0; 00682 sentry __cerb(*this, true); 00683 if (__cerb) 00684 { 00685 ios_base::iostate __err = ios_base::goodbit; 00686 __try 00687 { 00688 // Cannot compare int_type with streamsize generically. 00689 const streamsize __num = this->rdbuf()->in_avail(); 00690 if (__num > 0) 00691 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); 00692 else if (__num == -1) 00693 __err |= ios_base::eofbit; 00694 } 00695 __catch(__cxxabiv1::__forced_unwind&) 00696 { 00697 this->_M_setstate(ios_base::badbit); 00698 __throw_exception_again; 00699 } 00700 __catch(...) 00701 { this->_M_setstate(ios_base::badbit); } 00702 if (__err) 00703 this->setstate(__err); 00704 } 00705 return _M_gcount; 00706 } 00707 00708 template<typename _CharT, typename _Traits> 00709 basic_istream<_CharT, _Traits>& 00710 basic_istream<_CharT, _Traits>:: 00711 putback(char_type __c) 00712 { 00713 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00714 // 60. What is a formatted input function? 00715 _M_gcount = 0; 00716 // Clear eofbit per N3168. 00717 this->clear(this->rdstate() & ~ios_base::eofbit); 00718 sentry __cerb(*this, true); 00719 if (__cerb) 00720 { 00721 ios_base::iostate __err = ios_base::goodbit; 00722 __try 00723 { 00724 const int_type __eof = traits_type::eof(); 00725 __streambuf_type* __sb = this->rdbuf(); 00726 if (!__sb 00727 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) 00728 __err |= ios_base::badbit; 00729 } 00730 __catch(__cxxabiv1::__forced_unwind&) 00731 { 00732 this->_M_setstate(ios_base::badbit); 00733 __throw_exception_again; 00734 } 00735 __catch(...) 00736 { this->_M_setstate(ios_base::badbit); } 00737 if (__err) 00738 this->setstate(__err); 00739 } 00740 return *this; 00741 } 00742 00743 template<typename _CharT, typename _Traits> 00744 basic_istream<_CharT, _Traits>& 00745 basic_istream<_CharT, _Traits>:: 00746 unget(void) 00747 { 00748 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00749 // 60. What is a formatted input function? 00750 _M_gcount = 0; 00751 // Clear eofbit per N3168. 00752 this->clear(this->rdstate() & ~ios_base::eofbit); 00753 sentry __cerb(*this, true); 00754 if (__cerb) 00755 { 00756 ios_base::iostate __err = ios_base::goodbit; 00757 __try 00758 { 00759 const int_type __eof = traits_type::eof(); 00760 __streambuf_type* __sb = this->rdbuf(); 00761 if (!__sb 00762 || traits_type::eq_int_type(__sb->sungetc(), __eof)) 00763 __err |= ios_base::badbit; 00764 } 00765 __catch(__cxxabiv1::__forced_unwind&) 00766 { 00767 this->_M_setstate(ios_base::badbit); 00768 __throw_exception_again; 00769 } 00770 __catch(...) 00771 { this->_M_setstate(ios_base::badbit); } 00772 if (__err) 00773 this->setstate(__err); 00774 } 00775 return *this; 00776 } 00777 00778 template<typename _CharT, typename _Traits> 00779 int 00780 basic_istream<_CharT, _Traits>:: 00781 sync(void) 00782 { 00783 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00784 // DR60. Do not change _M_gcount. 00785 int __ret = -1; 00786 sentry __cerb(*this, true); 00787 if (__cerb) 00788 { 00789 ios_base::iostate __err = ios_base::goodbit; 00790 __try 00791 { 00792 __streambuf_type* __sb = this->rdbuf(); 00793 if (__sb) 00794 { 00795 if (__sb->pubsync() == -1) 00796 __err |= ios_base::badbit; 00797 else 00798 __ret = 0; 00799 } 00800 } 00801 __catch(__cxxabiv1::__forced_unwind&) 00802 { 00803 this->_M_setstate(ios_base::badbit); 00804 __throw_exception_again; 00805 } 00806 __catch(...) 00807 { this->_M_setstate(ios_base::badbit); } 00808 if (__err) 00809 this->setstate(__err); 00810 } 00811 return __ret; 00812 } 00813 00814 template<typename _CharT, typename _Traits> 00815 typename basic_istream<_CharT, _Traits>::pos_type 00816 basic_istream<_CharT, _Traits>:: 00817 tellg(void) 00818 { 00819 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00820 // DR60. Do not change _M_gcount. 00821 pos_type __ret = pos_type(-1); 00822 sentry __cerb(*this, true); 00823 if (__cerb) 00824 { 00825 __try 00826 { 00827 if (!this->fail()) 00828 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, 00829 ios_base::in); 00830 } 00831 __catch(__cxxabiv1::__forced_unwind&) 00832 { 00833 this->_M_setstate(ios_base::badbit); 00834 __throw_exception_again; 00835 } 00836 __catch(...) 00837 { this->_M_setstate(ios_base::badbit); } 00838 } 00839 return __ret; 00840 } 00841 00842 template<typename _CharT, typename _Traits> 00843 basic_istream<_CharT, _Traits>& 00844 basic_istream<_CharT, _Traits>:: 00845 seekg(pos_type __pos) 00846 { 00847 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00848 // DR60. Do not change _M_gcount. 00849 // Clear eofbit per N3168. 00850 this->clear(this->rdstate() & ~ios_base::eofbit); 00851 sentry __cerb(*this, true); 00852 if (__cerb) 00853 { 00854 ios_base::iostate __err = ios_base::goodbit; 00855 __try 00856 { 00857 if (!this->fail()) 00858 { 00859 // 136. seekp, seekg setting wrong streams? 00860 const pos_type __p = this->rdbuf()->pubseekpos(__pos, 00861 ios_base::in); 00862 00863 // 129. Need error indication from seekp() and seekg() 00864 if (__p == pos_type(off_type(-1))) 00865 __err |= ios_base::failbit; 00866 } 00867 } 00868 __catch(__cxxabiv1::__forced_unwind&) 00869 { 00870 this->_M_setstate(ios_base::badbit); 00871 __throw_exception_again; 00872 } 00873 __catch(...) 00874 { this->_M_setstate(ios_base::badbit); } 00875 if (__err) 00876 this->setstate(__err); 00877 } 00878 return *this; 00879 } 00880 00881 template<typename _CharT, typename _Traits> 00882 basic_istream<_CharT, _Traits>& 00883 basic_istream<_CharT, _Traits>:: 00884 seekg(off_type __off, ios_base::seekdir __dir) 00885 { 00886 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00887 // DR60. Do not change _M_gcount. 00888 // Clear eofbit per N3168. 00889 this->clear(this->rdstate() & ~ios_base::eofbit); 00890 sentry __cerb(*this, true); 00891 if (__cerb) 00892 { 00893 ios_base::iostate __err = ios_base::goodbit; 00894 __try 00895 { 00896 if (!this->fail()) 00897 { 00898 // 136. seekp, seekg setting wrong streams? 00899 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, 00900 ios_base::in); 00901 00902 // 129. Need error indication from seekp() and seekg() 00903 if (__p == pos_type(off_type(-1))) 00904 __err |= ios_base::failbit; 00905 } 00906 } 00907 __catch(__cxxabiv1::__forced_unwind&) 00908 { 00909 this->_M_setstate(ios_base::badbit); 00910 __throw_exception_again; 00911 } 00912 __catch(...) 00913 { this->_M_setstate(ios_base::badbit); } 00914 if (__err) 00915 this->setstate(__err); 00916 } 00917 return *this; 00918 } 00919 00920 // 27.6.1.2.3 Character extraction templates 00921 template<typename _CharT, typename _Traits> 00922 basic_istream<_CharT, _Traits>& 00923 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) 00924 { 00925 typedef basic_istream<_CharT, _Traits> __istream_type; 00926 typedef typename __istream_type::int_type __int_type; 00927 00928 typename __istream_type::sentry __cerb(__in, false); 00929 if (__cerb) 00930 { 00931 ios_base::iostate __err = ios_base::goodbit; 00932 __try 00933 { 00934 const __int_type __cb = __in.rdbuf()->sbumpc(); 00935 if (!_Traits::eq_int_type(__cb, _Traits::eof())) 00936 __c = _Traits::to_char_type(__cb); 00937 else 00938 __err |= (ios_base::eofbit | ios_base::failbit); 00939 } 00940 __catch(__cxxabiv1::__forced_unwind&) 00941 { 00942 __in._M_setstate(ios_base::badbit); 00943 __throw_exception_again; 00944 } 00945 __catch(...) 00946 { __in._M_setstate(ios_base::badbit); } 00947 if (__err) 00948 __in.setstate(__err); 00949 } 00950 return __in; 00951 } 00952 00953 template<typename _CharT, typename _Traits> 00954 basic_istream<_CharT, _Traits>& 00955 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) 00956 { 00957 typedef basic_istream<_CharT, _Traits> __istream_type; 00958 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 00959 typedef typename _Traits::int_type int_type; 00960 typedef _CharT char_type; 00961 typedef ctype<_CharT> __ctype_type; 00962 00963 streamsize __extracted = 0; 00964 ios_base::iostate __err = ios_base::goodbit; 00965 typename __istream_type::sentry __cerb(__in, false); 00966 if (__cerb) 00967 { 00968 __try 00969 { 00970 // Figure out how many characters to extract. 00971 streamsize __num = __in.width(); 00972 if (__num <= 0) 00973 __num = __gnu_cxx::__numeric_traits<streamsize>::__max; 00974 00975 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 00976 00977 const int_type __eof = _Traits::eof(); 00978 __streambuf_type* __sb = __in.rdbuf(); 00979 int_type __c = __sb->sgetc(); 00980 00981 while (__extracted < __num - 1 00982 && !_Traits::eq_int_type(__c, __eof) 00983 && !__ct.is(ctype_base::space, 00984 _Traits::to_char_type(__c))) 00985 { 00986 *__s++ = _Traits::to_char_type(__c); 00987 ++__extracted; 00988 __c = __sb->snextc(); 00989 } 00990 if (_Traits::eq_int_type(__c, __eof)) 00991 __err |= ios_base::eofbit; 00992 00993 // _GLIBCXX_RESOLVE_LIB_DEFECTS 00994 // 68. Extractors for char* should store null at end 00995 *__s = char_type(); 00996 __in.width(0); 00997 } 00998 __catch(__cxxabiv1::__forced_unwind&) 00999 { 01000 __in._M_setstate(ios_base::badbit); 01001 __throw_exception_again; 01002 } 01003 __catch(...) 01004 { __in._M_setstate(ios_base::badbit); } 01005 } 01006 if (!__extracted) 01007 __err |= ios_base::failbit; 01008 if (__err) 01009 __in.setstate(__err); 01010 return __in; 01011 } 01012 01013 // 27.6.1.4 Standard basic_istream manipulators 01014 template<typename _CharT, typename _Traits> 01015 basic_istream<_CharT, _Traits>& 01016 ws(basic_istream<_CharT, _Traits>& __in) 01017 { 01018 typedef basic_istream<_CharT, _Traits> __istream_type; 01019 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 01020 typedef typename __istream_type::int_type __int_type; 01021 typedef ctype<_CharT> __ctype_type; 01022 01023 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 01024 const __int_type __eof = _Traits::eof(); 01025 __streambuf_type* __sb = __in.rdbuf(); 01026 __int_type __c = __sb->sgetc(); 01027 01028 while (!_Traits::eq_int_type(__c, __eof) 01029 && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) 01030 __c = __sb->snextc(); 01031 01032 if (_Traits::eq_int_type(__c, __eof)) 01033 __in.setstate(ios_base::eofbit); 01034 return __in; 01035 } 01036 01037 // Inhibit implicit instantiations for required instantiations, 01038 // which are defined via explicit instantiations elsewhere. 01039 #if _GLIBCXX_EXTERN_TEMPLATE 01040 extern template class basic_istream<char>; 01041 extern template istream& ws(istream&); 01042 extern template istream& operator>>(istream&, char&); 01043 extern template istream& operator>>(istream&, char*); 01044 extern template istream& operator>>(istream&, unsigned char&); 01045 extern template istream& operator>>(istream&, signed char&); 01046 extern template istream& operator>>(istream&, unsigned char*); 01047 extern template istream& operator>>(istream&, signed char*); 01048 01049 extern template istream& istream::_M_extract(unsigned short&); 01050 extern template istream& istream::_M_extract(unsigned int&); 01051 extern template istream& istream::_M_extract(long&); 01052 extern template istream& istream::_M_extract(unsigned long&); 01053 extern template istream& istream::_M_extract(bool&); 01054 #ifdef _GLIBCXX_USE_LONG_LONG 01055 extern template istream& istream::_M_extract(long long&); 01056 extern template istream& istream::_M_extract(unsigned long long&); 01057 #endif 01058 extern template istream& istream::_M_extract(float&); 01059 extern template istream& istream::_M_extract(double&); 01060 extern template istream& istream::_M_extract(long double&); 01061 extern template istream& istream::_M_extract(void*&); 01062 01063 extern template class basic_iostream<char>; 01064 01065 #ifdef _GLIBCXX_USE_WCHAR_T 01066 extern template class basic_istream<wchar_t>; 01067 extern template wistream& ws(wistream&); 01068 extern template wistream& operator>>(wistream&, wchar_t&); 01069 extern template wistream& operator>>(wistream&, wchar_t*); 01070 01071 extern template wistream& wistream::_M_extract(unsigned short&); 01072 extern template wistream& wistream::_M_extract(unsigned int&); 01073 extern template wistream& wistream::_M_extract(long&); 01074 extern template wistream& wistream::_M_extract(unsigned long&); 01075 extern template wistream& wistream::_M_extract(bool&); 01076 #ifdef _GLIBCXX_USE_LONG_LONG 01077 extern template wistream& wistream::_M_extract(long long&); 01078 extern template wistream& wistream::_M_extract(unsigned long long&); 01079 #endif 01080 extern template wistream& wistream::_M_extract(float&); 01081 extern template wistream& wistream::_M_extract(double&); 01082 extern template wistream& wistream::_M_extract(long double&); 01083 extern template wistream& wistream::_M_extract(void*&); 01084 01085 extern template class basic_iostream<wchar_t>; 01086 #endif 01087 #endif 01088 01089 _GLIBCXX_END_NAMESPACE_VERSION 01090 } // namespace std 01091 01092 #endif