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