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 sentry __cerb(*this, true);
00845 if (__cerb)
00846 {
00847 try
00848 {
00849 const int_type __eof = traits_type::eof();
00850 __streambuf_type* __sb = this->rdbuf();
00851 if (!__sb
00852 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
00853 this->setstate(ios_base::badbit);
00854 }
00855 catch(exception& __fail)
00856 {
00857
00858
00859 this->setstate(ios_base::badbit);
00860 if ((this->exceptions() & ios_base::badbit) != 0)
00861 __throw_exception_again;
00862 }
00863 }
00864 else
00865 this->setstate(ios_base::failbit);
00866 return *this;
00867 }
00868
00869 template<typename _CharT, typename _Traits>
00870 basic_istream<_CharT, _Traits>&
00871 basic_istream<_CharT, _Traits>::
00872 unget(void)
00873 {
00874 _M_gcount = 0;
00875 sentry __cerb(*this, true);
00876 if (__cerb)
00877 {
00878 try
00879 {
00880 const int_type __eof = traits_type::eof();
00881 __streambuf_type* __sb = this->rdbuf();
00882 if (!__sb
00883 || traits_type::eq_int_type(__sb->sungetc(), __eof))
00884 this->setstate(ios_base::badbit);
00885 }
00886 catch(exception& __fail)
00887 {
00888
00889
00890 this->setstate(ios_base::badbit);
00891 if ((this->exceptions() & ios_base::badbit) != 0)
00892 __throw_exception_again;
00893 }
00894 }
00895 else
00896 this->setstate(ios_base::failbit);
00897 return *this;
00898 }
00899
00900 template<typename _CharT, typename _Traits>
00901 int
00902 basic_istream<_CharT, _Traits>::
00903 sync(void)
00904 {
00905 int __ret = -1;
00906 _M_gcount = 0;
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 _M_gcount = 0;
00951 if (!this->fail())
00952 {
00953 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00954
00955 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
00956
00957
00958 if (__err == pos_type(off_type(-1)))
00959 this->setstate(ios_base::failbit);
00960 #endif
00961 }
00962 return *this;
00963 }
00964
00965 template<typename _CharT, typename _Traits>
00966 basic_istream<_CharT, _Traits>&
00967 basic_istream<_CharT, _Traits>::
00968 seekg(off_type __off, ios_base::seekdir __dir)
00969 {
00970 _M_gcount = 0;
00971 if (!this->fail())
00972 {
00973 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00974
00975 pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
00976 ios_base::in);
00977
00978
00979 if (__err == pos_type(off_type(-1)))
00980 this->setstate(ios_base::failbit);
00981 #endif
00982 }
00983 return *this;
00984 }
00985
00986
00987 template<typename _CharT, typename _Traits>
00988 basic_istream<_CharT, _Traits>&
00989 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
00990 {
00991 typedef basic_istream<_CharT, _Traits> __istream_type;
00992 typename __istream_type::sentry __cerb(__in, false);
00993 if (__cerb)
00994 {
00995 try
00996 { __in.get(__c); }
00997 catch(exception& __fail)
00998 {
00999
01000
01001 __in.setstate(ios_base::badbit);
01002 if ((__in.exceptions() & ios_base::badbit) != 0)
01003 __throw_exception_again;
01004 }
01005 }
01006 else
01007 __in.setstate(ios_base::failbit);
01008 return __in;
01009 }
01010
01011 template<typename _CharT, typename _Traits>
01012 basic_istream<_CharT, _Traits>&
01013 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
01014 {
01015 typedef basic_istream<_CharT, _Traits> __istream_type;
01016 typedef typename __istream_type::__streambuf_type __streambuf_type;
01017 typedef typename _Traits::int_type int_type;
01018 typedef _CharT char_type;
01019 typedef ctype<_CharT> __ctype_type;
01020 streamsize __extracted = 0;
01021
01022 typename __istream_type::sentry __cerb(__in, false);
01023 if (__cerb)
01024 {
01025 try
01026 {
01027
01028 streamsize __num = __in.width();
01029 if (__num == 0)
01030 __num = numeric_limits<streamsize>::max();
01031
01032 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
01033 const int_type __eof = _Traits::eof();
01034 __streambuf_type* __sb = __in.rdbuf();
01035 int_type __c = __sb->sgetc();
01036
01037 while (__extracted < __num - 1
01038 && !_Traits::eq_int_type(__c, __eof)
01039 && !__ctype.is(ctype_base::space, __c))
01040 {
01041 *__s++ = __c;
01042 ++__extracted;
01043 __c = __sb->snextc();
01044 }
01045 if (_Traits::eq_int_type(__c, __eof))
01046 __in.setstate(ios_base::eofbit);
01047
01048 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
01049
01050 *__s = char_type();
01051 #endif
01052 __in.width(0);
01053 }
01054 catch(exception& __fail)
01055 {
01056
01057
01058 __in.setstate(ios_base::badbit);
01059 if ((__in.exceptions() & ios_base::badbit) != 0)
01060 __throw_exception_again;
01061 }
01062 }
01063 if (!__extracted)
01064 __in.setstate(ios_base::failbit);
01065 return __in;
01066 }
01067
01068
01069 template<typename _CharT, typename _Traits>
01070 basic_istream<_CharT,_Traits>&
01071 ws(basic_istream<_CharT,_Traits>& __in)
01072 {
01073 typedef basic_istream<_CharT, _Traits> __istream_type;
01074 typedef typename __istream_type::__streambuf_type __streambuf_type;
01075 typedef typename __istream_type::__ctype_type __ctype_type;
01076 typedef typename __istream_type::int_type __int_type;
01077
01078 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
01079 const __int_type __eof = _Traits::eof();
01080 __streambuf_type* __sb = __in.rdbuf();
01081 __int_type __c = __sb->sgetc();
01082
01083 while (!_Traits::eq_int_type(__c, __eof)
01084 && __ctype.is(ctype_base::space, __c))
01085 __c = __sb->snextc();
01086
01087 if (_Traits::eq_int_type(__c, __eof))
01088 __in.setstate(ios_base::eofbit);
01089
01090 return __in;
01091 }
01092
01093
01094 template<typename _CharT, typename _Traits, typename _Alloc>
01095 basic_istream<_CharT, _Traits>&
01096 operator>>(basic_istream<_CharT, _Traits>& __in,
01097 basic_string<_CharT, _Traits, _Alloc>& __str)
01098 {
01099 typedef basic_istream<_CharT, _Traits> __istream_type;
01100 typedef typename __istream_type::int_type __int_type;
01101 typedef typename __istream_type::__streambuf_type __streambuf_type;
01102 typedef typename __istream_type::__ctype_type __ctype_type;
01103 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01104 typedef typename __string_type::size_type __size_type;
01105 __size_type __extracted = 0;
01106
01107 typename __istream_type::sentry __cerb(__in, false);
01108 if (__cerb)
01109 {
01110 __str.erase();
01111 streamsize __w = __in.width();
01112 __size_type __n;
01113 __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
01114
01115 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
01116 const __int_type __eof = _Traits::eof();
01117 __streambuf_type* __sb = __in.rdbuf();
01118 __int_type __c = __sb->sgetc();
01119
01120 while (__extracted < __n
01121 && !_Traits::eq_int_type(__c, __eof)
01122 && !__ctype.is(ctype_base::space, __c))
01123 {
01124 __str += _Traits::to_char_type(__c);
01125 ++__extracted;
01126 __c = __sb->snextc();
01127 }
01128 if (_Traits::eq_int_type(__c, __eof))
01129 __in.setstate(ios_base::eofbit);
01130 __in.width(0);
01131 }
01132 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
01133
01134 if (!__extracted)
01135 __in.setstate (ios_base::failbit);
01136 #endif
01137 return __in;
01138 }
01139
01140 template<typename _CharT, typename _Traits, typename _Alloc>
01141 basic_istream<_CharT, _Traits>&
01142 getline(basic_istream<_CharT, _Traits>& __in,
01143 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
01144 {
01145 typedef basic_istream<_CharT, _Traits> __istream_type;
01146 typedef typename __istream_type::int_type __int_type;
01147 typedef typename __istream_type::__streambuf_type __streambuf_type;
01148 typedef typename __istream_type::__ctype_type __ctype_type;
01149 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01150 typedef typename __string_type::size_type __size_type;
01151
01152 __size_type __extracted = 0;
01153 bool __testdelim = false;
01154 typename __istream_type::sentry __cerb(__in, true);
01155 if (__cerb)
01156 {
01157 __str.erase();
01158 __size_type __n = __str.max_size();
01159
01160 __int_type __idelim = _Traits::to_int_type(__delim);
01161 __streambuf_type* __sb = __in.rdbuf();
01162 __int_type __c = __sb->sbumpc();
01163 const __int_type __eof = _Traits::eof();
01164 __testdelim = _Traits::eq_int_type(__c, __idelim);
01165
01166 while (__extracted <= __n
01167 && !_Traits::eq_int_type(__c, __eof)
01168 && !__testdelim)
01169 {
01170 __str += _Traits::to_char_type(__c);
01171 ++__extracted;
01172 __c = __sb->sbumpc();
01173 __testdelim = _Traits::eq_int_type(__c, __idelim);
01174 }
01175 if (_Traits::eq_int_type(__c, __eof))
01176 __in.setstate(ios_base::eofbit);
01177 }
01178 if (!__extracted && !__testdelim)
01179 __in.setstate(ios_base::failbit);
01180 return __in;
01181 }
01182
01183 template<class _CharT, class _Traits, class _Alloc>
01184 inline basic_istream<_CharT,_Traits>&
01185 getline(basic_istream<_CharT, _Traits>& __in,
01186 basic_string<_CharT,_Traits,_Alloc>& __str)
01187 { return getline(__in, __str, __in.widen('\n')); }
01188
01189
01190
01191
01192 extern template class basic_istream<char>;
01193 extern template istream& ws(istream&);
01194 extern template istream& operator>>(istream&, char&);
01195 extern template istream& operator>>(istream&, char*);
01196 extern template istream& operator>>(istream&, unsigned char&);
01197 extern template istream& operator>>(istream&, signed char&);
01198 extern template istream& operator>>(istream&, unsigned char*);
01199 extern template istream& operator>>(istream&, signed char*);
01200
01201 #ifdef _GLIBCPP_USE_WCHAR_T
01202 extern template class basic_istream<wchar_t>;
01203 extern template wistream& ws(wistream&);
01204 extern template wistream& operator>>(wistream&, wchar_t&);
01205 extern template wistream& operator>>(wistream&, wchar_t*);
01206 #endif
01207 }