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
00036
00037
00038
00039
00040
00041 #ifndef _ISTREAM_TCC
00042 #define _ISTREAM_TCC 1
00043
00044 #pragma GCC system_header
00045
00046 #include <cxxabi-forced.h>
00047
00048 _GLIBCXX_BEGIN_NAMESPACE(std)
00049
00050 template<typename _CharT, typename _Traits>
00051 basic_istream<_CharT, _Traits>::sentry::
00052 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
00053 {
00054 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00055 if (__in.good())
00056 {
00057 if (__in.tie())
00058 __in.tie()->flush();
00059 if (!__noskip && bool(__in.flags() & ios_base::skipws))
00060 {
00061 const __int_type __eof = traits_type::eof();
00062 __streambuf_type* __sb = __in.rdbuf();
00063 __int_type __c = __sb->sgetc();
00064
00065 const __ctype_type& __ct = __check_facet(__in._M_ctype);
00066 while (!traits_type::eq_int_type(__c, __eof)
00067 && __ct.is(ctype_base::space,
00068 traits_type::to_char_type(__c)))
00069 __c = __sb->snextc();
00070
00071
00072
00073
00074 if (traits_type::eq_int_type(__c, __eof))
00075 __err |= ios_base::eofbit;
00076 }
00077 }
00078
00079 if (__in.good() && __err == ios_base::goodbit)
00080 _M_ok = true;
00081 else
00082 {
00083 __err |= ios_base::failbit;
00084 __in.setstate(__err);
00085 }
00086 }
00087
00088 template<typename _CharT, typename _Traits>
00089 template<typename _ValueT>
00090 basic_istream<_CharT, _Traits>&
00091 basic_istream<_CharT, _Traits>::
00092 _M_extract(_ValueT& __v)
00093 {
00094 sentry __cerb(*this, false);
00095 if (__cerb)
00096 {
00097 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00098 try
00099 {
00100 const __num_get_type& __ng = __check_facet(this->_M_num_get);
00101 __ng.get(*this, 0, *this, __err, __v);
00102 }
00103 catch(__cxxabiv1::__forced_unwind&)
00104 {
00105 this->_M_setstate(ios_base::badbit);
00106 __throw_exception_again;
00107 }
00108 catch(...)
00109 { this->_M_setstate(ios_base::badbit); }
00110 if (__err)
00111 this->setstate(__err);
00112 }
00113 return *this;
00114 }
00115
00116 template<typename _CharT, typename _Traits>
00117 basic_istream<_CharT, _Traits>&
00118 basic_istream<_CharT, _Traits>::
00119 operator>>(short& __n)
00120 {
00121
00122
00123 long __l;
00124 _M_extract(__l);
00125 if (!this->fail())
00126 {
00127 if (__gnu_cxx::__numeric_traits<short>::__min <= __l
00128 && __l <= __gnu_cxx::__numeric_traits<short>::__max)
00129 __n = short(__l);
00130 else
00131 this->setstate(ios_base::failbit);
00132 }
00133 return *this;
00134 }
00135
00136 template<typename _CharT, typename _Traits>
00137 basic_istream<_CharT, _Traits>&
00138 basic_istream<_CharT, _Traits>::
00139 operator>>(int& __n)
00140 {
00141
00142
00143 long __l;
00144 _M_extract(__l);
00145 if (!this->fail())
00146 {
00147 if (__gnu_cxx::__numeric_traits<int>::__min <= __l
00148 && __l <= __gnu_cxx::__numeric_traits<int>::__max)
00149 __n = int(__l);
00150 else
00151 this->setstate(ios_base::failbit);
00152 }
00153 return *this;
00154 }
00155
00156 template<typename _CharT, typename _Traits>
00157 basic_istream<_CharT, _Traits>&
00158 basic_istream<_CharT, _Traits>::
00159 operator>>(__streambuf_type* __sbout)
00160 {
00161 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00162 sentry __cerb(*this, false);
00163 if (__cerb && __sbout)
00164 {
00165 try
00166 {
00167 bool __ineof;
00168 if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
00169 __err |= ios_base::failbit;
00170 if (__ineof)
00171 __err |= ios_base::eofbit;
00172 }
00173 catch(__cxxabiv1::__forced_unwind&)
00174 {
00175 this->_M_setstate(ios_base::failbit);
00176 __throw_exception_again;
00177 }
00178 catch(...)
00179 { this->_M_setstate(ios_base::failbit); }
00180 }
00181 else if (!__sbout)
00182 __err |= ios_base::failbit;
00183 if (__err)
00184 this->setstate(__err);
00185 return *this;
00186 }
00187
00188 template<typename _CharT, typename _Traits>
00189 typename basic_istream<_CharT, _Traits>::int_type
00190 basic_istream<_CharT, _Traits>::
00191 get(void)
00192 {
00193 const int_type __eof = traits_type::eof();
00194 int_type __c = __eof;
00195 _M_gcount = 0;
00196 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00197 sentry __cerb(*this, true);
00198 if (__cerb)
00199 {
00200 try
00201 {
00202 __c = this->rdbuf()->sbumpc();
00203
00204 if (!traits_type::eq_int_type(__c, __eof))
00205 _M_gcount = 1;
00206 else
00207 __err |= ios_base::eofbit;
00208 }
00209 catch(__cxxabiv1::__forced_unwind&)
00210 {
00211 this->_M_setstate(ios_base::badbit);
00212 __throw_exception_again;
00213 }
00214 catch(...)
00215 { this->_M_setstate(ios_base::badbit); }
00216 }
00217 if (!_M_gcount)
00218 __err |= ios_base::failbit;
00219 if (__err)
00220 this->setstate(__err);
00221 return __c;
00222 }
00223
00224 template<typename _CharT, typename _Traits>
00225 basic_istream<_CharT, _Traits>&
00226 basic_istream<_CharT, _Traits>::
00227 get(char_type& __c)
00228 {
00229 _M_gcount = 0;
00230 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00231 sentry __cerb(*this, true);
00232 if (__cerb)
00233 {
00234 try
00235 {
00236 const int_type __cb = this->rdbuf()->sbumpc();
00237
00238 if (!traits_type::eq_int_type(__cb, traits_type::eof()))
00239 {
00240 _M_gcount = 1;
00241 __c = traits_type::to_char_type(__cb);
00242 }
00243 else
00244 __err |= ios_base::eofbit;
00245 }
00246 catch(__cxxabiv1::__forced_unwind&)
00247 {
00248 this->_M_setstate(ios_base::badbit);
00249 __throw_exception_again;
00250 }
00251 catch(...)
00252 { this->_M_setstate(ios_base::badbit); }
00253 }
00254 if (!_M_gcount)
00255 __err |= ios_base::failbit;
00256 if (__err)
00257 this->setstate(__err);
00258 return *this;
00259 }
00260
00261 template<typename _CharT, typename _Traits>
00262 basic_istream<_CharT, _Traits>&
00263 basic_istream<_CharT, _Traits>::
00264 get(char_type* __s, streamsize __n, char_type __delim)
00265 {
00266 _M_gcount = 0;
00267 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00268 sentry __cerb(*this, true);
00269 if (__cerb)
00270 {
00271 try
00272 {
00273 const int_type __idelim = traits_type::to_int_type(__delim);
00274 const int_type __eof = traits_type::eof();
00275 __streambuf_type* __sb = this->rdbuf();
00276 int_type __c = __sb->sgetc();
00277
00278 while (_M_gcount + 1 < __n
00279 && !traits_type::eq_int_type(__c, __eof)
00280 && !traits_type::eq_int_type(__c, __idelim))
00281 {
00282 *__s++ = traits_type::to_char_type(__c);
00283 ++_M_gcount;
00284 __c = __sb->snextc();
00285 }
00286 if (traits_type::eq_int_type(__c, __eof))
00287 __err |= ios_base::eofbit;
00288 }
00289 catch(__cxxabiv1::__forced_unwind&)
00290 {
00291 this->_M_setstate(ios_base::badbit);
00292 __throw_exception_again;
00293 }
00294 catch(...)
00295 { this->_M_setstate(ios_base::badbit); }
00296 }
00297
00298
00299 if (__n > 0)
00300 *__s = char_type();
00301 if (!_M_gcount)
00302 __err |= ios_base::failbit;
00303 if (__err)
00304 this->setstate(__err);
00305 return *this;
00306 }
00307
00308 template<typename _CharT, typename _Traits>
00309 basic_istream<_CharT, _Traits>&
00310 basic_istream<_CharT, _Traits>::
00311 get(__streambuf_type& __sb, char_type __delim)
00312 {
00313 _M_gcount = 0;
00314 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00315 sentry __cerb(*this, true);
00316 if (__cerb)
00317 {
00318 try
00319 {
00320 const int_type __idelim = traits_type::to_int_type(__delim);
00321 const int_type __eof = traits_type::eof();
00322 __streambuf_type* __this_sb = this->rdbuf();
00323 int_type __c = __this_sb->sgetc();
00324 char_type __c2 = traits_type::to_char_type(__c);
00325
00326 while (!traits_type::eq_int_type(__c, __eof)
00327 && !traits_type::eq_int_type(__c, __idelim)
00328 && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
00329 {
00330 ++_M_gcount;
00331 __c = __this_sb->snextc();
00332 __c2 = traits_type::to_char_type(__c);
00333 }
00334 if (traits_type::eq_int_type(__c, __eof))
00335 __err |= ios_base::eofbit;
00336 }
00337 catch(__cxxabiv1::__forced_unwind&)
00338 {
00339 this->_M_setstate(ios_base::badbit);
00340 __throw_exception_again;
00341 }
00342 catch(...)
00343 { this->_M_setstate(ios_base::badbit); }
00344 }
00345 if (!_M_gcount)
00346 __err |= ios_base::failbit;
00347 if (__err)
00348 this->setstate(__err);
00349 return *this;
00350 }
00351
00352 template<typename _CharT, typename _Traits>
00353 basic_istream<_CharT, _Traits>&
00354 basic_istream<_CharT, _Traits>::
00355 getline(char_type* __s, streamsize __n, char_type __delim)
00356 {
00357 _M_gcount = 0;
00358 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00359 sentry __cerb(*this, true);
00360 if (__cerb)
00361 {
00362 try
00363 {
00364 const int_type __idelim = traits_type::to_int_type(__delim);
00365 const int_type __eof = traits_type::eof();
00366 __streambuf_type* __sb = this->rdbuf();
00367 int_type __c = __sb->sgetc();
00368
00369 while (_M_gcount + 1 < __n
00370 && !traits_type::eq_int_type(__c, __eof)
00371 && !traits_type::eq_int_type(__c, __idelim))
00372 {
00373 *__s++ = traits_type::to_char_type(__c);
00374 __c = __sb->snextc();
00375 ++_M_gcount;
00376 }
00377 if (traits_type::eq_int_type(__c, __eof))
00378 __err |= ios_base::eofbit;
00379 else
00380 {
00381 if (traits_type::eq_int_type(__c, __idelim))
00382 {
00383 __sb->sbumpc();
00384 ++_M_gcount;
00385 }
00386 else
00387 __err |= ios_base::failbit;
00388 }
00389 }
00390 catch(__cxxabiv1::__forced_unwind&)
00391 {
00392 this->_M_setstate(ios_base::badbit);
00393 __throw_exception_again;
00394 }
00395 catch(...)
00396 { this->_M_setstate(ios_base::badbit); }
00397 }
00398
00399
00400 if (__n > 0)
00401 *__s = char_type();
00402 if (!_M_gcount)
00403 __err |= ios_base::failbit;
00404 if (__err)
00405 this->setstate(__err);
00406 return *this;
00407 }
00408
00409
00410
00411
00412 template<typename _CharT, typename _Traits>
00413 basic_istream<_CharT, _Traits>&
00414 basic_istream<_CharT, _Traits>::
00415 ignore(void)
00416 {
00417 _M_gcount = 0;
00418 sentry __cerb(*this, true);
00419 if (__cerb)
00420 {
00421 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00422 try
00423 {
00424 const int_type __eof = traits_type::eof();
00425 __streambuf_type* __sb = this->rdbuf();
00426
00427 if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
00428 __err |= ios_base::eofbit;
00429 else
00430 _M_gcount = 1;
00431 }
00432 catch(__cxxabiv1::__forced_unwind&)
00433 {
00434 this->_M_setstate(ios_base::badbit);
00435 __throw_exception_again;
00436 }
00437 catch(...)
00438 { this->_M_setstate(ios_base::badbit); }
00439 if (__err)
00440 this->setstate(__err);
00441 }
00442 return *this;
00443 }
00444
00445 template<typename _CharT, typename _Traits>
00446 basic_istream<_CharT, _Traits>&
00447 basic_istream<_CharT, _Traits>::
00448 ignore(streamsize __n)
00449 {
00450 _M_gcount = 0;
00451 sentry __cerb(*this, true);
00452 if (__cerb && __n > 0)
00453 {
00454 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00455 try
00456 {
00457 const int_type __eof = traits_type::eof();
00458 __streambuf_type* __sb = this->rdbuf();
00459 int_type __c = __sb->sgetc();
00460
00461
00462
00463
00464
00465
00466
00467
00468 bool __large_ignore = false;
00469 while (true)
00470 {
00471 while (_M_gcount < __n
00472 && !traits_type::eq_int_type(__c, __eof))
00473 {
00474 ++_M_gcount;
00475 __c = __sb->snextc();
00476 }
00477 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
00478 && !traits_type::eq_int_type(__c, __eof))
00479 {
00480 _M_gcount =
00481 __gnu_cxx::__numeric_traits<streamsize>::__min;
00482 __large_ignore = true;
00483 }
00484 else
00485 break;
00486 }
00487
00488 if (__large_ignore)
00489 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
00490
00491 if (traits_type::eq_int_type(__c, __eof))
00492 __err |= ios_base::eofbit;
00493 }
00494 catch(__cxxabiv1::__forced_unwind&)
00495 {
00496 this->_M_setstate(ios_base::badbit);
00497 __throw_exception_again;
00498 }
00499 catch(...)
00500 { this->_M_setstate(ios_base::badbit); }
00501 if (__err)
00502 this->setstate(__err);
00503 }
00504 return *this;
00505 }
00506
00507 template<typename _CharT, typename _Traits>
00508 basic_istream<_CharT, _Traits>&
00509 basic_istream<_CharT, _Traits>::
00510 ignore(streamsize __n, int_type __delim)
00511 {
00512 _M_gcount = 0;
00513 sentry __cerb(*this, true);
00514 if (__cerb && __n > 0)
00515 {
00516 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00517 try
00518 {
00519 const int_type __eof = traits_type::eof();
00520 __streambuf_type* __sb = this->rdbuf();
00521 int_type __c = __sb->sgetc();
00522
00523
00524 bool __large_ignore = false;
00525 while (true)
00526 {
00527 while (_M_gcount < __n
00528 && !traits_type::eq_int_type(__c, __eof)
00529 && !traits_type::eq_int_type(__c, __delim))
00530 {
00531 ++_M_gcount;
00532 __c = __sb->snextc();
00533 }
00534 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
00535 && !traits_type::eq_int_type(__c, __eof)
00536 && !traits_type::eq_int_type(__c, __delim))
00537 {
00538 _M_gcount =
00539 __gnu_cxx::__numeric_traits<streamsize>::__min;
00540 __large_ignore = true;
00541 }
00542 else
00543 break;
00544 }
00545
00546 if (__large_ignore)
00547 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
00548
00549 if (traits_type::eq_int_type(__c, __eof))
00550 __err |= ios_base::eofbit;
00551 else if (traits_type::eq_int_type(__c, __delim))
00552 {
00553 if (_M_gcount
00554 < __gnu_cxx::__numeric_traits<streamsize>::__max)
00555 ++_M_gcount;
00556 __sb->sbumpc();
00557 }
00558 }
00559 catch(__cxxabiv1::__forced_unwind&)
00560 {
00561 this->_M_setstate(ios_base::badbit);
00562 __throw_exception_again;
00563 }
00564 catch(...)
00565 { this->_M_setstate(ios_base::badbit); }
00566 if (__err)
00567 this->setstate(__err);
00568 }
00569 return *this;
00570 }
00571
00572 template<typename _CharT, typename _Traits>
00573 typename basic_istream<_CharT, _Traits>::int_type
00574 basic_istream<_CharT, _Traits>::
00575 peek(void)
00576 {
00577 int_type __c = traits_type::eof();
00578 _M_gcount = 0;
00579 sentry __cerb(*this, true);
00580 if (__cerb)
00581 {
00582 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00583 try
00584 {
00585 __c = this->rdbuf()->sgetc();
00586 if (traits_type::eq_int_type(__c, traits_type::eof()))
00587 __err |= ios_base::eofbit;
00588 }
00589 catch(__cxxabiv1::__forced_unwind&)
00590 {
00591 this->_M_setstate(ios_base::badbit);
00592 __throw_exception_again;
00593 }
00594 catch(...)
00595 { this->_M_setstate(ios_base::badbit); }
00596 if (__err)
00597 this->setstate(__err);
00598 }
00599 return __c;
00600 }
00601
00602 template<typename _CharT, typename _Traits>
00603 basic_istream<_CharT, _Traits>&
00604 basic_istream<_CharT, _Traits>::
00605 read(char_type* __s, streamsize __n)
00606 {
00607 _M_gcount = 0;
00608 sentry __cerb(*this, true);
00609 if (__cerb)
00610 {
00611 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00612 try
00613 {
00614 _M_gcount = this->rdbuf()->sgetn(__s, __n);
00615 if (_M_gcount != __n)
00616 __err |= (ios_base::eofbit | ios_base::failbit);
00617 }
00618 catch(__cxxabiv1::__forced_unwind&)
00619 {
00620 this->_M_setstate(ios_base::badbit);
00621 __throw_exception_again;
00622 }
00623 catch(...)
00624 { this->_M_setstate(ios_base::badbit); }
00625 if (__err)
00626 this->setstate(__err);
00627 }
00628 return *this;
00629 }
00630
00631 template<typename _CharT, typename _Traits>
00632 streamsize
00633 basic_istream<_CharT, _Traits>::
00634 readsome(char_type* __s, streamsize __n)
00635 {
00636 _M_gcount = 0;
00637 sentry __cerb(*this, true);
00638 if (__cerb)
00639 {
00640 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00641 try
00642 {
00643
00644 const streamsize __num = this->rdbuf()->in_avail();
00645 if (__num > 0)
00646 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
00647 else if (__num == -1)
00648 __err |= ios_base::eofbit;
00649 }
00650 catch(__cxxabiv1::__forced_unwind&)
00651 {
00652 this->_M_setstate(ios_base::badbit);
00653 __throw_exception_again;
00654 }
00655 catch(...)
00656 { this->_M_setstate(ios_base::badbit); }
00657 if (__err)
00658 this->setstate(__err);
00659 }
00660 return _M_gcount;
00661 }
00662
00663 template<typename _CharT, typename _Traits>
00664 basic_istream<_CharT, _Traits>&
00665 basic_istream<_CharT, _Traits>::
00666 putback(char_type __c)
00667 {
00668
00669
00670 _M_gcount = 0;
00671 sentry __cerb(*this, true);
00672 if (__cerb)
00673 {
00674 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00675 try
00676 {
00677 const int_type __eof = traits_type::eof();
00678 __streambuf_type* __sb = this->rdbuf();
00679 if (!__sb
00680 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
00681 __err |= ios_base::badbit;
00682 }
00683 catch(__cxxabiv1::__forced_unwind&)
00684 {
00685 this->_M_setstate(ios_base::badbit);
00686 __throw_exception_again;
00687 }
00688 catch(...)
00689 { this->_M_setstate(ios_base::badbit); }
00690 if (__err)
00691 this->setstate(__err);
00692 }
00693 return *this;
00694 }
00695
00696 template<typename _CharT, typename _Traits>
00697 basic_istream<_CharT, _Traits>&
00698 basic_istream<_CharT, _Traits>::
00699 unget(void)
00700 {
00701
00702
00703 _M_gcount = 0;
00704 sentry __cerb(*this, true);
00705 if (__cerb)
00706 {
00707 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00708 try
00709 {
00710 const int_type __eof = traits_type::eof();
00711 __streambuf_type* __sb = this->rdbuf();
00712 if (!__sb
00713 || traits_type::eq_int_type(__sb->sungetc(), __eof))
00714 __err |= ios_base::badbit;
00715 }
00716 catch(__cxxabiv1::__forced_unwind&)
00717 {
00718 this->_M_setstate(ios_base::badbit);
00719 __throw_exception_again;
00720 }
00721 catch(...)
00722 { this->_M_setstate(ios_base::badbit); }
00723 if (__err)
00724 this->setstate(__err);
00725 }
00726 return *this;
00727 }
00728
00729 template<typename _CharT, typename _Traits>
00730 int
00731 basic_istream<_CharT, _Traits>::
00732 sync(void)
00733 {
00734
00735
00736 int __ret = -1;
00737 sentry __cerb(*this, true);
00738 if (__cerb)
00739 {
00740 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00741 try
00742 {
00743 __streambuf_type* __sb = this->rdbuf();
00744 if (__sb)
00745 {
00746 if (__sb->pubsync() == -1)
00747 __err |= ios_base::badbit;
00748 else
00749 __ret = 0;
00750 }
00751 }
00752 catch(__cxxabiv1::__forced_unwind&)
00753 {
00754 this->_M_setstate(ios_base::badbit);
00755 __throw_exception_again;
00756 }
00757 catch(...)
00758 { this->_M_setstate(ios_base::badbit); }
00759 if (__err)
00760 this->setstate(__err);
00761 }
00762 return __ret;
00763 }
00764
00765 template<typename _CharT, typename _Traits>
00766 typename basic_istream<_CharT, _Traits>::pos_type
00767 basic_istream<_CharT, _Traits>::
00768 tellg(void)
00769 {
00770
00771
00772 pos_type __ret = pos_type(-1);
00773 try
00774 {
00775 if (!this->fail())
00776 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
00777 ios_base::in);
00778 }
00779 catch(__cxxabiv1::__forced_unwind&)
00780 {
00781 this->_M_setstate(ios_base::badbit);
00782 __throw_exception_again;
00783 }
00784 catch(...)
00785 { this->_M_setstate(ios_base::badbit); }
00786 return __ret;
00787 }
00788
00789 template<typename _CharT, typename _Traits>
00790 basic_istream<_CharT, _Traits>&
00791 basic_istream<_CharT, _Traits>::
00792 seekg(pos_type __pos)
00793 {
00794
00795
00796 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00797 try
00798 {
00799 if (!this->fail())
00800 {
00801
00802 const pos_type __p = this->rdbuf()->pubseekpos(__pos,
00803 ios_base::in);
00804
00805
00806 if (__p == pos_type(off_type(-1)))
00807 __err |= ios_base::failbit;
00808 }
00809 }
00810 catch(__cxxabiv1::__forced_unwind&)
00811 {
00812 this->_M_setstate(ios_base::badbit);
00813 __throw_exception_again;
00814 }
00815 catch(...)
00816 { this->_M_setstate(ios_base::badbit); }
00817 if (__err)
00818 this->setstate(__err);
00819 return *this;
00820 }
00821
00822 template<typename _CharT, typename _Traits>
00823 basic_istream<_CharT, _Traits>&
00824 basic_istream<_CharT, _Traits>::
00825 seekg(off_type __off, ios_base::seekdir __dir)
00826 {
00827
00828
00829 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00830 try
00831 {
00832 if (!this->fail())
00833 {
00834
00835 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
00836 ios_base::in);
00837
00838
00839 if (__p == pos_type(off_type(-1)))
00840 __err |= ios_base::failbit;
00841 }
00842 }
00843 catch(__cxxabiv1::__forced_unwind&)
00844 {
00845 this->_M_setstate(ios_base::badbit);
00846 __throw_exception_again;
00847 }
00848 catch(...)
00849 { this->_M_setstate(ios_base::badbit); }
00850 if (__err)
00851 this->setstate(__err);
00852 return *this;
00853 }
00854
00855
00856 template<typename _CharT, typename _Traits>
00857 basic_istream<_CharT, _Traits>&
00858 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
00859 {
00860 typedef basic_istream<_CharT, _Traits> __istream_type;
00861 typedef typename __istream_type::int_type __int_type;
00862
00863 typename __istream_type::sentry __cerb(__in, false);
00864 if (__cerb)
00865 {
00866 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00867 try
00868 {
00869 const __int_type __cb = __in.rdbuf()->sbumpc();
00870 if (!_Traits::eq_int_type(__cb, _Traits::eof()))
00871 __c = _Traits::to_char_type(__cb);
00872 else
00873 __err |= (ios_base::eofbit | ios_base::failbit);
00874 }
00875 catch(__cxxabiv1::__forced_unwind&)
00876 {
00877 __in._M_setstate(ios_base::badbit);
00878 __throw_exception_again;
00879 }
00880 catch(...)
00881 { __in._M_setstate(ios_base::badbit); }
00882 if (__err)
00883 __in.setstate(__err);
00884 }
00885 return __in;
00886 }
00887
00888 template<typename _CharT, typename _Traits>
00889 basic_istream<_CharT, _Traits>&
00890 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
00891 {
00892 typedef basic_istream<_CharT, _Traits> __istream_type;
00893 typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
00894 typedef typename _Traits::int_type int_type;
00895 typedef _CharT char_type;
00896 typedef ctype<_CharT> __ctype_type;
00897
00898 streamsize __extracted = 0;
00899 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00900 typename __istream_type::sentry __cerb(__in, false);
00901 if (__cerb)
00902 {
00903 try
00904 {
00905
00906 streamsize __num = __in.width();
00907 if (__num <= 0)
00908 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
00909
00910 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
00911
00912 const int_type __eof = _Traits::eof();
00913 __streambuf_type* __sb = __in.rdbuf();
00914 int_type __c = __sb->sgetc();
00915
00916 while (__extracted < __num - 1
00917 && !_Traits::eq_int_type(__c, __eof)
00918 && !__ct.is(ctype_base::space,
00919 _Traits::to_char_type(__c)))
00920 {
00921 *__s++ = _Traits::to_char_type(__c);
00922 ++__extracted;
00923 __c = __sb->snextc();
00924 }
00925 if (_Traits::eq_int_type(__c, __eof))
00926 __err |= ios_base::eofbit;
00927
00928
00929
00930 *__s = char_type();
00931 __in.width(0);
00932 }
00933 catch(__cxxabiv1::__forced_unwind&)
00934 {
00935 __in._M_setstate(ios_base::badbit);
00936 __throw_exception_again;
00937 }
00938 catch(...)
00939 { __in._M_setstate(ios_base::badbit); }
00940 }
00941 if (!__extracted)
00942 __err |= ios_base::failbit;
00943 if (__err)
00944 __in.setstate(__err);
00945 return __in;
00946 }
00947
00948
00949 template<typename _CharT, typename _Traits>
00950 basic_istream<_CharT, _Traits>&
00951 ws(basic_istream<_CharT, _Traits>& __in)
00952 {
00953 typedef basic_istream<_CharT, _Traits> __istream_type;
00954 typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
00955 typedef typename __istream_type::int_type __int_type;
00956 typedef ctype<_CharT> __ctype_type;
00957
00958 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
00959 const __int_type __eof = _Traits::eof();
00960 __streambuf_type* __sb = __in.rdbuf();
00961 __int_type __c = __sb->sgetc();
00962
00963 while (!_Traits::eq_int_type(__c, __eof)
00964 && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
00965 __c = __sb->snextc();
00966
00967 if (_Traits::eq_int_type(__c, __eof))
00968 __in.setstate(ios_base::eofbit);
00969 return __in;
00970 }
00971
00972
00973
00974
00975 #if _GLIBCXX_EXTERN_TEMPLATE
00976 extern template class basic_istream<char>;
00977 extern template istream& ws(istream&);
00978 extern template istream& operator>>(istream&, char&);
00979 extern template istream& operator>>(istream&, char*);
00980 extern template istream& operator>>(istream&, unsigned char&);
00981 extern template istream& operator>>(istream&, signed char&);
00982 extern template istream& operator>>(istream&, unsigned char*);
00983 extern template istream& operator>>(istream&, signed char*);
00984
00985 extern template istream& istream::_M_extract(unsigned short&);
00986 extern template istream& istream::_M_extract(unsigned int&);
00987 extern template istream& istream::_M_extract(long&);
00988 extern template istream& istream::_M_extract(unsigned long&);
00989 extern template istream& istream::_M_extract(bool&);
00990 #ifdef _GLIBCXX_USE_LONG_LONG
00991 extern template istream& istream::_M_extract(long long&);
00992 extern template istream& istream::_M_extract(unsigned long long&);
00993 #endif
00994 extern template istream& istream::_M_extract(float&);
00995 extern template istream& istream::_M_extract(double&);
00996 extern template istream& istream::_M_extract(long double&);
00997 extern template istream& istream::_M_extract(void*&);
00998
00999 extern template class basic_iostream<char>;
01000
01001 #ifdef _GLIBCXX_USE_WCHAR_T
01002 extern template class basic_istream<wchar_t>;
01003 extern template wistream& ws(wistream&);
01004 extern template wistream& operator>>(wistream&, wchar_t&);
01005 extern template wistream& operator>>(wistream&, wchar_t*);
01006
01007 extern template wistream& wistream::_M_extract(unsigned short&);
01008 extern template wistream& wistream::_M_extract(unsigned int&);
01009 extern template wistream& wistream::_M_extract(long&);
01010 extern template wistream& wistream::_M_extract(unsigned long&);
01011 extern template wistream& wistream::_M_extract(bool&);
01012 #ifdef _GLIBCXX_USE_LONG_LONG
01013 extern template wistream& wistream::_M_extract(long long&);
01014 extern template wistream& wistream::_M_extract(unsigned long long&);
01015 #endif
01016 extern template wistream& wistream::_M_extract(float&);
01017 extern template wistream& wistream::_M_extract(double&);
01018 extern template wistream& wistream::_M_extract(long double&);
01019 extern template wistream& wistream::_M_extract(void*&);
01020
01021 extern template class basic_iostream<wchar_t>;
01022 #endif
01023 #endif
01024
01025 _GLIBCXX_END_NAMESPACE
01026
01027 #endif