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