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
}