Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/c++/15/bits/istream.tcc
1 // istream classes -*- C++ -*- 2 3 // Copyright (C) 1997-2025 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** @file bits/istream.tcc 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{istream} 28 */ 29 30 // 31 // ISO C++ 14882: 27.6.1 Input streams 32 // 33 34 #ifndef _ISTREAM_TCC 35 #define _ISTREAM_TCC 1 36 37 #ifdef _GLIBCXX_SYSHDR 38 #pragma GCC system_header 39 #endif 40 41 #pragma GCC diagnostic push 42 #pragma GCC diagnostic ignored "-Wc++11-extensions" // extern template 43 44 #include <bits/cxxabi_forced.h> 45 46 namespace std _GLIBCXX_VISIBILITY(default) 47 { 48 _GLIBCXX_BEGIN_NAMESPACE_VERSION 49 50 template<typename _CharT, typename _Traits> 51 basic_istream<_CharT, _Traits>::sentry:: 52 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) 53 { 54 ios_base::iostate __err = ios_base::goodbit; 55 if (__in.good()) 56 { 57 __try 58 { 59 if (__in.tie()) 60 __in.tie()->flush(); 61 if (!__noskip && bool(__in.flags() & ios_base::skipws)) 62 { 63 const __int_type __eof = traits_type::eof(); 64 __streambuf_type* __sb = __in.rdbuf(); 65 __int_type __c = __sb->sgetc(); 66 67 const __ctype_type& __ct = __check_facet(__in._M_ctype); 68 while (!traits_type::eq_int_type(__c, __eof) 69 && __ct.is(ctype_base::space, 70 traits_type::to_char_type(__c))) 71 __c = __sb->snextc(); 72 73 // _GLIBCXX_RESOLVE_LIB_DEFECTS 74 // 195. Should basic_istream::sentry's constructor ever 75 // set eofbit? 76 if (traits_type::eq_int_type(__c, __eof)) 77 __err |= ios_base::eofbit; 78 } 79 } 80 __catch(__cxxabiv1::__forced_unwind&) 81 { 82 __in._M_setstate(ios_base::badbit); 83 __throw_exception_again; 84 } 85 __catch(...) 86 { __in._M_setstate(ios_base::badbit); } 87 } 88 89 if (__in.good() && __err == ios_base::goodbit) 90 _M_ok = true; 91 else 92 { 93 __err |= ios_base::failbit; 94 __in.setstate(__err); 95 } 96 } 97 98 template<typename _CharT, typename _Traits> 99 template<typename _ValueT> 100 basic_istream<_CharT, _Traits>& 101 basic_istream<_CharT, _Traits>:: 102 _M_extract(_ValueT& __v) 103 { 104 sentry __cerb(*this, false); 105 if (__cerb) 106 { 107 ios_base::iostate __err = ios_base::goodbit; 108 __try 109 { 110 #ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT 111 const __num_get_type& __ng = __check_facet(this->_M_num_get); 112 #else 113 const __num_get_type& __ng 114 = use_facet<__num_get_type>(this->_M_ios_locale); 115 #endif 116 __ng.get(*this, 0, *this, __err, __v); 117 } 118 __catch(__cxxabiv1::__forced_unwind&) 119 { 120 this->_M_setstate(ios_base::badbit); 121 __throw_exception_again; 122 } 123 __catch(...) 124 { this->_M_setstate(ios_base::badbit); } 125 if (__err) 126 this->setstate(__err); 127 } 128 return *this; 129 } 130 131 template<typename _CharT, typename _Traits> 132 basic_istream<_CharT, _Traits>& 133 basic_istream<_CharT, _Traits>:: 134 operator>>(short& __n) 135 { 136 // _GLIBCXX_RESOLVE_LIB_DEFECTS 137 // 118. basic_istream uses nonexistent num_get member functions. 138 sentry __cerb(*this, false); 139 if (__cerb) 140 { 141 ios_base::iostate __err = ios_base::goodbit; 142 __try 143 { 144 long __l; 145 #ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT 146 const __num_get_type& __ng = __check_facet(this->_M_num_get); 147 #else 148 const __num_get_type& __ng 149 = use_facet<__num_get_type>(this->_M_ios_locale); 150 #endif 151 __ng.get(*this, 0, *this, __err, __l); 152 153 // _GLIBCXX_RESOLVE_LIB_DEFECTS 154 // 696. istream::operator>>(int&) broken. 155 if (__l < __gnu_cxx::__numeric_traits<short>::__min) 156 { 157 __err |= ios_base::failbit; 158 __n = __gnu_cxx::__numeric_traits<short>::__min; 159 } 160 else if (__l > __gnu_cxx::__numeric_traits<short>::__max) 161 { 162 __err |= ios_base::failbit; 163 __n = __gnu_cxx::__numeric_traits<short>::__max; 164 } 165 else 166 __n = short(__l); 167 } 168 __catch(__cxxabiv1::__forced_unwind&) 169 { 170 this->_M_setstate(ios_base::badbit); 171 __throw_exception_again; 172 } 173 __catch(...) 174 { this->_M_setstate(ios_base::badbit); } 175 if (__err) 176 this->setstate(__err); 177 } 178 return *this; 179 } 180 181 template<typename _CharT, typename _Traits> 182 basic_istream<_CharT, _Traits>& 183 basic_istream<_CharT, _Traits>:: 184 operator>>(int& __n) 185 { 186 // _GLIBCXX_RESOLVE_LIB_DEFECTS 187 // 118. basic_istream uses nonexistent num_get member functions. 188 sentry __cerb(*this, false); 189 if (__cerb) 190 { 191 ios_base::iostate __err = ios_base::goodbit; 192 __try 193 { 194 long __l; 195 #ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT 196 const __num_get_type& __ng = __check_facet(this->_M_num_get); 197 #else 198 const __num_get_type& __ng 199 = use_facet<__num_get_type>(this->_M_ios_locale); 200 #endif 201 __ng.get(*this, 0, *this, __err, __l); 202 203 // _GLIBCXX_RESOLVE_LIB_DEFECTS 204 // 696. istream::operator>>(int&) broken. 205 if (__l < __gnu_cxx::__numeric_traits<int>::__min) 206 { 207 __err |= ios_base::failbit; 208 __n = __gnu_cxx::__numeric_traits<int>::__min; 209 } 210 else if (__l > __gnu_cxx::__numeric_traits<int>::__max) 211 { 212 __err |= ios_base::failbit; 213 __n = __gnu_cxx::__numeric_traits<int>::__max; 214 } 215 else 216 __n = int(__l); 217 } 218 __catch(__cxxabiv1::__forced_unwind&) 219 { 220 this->_M_setstate(ios_base::badbit); 221 __throw_exception_again; 222 } 223 __catch(...) 224 { this->_M_setstate(ios_base::badbit); } 225 if (__err) 226 this->setstate(__err); 227 } 228 return *this; 229 } 230 231 template<typename _CharT, typename _Traits> 232 basic_istream<_CharT, _Traits>& 233 basic_istream<_CharT, _Traits>:: 234 operator>>(__streambuf_type* __sbout) 235 { 236 ios_base::iostate __err = ios_base::goodbit; 237 sentry __cerb(*this, false); 238 if (__cerb && __sbout) 239 { 240 __try 241 { 242 bool __ineof; 243 if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) 244 __err |= ios_base::failbit; 245 if (__ineof) 246 __err |= ios_base::eofbit; 247 } 248 __catch(__cxxabiv1::__forced_unwind&) 249 { 250 this->_M_setstate(ios_base::failbit); 251 __throw_exception_again; 252 } 253 __catch(...) 254 { this->_M_setstate(ios_base::failbit); } 255 } 256 else if (!__sbout) 257 __err |= ios_base::failbit; 258 if (__err) 259 this->setstate(__err); 260 return *this; 261 } 262 263 template<typename _CharT, typename _Traits> 264 typename basic_istream<_CharT, _Traits>::int_type 265 basic_istream<_CharT, _Traits>:: 266 get(void) 267 { 268 const int_type __eof = traits_type::eof(); 269 int_type __c = __eof; 270 _M_gcount = 0; 271 ios_base::iostate __err = ios_base::goodbit; 272 sentry __cerb(*this, true); 273 if (__cerb) 274 { 275 __try 276 { 277 __c = this->rdbuf()->sbumpc(); 278 // 27.6.1.1 paragraph 3 279 if (!traits_type::eq_int_type(__c, __eof)) 280 _M_gcount = 1; 281 else 282 __err |= ios_base::eofbit; 283 } 284 __catch(__cxxabiv1::__forced_unwind&) 285 { 286 this->_M_setstate(ios_base::badbit); 287 __throw_exception_again; 288 } 289 __catch(...) 290 { this->_M_setstate(ios_base::badbit); } 291 } 292 if (!_M_gcount) 293 __err |= ios_base::failbit; 294 if (__err) 295 this->setstate(__err); 296 return __c; 297 } 298 299 template<typename _CharT, typename _Traits> 300 basic_istream<_CharT, _Traits>& 301 basic_istream<_CharT, _Traits>:: 302 get(char_type& __c) 303 { 304 _M_gcount = 0; 305 ios_base::iostate __err = ios_base::goodbit; 306 sentry __cerb(*this, true); 307 if (__cerb) 308 { 309 __try 310 { 311 const int_type __cb = this->rdbuf()->sbumpc(); 312 // 27.6.1.1 paragraph 3 313 if (!traits_type::eq_int_type(__cb, traits_type::eof())) 314 { 315 _M_gcount = 1; 316 __c = traits_type::to_char_type(__cb); 317 } 318 else 319 __err |= ios_base::eofbit; 320 } 321 __catch(__cxxabiv1::__forced_unwind&) 322 { 323 this->_M_setstate(ios_base::badbit); 324 __throw_exception_again; 325 } 326 __catch(...) 327 { this->_M_setstate(ios_base::badbit); } 328 } 329 if (!_M_gcount) 330 __err |= ios_base::failbit; 331 if (__err) 332 this->setstate(__err); 333 return *this; 334 } 335 336 template<typename _CharT, typename _Traits> 337 basic_istream<_CharT, _Traits>& 338 basic_istream<_CharT, _Traits>:: 339 get(char_type* __s, streamsize __n, char_type __delim) 340 { 341 _M_gcount = 0; 342 ios_base::iostate __err = ios_base::goodbit; 343 sentry __cerb(*this, true); 344 if (__cerb) 345 { 346 __try 347 { 348 const int_type __idelim = traits_type::to_int_type(__delim); 349 const int_type __eof = traits_type::eof(); 350 __streambuf_type* __sb = this->rdbuf(); 351 int_type __c = __sb->sgetc(); 352 353 while (_M_gcount + 1 < __n 354 && !traits_type::eq_int_type(__c, __eof) 355 && !traits_type::eq_int_type(__c, __idelim)) 356 { 357 *__s++ = traits_type::to_char_type(__c); 358 ++_M_gcount; 359 __c = __sb->snextc(); 360 } 361 if (traits_type::eq_int_type(__c, __eof)) 362 __err |= ios_base::eofbit; 363 } 364 __catch(__cxxabiv1::__forced_unwind&) 365 { 366 this->_M_setstate(ios_base::badbit); 367 __throw_exception_again; 368 } 369 __catch(...) 370 { this->_M_setstate(ios_base::badbit); } 371 } 372 // _GLIBCXX_RESOLVE_LIB_DEFECTS 373 // 243. get and getline when sentry reports failure. 374 if (__n > 0) 375 *__s = char_type(); 376 if (!_M_gcount) 377 __err |= ios_base::failbit; 378 if (__err) 379 this->setstate(__err); 380 return *this; 381 } 382 383 template<typename _CharT, typename _Traits> 384 basic_istream<_CharT, _Traits>& 385 basic_istream<_CharT, _Traits>:: 386 get(__streambuf_type& __sb, char_type __delim) 387 { 388 _M_gcount = 0; 389 ios_base::iostate __err = ios_base::goodbit; 390 sentry __cerb(*this, true); 391 if (__cerb) 392 { 393 __try 394 { 395 const int_type __idelim = traits_type::to_int_type(__delim); 396 const int_type __eof = traits_type::eof(); 397 __streambuf_type* __this_sb = this->rdbuf(); 398 int_type __c = __this_sb->sgetc(); 399 char_type __c2 = traits_type::to_char_type(__c); 400 #pragma GCC diagnostic push 401 #pragma GCC diagnostic ignored "-Wlong-long" 402 unsigned long long __gcount = 0; 403 #pragma GCC diagnostic pop 404 405 while (!traits_type::eq_int_type(__c, __eof) 406 && !traits_type::eq_int_type(__c, __idelim) 407 && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) 408 { 409 ++__gcount; 410 __c = __this_sb->snextc(); 411 __c2 = traits_type::to_char_type(__c); 412 } 413 if (traits_type::eq_int_type(__c, __eof)) 414 __err |= ios_base::eofbit; 415 // _GLIBCXX_RESOLVE_LIB_DEFECTS 416 // 3464. istream::gcount() can overflow 417 if (__gcount <= __gnu_cxx::__numeric_traits<streamsize>::__max) 418 _M_gcount = __gcount; 419 else 420 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 421 } 422 __catch(__cxxabiv1::__forced_unwind&) 423 { 424 this->_M_setstate(ios_base::badbit); 425 __throw_exception_again; 426 } 427 __catch(...) 428 { this->_M_setstate(ios_base::badbit); } 429 } 430 if (!_M_gcount) 431 __err |= ios_base::failbit; 432 if (__err) 433 this->setstate(__err); 434 return *this; 435 } 436 437 template<typename _CharT, typename _Traits> 438 basic_istream<_CharT, _Traits>& 439 basic_istream<_CharT, _Traits>:: 440 getline(char_type* __s, streamsize __n, char_type __delim) 441 { 442 _M_gcount = 0; 443 ios_base::iostate __err = ios_base::goodbit; 444 sentry __cerb(*this, true); 445 if (__cerb) 446 { 447 __try 448 { 449 const int_type __idelim = traits_type::to_int_type(__delim); 450 const int_type __eof = traits_type::eof(); 451 __streambuf_type* __sb = this->rdbuf(); 452 int_type __c = __sb->sgetc(); 453 454 while (_M_gcount + 1 < __n 455 && !traits_type::eq_int_type(__c, __eof) 456 && !traits_type::eq_int_type(__c, __idelim)) 457 { 458 *__s++ = traits_type::to_char_type(__c); 459 __c = __sb->snextc(); 460 ++_M_gcount; 461 } 462 if (traits_type::eq_int_type(__c, __eof)) 463 __err |= ios_base::eofbit; 464 else 465 { 466 if (traits_type::eq_int_type(__c, __idelim)) 467 { 468 __sb->sbumpc(); 469 ++_M_gcount; 470 } 471 else 472 __err |= ios_base::failbit; 473 } 474 } 475 __catch(__cxxabiv1::__forced_unwind&) 476 { 477 this->_M_setstate(ios_base::badbit); 478 __throw_exception_again; 479 } 480 __catch(...) 481 { this->_M_setstate(ios_base::badbit); } 482 } 483 // _GLIBCXX_RESOLVE_LIB_DEFECTS 484 // 243. get and getline when sentry reports failure. 485 if (__n > 0) 486 *__s = char_type(); 487 if (!_M_gcount) 488 __err |= ios_base::failbit; 489 if (__err) 490 this->setstate(__err); 491 return *this; 492 } 493 494 // We provide three overloads, since the first two are much simpler 495 // than the general case. Also, the latter two can thus adopt the 496 // same "batchy" strategy used by getline above. 497 template<typename _CharT, typename _Traits> 498 basic_istream<_CharT, _Traits>& 499 basic_istream<_CharT, _Traits>:: 500 ignore(void) 501 { 502 _M_gcount = 0; 503 sentry __cerb(*this, true); 504 if (__cerb) 505 { 506 ios_base::iostate __err = ios_base::goodbit; 507 __try 508 { 509 const int_type __eof = traits_type::eof(); 510 __streambuf_type* __sb = this->rdbuf(); 511 512 if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) 513 __err |= ios_base::eofbit; 514 else 515 _M_gcount = 1; 516 } 517 __catch(__cxxabiv1::__forced_unwind&) 518 { 519 this->_M_setstate(ios_base::badbit); 520 __throw_exception_again; 521 } 522 __catch(...) 523 { this->_M_setstate(ios_base::badbit); } 524 if (__err) 525 this->setstate(__err); 526 } 527 return *this; 528 } 529 530 template<typename _CharT, typename _Traits> 531 basic_istream<_CharT, _Traits>& 532 basic_istream<_CharT, _Traits>:: 533 ignore(streamsize __n) 534 { 535 _M_gcount = 0; 536 sentry __cerb(*this, true); 537 if (__cerb && __n > 0) 538 { 539 ios_base::iostate __err = ios_base::goodbit; 540 __try 541 { 542 const int_type __eof = traits_type::eof(); 543 __streambuf_type* __sb = this->rdbuf(); 544 int_type __c = __sb->sgetc(); 545 546 // N.B. On LFS-enabled platforms streamsize is still 32 bits 547 // wide: if we want to implement the standard mandated behavior 548 // for n == max() (see 27.6.1.3/24) we are at risk of signed 549 // integer overflow: thus these contortions. Also note that, 550 // by definition, when more than 2G chars are actually ignored, 551 // _M_gcount (the return value of gcount, that is) cannot be 552 // really correct, being unavoidably too small. 553 bool __large_ignore = false; 554 while (true) 555 { 556 while (_M_gcount < __n 557 && !traits_type::eq_int_type(__c, __eof)) 558 { 559 ++_M_gcount; 560 __c = __sb->snextc(); 561 } 562 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 563 && !traits_type::eq_int_type(__c, __eof)) 564 { 565 _M_gcount = 566 __gnu_cxx::__numeric_traits<streamsize>::__min; 567 __large_ignore = true; 568 } 569 else 570 break; 571 } 572 573 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max) 574 { 575 if (__large_ignore) 576 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 577 578 if (traits_type::eq_int_type(__c, __eof)) 579 __err |= ios_base::eofbit; 580 } 581 else if (_M_gcount < __n) 582 { 583 if (traits_type::eq_int_type(__c, __eof)) 584 __err |= ios_base::eofbit; 585 } 586 } 587 __catch(__cxxabiv1::__forced_unwind&) 588 { 589 this->_M_setstate(ios_base::badbit); 590 __throw_exception_again; 591 } 592 __catch(...) 593 { this->_M_setstate(ios_base::badbit); } 594 if (__err) 595 this->setstate(__err); 596 } 597 return *this; 598 } 599 600 template<typename _CharT, typename _Traits> 601 basic_istream<_CharT, _Traits>& 602 basic_istream<_CharT, _Traits>:: 603 ignore(streamsize __n, int_type __delim) 604 { 605 _M_gcount = 0; 606 sentry __cerb(*this, true); 607 if (__cerb && __n > 0) 608 { 609 ios_base::iostate __err = ios_base::goodbit; 610 __try 611 { 612 const int_type __eof = traits_type::eof(); 613 __streambuf_type* __sb = this->rdbuf(); 614 int_type __c = __sb->sgetc(); 615 616 // See comment above. 617 bool __large_ignore = false; 618 while (true) 619 { 620 while (_M_gcount < __n 621 && !traits_type::eq_int_type(__c, __eof) 622 && !traits_type::eq_int_type(__c, __delim)) 623 { 624 ++_M_gcount; 625 __c = __sb->snextc(); 626 } 627 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 628 && !traits_type::eq_int_type(__c, __eof) 629 && !traits_type::eq_int_type(__c, __delim)) 630 { 631 _M_gcount = 632 __gnu_cxx::__numeric_traits<streamsize>::__min; 633 __large_ignore = true; 634 } 635 else 636 break; 637 } 638 639 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max) 640 { 641 if (__large_ignore) 642 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 643 644 if (traits_type::eq_int_type(__c, __eof)) 645 __err |= ios_base::eofbit; 646 else 647 { 648 if (_M_gcount != __n) 649 ++_M_gcount; 650 __sb->sbumpc(); 651 } 652 } 653 else if (_M_gcount < __n) // implies __c == __delim or EOF 654 { 655 if (traits_type::eq_int_type(__c, __eof)) 656 __err |= ios_base::eofbit; 657 else 658 { 659 ++_M_gcount; 660 __sb->sbumpc(); 661 } 662 } 663 } 664 __catch(__cxxabiv1::__forced_unwind&) 665 { 666 this->_M_setstate(ios_base::badbit); 667 __throw_exception_again; 668 } 669 __catch(...) 670 { this->_M_setstate(ios_base::badbit); } 671 if (__err) 672 this->setstate(__err); 673 } 674 return *this; 675 } 676 677 template<typename _CharT, typename _Traits> 678 typename basic_istream<_CharT, _Traits>::int_type 679 basic_istream<_CharT, _Traits>:: 680 peek(void) 681 { 682 int_type __c = traits_type::eof(); 683 _M_gcount = 0; 684 sentry __cerb(*this, true); 685 if (__cerb) 686 { 687 ios_base::iostate __err = ios_base::goodbit; 688 __try 689 { 690 __c = this->rdbuf()->sgetc(); 691 if (traits_type::eq_int_type(__c, traits_type::eof())) 692 __err |= ios_base::eofbit; 693 } 694 __catch(__cxxabiv1::__forced_unwind&) 695 { 696 this->_M_setstate(ios_base::badbit); 697 __throw_exception_again; 698 } 699 __catch(...) 700 { this->_M_setstate(ios_base::badbit); } 701 if (__err) 702 this->setstate(__err); 703 } 704 return __c; 705 } 706 707 template<typename _CharT, typename _Traits> 708 basic_istream<_CharT, _Traits>& 709 basic_istream<_CharT, _Traits>:: 710 read(char_type* __s, streamsize __n) 711 { 712 _M_gcount = 0; 713 sentry __cerb(*this, true); 714 if (__cerb) 715 { 716 ios_base::iostate __err = ios_base::goodbit; 717 __try 718 { 719 _M_gcount = this->rdbuf()->sgetn(__s, __n); 720 if (_M_gcount != __n) 721 __err |= (ios_base::eofbit | ios_base::failbit); 722 } 723 __catch(__cxxabiv1::__forced_unwind&) 724 { 725 this->_M_setstate(ios_base::badbit); 726 __throw_exception_again; 727 } 728 __catch(...) 729 { this->_M_setstate(ios_base::badbit); } 730 if (__err) 731 this->setstate(__err); 732 } 733 return *this; 734 } 735 736 template<typename _CharT, typename _Traits> 737 streamsize 738 basic_istream<_CharT, _Traits>:: 739 readsome(char_type* __s, streamsize __n) 740 { 741 _M_gcount = 0; 742 sentry __cerb(*this, true); 743 if (__cerb) 744 { 745 ios_base::iostate __err = ios_base::goodbit; 746 __try 747 { 748 // Cannot compare int_type with streamsize generically. 749 const streamsize __num = this->rdbuf()->in_avail(); 750 if (__num > 0) 751 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); 752 else if (__num == -1) 753 __err |= ios_base::eofbit; 754 } 755 __catch(__cxxabiv1::__forced_unwind&) 756 { 757 this->_M_setstate(ios_base::badbit); 758 __throw_exception_again; 759 } 760 __catch(...) 761 { this->_M_setstate(ios_base::badbit); } 762 if (__err) 763 this->setstate(__err); 764 } 765 return _M_gcount; 766 } 767 768 template<typename _CharT, typename _Traits> 769 basic_istream<_CharT, _Traits>& 770 basic_istream<_CharT, _Traits>:: 771 putback(char_type __c) 772 { 773 // _GLIBCXX_RESOLVE_LIB_DEFECTS 774 // 60. What is a formatted input function? 775 _M_gcount = 0; 776 // Clear eofbit per N3168. 777 this->clear(this->rdstate() & ~ios_base::eofbit); 778 sentry __cerb(*this, true); 779 if (__cerb) 780 { 781 ios_base::iostate __err = ios_base::goodbit; 782 __try 783 { 784 const int_type __eof = traits_type::eof(); 785 __streambuf_type* __sb = this->rdbuf(); 786 if (!__sb 787 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) 788 __err |= ios_base::badbit; 789 } 790 __catch(__cxxabiv1::__forced_unwind&) 791 { 792 this->_M_setstate(ios_base::badbit); 793 __throw_exception_again; 794 } 795 __catch(...) 796 { this->_M_setstate(ios_base::badbit); } 797 if (__err) 798 this->setstate(__err); 799 } 800 return *this; 801 } 802 803 template<typename _CharT, typename _Traits> 804 basic_istream<_CharT, _Traits>& 805 basic_istream<_CharT, _Traits>:: 806 unget(void) 807 { 808 // _GLIBCXX_RESOLVE_LIB_DEFECTS 809 // 60. What is a formatted input function? 810 _M_gcount = 0; 811 // Clear eofbit per N3168. 812 this->clear(this->rdstate() & ~ios_base::eofbit); 813 sentry __cerb(*this, true); 814 if (__cerb) 815 { 816 ios_base::iostate __err = ios_base::goodbit; 817 __try 818 { 819 const int_type __eof = traits_type::eof(); 820 __streambuf_type* __sb = this->rdbuf(); 821 if (!__sb 822 || traits_type::eq_int_type(__sb->sungetc(), __eof)) 823 __err |= ios_base::badbit; 824 } 825 __catch(__cxxabiv1::__forced_unwind&) 826 { 827 this->_M_setstate(ios_base::badbit); 828 __throw_exception_again; 829 } 830 __catch(...) 831 { this->_M_setstate(ios_base::badbit); } 832 if (__err) 833 this->setstate(__err); 834 } 835 return *this; 836 } 837 838 template<typename _CharT, typename _Traits> 839 int 840 basic_istream<_CharT, _Traits>:: 841 sync(void) 842 { 843 // _GLIBCXX_RESOLVE_LIB_DEFECTS 844 // DR60. Do not change _M_gcount. 845 int __ret = -1; 846 sentry __cerb(*this, true); 847 if (__cerb) 848 { 849 ios_base::iostate __err = ios_base::goodbit; 850 __try 851 { 852 __streambuf_type* __sb = this->rdbuf(); 853 if (__sb) 854 { 855 if (__sb->pubsync() == -1) 856 __err |= ios_base::badbit; 857 else 858 __ret = 0; 859 } 860 } 861 __catch(__cxxabiv1::__forced_unwind&) 862 { 863 this->_M_setstate(ios_base::badbit); 864 __throw_exception_again; 865 } 866 __catch(...) 867 { this->_M_setstate(ios_base::badbit); } 868 if (__err) 869 this->setstate(__err); 870 } 871 return __ret; 872 } 873 874 template<typename _CharT, typename _Traits> 875 typename basic_istream<_CharT, _Traits>::pos_type 876 basic_istream<_CharT, _Traits>:: 877 tellg(void) 878 { 879 // _GLIBCXX_RESOLVE_LIB_DEFECTS 880 // DR60. Do not change _M_gcount. 881 pos_type __ret = pos_type(-1); 882 sentry __cerb(*this, true); 883 if (__cerb) 884 { 885 __try 886 { 887 if (!this->fail()) 888 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, 889 ios_base::in); 890 } 891 __catch(__cxxabiv1::__forced_unwind&) 892 { 893 this->_M_setstate(ios_base::badbit); 894 __throw_exception_again; 895 } 896 __catch(...) 897 { this->_M_setstate(ios_base::badbit); } 898 } 899 return __ret; 900 } 901 902 template<typename _CharT, typename _Traits> 903 basic_istream<_CharT, _Traits>& 904 basic_istream<_CharT, _Traits>:: 905 seekg(pos_type __pos) 906 { 907 // _GLIBCXX_RESOLVE_LIB_DEFECTS 908 // DR60. Do not change _M_gcount. 909 // Clear eofbit per N3168. 910 this->clear(this->rdstate() & ~ios_base::eofbit); 911 sentry __cerb(*this, true); 912 if (__cerb) 913 { 914 ios_base::iostate __err = ios_base::goodbit; 915 __try 916 { 917 if (!this->fail()) 918 { 919 // 136. seekp, seekg setting wrong streams? 920 const pos_type __p = this->rdbuf()->pubseekpos(__pos, 921 ios_base::in); 922 923 // 129. Need error indication from seekp() and seekg() 924 if (__p == pos_type(off_type(-1))) 925 __err |= ios_base::failbit; 926 } 927 } 928 __catch(__cxxabiv1::__forced_unwind&) 929 { 930 this->_M_setstate(ios_base::badbit); 931 __throw_exception_again; 932 } 933 __catch(...) 934 { this->_M_setstate(ios_base::badbit); } 935 if (__err) 936 this->setstate(__err); 937 } 938 return *this; 939 } 940 941 template<typename _CharT, typename _Traits> 942 basic_istream<_CharT, _Traits>& 943 basic_istream<_CharT, _Traits>:: 944 seekg(off_type __off, ios_base::seekdir __dir) 945 { 946 // _GLIBCXX_RESOLVE_LIB_DEFECTS 947 // DR60. Do not change _M_gcount. 948 // Clear eofbit per N3168. 949 this->clear(this->rdstate() & ~ios_base::eofbit); 950 sentry __cerb(*this, true); 951 if (__cerb) 952 { 953 ios_base::iostate __err = ios_base::goodbit; 954 __try 955 { 956 if (!this->fail()) 957 { 958 // 136. seekp, seekg setting wrong streams? 959 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, 960 ios_base::in); 961 962 // 129. Need error indication from seekp() and seekg() 963 if (__p == pos_type(off_type(-1))) 964 __err |= ios_base::failbit; 965 } 966 } 967 __catch(__cxxabiv1::__forced_unwind&) 968 { 969 this->_M_setstate(ios_base::badbit); 970 __throw_exception_again; 971 } 972 __catch(...) 973 { this->_M_setstate(ios_base::badbit); } 974 if (__err) 975 this->setstate(__err); 976 } 977 return *this; 978 } 979 980 // 27.6.1.2.3 Character extraction templates 981 template<typename _CharT, typename _Traits> 982 basic_istream<_CharT, _Traits>& 983 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) 984 { 985 typedef basic_istream<_CharT, _Traits> __istream_type; 986 typedef typename __istream_type::int_type __int_type; 987 988 typename __istream_type::sentry __cerb(__in, false); 989 if (__cerb) 990 { 991 ios_base::iostate __err = ios_base::goodbit; 992 __try 993 { 994 const __int_type __cb = __in.rdbuf()->sbumpc(); 995 if (!_Traits::eq_int_type(__cb, _Traits::eof())) 996 __c = _Traits::to_char_type(__cb); 997 else 998 __err |= (ios_base::eofbit | ios_base::failbit); 999 } 1000 __catch(__cxxabiv1::__forced_unwind&) 1001 { 1002 __in._M_setstate(ios_base::badbit); 1003 __throw_exception_again; 1004 } 1005 __catch(...) 1006 { __in._M_setstate(ios_base::badbit); } 1007 if (__err) 1008 __in.setstate(__err); 1009 } 1010 return __in; 1011 } 1012 1013 template<typename _CharT, typename _Traits> 1014 void 1015 __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s, 1016 streamsize __num) 1017 { 1018 typedef basic_istream<_CharT, _Traits> __istream_type; 1019 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 1020 typedef typename _Traits::int_type int_type; 1021 typedef _CharT char_type; 1022 typedef ctype<_CharT> __ctype_type; 1023 1024 streamsize __extracted = 0; 1025 ios_base::iostate __err = ios_base::goodbit; 1026 typename __istream_type::sentry __cerb(__in, false); 1027 if (__cerb) 1028 { 1029 __try 1030 { 1031 // Figure out how many characters to extract. 1032 streamsize __width = __in.width(); 1033 if (0 < __width && __width < __num) 1034 __num = __width; 1035 1036 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 1037 1038 const int_type __eof = _Traits::eof(); 1039 __streambuf_type* __sb = __in.rdbuf(); 1040 int_type __c = __sb->sgetc(); 1041 1042 while (__extracted < __num - 1 1043 && !_Traits::eq_int_type(__c, __eof) 1044 && !__ct.is(ctype_base::space, 1045 _Traits::to_char_type(__c))) 1046 { 1047 *__s++ = _Traits::to_char_type(__c); 1048 ++__extracted; 1049 __c = __sb->snextc(); 1050 } 1051 1052 if (__extracted < __num - 1 1053 && _Traits::eq_int_type(__c, __eof)) 1054 __err |= ios_base::eofbit; 1055 1056 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1057 // 68. Extractors for char* should store null at end 1058 *__s = char_type(); 1059 __in.width(0); 1060 } 1061 __catch(__cxxabiv1::__forced_unwind&) 1062 { 1063 __in._M_setstate(ios_base::badbit); 1064 __throw_exception_again; 1065 } 1066 __catch(...) 1067 { __in._M_setstate(ios_base::badbit); } 1068 } 1069 if (!__extracted) 1070 __err |= ios_base::failbit; 1071 if (__err) 1072 __in.setstate(__err); 1073 } 1074 1075 // 27.6.1.4 Standard basic_istream manipulators 1076 template<typename _CharT, typename _Traits> 1077 basic_istream<_CharT, _Traits>& 1078 ws(basic_istream<_CharT, _Traits>& __in) 1079 { 1080 typedef basic_istream<_CharT, _Traits> __istream_type; 1081 typedef basic_streambuf<_CharT, _Traits> __streambuf_type; 1082 typedef typename __istream_type::int_type __int_type; 1083 typedef ctype<_CharT> __ctype_type; 1084 1085 // _GLIBCXX_RESOLVE_LIB_DEFECTS 1086 // 451. behavior of std::ws 1087 typename __istream_type::sentry __cerb(__in, true); 1088 if (__cerb) 1089 { 1090 ios_base::iostate __err = ios_base::goodbit; 1091 __try 1092 { 1093 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 1094 const __int_type __eof = _Traits::eof(); 1095 __streambuf_type* __sb = __in.rdbuf(); 1096 __int_type __c = __sb->sgetc(); 1097 1098 while (true) 1099 { 1100 if (_Traits::eq_int_type(__c, __eof)) 1101 { 1102 __err = ios_base::eofbit; 1103 break; 1104 } 1105 if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) 1106 break; 1107 __c = __sb->snextc(); 1108 } 1109 } 1110 __catch (const __cxxabiv1::__forced_unwind&) 1111 { 1112 __in._M_setstate(ios_base::badbit); 1113 __throw_exception_again; 1114 } 1115 __catch (...) 1116 { 1117 __in._M_setstate(ios_base::badbit); 1118 } 1119 if (__err) 1120 __in.setstate(__err); 1121 } 1122 return __in; 1123 } 1124 1125 // Inhibit implicit instantiations for required instantiations, 1126 // which are defined via explicit instantiations elsewhere. 1127 #if _GLIBCXX_EXTERN_TEMPLATE 1128 #pragma GCC diagnostic push 1129 #pragma GCC diagnostic ignored "-Wc++11-extensions" // extern template 1130 #pragma GCC diagnostic ignored "-Wlong-long" 1131 extern template class basic_istream<char>; 1132 extern template istream& ws(istream&); 1133 extern template istream& operator>>(istream&, char&); 1134 extern template istream& operator>>(istream&, unsigned char&); 1135 extern template istream& operator>>(istream&, signed char&); 1136 1137 extern template istream& istream::_M_extract(unsigned short&); 1138 extern template istream& istream::_M_extract(unsigned int&); 1139 extern template istream& istream::_M_extract(long&); 1140 extern template istream& istream::_M_extract(unsigned long&); 1141 extern template istream& istream::_M_extract(bool&); 1142 #ifdef _GLIBCXX_USE_LONG_LONG 1143 #pragma GCC diagnostic push 1144 #pragma GCC diagnostic ignored "-Wlong-long" 1145 extern template istream& istream::_M_extract(long long&); 1146 extern template istream& istream::_M_extract(unsigned long long&); 1147 #pragma GCC diagnostic pop 1148 #endif 1149 extern template istream& istream::_M_extract(float&); 1150 extern template istream& istream::_M_extract(double&); 1151 extern template istream& istream::_M_extract(long double&); 1152 extern template istream& istream::_M_extract(void*&); 1153 1154 extern template class basic_iostream<char>; 1155 1156 #ifdef _GLIBCXX_USE_WCHAR_T 1157 extern template class basic_istream<wchar_t>; 1158 extern template wistream& ws(wistream&); 1159 extern template wistream& operator>>(wistream&, wchar_t&); 1160 extern template void __istream_extract(wistream&, wchar_t*, streamsize); 1161 1162 extern template wistream& wistream::_M_extract(unsigned short&); 1163 extern template wistream& wistream::_M_extract(unsigned int&); 1164 extern template wistream& wistream::_M_extract(long&); 1165 extern template wistream& wistream::_M_extract(unsigned long&); 1166 extern template wistream& wistream::_M_extract(bool&); 1167 #ifdef _GLIBCXX_USE_LONG_LONG 1168 extern template wistream& wistream::_M_extract(long long&); 1169 extern template wistream& wistream::_M_extract(unsigned long long&); 1170 #endif 1171 extern template wistream& wistream::_M_extract(float&); 1172 extern template wistream& wistream::_M_extract(double&); 1173 extern template wistream& wistream::_M_extract(long double&); 1174 extern template wistream& wistream::_M_extract(void*&); 1175 1176 extern template class basic_iostream<wchar_t>; 1177 #endif 1178 #pragma GCC diagnostic pop 1179 #endif 1180 1181 _GLIBCXX_END_NAMESPACE_VERSION 1182 } // namespace std 1183 1184 #pragma GCC diagnostic pop 1185 #endif
