istream.tcc revision 107606
1// istream classes -*- C++ -*- 2 3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 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(exception& __fail) 122 { 123 // 27.6.1.2.1 Common requirements. 124 // Turn this on without causing an ios::failure to be thrown. 125 this->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(exception& __fail) 159 { 160 // 27.6.1.2.1 Common requirements. 161 // Turn this on without causing an ios::failure to be thrown. 162 this->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(exception& __fail) 186 { 187 // 27.6.1.2.1 Common requirements. 188 // Turn this on without causing an ios::failure to be thrown. 189 this->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(exception& __fail) 223 { 224 // 27.6.1.2.1 Common requirements. 225 // Turn this on without causing an ios::failure to be thrown. 226 this->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(exception& __fail) 250 { 251 // 27.6.1.2.1 Common requirements. 252 // Turn this on without causing an ios::failure to be thrown. 253 this->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(exception& __fail) 277 { 278 // 27.6.1.2.1 Common requirements. 279 // Turn this on without causing an ios::failure to be thrown. 280 this->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(exception& __fail) 304 { 305 // 27.6.1.2.1 Common requirements. 306 // Turn this on without causing an ios::failure to be thrown. 307 this->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(exception& __fail) 332 { 333 // 27.6.1.2.1 Common requirements. 334 // Turn this on without causing an ios::failure to be thrown. 335 this->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(exception& __fail) 359 { 360 // 27.6.1.2.1 Common requirements. 361 // Turn this on without causing an ios::failure to be thrown. 362 this->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(exception& __fail) 387 { 388 // 27.6.1.2.1 Common requirements. 389 // Turn this on without causing an ios::failure to be thrown. 390 this->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(exception& __fail) 414 { 415 // 27.6.1.2.1 Common requirements. 416 // Turn this on without causing an ios::failure to be thrown. 417 this->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(exception& __fail) 441 { 442 // 27.6.1.2.1 Common requirements. 443 // Turn this on without causing an ios::failure to be thrown. 444 this->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(exception& __fail) 468 { 469 // 27.6.1.2.1 Common requirements. 470 // Turn this on without causing an ios::failure to be thrown. 471 this->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(exception& __fail) 499 { 500 // 27.6.2.5.1 Common requirements. 501 // Turn this on without causing an ios::failure to be thrown. 502 this->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(exception& __fail) 531 { 532 // 27.6.1.3 paragraph 1 533 // Turn this on without causing an ios::failure to be thrown. 534 this->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(exception& __fail) 565 { 566 // 27.6.1.3 paragraph 1 567 // Turn this on without causing an ios::failure to be thrown. 568 this->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(exception& __fail) 604 { 605 // 27.6.1.3 paragraph 1 606 // Turn this on without causing an ios::failure to be thrown. 607 this->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(exception& __fail) 647 { 648 // 27.6.1.3 paragraph 1 649 // Turn this on without causing an ios::failure to be thrown. 650 this->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(exception& __fail) 698 { 699 // 27.6.1.3 paragraph 1 700 // Turn this on without causing an ios::failure to be thrown. 701 this->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(exception& __fail) 739 { 740 // 27.6.1.3 paragraph 1 741 // Turn this on without causing an ios::failure to be thrown. 742 this->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 { __c = this->rdbuf()->sgetc(); } 762 catch(exception& __fail) 763 { 764 // 27.6.1.3 paragraph 1 765 // Turn this on without causing an ios::failure to be thrown. 766 this->setstate(ios_base::badbit); 767 if ((this->exceptions() & ios_base::badbit) != 0) 768 __throw_exception_again; 769 } 770 } 771 return __c; 772 } 773 774 template<typename _CharT, typename _Traits> 775 basic_istream<_CharT, _Traits>& 776 basic_istream<_CharT, _Traits>:: 777 read(char_type* __s, streamsize __n) 778 { 779 _M_gcount = 0; 780 sentry __cerb(*this, true); 781 if (__cerb) 782 { 783 try 784 { 785 _M_gcount = this->rdbuf()->sgetn(__s, __n); 786 if (_M_gcount != __n) 787 this->setstate(ios_base::eofbit | ios_base::failbit); 788 } 789 catch(exception& __fail) 790 { 791 // 27.6.1.3 paragraph 1 792 // Turn this on without causing an ios::failure to be thrown. 793 this->setstate(ios_base::badbit); 794 if ((this->exceptions() & ios_base::badbit) != 0) 795 __throw_exception_again; 796 } 797 } 798 else 799 this->setstate(ios_base::failbit); 800 return *this; 801 } 802 803 template<typename _CharT, typename _Traits> 804 streamsize 805 basic_istream<_CharT, _Traits>:: 806 readsome(char_type* __s, streamsize __n) 807 { 808 _M_gcount = 0; 809 sentry __cerb(*this, true); 810 if (__cerb) 811 { 812 try 813 { 814 // Cannot compare int_type with streamsize generically. 815 streamsize __num = this->rdbuf()->in_avail(); 816 if (__num >= 0) 817 { 818 __num = min(__num, __n); 819 if (__num) 820 _M_gcount = this->rdbuf()->sgetn(__s, __num); 821 } 822 else 823 this->setstate(ios_base::eofbit); 824 } 825 catch(exception& __fail) 826 { 827 // 27.6.1.3 paragraph 1 828 // Turn this on without causing an ios::failure to be thrown. 829 this->setstate(ios_base::badbit); 830 if ((this->exceptions() & ios_base::badbit) != 0) 831 __throw_exception_again; 832 } 833 } 834 else 835 this->setstate(ios_base::failbit); 836 return _M_gcount; 837 } 838 839 template<typename _CharT, typename _Traits> 840 basic_istream<_CharT, _Traits>& 841 basic_istream<_CharT, _Traits>:: 842 putback(char_type __c) 843 { 844 sentry __cerb(*this, true); 845 if (__cerb) 846 { 847 try 848 { 849 const int_type __eof = traits_type::eof(); 850 __streambuf_type* __sb = this->rdbuf(); 851 if (!__sb 852 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) 853 this->setstate(ios_base::badbit); 854 } 855 catch(exception& __fail) 856 { 857 // 27.6.1.3 paragraph 1 858 // Turn this on without causing an ios::failure to be thrown. 859 this->setstate(ios_base::badbit); 860 if ((this->exceptions() & ios_base::badbit) != 0) 861 __throw_exception_again; 862 } 863 } 864 else 865 this->setstate(ios_base::failbit); 866 return *this; 867 } 868 869 template<typename _CharT, typename _Traits> 870 basic_istream<_CharT, _Traits>& 871 basic_istream<_CharT, _Traits>:: 872 unget(void) 873 { 874 _M_gcount = 0; 875 sentry __cerb(*this, true); 876 if (__cerb) 877 { 878 try 879 { 880 const int_type __eof = traits_type::eof(); 881 __streambuf_type* __sb = this->rdbuf(); 882 if (!__sb 883 || traits_type::eq_int_type(__sb->sungetc(), __eof)) 884 this->setstate(ios_base::badbit); 885 } 886 catch(exception& __fail) 887 { 888 // 27.6.1.3 paragraph 1 889 // Turn this on without causing an ios::failure to be thrown. 890 this->setstate(ios_base::badbit); 891 if ((this->exceptions() & ios_base::badbit) != 0) 892 __throw_exception_again; 893 } 894 } 895 else 896 this->setstate(ios_base::failbit); 897 return *this; 898 } 899 900 template<typename _CharT, typename _Traits> 901 int 902 basic_istream<_CharT, _Traits>:: 903 sync(void) 904 { 905 int __ret = -1; 906 _M_gcount = 0; 907 sentry __cerb(*this, true); 908 if (__cerb) 909 { 910 try 911 { 912 __streambuf_type* __sb = this->rdbuf(); 913 if (__sb) 914 { 915 if (__sb->pubsync() == -1) 916 this->setstate(ios_base::badbit); 917 else 918 __ret = 0; 919 } 920 } 921 catch(exception& __fail) 922 { 923 // 27.6.1.3 paragraph 1 924 // Turn this on without causing an ios::failure to be thrown. 925 this->setstate(ios_base::badbit); 926 if ((this->exceptions() & ios_base::badbit) != 0) 927 __throw_exception_again; 928 } 929 } 930 return __ret; 931 } 932 933 template<typename _CharT, typename _Traits> 934 typename basic_istream<_CharT, _Traits>::pos_type 935 basic_istream<_CharT, _Traits>:: 936 tellg(void) 937 { 938 pos_type __ret = pos_type(-1); 939 if (!this->fail()) 940 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); 941 return __ret; 942 } 943 944 945 template<typename _CharT, typename _Traits> 946 basic_istream<_CharT, _Traits>& 947 basic_istream<_CharT, _Traits>:: 948 seekg(pos_type __pos) 949 { 950 _M_gcount = 0; 951 if (!this->fail()) 952 { 953#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 954// 136. seekp, seekg setting wrong streams? 955 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in); 956 957// 129. Need error indication from seekp() and seekg() 958 if (__err == pos_type(off_type(-1))) 959 this->setstate(ios_base::failbit); 960#endif 961 } 962 return *this; 963 } 964 965 template<typename _CharT, typename _Traits> 966 basic_istream<_CharT, _Traits>& 967 basic_istream<_CharT, _Traits>:: 968 seekg(off_type __off, ios_base::seekdir __dir) 969 { 970 _M_gcount = 0; 971 if (!this->fail()) 972 { 973#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 974// 136. seekp, seekg setting wrong streams? 975 pos_type __err = this->rdbuf()->pubseekoff(__off, __dir, 976 ios_base::in); 977 978// 129. Need error indication from seekp() and seekg() 979 if (__err == pos_type(off_type(-1))) 980 this->setstate(ios_base::failbit); 981#endif 982 } 983 return *this; 984 } 985 986 // 27.6.1.2.3 Character extraction templates 987 template<typename _CharT, typename _Traits> 988 basic_istream<_CharT, _Traits>& 989 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) 990 { 991 typedef basic_istream<_CharT, _Traits> __istream_type; 992 typename __istream_type::sentry __cerb(__in, false); 993 if (__cerb) 994 { 995 try 996 { __in.get(__c); } 997 catch(exception& __fail) 998 { 999 // 27.6.1.2.1 Common requirements. 1000 // Turn this on without causing an ios::failure to be thrown. 1001 __in.setstate(ios_base::badbit); 1002 if ((__in.exceptions() & ios_base::badbit) != 0) 1003 __throw_exception_again; 1004 } 1005 } 1006 else 1007 __in.setstate(ios_base::failbit); 1008 return __in; 1009 } 1010 1011 template<typename _CharT, typename _Traits> 1012 basic_istream<_CharT, _Traits>& 1013 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) 1014 { 1015 typedef basic_istream<_CharT, _Traits> __istream_type; 1016 typedef typename __istream_type::__streambuf_type __streambuf_type; 1017 typedef typename _Traits::int_type int_type; 1018 typedef _CharT char_type; 1019 typedef ctype<_CharT> __ctype_type; 1020 streamsize __extracted = 0; 1021 1022 typename __istream_type::sentry __cerb(__in, false); 1023 if (__cerb) 1024 { 1025 try 1026 { 1027 // Figure out how many characters to extract. 1028 streamsize __num = __in.width(); 1029 if (__num == 0) 1030 __num = numeric_limits<streamsize>::max(); 1031 1032 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc()); 1033 const int_type __eof = _Traits::eof(); 1034 __streambuf_type* __sb = __in.rdbuf(); 1035 int_type __c = __sb->sgetc(); 1036 1037 while (__extracted < __num - 1 1038 && !_Traits::eq_int_type(__c, __eof) 1039 && !__ctype.is(ctype_base::space, __c)) 1040 { 1041 *__s++ = __c; 1042 ++__extracted; 1043 __c = __sb->snextc(); 1044 } 1045 if (_Traits::eq_int_type(__c, __eof)) 1046 __in.setstate(ios_base::eofbit); 1047 1048#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 1049//68. Extractors for char* should store null at end 1050 *__s = char_type(); 1051#endif 1052 __in.width(0); 1053 } 1054 catch(exception& __fail) 1055 { 1056 // 27.6.1.2.1 Common requirements. 1057 // Turn this on without causing an ios::failure to be thrown. 1058 __in.setstate(ios_base::badbit); 1059 if ((__in.exceptions() & ios_base::badbit) != 0) 1060 __throw_exception_again; 1061 } 1062 } 1063 if (!__extracted) 1064 __in.setstate(ios_base::failbit); 1065 return __in; 1066 } 1067 1068 // 27.6.1.4 Standard basic_istream manipulators 1069 template<typename _CharT, typename _Traits> 1070 basic_istream<_CharT,_Traits>& 1071 ws(basic_istream<_CharT,_Traits>& __in) 1072 { 1073 typedef basic_istream<_CharT, _Traits> __istream_type; 1074 typedef typename __istream_type::__streambuf_type __streambuf_type; 1075 typedef typename __istream_type::__ctype_type __ctype_type; 1076 typedef typename __istream_type::int_type __int_type; 1077 1078 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc()); 1079 const __int_type __eof = _Traits::eof(); 1080 __streambuf_type* __sb = __in.rdbuf(); 1081 __int_type __c = __sb->sgetc(); 1082 1083 while (!_Traits::eq_int_type(__c, __eof) 1084 && __ctype.is(ctype_base::space, __c)) 1085 __c = __sb->snextc(); 1086 1087 if (_Traits::eq_int_type(__c, __eof)) 1088 __in.setstate(ios_base::eofbit); 1089 1090 return __in; 1091 } 1092 1093 // 21.3.7.9 basic_string::getline and operators 1094 template<typename _CharT, typename _Traits, typename _Alloc> 1095 basic_istream<_CharT, _Traits>& 1096 operator>>(basic_istream<_CharT, _Traits>& __in, 1097 basic_string<_CharT, _Traits, _Alloc>& __str) 1098 { 1099 typedef basic_istream<_CharT, _Traits> __istream_type; 1100 typedef typename __istream_type::int_type __int_type; 1101 typedef typename __istream_type::__streambuf_type __streambuf_type; 1102 typedef typename __istream_type::__ctype_type __ctype_type; 1103 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 1104 typedef typename __string_type::size_type __size_type; 1105 __size_type __extracted = 0; 1106 1107 typename __istream_type::sentry __cerb(__in, false); 1108 if (__cerb) 1109 { 1110 __str.erase(); 1111 streamsize __w = __in.width(); 1112 __size_type __n; 1113 __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size(); 1114 1115 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc()); 1116 const __int_type __eof = _Traits::eof(); 1117 __streambuf_type* __sb = __in.rdbuf(); 1118 __int_type __c = __sb->sgetc(); 1119 1120 while (__extracted < __n 1121 && !_Traits::eq_int_type(__c, __eof) 1122 && !__ctype.is(ctype_base::space, __c)) 1123 { 1124 __str += _Traits::to_char_type(__c); 1125 ++__extracted; 1126 __c = __sb->snextc(); 1127 } 1128 if (_Traits::eq_int_type(__c, __eof)) 1129 __in.setstate(ios_base::eofbit); 1130 __in.width(0); 1131 } 1132#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS 1133//211. operator>>(istream&, string&) doesn't set failbit 1134 if (!__extracted) 1135 __in.setstate (ios_base::failbit); 1136#endif 1137 return __in; 1138 } 1139 1140 template<typename _CharT, typename _Traits, typename _Alloc> 1141 basic_istream<_CharT, _Traits>& 1142 getline(basic_istream<_CharT, _Traits>& __in, 1143 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) 1144 { 1145 typedef basic_istream<_CharT, _Traits> __istream_type; 1146 typedef typename __istream_type::int_type __int_type; 1147 typedef typename __istream_type::__streambuf_type __streambuf_type; 1148 typedef typename __istream_type::__ctype_type __ctype_type; 1149 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 1150 typedef typename __string_type::size_type __size_type; 1151 1152 __size_type __extracted = 0; 1153 bool __testdelim = false; 1154 typename __istream_type::sentry __cerb(__in, true); 1155 if (__cerb) 1156 { 1157 __str.erase(); 1158 __size_type __n = __str.max_size(); 1159 1160 __int_type __idelim = _Traits::to_int_type(__delim); 1161 __streambuf_type* __sb = __in.rdbuf(); 1162 __int_type __c = __sb->sbumpc(); 1163 const __int_type __eof = _Traits::eof(); 1164 __testdelim = _Traits::eq_int_type(__c, __idelim); 1165 1166 while (__extracted <= __n 1167 && !_Traits::eq_int_type(__c, __eof) 1168 && !__testdelim) 1169 { 1170 __str += _Traits::to_char_type(__c); 1171 ++__extracted; 1172 __c = __sb->sbumpc(); 1173 __testdelim = _Traits::eq_int_type(__c, __idelim); 1174 } 1175 if (_Traits::eq_int_type(__c, __eof)) 1176 __in.setstate(ios_base::eofbit); 1177 } 1178 if (!__extracted && !__testdelim) 1179 __in.setstate(ios_base::failbit); 1180 return __in; 1181 } 1182 1183 template<class _CharT, class _Traits, class _Alloc> 1184 inline basic_istream<_CharT,_Traits>& 1185 getline(basic_istream<_CharT, _Traits>& __in, 1186 basic_string<_CharT,_Traits,_Alloc>& __str) 1187 { return getline(__in, __str, __in.widen('\n')); } 1188 1189 // Inhibit implicit instantiations for required instantiations, 1190 // which are defined via explicit instantiations elsewhere. 1191 // NB: This syntax is a GNU extension. 1192 extern template class basic_istream<char>; 1193 extern template istream& ws(istream&); 1194 extern template istream& operator>>(istream&, char&); 1195 extern template istream& operator>>(istream&, char*); 1196 extern template istream& operator>>(istream&, unsigned char&); 1197 extern template istream& operator>>(istream&, signed char&); 1198 extern template istream& operator>>(istream&, unsigned char*); 1199 extern template istream& operator>>(istream&, signed char*); 1200 1201#ifdef _GLIBCPP_USE_WCHAR_T 1202 extern template class basic_istream<wchar_t>; 1203 extern template wistream& ws(wistream&); 1204 extern template wistream& operator>>(wistream&, wchar_t&); 1205 extern template wistream& operator>>(wistream&, wchar_t*); 1206#endif 1207} // namespace std 1208