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