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