00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00036
00037
00038
00039
00040 #ifndef _ISTREAM_TCC
00041 #define _ISTREAM_TCC 1
00042
00043 #pragma GCC system_header
00044
00045 #include <locale>
00046 #include <ostream>
00047
00048 namespace std
00049 {
00050 template<typename _CharT, typename _Traits>
00051 basic_istream<_CharT, _Traits>::sentry::
00052 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
00053 {
00054 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00055 if (__in.good())
00056 {
00057 if (__in.tie())
00058 __in.tie()->flush();
00059 if (!__noskip && (__in.flags() & ios_base::skipws))
00060 {
00061 const __int_type __eof = traits_type::eof();
00062 __streambuf_type* __sb = __in.rdbuf();
00063 __int_type __c = __sb->sgetc();
00064
00065 const __ctype_type& __ct = __check_facet(__in._M_ctype);
00066 while (!traits_type::eq_int_type(__c, __eof)
00067 && __ct.is(ctype_base::space,
00068 traits_type::to_char_type(__c)))
00069 __c = __sb->snextc();
00070
00071
00072
00073
00074 if (traits_type::eq_int_type(__c, __eof))
00075 __err |= ios_base::eofbit;
00076 }
00077 }
00078
00079 if (__in.good() && __err == ios_base::goodbit)
00080 _M_ok = true;
00081 else
00082 {
00083 __err |= ios_base::failbit;
00084 __in.setstate(__err);
00085 }
00086 }
00087
00088 template<typename _CharT, typename _Traits>
00089 basic_istream<_CharT, _Traits>&
00090 basic_istream<_CharT, _Traits>::
00091 operator>>(__istream_type& (*__pf)(__istream_type&))
00092 { return __pf(*this); }
00093
00094 template<typename _CharT, typename _Traits>
00095 basic_istream<_CharT, _Traits>&
00096 basic_istream<_CharT, _Traits>::
00097 operator>>(__ios_type& (*__pf)(__ios_type&))
00098 {
00099 __pf(*this);
00100 return *this;
00101 }
00102
00103 template<typename _CharT, typename _Traits>
00104 basic_istream<_CharT, _Traits>&
00105 basic_istream<_CharT, _Traits>::
00106 operator>>(ios_base& (*__pf)(ios_base&))
00107 {
00108 __pf(*this);
00109 return *this;
00110 }
00111
00112 template<typename _CharT, typename _Traits>
00113 basic_istream<_CharT, _Traits>&
00114 basic_istream<_CharT, _Traits>::
00115 operator>>(bool& __n)
00116 {
00117 sentry __cerb(*this, false);
00118 if (__cerb)
00119 {
00120 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00121 try
00122 {
00123 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00124 __ng.get(*this, 0, *this, __err, __n);
00125 }
00126 catch(...)
00127 { this->_M_setstate(ios_base::badbit); }
00128 if (__err)
00129 this->setstate(__err);
00130 }
00131 return *this;
00132 }
00133
00134 template<typename _CharT, typename _Traits>
00135 basic_istream<_CharT, _Traits>&
00136 basic_istream<_CharT, _Traits>::
00137 operator>>(short& __n)
00138 {
00139 sentry __cerb(*this, false);
00140 if (__cerb)
00141 {
00142 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00143 try
00144 {
00145 long __l;
00146 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00147 __ng.get(*this, 0, *this, __err, __l);
00148
00149
00150 if (!(__err & ios_base::failbit)
00151 && (numeric_limits<short>::min() <= __l
00152 && __l <= numeric_limits<short>::max()))
00153 __n = __l;
00154 else
00155 __err |= ios_base::failbit;
00156 }
00157 catch(...)
00158 { this->_M_setstate(ios_base::badbit); }
00159 if (__err)
00160 this->setstate(__err);
00161 }
00162 return *this;
00163 }
00164
00165 template<typename _CharT, typename _Traits>
00166 basic_istream<_CharT, _Traits>&
00167 basic_istream<_CharT, _Traits>::
00168 operator>>(unsigned short& __n)
00169 {
00170 sentry __cerb(*this, false);
00171 if (__cerb)
00172 {
00173 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00174 try
00175 {
00176 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00177 __ng.get(*this, 0, *this, __err, __n);
00178 }
00179 catch(...)
00180 { this->_M_setstate(ios_base::badbit); }
00181 if (__err)
00182 this->setstate(__err);
00183 }
00184 return *this;
00185 }
00186
00187 template<typename _CharT, typename _Traits>
00188 basic_istream<_CharT, _Traits>&
00189 basic_istream<_CharT, _Traits>::
00190 operator>>(int& __n)
00191 {
00192 sentry __cerb(*this, false);
00193 if (__cerb)
00194 {
00195 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00196 try
00197 {
00198 long __l;
00199 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00200 __ng.get(*this, 0, *this, __err, __l);
00201
00202
00203 if (!(__err & ios_base::failbit)
00204 && (numeric_limits<int>::min() <= __l
00205 && __l <= numeric_limits<int>::max()))
00206 __n = __l;
00207 else
00208 __err |= ios_base::failbit;
00209 }
00210 catch(...)
00211 { this->_M_setstate(ios_base::badbit); }
00212 if (__err)
00213 this->setstate(__err);
00214 }
00215 return *this;
00216 }
00217
00218 template<typename _CharT, typename _Traits>
00219 basic_istream<_CharT, _Traits>&
00220 basic_istream<_CharT, _Traits>::
00221 operator>>(unsigned int& __n)
00222 {
00223 sentry __cerb(*this, false);
00224 if (__cerb)
00225 {
00226 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00227 try
00228 {
00229 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00230 __ng.get(*this, 0, *this, __err, __n);
00231 }
00232 catch(...)
00233 { this->_M_setstate(ios_base::badbit); }
00234 if (__err)
00235 this->setstate(__err);
00236 }
00237 return *this;
00238 }
00239
00240 template<typename _CharT, typename _Traits>
00241 basic_istream<_CharT, _Traits>&
00242 basic_istream<_CharT, _Traits>::
00243 operator>>(long& __n)
00244 {
00245 sentry __cerb(*this, false);
00246 if (__cerb)
00247 {
00248 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00249 try
00250 {
00251 const __num_get_type& __ng = __check_facet(this->_M_num_get);
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 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00274 __ng.get(*this, 0, *this, __err, __n);
00275 }
00276 catch(...)
00277 { this->_M_setstate(ios_base::badbit); }
00278 if (__err)
00279 this->setstate(__err);
00280 }
00281 return *this;
00282 }
00283
00284 #ifdef _GLIBCXX_USE_LONG_LONG
00285 template<typename _CharT, typename _Traits>
00286 basic_istream<_CharT, _Traits>&
00287 basic_istream<_CharT, _Traits>::
00288 operator>>(long long& __n)
00289 {
00290 sentry __cerb(*this, false);
00291 if (__cerb)
00292 {
00293 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00294 try
00295 {
00296 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00297 __ng.get(*this, 0, *this, __err, __n);
00298 }
00299 catch(...)
00300 { this->_M_setstate(ios_base::badbit); }
00301 if (__err)
00302 this->setstate(__err);
00303 }
00304 return *this;
00305 }
00306
00307 template<typename _CharT, typename _Traits>
00308 basic_istream<_CharT, _Traits>&
00309 basic_istream<_CharT, _Traits>::
00310 operator>>(unsigned long long& __n)
00311 {
00312 sentry __cerb(*this, false);
00313 if (__cerb)
00314 {
00315 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00316 try
00317 {
00318 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00319 __ng.get(*this, 0, *this, __err, __n);
00320 }
00321 catch(...)
00322 { this->_M_setstate(ios_base::badbit); }
00323 if (__err)
00324 this->setstate(__err);
00325 }
00326 return *this;
00327 }
00328 #endif
00329
00330 template<typename _CharT, typename _Traits>
00331 basic_istream<_CharT, _Traits>&
00332 basic_istream<_CharT, _Traits>::
00333 operator>>(float& __n)
00334 {
00335 sentry __cerb(*this, false);
00336 if (__cerb)
00337 {
00338 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00339 try
00340 {
00341 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00342 __ng.get(*this, 0, *this, __err, __n);
00343 }
00344 catch(...)
00345 { this->_M_setstate(ios_base::badbit); }
00346 if (__err)
00347 this->setstate(__err);
00348 }
00349 return *this;
00350 }
00351
00352 template<typename _CharT, typename _Traits>
00353 basic_istream<_CharT, _Traits>&
00354 basic_istream<_CharT, _Traits>::
00355 operator>>(double& __n)
00356 {
00357 sentry __cerb(*this, false);
00358 if (__cerb)
00359 {
00360 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00361 try
00362 {
00363 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00364 __ng.get(*this, 0, *this, __err, __n);
00365 }
00366 catch(...)
00367 { this->_M_setstate(ios_base::badbit); }
00368 if (__err)
00369 this->setstate(__err);
00370 }
00371 return *this;
00372 }
00373
00374 template<typename _CharT, typename _Traits>
00375 basic_istream<_CharT, _Traits>&
00376 basic_istream<_CharT, _Traits>::
00377 operator>>(long double& __n)
00378 {
00379 sentry __cerb(*this, false);
00380 if (__cerb)
00381 {
00382 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00383 try
00384 {
00385 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00386 __ng.get(*this, 0, *this, __err, __n);
00387 }
00388 catch(...)
00389 { this->_M_setstate(ios_base::badbit); }
00390 if (__err)
00391 this->setstate(__err);
00392 }
00393 return *this;
00394 }
00395
00396 template<typename _CharT, typename _Traits>
00397 basic_istream<_CharT, _Traits>&
00398 basic_istream<_CharT, _Traits>::
00399 operator>>(void*& __n)
00400 {
00401 sentry __cerb(*this, false);
00402 if (__cerb)
00403 {
00404 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00405 try
00406 {
00407 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00408 __ng.get(*this, 0, *this, __err, __n);
00409 }
00410 catch(...)
00411 { this->_M_setstate(ios_base::badbit); }
00412 if (__err)
00413 this->setstate(__err);
00414 }
00415 return *this;
00416 }
00417
00418 template<typename _CharT, typename _Traits>
00419 basic_istream<_CharT, _Traits>&
00420 basic_istream<_CharT, _Traits>::
00421 operator>>(__streambuf_type* __sbout)
00422 {
00423 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00424 sentry __cerb(*this, false);
00425 if (__cerb && __sbout)
00426 {
00427 try
00428 {
00429 if (!__copy_streambufs(this->rdbuf(), __sbout))
00430 __err |= ios_base::failbit;
00431 }
00432 catch(...)
00433 { this->_M_setstate(ios_base::failbit); }
00434 }
00435 else if (!__sbout)
00436 __err |= ios_base::failbit;
00437 if (__err)
00438 this->setstate(__err);
00439 return *this;
00440 }
00441
00442 template<typename _CharT, typename _Traits>
00443 typename basic_istream<_CharT, _Traits>::int_type
00444 basic_istream<_CharT, _Traits>::
00445 get(void)
00446 {
00447 const int_type __eof = traits_type::eof();
00448 int_type __c = __eof;
00449 _M_gcount = 0;
00450 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00451 sentry __cerb(*this, true);
00452 if (__cerb)
00453 {
00454 try
00455 {
00456 __c = this->rdbuf()->sbumpc();
00457
00458 if (!traits_type::eq_int_type(__c, __eof))
00459 _M_gcount = 1;
00460 else
00461 __err |= ios_base::eofbit;
00462 }
00463 catch(...)
00464 { this->_M_setstate(ios_base::badbit); }
00465 }
00466 if (!_M_gcount)
00467 __err |= ios_base::failbit;
00468 if (__err)
00469 this->setstate(__err);
00470 return __c;
00471 }
00472
00473 template<typename _CharT, typename _Traits>
00474 basic_istream<_CharT, _Traits>&
00475 basic_istream<_CharT, _Traits>::
00476 get(char_type& __c)
00477 {
00478 _M_gcount = 0;
00479 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00480 sentry __cerb(*this, true);
00481 if (__cerb)
00482 {
00483 try
00484 {
00485 const int_type __cb = this->rdbuf()->sbumpc();
00486
00487 if (!traits_type::eq_int_type(__cb, traits_type::eof()))
00488 {
00489 _M_gcount = 1;
00490 __c = traits_type::to_char_type(__cb);
00491 }
00492 else
00493 __err |= ios_base::eofbit;
00494 }
00495 catch(...)
00496 { this->_M_setstate(ios_base::badbit); }
00497 }
00498 if (!_M_gcount)
00499 __err |= ios_base::failbit;
00500 if (__err)
00501 this->setstate(__err);
00502 return *this;
00503 }
00504
00505 template<typename _CharT, typename _Traits>
00506 basic_istream<_CharT, _Traits>&
00507 basic_istream<_CharT, _Traits>::
00508 get(char_type* __s, streamsize __n, char_type __delim)
00509 {
00510 _M_gcount = 0;
00511 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00512 sentry __cerb(*this, true);
00513 if (__cerb)
00514 {
00515 try
00516 {
00517 const int_type __idelim = traits_type::to_int_type(__delim);
00518 const int_type __eof = traits_type::eof();
00519 __streambuf_type* __sb = this->rdbuf();
00520 int_type __c = __sb->sgetc();
00521
00522 while (_M_gcount + 1 < __n
00523 && !traits_type::eq_int_type(__c, __eof)
00524 && !traits_type::eq_int_type(__c, __idelim))
00525 {
00526 *__s++ = traits_type::to_char_type(__c);
00527 ++_M_gcount;
00528 __c = __sb->snextc();
00529 }
00530 if (traits_type::eq_int_type(__c, __eof))
00531 __err |= ios_base::eofbit;
00532 }
00533 catch(...)
00534 { this->_M_setstate(ios_base::badbit); }
00535 }
00536
00537
00538 if (__n > 0)
00539 *__s = char_type();
00540 if (!_M_gcount)
00541 __err |= ios_base::failbit;
00542 if (__err)
00543 this->setstate(__err);
00544 return *this;
00545 }
00546
00547 template<typename _CharT, typename _Traits>
00548 basic_istream<_CharT, _Traits>&
00549 basic_istream<_CharT, _Traits>::
00550 get(__streambuf_type& __sb, char_type __delim)
00551 {
00552 _M_gcount = 0;
00553 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00554 sentry __cerb(*this, true);
00555 if (__cerb)
00556 {
00557 try
00558 {
00559 const int_type __idelim = traits_type::to_int_type(__delim);
00560 const int_type __eof = traits_type::eof();
00561 __streambuf_type* __this_sb = this->rdbuf();
00562 int_type __c = __this_sb->sgetc();
00563 char_type __c2 = traits_type::to_char_type(__c);
00564
00565 while (!traits_type::eq_int_type(__c, __eof)
00566 && !traits_type::eq_int_type(__c, __idelim)
00567 && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
00568 {
00569 ++_M_gcount;
00570 __c = __this_sb->snextc();
00571 __c2 = traits_type::to_char_type(__c);
00572 }
00573 if (traits_type::eq_int_type(__c, __eof))
00574 __err |= ios_base::eofbit;
00575 }
00576 catch(...)
00577 { this->_M_setstate(ios_base::badbit); }
00578 }
00579 if (!_M_gcount)
00580 __err |= ios_base::failbit;
00581 if (__err)
00582 this->setstate(__err);
00583 return *this;
00584 }
00585
00586 template<typename _CharT, typename _Traits>
00587 basic_istream<_CharT, _Traits>&
00588 basic_istream<_CharT, _Traits>::
00589 getline(char_type* __s, streamsize __n, char_type __delim)
00590 {
00591 _M_gcount = 0;
00592 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00593 sentry __cerb(*this, true);
00594 if (__cerb)
00595 {
00596 try
00597 {
00598 const int_type __idelim = traits_type::to_int_type(__delim);
00599 const int_type __eof = traits_type::eof();
00600 __streambuf_type* __sb = this->rdbuf();
00601 int_type __c = __sb->sgetc();
00602
00603 while (_M_gcount + 1 < __n
00604 && !traits_type::eq_int_type(__c, __eof)
00605 && !traits_type::eq_int_type(__c, __idelim))
00606 {
00607 *__s++ = traits_type::to_char_type(__c);
00608 __c = __sb->snextc();
00609 ++_M_gcount;
00610 }
00611 if (traits_type::eq_int_type(__c, __eof))
00612 __err |= ios_base::eofbit;
00613 else
00614 {
00615 if (traits_type::eq_int_type(__c, __idelim))
00616 {
00617 __sb->sbumpc();
00618 ++_M_gcount;
00619 }
00620 else
00621 __err |= ios_base::failbit;
00622 }
00623 }
00624 catch(...)
00625 { this->_M_setstate(ios_base::badbit); }
00626 }
00627
00628
00629 if (__n > 0)
00630 *__s = char_type();
00631 if (!_M_gcount)
00632 __err |= ios_base::failbit;
00633 if (__err)
00634 this->setstate(__err);
00635 return *this;
00636 }
00637
00638
00639
00640
00641 template<typename _CharT, typename _Traits>
00642 basic_istream<_CharT, _Traits>&
00643 basic_istream<_CharT, _Traits>::
00644 ignore(void)
00645 {
00646 _M_gcount = 0;
00647 sentry __cerb(*this, true);
00648 if (__cerb)
00649 {
00650 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00651 try
00652 {
00653 const int_type __eof = traits_type::eof();
00654 __streambuf_type* __sb = this->rdbuf();
00655
00656 if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
00657 __err |= ios_base::eofbit;
00658 else
00659 _M_gcount = 1;
00660 }
00661 catch(...)
00662 { this->_M_setstate(ios_base::badbit); }
00663 if (__err)
00664 this->setstate(__err);
00665 }
00666 return *this;
00667 }
00668
00669 template<typename _CharT, typename _Traits>
00670 basic_istream<_CharT, _Traits>&
00671 basic_istream<_CharT, _Traits>::
00672 ignore(streamsize __n)
00673 {
00674 _M_gcount = 0;
00675 sentry __cerb(*this, true);
00676 if (__cerb && __n > 0)
00677 {
00678 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00679 try
00680 {
00681 const int_type __eof = traits_type::eof();
00682 __streambuf_type* __sb = this->rdbuf();
00683 int_type __c = __sb->sgetc();
00684
00685
00686
00687
00688
00689
00690
00691
00692 bool __large_ignore = false;
00693 while (true)
00694 {
00695 while (_M_gcount < __n
00696 && !traits_type::eq_int_type(__c, __eof))
00697 {
00698 ++_M_gcount;
00699 __c = __sb->snextc();
00700 }
00701 if (__n == numeric_limits<streamsize>::max()
00702 && !traits_type::eq_int_type(__c, __eof))
00703 {
00704 _M_gcount = numeric_limits<streamsize>::min();
00705 __large_ignore = true;
00706 }
00707 else
00708 break;
00709 }
00710
00711 if (__large_ignore)
00712 _M_gcount = numeric_limits<streamsize>::max();
00713
00714 if (traits_type::eq_int_type(__c, __eof))
00715 __err |= ios_base::eofbit;
00716 }
00717 catch(...)
00718 { this->_M_setstate(ios_base::badbit); }
00719 if (__err)
00720 this->setstate(__err);
00721 }
00722 return *this;
00723 }
00724
00725 template<typename _CharT, typename _Traits>
00726 basic_istream<_CharT, _Traits>&
00727 basic_istream<_CharT, _Traits>::
00728 ignore(streamsize __n, int_type __delim)
00729 {
00730 _M_gcount = 0;
00731 sentry __cerb(*this, true);
00732 if (__cerb && __n > 0)
00733 {
00734 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00735 try
00736 {
00737 const int_type __eof = traits_type::eof();
00738 __streambuf_type* __sb = this->rdbuf();
00739 int_type __c = __sb->sgetc();
00740
00741
00742 bool __large_ignore = false;
00743 while (true)
00744 {
00745 while (_M_gcount < __n
00746 && !traits_type::eq_int_type(__c, __eof)
00747 && !traits_type::eq_int_type(__c, __delim))
00748 {
00749 ++_M_gcount;
00750 __c = __sb->snextc();
00751 }
00752 if (__n == numeric_limits<streamsize>::max()
00753 && !traits_type::eq_int_type(__c, __eof)
00754 && !traits_type::eq_int_type(__c, __delim))
00755 {
00756 _M_gcount = numeric_limits<streamsize>::min();
00757 __large_ignore = true;
00758 }
00759 else
00760 break;
00761 }
00762
00763 if (__large_ignore)
00764 _M_gcount = numeric_limits<streamsize>::max();
00765
00766 if (traits_type::eq_int_type(__c, __eof))
00767 __err |= ios_base::eofbit;
00768 else if (traits_type::eq_int_type(__c, __delim))
00769 {
00770 if (_M_gcount < numeric_limits<streamsize>::max())
00771 ++_M_gcount;
00772 __sb->sbumpc();
00773 }
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 typename basic_istream<_CharT, _Traits>::int_type
00785 basic_istream<_CharT, _Traits>::
00786 peek(void)
00787 {
00788 int_type __c = traits_type::eof();
00789 _M_gcount = 0;
00790 sentry __cerb(*this, true);
00791 if (__cerb)
00792 {
00793 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00794 try
00795 {
00796 __c = this->rdbuf()->sgetc();
00797 if (traits_type::eq_int_type(__c, traits_type::eof()))
00798 __err |= ios_base::eofbit;
00799 }
00800 catch(...)
00801 { this->_M_setstate(ios_base::badbit); }
00802 if (__err)
00803 this->setstate(__err);
00804 }
00805 return __c;
00806 }
00807
00808 template<typename _CharT, typename _Traits>
00809 basic_istream<_CharT, _Traits>&
00810 basic_istream<_CharT, _Traits>::
00811 read(char_type* __s, streamsize __n)
00812 {
00813 _M_gcount = 0;
00814 sentry __cerb(*this, true);
00815 if (__cerb)
00816 {
00817 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00818 try
00819 {
00820 _M_gcount = this->rdbuf()->sgetn(__s, __n);
00821 if (_M_gcount != __n)
00822 __err |= (ios_base::eofbit | ios_base::failbit);
00823 }
00824 catch(...)
00825 { this->_M_setstate(ios_base::badbit); }
00826 if (__err)
00827 this->setstate(__err);
00828 }
00829 return *this;
00830 }
00831
00832 template<typename _CharT, typename _Traits>
00833 streamsize
00834 basic_istream<_CharT, _Traits>::
00835 readsome(char_type* __s, streamsize __n)
00836 {
00837 _M_gcount = 0;
00838 sentry __cerb(*this, true);
00839 if (__cerb)
00840 {
00841 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00842 try
00843 {
00844
00845 const streamsize __num = this->rdbuf()->in_avail();
00846 if (__num > 0)
00847 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
00848 else if (__num == -1)
00849 __err |= ios_base::eofbit;
00850 }
00851 catch(...)
00852 { this->_M_setstate(ios_base::badbit); }
00853 if (__err)
00854 this->setstate(__err);
00855 }
00856 return _M_gcount;
00857 }
00858
00859 template<typename _CharT, typename _Traits>
00860 basic_istream<_CharT, _Traits>&
00861 basic_istream<_CharT, _Traits>::
00862 putback(char_type __c)
00863 {
00864
00865
00866 _M_gcount = 0;
00867 sentry __cerb(*this, true);
00868 if (__cerb)
00869 {
00870 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00871 try
00872 {
00873 const int_type __eof = traits_type::eof();
00874 __streambuf_type* __sb = this->rdbuf();
00875 if (!__sb
00876 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
00877 __err |= ios_base::badbit;
00878 }
00879 catch(...)
00880 { this->_M_setstate(ios_base::badbit); }
00881 if (__err)
00882 this->setstate(__err);
00883 }
00884 return *this;
00885 }
00886
00887 template<typename _CharT, typename _Traits>
00888 basic_istream<_CharT, _Traits>&
00889 basic_istream<_CharT, _Traits>::
00890 unget(void)
00891 {
00892
00893
00894 _M_gcount = 0;
00895 sentry __cerb(*this, true);
00896 if (__cerb)
00897 {
00898 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00899 try
00900 {
00901 const int_type __eof = traits_type::eof();
00902 __streambuf_type* __sb = this->rdbuf();
00903 if (!__sb
00904 || traits_type::eq_int_type(__sb->sungetc(), __eof))
00905 __err |= ios_base::badbit;
00906 }
00907 catch(...)
00908 { this->_M_setstate(ios_base::badbit); }
00909 if (__err)
00910 this->setstate(__err);
00911 }
00912 return *this;
00913 }
00914
00915 template<typename _CharT, typename _Traits>
00916 int
00917 basic_istream<_CharT, _Traits>::
00918 sync(void)
00919 {
00920
00921
00922 int __ret = -1;
00923 sentry __cerb(*this, true);
00924 if (__cerb)
00925 {
00926 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00927 try
00928 {
00929 __streambuf_type* __sb = this->rdbuf();
00930 if (__sb)
00931 {
00932 if (__sb->pubsync() == -1)
00933 __err |= ios_base::badbit;
00934 else
00935 __ret = 0;
00936 }
00937 }
00938 catch(...)
00939 { this->_M_setstate(ios_base::badbit); }
00940 if (__err)
00941 this->setstate(__err);
00942 }
00943 return __ret;
00944 }
00945
00946 template<typename _CharT, typename _Traits>
00947 typename basic_istream<_CharT, _Traits>::pos_type
00948 basic_istream<_CharT, _Traits>::
00949 tellg(void)
00950 {
00951
00952
00953 pos_type __ret = pos_type(-1);
00954 try
00955 {
00956 if (!this->fail())
00957 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
00958 }
00959 catch(...)
00960 { this->_M_setstate(ios_base::badbit); }
00961 return __ret;
00962 }
00963
00964 template<typename _CharT, typename _Traits>
00965 basic_istream<_CharT, _Traits>&
00966 basic_istream<_CharT, _Traits>::
00967 seekg(pos_type __pos)
00968 {
00969
00970
00971 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00972 try
00973 {
00974 if (!this->fail())
00975 {
00976
00977 const pos_type __p = this->rdbuf()->pubseekpos(__pos,
00978 ios_base::in);
00979
00980
00981 if (__p == pos_type(off_type(-1)))
00982 __err |= ios_base::failbit;
00983 }
00984 }
00985 catch(...)
00986 { this->_M_setstate(ios_base::badbit); }
00987 if (__err)
00988 this->setstate(__err);
00989 return *this;
00990 }
00991
00992 template<typename _CharT, typename _Traits>
00993 basic_istream<_CharT, _Traits>&
00994 basic_istream<_CharT, _Traits>::
00995 seekg(off_type __off, ios_base::seekdir __dir)
00996 {
00997
00998
00999 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01000 try
01001 {
01002 if (!this->fail())
01003 {
01004
01005 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
01006 ios_base::in);
01007
01008
01009 if (__p == pos_type(off_type(-1)))
01010 __err |= ios_base::failbit;
01011 }
01012 }
01013 catch(...)
01014 { this->_M_setstate(ios_base::badbit); }
01015 if (__err)
01016 this->setstate(__err);
01017 return *this;
01018 }
01019
01020
01021 template<typename _CharT, typename _Traits>
01022 basic_istream<_CharT, _Traits>&
01023 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
01024 {
01025 typedef basic_istream<_CharT, _Traits> __istream_type;
01026 typedef typename __istream_type::int_type __int_type;
01027
01028 typename __istream_type::sentry __cerb(__in, false);
01029 if (__cerb)
01030 {
01031 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01032 try
01033 {
01034 const __int_type __cb = __in.rdbuf()->sbumpc();
01035 if (!_Traits::eq_int_type(__cb, _Traits::eof()))
01036 __c = _Traits::to_char_type(__cb);
01037 else
01038 __err |= (ios_base::eofbit | ios_base::failbit);
01039 }
01040 catch(...)
01041 { __in._M_setstate(ios_base::badbit); }
01042 if (__err)
01043 __in.setstate(__err);
01044 }
01045 return __in;
01046 }
01047
01048 template<typename _CharT, typename _Traits>
01049 basic_istream<_CharT, _Traits>&
01050 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
01051 {
01052 typedef basic_istream<_CharT, _Traits> __istream_type;
01053 typedef typename __istream_type::__streambuf_type __streambuf_type;
01054 typedef typename _Traits::int_type int_type;
01055 typedef _CharT char_type;
01056 typedef ctype<_CharT> __ctype_type;
01057
01058 streamsize __extracted = 0;
01059 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01060 typename __istream_type::sentry __cerb(__in, false);
01061 if (__cerb)
01062 {
01063 try
01064 {
01065
01066 streamsize __num = __in.width();
01067 if (__num <= 0)
01068 __num = numeric_limits<streamsize>::max();
01069
01070 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
01071
01072 const int_type __eof = _Traits::eof();
01073 __streambuf_type* __sb = __in.rdbuf();
01074 int_type __c = __sb->sgetc();
01075
01076 while (__extracted < __num - 1
01077 && !_Traits::eq_int_type(__c, __eof)
01078 && !__ct.is(ctype_base::space,
01079 _Traits::to_char_type(__c)))
01080 {
01081 *__s++ = _Traits::to_char_type(__c);
01082 ++__extracted;
01083 __c = __sb->snextc();
01084 }
01085 if (_Traits::eq_int_type(__c, __eof))
01086 __err |= ios_base::eofbit;
01087
01088
01089
01090 *__s = char_type();
01091 __in.width(0);
01092 }
01093 catch(...)
01094 { __in._M_setstate(ios_base::badbit); }
01095 }
01096 if (!__extracted)
01097 __err |= ios_base::failbit;
01098 if (__err)
01099 __in.setstate(__err);
01100 return __in;
01101 }
01102
01103
01104 template<typename _CharT, typename _Traits>
01105 basic_istream<_CharT,_Traits>&
01106 ws(basic_istream<_CharT,_Traits>& __in)
01107 {
01108 typedef basic_istream<_CharT, _Traits> __istream_type;
01109 typedef typename __istream_type::__streambuf_type __streambuf_type;
01110 typedef typename __istream_type::__ctype_type __ctype_type;
01111 typedef typename __istream_type::int_type __int_type;
01112
01113 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
01114 const __int_type __eof = _Traits::eof();
01115 __streambuf_type* __sb = __in.rdbuf();
01116 __int_type __c = __sb->sgetc();
01117
01118 while (!_Traits::eq_int_type(__c, __eof)
01119 && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
01120 __c = __sb->snextc();
01121
01122 if (_Traits::eq_int_type(__c, __eof))
01123 __in.setstate(ios_base::eofbit);
01124 return __in;
01125 }
01126
01127
01128 template<typename _CharT, typename _Traits, typename _Alloc>
01129 basic_istream<_CharT, _Traits>&
01130 operator>>(basic_istream<_CharT, _Traits>& __in,
01131 basic_string<_CharT, _Traits, _Alloc>& __str)
01132 {
01133 typedef basic_istream<_CharT, _Traits> __istream_type;
01134 typedef typename __istream_type::int_type __int_type;
01135 typedef typename __istream_type::__streambuf_type __streambuf_type;
01136 typedef typename __istream_type::__ctype_type __ctype_type;
01137 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01138 typedef typename __string_type::size_type __size_type;
01139
01140 __size_type __extracted = 0;
01141 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01142 typename __istream_type::sentry __cerb(__in, false);
01143 if (__cerb)
01144 {
01145 try
01146 {
01147
01148 __str.erase();
01149 _CharT __buf[128];
01150 __size_type __len = 0;
01151 const streamsize __w = __in.width();
01152 const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
01153 : __str.max_size();
01154 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
01155 const __int_type __eof = _Traits::eof();
01156 __streambuf_type* __sb = __in.rdbuf();
01157 __int_type __c = __sb->sgetc();
01158
01159 while (__extracted < __n
01160 && !_Traits::eq_int_type(__c, __eof)
01161 && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
01162 {
01163 if (__len == sizeof(__buf) / sizeof(_CharT))
01164 {
01165 __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
01166 __len = 0;
01167 }
01168 __buf[__len++] = _Traits::to_char_type(__c);
01169 ++__extracted;
01170 __c = __sb->snextc();
01171 }
01172 __str.append(__buf, __len);
01173
01174 if (_Traits::eq_int_type(__c, __eof))
01175 __err |= ios_base::eofbit;
01176 __in.width(0);
01177 }
01178 catch(...)
01179 {
01180
01181
01182
01183 __in._M_setstate(ios_base::badbit);
01184 }
01185 }
01186
01187 if (!__extracted)
01188 __err |= ios_base::failbit;
01189 if (__err)
01190 __in.setstate(__err);
01191 return __in;
01192 }
01193
01194 template<typename _CharT, typename _Traits, typename _Alloc>
01195 basic_istream<_CharT, _Traits>&
01196 getline(basic_istream<_CharT, _Traits>& __in,
01197 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
01198 {
01199 typedef basic_istream<_CharT, _Traits> __istream_type;
01200 typedef typename __istream_type::int_type __int_type;
01201 typedef typename __istream_type::__streambuf_type __streambuf_type;
01202 typedef typename __istream_type::__ctype_type __ctype_type;
01203 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01204 typedef typename __string_type::size_type __size_type;
01205
01206 __size_type __extracted = 0;
01207 const __size_type __n = __str.max_size();
01208 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
01209 typename __istream_type::sentry __cerb(__in, true);
01210 if (__cerb)
01211 {
01212 try
01213 {
01214 __str.erase();
01215 const __int_type __idelim = _Traits::to_int_type(__delim);
01216 const __int_type __eof = _Traits::eof();
01217 __streambuf_type* __sb = __in.rdbuf();
01218 __int_type __c = __sb->sgetc();
01219
01220 while (__extracted < __n
01221 && !_Traits::eq_int_type(__c, __eof)
01222 && !_Traits::eq_int_type(__c, __idelim))
01223 {
01224 __str += _Traits::to_char_type(__c);
01225 ++__extracted;
01226 __c = __sb->snextc();
01227 }
01228
01229 if (_Traits::eq_int_type(__c, __eof))
01230 __err |= ios_base::eofbit;
01231 else if (_Traits::eq_int_type(__c, __idelim))
01232 {
01233 ++__extracted;
01234 __sb->sbumpc();
01235 }
01236 else
01237 __err |= ios_base::failbit;
01238 }
01239 catch(...)
01240 {
01241
01242
01243
01244 __in._M_setstate(ios_base::badbit);
01245 }
01246 }
01247 if (!__extracted)
01248 __err |= ios_base::failbit;
01249 if (__err)
01250 __in.setstate(__err);
01251 return __in;
01252 }
01253
01254 template<class _CharT, class _Traits, class _Alloc>
01255 inline basic_istream<_CharT,_Traits>&
01256 getline(basic_istream<_CharT, _Traits>& __in,
01257 basic_string<_CharT,_Traits,_Alloc>& __str)
01258 { return getline(__in, __str, __in.widen('\n')); }
01259
01260
01261
01262
01263 #if _GLIBCXX_EXTERN_TEMPLATE
01264 extern template class basic_istream<char>;
01265 extern template istream& ws(istream&);
01266 extern template istream& operator>>(istream&, char&);
01267 extern template istream& operator>>(istream&, char*);
01268 extern template istream& operator>>(istream&, unsigned char&);
01269 extern template istream& operator>>(istream&, signed char&);
01270 extern template istream& operator>>(istream&, unsigned char*);
01271 extern template istream& operator>>(istream&, signed char*);
01272
01273 extern template class basic_iostream<char>;
01274
01275 #ifdef _GLIBCXX_USE_WCHAR_T
01276 extern template class basic_istream<wchar_t>;
01277 extern template wistream& ws(wistream&);
01278 extern template wistream& operator>>(wistream&, wchar_t&);
01279 extern template wistream& operator>>(wistream&, wchar_t*);
01280
01281 extern template class basic_iostream<wchar_t>;
01282 #endif
01283 #endif
01284 }
01285
01286 #endif