libstdc++-v3/include/bits/istream.tcc

   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
  40 namespace 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(this->_M_fnumget))
 118                 this->_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(this->_M_fnumget))
 146                 this->_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(this->_M_fnumget))
 182                 this->_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(this->_M_fnumget))
 210                 this->_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(this->_M_fnumget))
 246                 this->_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(this->_M_fnumget))
 273                 this->_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(this->_M_fnumget))
 300                 this->_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(this->_M_fnumget))
 328                 this->_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(this->_M_fnumget))
 355                 this->_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(this->_M_fnumget))
 383                 this->_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(this->_M_fnumget))
 410                 this->_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(this->_M_fnumget))
 437                 this->_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(this->_M_fnumget))
 464                 this->_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 = std::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             { __c = this->rdbuf()->sgetc(); }
 762           catch(...)
 763             {
 764               // 27.6.1.3 paragraph 1
 765               // Turn this on without causing an ios::failure to be thrown.
 766               this->_M_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(...)
 790             {
 791               // 27.6.1.3 paragraph 1
 792               // Turn this on without causing an ios::failure to be thrown.
 793               this->_M_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 = std::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(...)
 826             {
 827               // 27.6.1.3 paragraph 1
 828               // Turn this on without causing an ios::failure to be thrown.
 829               this->_M_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 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 845 // 60. What is a formatted input function?
 846       _M_gcount = 0;
 847 #endif
 848       sentry __cerb(*this, true);
 849       if (__cerb)
 850         {
 851           try
 852             {
 853               const int_type __eof = traits_type::eof();
 854               __streambuf_type* __sb = this->rdbuf();
 855               if (!__sb
 856                   || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
 857                 this->setstate(ios_base::badbit);
 858             }
 859           catch(...)
 860             {
 861               // 27.6.1.3 paragraph 1
 862               // Turn this on without causing an ios::failure to be thrown.
 863               this->_M_setstate(ios_base::badbit);
 864               if ((this->exceptions() & ios_base::badbit) != 0)
 865                 __throw_exception_again;
 866             }
 867         }
 868       else
 869         this->setstate(ios_base::failbit);
 870       return *this;
 871     }
 872
 873   template<typename _CharT, typename _Traits>
 874     basic_istream<_CharT, _Traits>&
 875     basic_istream<_CharT, _Traits>::
 876     unget(void)
 877     {
 878 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 879 // 60. What is a formatted input function?
 880       _M_gcount = 0;
 881 #endif
 882       sentry __cerb(*this, true);
 883       if (__cerb)
 884         {
 885           try
 886             {
 887               const int_type __eof = traits_type::eof();
 888               __streambuf_type* __sb = this->rdbuf();
 889               if (!__sb
 890                   || traits_type::eq_int_type(__sb->sungetc(), __eof))
 891                 this->setstate(ios_base::badbit);
 892             }
 893           catch(...)
 894             {
 895               // 27.6.1.3 paragraph 1
 896               // Turn this on without causing an ios::failure to be thrown.
 897               this->_M_setstate(ios_base::badbit);
 898               if ((this->exceptions() & ios_base::badbit) != 0)
 899                 __throw_exception_again;
 900             }
 901         }
 902       else
 903         this->setstate(ios_base::failbit);
 904       return *this;
 905     }
 906
 907   template<typename _CharT, typename _Traits>
 908     int
 909     basic_istream<_CharT, _Traits>::
 910     sync(void)
 911     {
 912       // DR60.  Do not change _M_gcount.
 913       int __ret = -1;
 914       sentry __cerb(*this, true);
 915       if (__cerb)
 916         {
 917           try
 918             {
 919               __streambuf_type* __sb = this->rdbuf();
 920               if (__sb)
 921                 {
 922                   if (__sb->pubsync() == -1)
 923                     this->setstate(ios_base::badbit);
 924                   else
 925                     __ret = 0;
 926                 }
 927             }
 928           catch(...)
 929             {
 930               // 27.6.1.3 paragraph 1
 931               // Turn this on without causing an ios::failure to be thrown.
 932               this->_M_setstate(ios_base::badbit);
 933               if ((this->exceptions() & ios_base::badbit) != 0)
 934                 __throw_exception_again;
 935             }
 936         }
 937       return __ret;
 938     }
 939
 940   template<typename _CharT, typename _Traits>
 941     typename basic_istream<_CharT, _Traits>::pos_type
 942     basic_istream<_CharT, _Traits>::
 943     tellg(void)
 944     {
 945       // DR60.  Do not change _M_gcount.
 946       pos_type __ret = pos_type(-1);
 947       if (!this->fail())
 948         __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
 949       return __ret;
 950     }
 951
 952
 953   template<typename _CharT, typename _Traits>
 954     basic_istream<_CharT, _Traits>&
 955     basic_istream<_CharT, _Traits>::
 956     seekg(pos_type __pos)
 957     {
 958       // DR60.  Do not change _M_gcount.
 959       if (!this->fail())
 960         {
 961 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 962 // 136.  seekp, seekg setting wrong streams?
 963           pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
 964
 965 // 129. Need error indication from seekp() and seekg()
 966           if (__err == pos_type(off_type(-1)))
 967             this->setstate(ios_base::failbit);
 968 #endif
 969         }
 970       return *this;
 971     }
 972
 973   template<typename _CharT, typename _Traits>
 974     basic_istream<_CharT, _Traits>&
 975     basic_istream<_CharT, _Traits>::
 976     seekg(off_type __off, ios_base::seekdir __dir)
 977     {
 978       // DR60.  Do not change _M_gcount.
 979       if (!this->fail())
 980         {
 981 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 982 // 136.  seekp, seekg setting wrong streams?
 983           pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
 984                                                      ios_base::in);
 985
 986 // 129. Need error indication from seekp() and seekg()
 987           if (__err == pos_type(off_type(-1)))
 988             this->setstate(ios_base::failbit);
 989 #endif
 990         }
 991       return *this;
 992     }
 993
 994   // 27.6.1.2.3 Character extraction templates
 995   template<typename _CharT, typename _Traits>
 996     basic_istream<_CharT, _Traits>&
 997     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
 998     {
 999       typedef basic_istream<_CharT, _Traits>            __istream_type;
1000       typename __istream_type::sentry __cerb(__in, false);
1001       if (__cerb)
1002         {
1003           try
1004             { __in.get(__c); }
1005           catch(...)
1006             {
1007               // 27.6.1.2.1 Common requirements.
1008               // Turn this on without causing an ios::failure to be thrown.
1009               __in._M_setstate(ios_base::badbit);
1010               if ((__in.exceptions() & ios_base::badbit) != 0)
1011                 __throw_exception_again;
1012             }
1013         }
1014       else
1015         __in.setstate(ios_base::failbit);
1016       return __in;
1017     }
1018
1019   template<typename _CharT, typename _Traits>
1020     basic_istream<_CharT, _Traits>&
1021     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
1022     {
1023       typedef basic_istream<_CharT, _Traits>            __istream_type;
1024       typedef typename __istream_type::__streambuf_type __streambuf_type;
1025       typedef typename _Traits::int_type                int_type;
1026       typedef _CharT                                    char_type;
1027       typedef ctype<_CharT>                             __ctype_type;
1028       streamsize __extracted = 0;
1029
1030       typename __istream_type::sentry __cerb(__in, false);
1031       if (__cerb)
1032         {
1033           try
1034             {
1035               // Figure out how many characters to extract.
1036               streamsize __num = __in.width();
1037               if (__num == 0)
1038                 __num = numeric_limits<streamsize>::max();
1039
1040               const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1041               const int_type __eof = _Traits::eof();
1042               __streambuf_type* __sb = __in.rdbuf();
1043               int_type __c = __sb->sgetc();
1044
1045               while (__extracted < __num - 1
1046                      && !_Traits::eq_int_type(__c, __eof)
1047                      && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1048                 {
1049                   *__s++ = _Traits::to_char_type(__c);
1050                   ++__extracted;
1051                   __c = __sb->snextc();
1052                 }
1053               if (_Traits::eq_int_type(__c, __eof))
1054                 __in.setstate(ios_base::eofbit);
1055
1056 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1057 //68.  Extractors for char* should store null at end
1058               *__s = char_type();
1059 #endif
1060               __in.width(0);
1061             }
1062           catch(...)
1063             {
1064               // 27.6.1.2.1 Common requirements.
1065               // Turn this on without causing an ios::failure to be thrown.
1066               __in._M_setstate(ios_base::badbit);
1067               if ((__in.exceptions() & ios_base::badbit) != 0)
1068                 __throw_exception_again;
1069             }
1070         }
1071       if (!__extracted)
1072         __in.setstate(ios_base::failbit);
1073       return __in;
1074     }
1075
1076   // 27.6.1.4 Standard basic_istream manipulators
1077   template<typename _CharT, typename _Traits>
1078     basic_istream<_CharT,_Traits>&
1079     ws(basic_istream<_CharT,_Traits>& __in)
1080     {
1081       typedef basic_istream<_CharT, _Traits>            __istream_type;
1082       typedef typename __istream_type::__streambuf_type __streambuf_type;
1083       typedef typename __istream_type::__ctype_type     __ctype_type;
1084       typedef typename __istream_type::int_type         __int_type;
1085
1086       const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1087       const __int_type __eof = _Traits::eof();
1088       __streambuf_type* __sb = __in.rdbuf();
1089       __int_type __c = __sb->sgetc();
1090
1091       while (!_Traits::eq_int_type(__c, __eof)
1092              && __ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1093         __c = __sb->snextc();
1094
1095        if (_Traits::eq_int_type(__c, __eof))
1096         __in.setstate(ios_base::eofbit);
1097
1098       return __in;
1099     }
1100
1101   // 21.3.7.9 basic_string::getline and operators
1102   template<typename _CharT, typename _Traits, typename _Alloc>
1103     basic_istream<_CharT, _Traits>&
1104     operator>>(basic_istream<_CharT, _Traits>& __in,
1105                basic_string<_CharT, _Traits, _Alloc>& __str)
1106     {
1107       typedef basic_istream<_CharT, _Traits>            __istream_type;
1108       typedef typename __istream_type::int_type         __int_type;
1109       typedef typename __istream_type::__streambuf_type __streambuf_type;
1110       typedef typename __istream_type::__ctype_type     __ctype_type;
1111       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
1112       typedef typename __string_type::size_type         __size_type;
1113       __size_type __extracted = 0;
1114
1115       typename __istream_type::sentry __cerb(__in, false);
1116       if (__cerb)
1117         {
1118           __str.erase();
1119           streamsize __w = __in.width();
1120           __size_type __n;
1121           __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
1122
1123           const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1124           const __int_type __eof = _Traits::eof();
1125           __streambuf_type* __sb = __in.rdbuf();
1126           __int_type __c = __sb->sgetc();
1127
1128           while (__extracted < __n
1129                  && !_Traits::eq_int_type(__c, __eof)
1130                  && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1131             {
1132               __str += _Traits::to_char_type(__c);
1133               ++__extracted;
1134               __c = __sb->snextc();
1135             }
1136           if (_Traits::eq_int_type(__c, __eof))
1137             __in.setstate(ios_base::eofbit);
1138           __in.width(0);
1139         }
1140 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1141 //211.  operator>>(istream&, string&) doesn't set failbit
1142       if (!__extracted)
1143         __in.setstate (ios_base::failbit);
1144 #endif
1145       return __in;
1146     }
1147
1148   template<typename _CharT, typename _Traits, typename _Alloc>
1149     basic_istream<_CharT, _Traits>&
1150     getline(basic_istream<_CharT, _Traits>& __in,
1151             basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1152     {
1153       typedef basic_istream<_CharT, _Traits>            __istream_type;
1154       typedef typename __istream_type::int_type         __int_type;
1155       typedef typename __istream_type::__streambuf_type __streambuf_type;
1156       typedef typename __istream_type::__ctype_type     __ctype_type;
1157       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
1158       typedef typename __string_type::size_type         __size_type;
1159
1160       __size_type __extracted = 0;
1161       bool __testdelim = false;
1162       typename __istream_type::sentry __cerb(__in, true);
1163       if (__cerb)
1164         {
1165           __str.erase();
1166           __size_type __n = __str.max_size();
1167
1168           __int_type __idelim = _Traits::to_int_type(__delim);
1169           __streambuf_type* __sb = __in.rdbuf();
1170           __int_type __c = __sb->sbumpc();
1171           const __int_type __eof = _Traits::eof();
1172           __testdelim = _Traits::eq_int_type(__c, __idelim);
1173
1174           while (__extracted <= __n
1175                  && !_Traits::eq_int_type(__c, __eof)
1176                  && !__testdelim)
1177             {
1178               __str += _Traits::to_char_type(__c);
1179               ++__extracted;
1180               __c = __sb->sbumpc();
1181               __testdelim = _Traits::eq_int_type(__c, __idelim);
1182             }
1183           if (_Traits::eq_int_type(__c, __eof))
1184             __in.setstate(ios_base::eofbit);
1185         }
1186       if (!__extracted && !__testdelim)
1187         __in.setstate(ios_base::failbit);
1188       return __in;
1189     }
1190
1191   template<class _CharT, class _Traits, class _Alloc>
1192     inline basic_istream<_CharT,_Traits>&
1193     getline(basic_istream<_CharT, _Traits>& __in,
1194             basic_string<_CharT,_Traits,_Alloc>& __str)
1195     { return getline(__in, __str, __in.widen('\n')); }
1196
1197   // Inhibit implicit instantiations for required instantiations,
1198   // which are defined via explicit instantiations elsewhere.
1199   // NB:  This syntax is a GNU extension.
1200 #if _GLIBCPP_EXTERN_TEMPLATE
1201   extern template class basic_istream<char>;
1202   extern template istream& ws(istream&);
1203   extern template istream& operator>>(istream&, char&);
1204   extern template istream& operator>>(istream&, char*);
1205   extern template istream& operator>>(istream&, unsigned char&);
1206   extern template istream& operator>>(istream&, signed char&);
1207   extern template istream& operator>>(istream&, unsigned char*);
1208   extern template istream& operator>>(istream&, signed char*);
1209
1210 #ifdef _GLIBCPP_USE_WCHAR_T
1211   extern template class basic_istream<wchar_t>;
1212   extern template wistream& ws(wistream&);
1213   extern template wistream& operator>>(wistream&, wchar_t&);
1214   extern template wistream& operator>>(wistream&, wchar_t*);
1215 #endif
1216 #endif
1217 } // namespace std