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 #include <bits/std_locale.h>
00033 #include <bits/std_ostream.h>
00034
00035 namespace std
00036 {
00037 template<typename _CharT, typename _Traits>
00038 basic_istream<_CharT, _Traits>::sentry::
00039 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
00040 {
00041 if (__in.good())
00042 {
00043 if (__in.tie())
00044 __in.tie()->flush();
00045 if (!__noskipws && (__in.flags() & ios_base::skipws))
00046 {
00047 const __int_type __eof = traits_type::eof();
00048 const __ctype_type* __ctype = __in._M_get_fctype_ios();
00049 __streambuf_type* __sb = __in.rdbuf();
00050 __int_type __c = __sb->sgetc();
00051
00052 while (__c != __eof && __ctype->is(ctype_base::space, __c))
00053 __c = __sb->snextc();
00054
00055 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00056
00057 if (__c == __eof)
00058 __in.setstate(ios_base::eofbit);
00059 #endif
00060 }
00061 }
00062
00063 if (__in.good())
00064 _M_ok = true;
00065 else
00066 {
00067 _M_ok = false;
00068 __in.setstate(ios_base::failbit);
00069 }
00070 }
00071
00072 template<typename _CharT, typename _Traits>
00073 basic_istream<_CharT, _Traits>&
00074 basic_istream<_CharT, _Traits>::
00075 operator>>(__istream_type& (*__pf)(__istream_type&))
00076 {
00077 __pf(*this);
00078 return *this;
00079 }
00080
00081 template<typename _CharT, typename _Traits>
00082 basic_istream<_CharT, _Traits>&
00083 basic_istream<_CharT, _Traits>::
00084 operator>>(__ios_type& (*__pf)(__ios_type&))
00085 {
00086 __pf(*this);
00087 return *this;
00088 }
00089
00090 template<typename _CharT, typename _Traits>
00091 basic_istream<_CharT, _Traits>&
00092 basic_istream<_CharT, _Traits>::
00093 operator>>(ios_base& (*__pf)(ios_base&))
00094 {
00095 __pf(*this);
00096 return *this;
00097 }
00098
00099 template<typename _CharT, typename _Traits>
00100 basic_istream<_CharT, _Traits>&
00101 basic_istream<_CharT, _Traits>::
00102 operator>>(bool& __n)
00103 {
00104 sentry __cerb(*this, false);
00105 if (__cerb)
00106 {
00107 try
00108 {
00109 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00110 if (_M_check_facet(_M_fnumget))
00111 _M_fnumget->get(*this, 0, *this, __err, __n);
00112 this->setstate(__err);
00113 }
00114 catch(exception& __fail)
00115 {
00116
00117
00118 this->setstate(ios_base::badbit);
00119 if ((this->exceptions() & ios_base::badbit) != 0)
00120 __throw_exception_again;
00121 }
00122 }
00123 return *this;
00124 }
00125
00126 template<typename _CharT, typename _Traits>
00127 basic_istream<_CharT, _Traits>&
00128 basic_istream<_CharT, _Traits>::
00129 operator>>(short& __n)
00130 {
00131 sentry __cerb(*this, false);
00132 if (__cerb)
00133 {
00134 try
00135 {
00136 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00137 if (_M_check_facet(_M_fnumget))
00138 _M_fnumget->get(*this, 0, *this, __err, __n);
00139 this->setstate(__err);
00140 }
00141 catch(exception& __fail)
00142 {
00143
00144
00145 this->setstate(ios_base::badbit);
00146 if ((this->exceptions() & ios_base::badbit) != 0)
00147 __throw_exception_again;
00148 }
00149 }
00150 return *this;
00151 }
00152
00153 template<typename _CharT, typename _Traits>
00154 basic_istream<_CharT, _Traits>&
00155 basic_istream<_CharT, _Traits>::
00156 operator>>(unsigned short& __n)
00157 {
00158 sentry __cerb(*this, false);
00159 if (__cerb)
00160 {
00161 try
00162 {
00163 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00164 if (_M_check_facet(_M_fnumget))
00165 _M_fnumget->get(*this, 0, *this, __err, __n);
00166 this->setstate(__err);
00167 }
00168 catch(exception& __fail)
00169 {
00170
00171
00172 this->setstate(ios_base::badbit);
00173 if ((this->exceptions() & ios_base::badbit) != 0)
00174 __throw_exception_again;
00175 }
00176 }
00177 return *this;
00178 }
00179
00180 template<typename _CharT, typename _Traits>
00181 basic_istream<_CharT, _Traits>&
00182 basic_istream<_CharT, _Traits>::
00183 operator>>(int& __n)
00184 {
00185 sentry __cerb(*this, false);
00186 if (__cerb)
00187 {
00188 try
00189 {
00190 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00191 if (_M_check_facet(_M_fnumget))
00192 _M_fnumget->get(*this, 0, *this, __err, __n);
00193 this->setstate(__err);
00194 }
00195 catch(exception& __fail)
00196 {
00197
00198
00199 this->setstate(ios_base::badbit);
00200 if ((this->exceptions() & ios_base::badbit) != 0)
00201 __throw_exception_again;
00202 }
00203 }
00204 return *this;
00205 }
00206
00207 template<typename _CharT, typename _Traits>
00208 basic_istream<_CharT, _Traits>&
00209 basic_istream<_CharT, _Traits>::
00210 operator>>(unsigned int& __n)
00211 {
00212 sentry __cerb(*this, false);
00213 if (__cerb)
00214 {
00215 try
00216 {
00217 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00218 if (_M_check_facet(_M_fnumget))
00219 _M_fnumget->get(*this, 0, *this, __err, __n);
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>>(long& __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>>(unsigned 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 #ifdef _GLIBCPP_USE_LONG_LONG
00289 template<typename _CharT, typename _Traits>
00290 basic_istream<_CharT, _Traits>&
00291 basic_istream<_CharT, _Traits>::
00292 operator>>(long long& __n)
00293 {
00294 sentry __cerb(*this, false);
00295 if (__cerb)
00296 {
00297 try
00298 {
00299 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00300 if (_M_check_facet(_M_fnumget))
00301 _M_fnumget->get(*this, 0, *this, __err, __n);
00302 this->setstate(__err);
00303 }
00304 catch(exception& __fail)
00305 {
00306
00307
00308 this->setstate(ios_base::badbit);
00309 if ((this->exceptions() & ios_base::badbit) != 0)
00310 __throw_exception_again;
00311 }
00312 }
00313 return *this;
00314 }
00315
00316 template<typename _CharT, typename _Traits>
00317 basic_istream<_CharT, _Traits>&
00318 basic_istream<_CharT, _Traits>::
00319 operator>>(unsigned 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 #endif
00343
00344 template<typename _CharT, typename _Traits>
00345 basic_istream<_CharT, _Traits>&
00346 basic_istream<_CharT, _Traits>::
00347 operator>>(float& __n)
00348 {
00349 sentry __cerb(*this, false);
00350 if (__cerb)
00351 {
00352 try
00353 {
00354 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00355 if (_M_check_facet(_M_fnumget))
00356 _M_fnumget->get(*this, 0, *this, __err, __n);
00357 this->setstate(__err);
00358 }
00359 catch(exception& __fail)
00360 {
00361
00362
00363 this->setstate(ios_base::badbit);
00364 if ((this->exceptions() & ios_base::badbit) != 0)
00365 __throw_exception_again;
00366 }
00367 }
00368 return *this;
00369 }
00370
00371 template<typename _CharT, typename _Traits>
00372 basic_istream<_CharT, _Traits>&
00373 basic_istream<_CharT, _Traits>::
00374 operator>>(double& __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>>(long 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>>(void*& __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>>(__streambuf_type* __sbout)
00456 {
00457 streamsize __xtrct = 0;
00458 __streambuf_type* __sbin = this->rdbuf();
00459 sentry __cerb(*this, false);
00460 if (__sbout && __cerb)
00461 __xtrct = __copy_streambufs(*this, __sbin, __sbout);
00462 if (!__sbout || !__xtrct)
00463 this->setstate(ios_base::failbit);
00464 return *this;
00465 }
00466
00467 template<typename _CharT, typename _Traits>
00468 typename basic_istream<_CharT, _Traits>::int_type
00469 basic_istream<_CharT, _Traits>::
00470 get(void)
00471 {
00472 const int_type __eof = traits_type::eof();
00473 int_type __c = __eof;
00474 _M_gcount = 0;
00475 sentry __cerb(*this, true);
00476 if (__cerb)
00477 {
00478 try
00479 {
00480 __c = this->rdbuf()->sbumpc();
00481
00482 if (__c != __eof)
00483 _M_gcount = 1;
00484 else
00485 this->setstate(ios_base::eofbit | ios_base::failbit);
00486 }
00487 catch(exception& __fail)
00488 {
00489
00490
00491 this->setstate(ios_base::badbit);
00492 if ((this->exceptions() & ios_base::badbit) != 0)
00493 __throw_exception_again;
00494 }
00495 }
00496 return __c;
00497 }
00498
00499 template<typename _CharT, typename _Traits>
00500 basic_istream<_CharT, _Traits>&
00501 basic_istream<_CharT, _Traits>::
00502 get(char_type& __c)
00503 {
00504 _M_gcount = 0;
00505 sentry __cerb(*this, true);
00506 if (__cerb)
00507 {
00508 try
00509 {
00510 const int_type __eof = traits_type::eof();
00511 int_type __bufval = this->rdbuf()->sbumpc();
00512
00513 if (__bufval != __eof)
00514 {
00515 _M_gcount = 1;
00516 __c = traits_type::to_char_type(__bufval);
00517 }
00518 else
00519 this->setstate(ios_base::eofbit | ios_base::failbit);
00520 }
00521 catch(exception& __fail)
00522 {
00523
00524
00525 this->setstate(ios_base::badbit);
00526 if ((this->exceptions() & ios_base::badbit) != 0)
00527 __throw_exception_again;
00528 }
00529 }
00530 return *this;
00531 }
00532
00533 template<typename _CharT, typename _Traits>
00534 basic_istream<_CharT, _Traits>&
00535 basic_istream<_CharT, _Traits>::
00536 get(char_type* __s, streamsize __n, char_type __delim)
00537 {
00538 _M_gcount = 0;
00539 sentry __cerb(*this, true);
00540 if (__cerb && __n > 1)
00541 {
00542 try
00543 {
00544 const int_type __idelim = traits_type::to_int_type(__delim);
00545 const int_type __eof = traits_type::eof();
00546 __streambuf_type* __sb = this->rdbuf();
00547 int_type __c = __sb->sbumpc();
00548 bool __testdelim = __c == __idelim;
00549 bool __testeof = __c == __eof;
00550
00551 while (_M_gcount < __n - 1 && !__testeof && !__testdelim)
00552 {
00553 *__s++ = traits_type::to_char_type(__c);
00554 ++_M_gcount;
00555 __c = __sb->sbumpc();
00556 __testeof = __c == __eof;
00557 __testdelim = __c == __idelim;
00558 }
00559 if (__testdelim || _M_gcount == __n - 1)
00560 __sb->sputbackc(__c);
00561 if (__testeof)
00562 this->setstate(ios_base::eofbit);
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 *__s = char_type();
00574 if (!_M_gcount)
00575 this->setstate(ios_base::failbit);
00576 return *this;
00577 }
00578
00579 template<typename _CharT, typename _Traits>
00580 basic_istream<_CharT, _Traits>&
00581 basic_istream<_CharT, _Traits>::
00582 get(__streambuf_type& __sb, char_type __delim)
00583 {
00584 _M_gcount = 0;
00585 sentry __cerb(*this, true);
00586 if (__cerb)
00587 {
00588 int_type __c;
00589 __streambuf_type* __this_sb = this->rdbuf();
00590 try
00591 {
00592 const int_type __idelim = traits_type::to_int_type(__delim);
00593 const int_type __eof = traits_type::eof();
00594 __c = __this_sb->sbumpc();
00595 bool __testdelim = __c == __idelim;
00596 bool __testeof = __c == __eof;
00597 bool __testput = true;
00598
00599 while (!__testeof && !__testdelim
00600 && (__testput = __sb.sputc(traits_type::to_char_type(__c))
00601 != __eof))
00602 {
00603 ++_M_gcount;
00604 __c = __this_sb->sbumpc();
00605 __testeof = __c == __eof;
00606 __testdelim = __c == __idelim;
00607 }
00608 if (__testdelim || !__testput)
00609 __this_sb->sputbackc(traits_type::to_char_type(__c));
00610 if (__testeof)
00611 this->setstate(ios_base::eofbit);
00612 }
00613 catch(exception& __fail)
00614 {
00615
00616 __this_sb->sputbackc(traits_type::to_char_type(__c));
00617 }
00618 }
00619 if (!_M_gcount)
00620 this->setstate(ios_base::failbit);
00621 return *this;
00622 }
00623
00624 template<typename _CharT, typename _Traits>
00625 basic_istream<_CharT, _Traits>&
00626 basic_istream<_CharT, _Traits>::
00627 getline(char_type* __s, streamsize __n, char_type __delim)
00628 {
00629 _M_gcount = 0;
00630 sentry __cerb(*this, true);
00631 if (__cerb)
00632 {
00633 try
00634 {
00635 __streambuf_type* __sb = this->rdbuf();
00636 int_type __c = __sb->sbumpc();
00637 ++_M_gcount;
00638 const int_type __idelim = traits_type::to_int_type(__delim);
00639 const int_type __eof = traits_type::eof();
00640 bool __testdelim = __c == __idelim;
00641 bool __testeof = __c == __eof;
00642
00643 while (_M_gcount < __n && !__testeof && !__testdelim)
00644 {
00645 *__s++ = traits_type::to_char_type(__c);
00646 __c = __sb->sbumpc();
00647 ++_M_gcount;
00648 __testeof = __c == __eof;
00649 __testdelim = __c == __idelim;
00650 }
00651
00652 if (__testeof)
00653 {
00654 --_M_gcount;
00655 this->setstate(ios_base::eofbit);
00656 }
00657 else if (!__testdelim)
00658 {
00659 --_M_gcount;
00660 __sb->sputbackc(traits_type::to_char_type(__c));
00661 this->setstate(ios_base::failbit);
00662 }
00663 }
00664 catch(exception& __fail)
00665 {
00666
00667
00668 this->setstate(ios_base::badbit);
00669 if ((this->exceptions() & ios_base::badbit) != 0)
00670 __throw_exception_again;
00671 }
00672 }
00673 *__s = char_type();
00674 if (!_M_gcount)
00675 this->setstate(ios_base::failbit);
00676 return *this;
00677 }
00678
00679 template<typename _CharT, typename _Traits>
00680 basic_istream<_CharT, _Traits>&
00681 basic_istream<_CharT, _Traits>::
00682 ignore(streamsize __n, int_type __delim)
00683 {
00684 _M_gcount = 0;
00685 sentry __cerb(*this, true);
00686 if (__cerb && __n > 0)
00687 {
00688 try
00689 {
00690 const int_type __idelim = traits_type::to_int_type(__delim);
00691 const int_type __eof = traits_type::eof();
00692 __streambuf_type* __sb = this->rdbuf();
00693 int_type __c = __sb->sbumpc();
00694 bool __testdelim = __c == __idelim;
00695 bool __testeof = __c == __eof;
00696
00697 __n = min(__n, numeric_limits<streamsize>::max());
00698 while (_M_gcount < __n - 1 && !__testeof && !__testdelim)
00699 {
00700 ++_M_gcount;
00701 __c = __sb->sbumpc();
00702 __testeof = __c == __eof;
00703 __testdelim = __c == __idelim;
00704 }
00705 if ((_M_gcount == __n - 1 && !__testeof) || __testdelim)
00706 ++_M_gcount;
00707 if (__testeof)
00708 this->setstate(ios_base::eofbit);
00709 }
00710 catch(exception& __fail)
00711 {
00712
00713
00714 this->setstate(ios_base::badbit);
00715 if ((this->exceptions() & ios_base::badbit) != 0)
00716 __throw_exception_again;
00717 }
00718 }
00719 return *this;
00720 }
00721
00722 template<typename _CharT, typename _Traits>
00723 typename basic_istream<_CharT, _Traits>::int_type
00724 basic_istream<_CharT, _Traits>::
00725 peek(void)
00726 {
00727 int_type __c = traits_type::eof();
00728 _M_gcount = 0;
00729 sentry __cerb(*this, true);
00730 if (__cerb)
00731 {
00732 try
00733 { __c = this->rdbuf()->sgetc(); }
00734 catch(exception& __fail)
00735 {
00736
00737
00738 this->setstate(ios_base::badbit);
00739 if ((this->exceptions() & ios_base::badbit) != 0)
00740 __throw_exception_again;
00741 }
00742 }
00743 return __c;
00744 }
00745
00746 template<typename _CharT, typename _Traits>
00747 basic_istream<_CharT, _Traits>&
00748 basic_istream<_CharT, _Traits>::
00749 read(char_type* __s, streamsize __n)
00750 {
00751 _M_gcount = 0;
00752 sentry __cerb(*this, true);
00753 if (__cerb)
00754 {
00755 if (__n > 0)
00756 {
00757 try
00758 {
00759 const int_type __eof = traits_type::eof();
00760 __streambuf_type* __sb = this->rdbuf();
00761 int_type __c = __sb->sbumpc();
00762 bool __testeof = __c == __eof;
00763
00764 while (_M_gcount < __n - 1 && !__testeof)
00765 {
00766 *__s++ = traits_type::to_char_type(__c);
00767 ++_M_gcount;
00768 __c = __sb->sbumpc();
00769 __testeof = __c == __eof;
00770 }
00771 if (__testeof)
00772 this->setstate(ios_base::eofbit | ios_base::failbit);
00773 else
00774 {
00775
00776 *__s++ = traits_type::to_char_type(__c);
00777 ++_M_gcount;
00778 }
00779 }
00780 catch(exception& __fail)
00781 {
00782
00783
00784 this->setstate(ios_base::badbit);
00785 if ((this->exceptions() & ios_base::badbit) != 0)
00786 __throw_exception_again;
00787 }
00788 }
00789 }
00790 else
00791 this->setstate(ios_base::failbit);
00792 return *this;
00793 }
00794
00795 template<typename _CharT, typename _Traits>
00796 streamsize
00797 basic_istream<_CharT, _Traits>::
00798 readsome(char_type* __s, streamsize __n)
00799 {
00800 const int_type __eof = traits_type::eof();
00801 _M_gcount = 0;
00802 sentry __cerb(*this, true);
00803 if (__cerb)
00804 {
00805 if (__n > 0)
00806 {
00807 try
00808 {
00809 streamsize __num = this->rdbuf()->in_avail();
00810 if (__num != static_cast<streamsize>(__eof))
00811 {
00812 __num = min(__num, __n);
00813 _M_gcount = this->rdbuf()->sgetn(__s, __num);
00814 }
00815 else
00816 this->setstate(ios_base::eofbit);
00817 }
00818 catch(exception& __fail)
00819 {
00820
00821
00822 this->setstate(ios_base::badbit);
00823 if ((this->exceptions() & ios_base::badbit) != 0)
00824 __throw_exception_again;
00825 }
00826 }
00827 }
00828 else
00829 this->setstate(ios_base::failbit);
00830 return _M_gcount;
00831 }
00832
00833 template<typename _CharT, typename _Traits>
00834 basic_istream<_CharT, _Traits>&
00835 basic_istream<_CharT, _Traits>::
00836 putback(char_type __c)
00837 {
00838 sentry __cerb(*this, true);
00839 if (__cerb)
00840 {
00841 try
00842 {
00843 const int_type __eof = traits_type::eof();
00844 __streambuf_type* __sb = this->rdbuf();
00845 if (!__sb || __sb->sputbackc(__c) == __eof)
00846 this->setstate(ios_base::badbit);
00847 }
00848 catch(exception& __fail)
00849 {
00850
00851
00852 this->setstate(ios_base::badbit);
00853 if ((this->exceptions() & ios_base::badbit) != 0)
00854 __throw_exception_again;
00855 }
00856 }
00857 else
00858 this->setstate(ios_base::failbit);
00859 return *this;
00860 }
00861
00862 template<typename _CharT, typename _Traits>
00863 basic_istream<_CharT, _Traits>&
00864 basic_istream<_CharT, _Traits>::
00865 unget(void)
00866 {
00867 _M_gcount = 0;
00868 sentry __cerb(*this, true);
00869 if (__cerb)
00870 {
00871 try
00872 {
00873 const int_type __eof = traits_type::eof();
00874 __streambuf_type* __sb = this->rdbuf();
00875 if (!__sb || __eof == __sb->sungetc())
00876 this->setstate(ios_base::badbit);
00877 }
00878 catch(exception& __fail)
00879 {
00880
00881
00882 this->setstate(ios_base::badbit);
00883 if ((this->exceptions() & ios_base::badbit) != 0)
00884 __throw_exception_again;
00885 }
00886 }
00887 else
00888 this->setstate(ios_base::failbit);
00889 return *this;
00890 }
00891
00892 template<typename _CharT, typename _Traits>
00893 int
00894 basic_istream<_CharT, _Traits>::
00895 sync(void)
00896 {
00897 int __ret = traits_type::eof();
00898 _M_gcount = 0;
00899 sentry __cerb(*this, true);
00900 if (__cerb)
00901 {
00902 try
00903 {
00904 __streambuf_type* __sb = this->rdbuf();
00905 if (!__sb || __ret == __sb->pubsync())
00906 this->setstate(ios_base::badbit);
00907 else
00908 __ret = 0;
00909 }
00910 catch(exception& __fail)
00911 {
00912
00913
00914 this->setstate(ios_base::badbit);
00915 if ((this->exceptions() & ios_base::badbit) != 0)
00916 __throw_exception_again;
00917 }
00918 }
00919 return __ret;
00920 }
00921
00922 template<typename _CharT, typename _Traits>
00923 typename basic_istream<_CharT, _Traits>::pos_type
00924 basic_istream<_CharT, _Traits>::
00925 tellg(void)
00926 {
00927 pos_type __ret = pos_type(-1);
00928 _M_gcount = 0;
00929 sentry __cerb(*this, true);
00930 if (__cerb)
00931 {
00932 try
00933 {
00934 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
00935 }
00936 catch(exception& __fail)
00937 {
00938
00939
00940 this->setstate(ios_base::badbit);
00941 if ((this->exceptions() & ios_base::badbit) != 0)
00942 __throw_exception_again;
00943 }
00944 }
00945 return __ret;
00946 }
00947
00948
00949 template<typename _CharT, typename _Traits>
00950 basic_istream<_CharT, _Traits>&
00951 basic_istream<_CharT, _Traits>::
00952 seekg(pos_type __pos)
00953 {
00954 _M_gcount = 0;
00955 sentry __cerb(*this, true);
00956 if (__cerb)
00957 {
00958 try
00959 {
00960 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00961
00962 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
00963
00964
00965 if (__err == pos_type(off_type(-1)))
00966 this->setstate(failbit);
00967 #endif
00968 }
00969 catch(exception& __fail)
00970 {
00971
00972
00973 this->setstate(ios_base::badbit);
00974 if ((this->exceptions() & ios_base::badbit) != 0)
00975 __throw_exception_again;
00976 }
00977 }
00978 return *this;
00979 }
00980
00981 template<typename _CharT, typename _Traits>
00982 basic_istream<_CharT, _Traits>&
00983 basic_istream<_CharT, _Traits>::
00984 seekg(off_type __off, ios_base::seekdir __dir)
00985 {
00986 _M_gcount = 0;
00987 sentry __cerb(*this, true);
00988 if (__cerb)
00989 {
00990 try
00991 {
00992 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00993
00994 pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
00995 ios_base::in);
00996
00997
00998 if (__err == pos_type(off_type(-1)))
00999 this->setstate(failbit);
01000 #endif
01001 }
01002 catch(exception& __fail)
01003 {
01004
01005
01006 this->setstate(ios_base::badbit);
01007 if ((this->exceptions() & ios_base::badbit) != 0)
01008 __throw_exception_again;
01009 }
01010 }
01011 return *this;
01012 }
01013
01014
01015 template<typename _CharT, typename _Traits>
01016 basic_istream<_CharT, _Traits>&
01017 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
01018 {
01019 typedef basic_istream<_CharT, _Traits> __istream_type;
01020 typename __istream_type::sentry __cerb(__in, false);
01021 if (__cerb)
01022 {
01023 try
01024 { __in.get(__c); }
01025 catch(exception& __fail)
01026 {
01027
01028
01029 __in.setstate(ios_base::badbit);
01030 if ((__in.exceptions() & ios_base::badbit) != 0)
01031 __throw_exception_again;
01032 }
01033 }
01034 else
01035 __in.setstate(ios_base::failbit);
01036 return __in;
01037 }
01038
01039 template<typename _CharT, typename _Traits>
01040 basic_istream<_CharT, _Traits>&
01041 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
01042 {
01043 typedef basic_istream<_CharT, _Traits> __istream_type;
01044 typedef typename __istream_type::__streambuf_type __streambuf_type;
01045 typedef typename _Traits::int_type int_type;
01046 typedef _CharT char_type;
01047 typedef ctype<_CharT> __ctype_type;
01048 streamsize __extracted = 0;
01049
01050 typename __istream_type::sentry __cerb(__in, false);
01051 if (__cerb)
01052 {
01053 try
01054 {
01055
01056 streamsize __num = __in.width();
01057 if (__num == 0)
01058 __num = numeric_limits<streamsize>::max();
01059
01060 __streambuf_type* __sb = __in.rdbuf();
01061 const __ctype_type* __ctype = __in._M_get_fctype_ios();
01062 int_type __c = __sb->sbumpc();
01063 const int_type __eof = _Traits::eof();
01064 bool __testsp = __ctype->is(ctype_base::space, __c);
01065 bool __testeof = __c == __eof;
01066
01067 while (__extracted < __num - 1 && !__testeof && !__testsp)
01068 {
01069 *__s++ = __c;
01070 ++__extracted;
01071 __c = __sb->sbumpc();
01072 __testeof = __c == __eof;
01073 __testsp = __ctype->is(ctype_base::space, __c);
01074 }
01075
01076 if (!__testeof)
01077 __sb->sputbackc(__c);
01078 else
01079 __in.setstate(ios_base::eofbit);
01080
01081 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
01082
01083 *__s = char_type();
01084 #endif
01085 __in.width(0);
01086 }
01087 catch(exception& __fail)
01088 {
01089
01090
01091 __in.setstate(ios_base::badbit);
01092 if ((__in.exceptions() & ios_base::badbit) != 0)
01093 __throw_exception_again;
01094 }
01095 }
01096 if (!__extracted)
01097 __in.setstate(ios_base::failbit);
01098 return __in;
01099 }
01100
01101
01102 template<typename _CharT, typename _Traits>
01103 basic_istream<_CharT,_Traits>&
01104 ws(basic_istream<_CharT,_Traits>& __in)
01105 {
01106 typedef basic_istream<_CharT, _Traits> __istream_type;
01107 typedef typename __istream_type::__streambuf_type __streambuf_type;
01108 typedef typename __istream_type::__ctype_type __ctype_type;
01109 typedef typename __istream_type::int_type __int_type;
01110 typedef typename __istream_type::char_type __char_type;
01111
01112 __streambuf_type* __sb = __in.rdbuf();
01113 const __ctype_type* __ctype = __in._M_get_fctype_ios();
01114 const __int_type __eof = _Traits::eof();
01115 __int_type __c;
01116 bool __testeof;
01117 bool __testsp;
01118
01119 do
01120 {
01121 __c = __sb->sbumpc();
01122 __testeof = __c == __eof;
01123 __testsp = __ctype->is(ctype_base::space, __c);
01124 }
01125 while (!__testeof && __testsp);
01126
01127 if (!__testeof && !__testsp)
01128 __sb->sputbackc(__c);
01129 else
01130 __in.setstate(ios_base::eofbit);
01131
01132 return __in;
01133 }
01134
01135
01136 template<typename _CharT, typename _Traits, typename _Alloc>
01137 basic_istream<_CharT, _Traits>&
01138 operator>>(basic_istream<_CharT, _Traits>& __in,
01139 basic_string<_CharT, _Traits, _Alloc>& __str)
01140 {
01141 typedef basic_istream<_CharT, _Traits> __istream_type;
01142 typedef typename __istream_type::int_type __int_type;
01143 typedef typename __istream_type::__streambuf_type __streambuf_type;
01144 typedef typename __istream_type::__ctype_type __ctype_type;
01145 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01146 typedef typename __string_type::size_type __size_type;
01147 __size_type __extracted = 0;
01148
01149 typename __istream_type::sentry __cerb(__in, false);
01150 if (__cerb)
01151 {
01152 __str.erase();
01153 streamsize __w = __in.width();
01154 __size_type __n;
01155 __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
01156
01157 __streambuf_type* __sb = __in.rdbuf();
01158 const __ctype_type* __ctype = __in._M_get_fctype_ios();
01159 __int_type __c = __sb->sbumpc();
01160 const __int_type __eof = _Traits::eof();
01161 bool __testsp = __ctype->is(ctype_base::space, __c);
01162 bool __testeof = __c == __eof;
01163
01164 while (__extracted < __n && !__testeof && !__testsp)
01165 {
01166 __str += _Traits::to_char_type(__c);
01167 ++__extracted;
01168 __c = __sb->sbumpc();
01169 __testeof = __c == __eof;
01170 __testsp = __ctype->is(ctype_base::space, __c);
01171 }
01172 if (!__testeof)
01173 __sb->sputbackc(__c);
01174 else
01175 __in.setstate(ios_base::eofbit);
01176 __in.width(0);
01177 }
01178 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
01179
01180 if (!__extracted)
01181 __in.setstate (ios_base::failbit);
01182 #endif
01183 return __in;
01184 }
01185
01186 template<typename _CharT, typename _Traits, typename _Alloc>
01187 basic_istream<_CharT, _Traits>&
01188 getline(basic_istream<_CharT, _Traits>& __in,
01189 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
01190 {
01191 typedef basic_istream<_CharT, _Traits> __istream_type;
01192 typedef typename __istream_type::int_type __int_type;
01193 typedef typename __istream_type::__streambuf_type __streambuf_type;
01194 typedef typename __istream_type::__ctype_type __ctype_type;
01195 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
01196 typedef typename __string_type::size_type __size_type;
01197
01198 __size_type __extracted = 0;
01199 bool __testdelim = false;
01200 typename __istream_type::sentry __cerb(__in, true);
01201 if (__cerb)
01202 {
01203 __str.erase();
01204 __size_type __n = __str.max_size();
01205
01206 __int_type __idelim = _Traits::to_int_type(__delim);
01207 __streambuf_type* __sb = __in.rdbuf();
01208 __int_type __c = __sb->sbumpc();
01209 const __int_type __eof = _Traits::eof();
01210 __testdelim = __c == __idelim;
01211 bool __testeof = __c == __eof;
01212
01213 while (__extracted <= __n && !__testeof && !__testdelim)
01214 {
01215 __str += _Traits::to_char_type(__c);
01216 ++__extracted;
01217 __c = __sb->sbumpc();
01218 __testeof = __c == __eof;
01219 __testdelim = __c == __idelim;
01220 }
01221 if (__testeof)
01222 __in.setstate(ios_base::eofbit);
01223 }
01224 if (!__extracted && !__testdelim)
01225 __in.setstate(ios_base::failbit);
01226 return __in;
01227 }
01228
01229 template<class _CharT, class _Traits, class _Alloc>
01230 inline basic_istream<_CharT,_Traits>&
01231 getline(basic_istream<_CharT, _Traits>& __in,
01232 basic_string<_CharT,_Traits,_Alloc>& __str)
01233 { return getline(__in, __str, __in.widen('\n')); }
01234 }
01235
01236
01237
01238
01239