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

   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
  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(_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 = __sb->sgetc();
 726
 727               __n = min(__n, numeric_limits<streamsize>::max());
 728               while (_M_gcount < __n
 729                      && !traits_type::eq_int_type(__c, __eof)
 730                      && !traits_type::eq_int_type(__c, __delim))
 731                 {
 732                   __c = __sb->snextc();
 733                   ++_M_gcount;
 734                 }
 735               if (traits_type::eq_int_type(__c, __eof))
 736                 this->setstate(ios_base::eofbit);
 737               else if (traits_type::eq_int_type(__c, __delim))
 738                 {
 739                   __sb->sbumpc();
 740                   ++_M_gcount;
 741                 }
 742             }
 743           catch(exception& __fail)
 744             {
 745               // 27.6.1.3 paragraph 1
 746               // Turn this on without causing an ios::failure to be thrown.
 747               this->setstate(ios_base::badbit);
 748               if ((this->exceptions() & ios_base::badbit) != 0)
 749                 __throw_exception_again;
 750             }
 751         }
 752       return *this;
 753     }
 754
 755   template<typename _CharT, typename _Traits>
 756     typename basic_istream<_CharT, _Traits>::int_type
 757     basic_istream<_CharT, _Traits>::
 758     peek(void)
 759     {
 760       int_type __c = traits_type::eof();
 761       _M_gcount = 0;
 762       sentry __cerb(*this, true);
 763       if (__cerb)
 764         {
 765           try
 766             { __c = this->rdbuf()->sgetc(); }
 767           catch(exception& __fail)
 768             {
 769               // 27.6.1.3 paragraph 1
 770               // Turn this on without causing an ios::failure to be thrown.
 771               this->setstate(ios_base::badbit);
 772               if ((this->exceptions() & ios_base::badbit) != 0)
 773                 __throw_exception_again;
 774             }
 775         }
 776       return __c;
 777     }
 778
 779   template<typename _CharT, typename _Traits>
 780     basic_istream<_CharT, _Traits>&
 781     basic_istream<_CharT, _Traits>::
 782     read(char_type* __s, streamsize __n)
 783     {
 784       _M_gcount = 0;
 785       sentry __cerb(*this, true);
 786       if (__cerb)
 787         {
 788           try
 789             {
 790               _M_gcount = this->rdbuf()->sgetn(__s, __n);
 791               if (_M_gcount != __n)
 792                 this->setstate(ios_base::eofbit | ios_base::failbit);
 793             }
 794           catch(exception& __fail)
 795             {
 796               // 27.6.1.3 paragraph 1
 797               // Turn this on without causing an ios::failure to be thrown.
 798               this->setstate(ios_base::badbit);
 799               if ((this->exceptions() & ios_base::badbit) != 0)
 800                 __throw_exception_again;
 801             }
 802         }
 803       else
 804         this->setstate(ios_base::failbit);
 805       return *this;
 806     }
 807
 808   template<typename _CharT, typename _Traits>
 809     streamsize
 810     basic_istream<_CharT, _Traits>::
 811     readsome(char_type* __s, streamsize __n)
 812     {
 813       _M_gcount = 0;
 814       sentry __cerb(*this, true);
 815       if (__cerb)
 816         {
 817           try
 818             {
 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(exception& __fail)
 830             {
 831               // 27.6.1.3 paragraph 1
 832               // Turn this on without causing an ios::failure to be thrown.
 833               this->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       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(exception& __fail)
 860             {
 861               // 27.6.1.3 paragraph 1
 862               // Turn this on without causing an ios::failure to be thrown.
 863               this->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       _M_gcount = 0;
 879       sentry __cerb(*this, true);
 880       if (__cerb)
 881         {
 882           try
 883             {
 884               const int_type __eof = traits_type::eof();
 885               __streambuf_type* __sb = this->rdbuf();
 886               if (!__sb
 887                   || traits_type::eq_int_type(__sb->sungetc(), __eof))
 888                 this->setstate(ios_base::badbit);
 889             }
 890           catch(exception& __fail)
 891             {
 892               // 27.6.1.3 paragraph 1
 893               // Turn this on without causing an ios::failure to be thrown.
 894               this->setstate(ios_base::badbit);
 895               if ((this->exceptions() & ios_base::badbit) != 0)
 896                 __throw_exception_again;
 897             }
 898         }
 899       else
 900         this->setstate(ios_base::failbit);
 901       return *this;
 902     }
 903
 904   template<typename _CharT, typename _Traits>
 905     int
 906     basic_istream<_CharT, _Traits>::
 907     sync(void)
 908     {
 909       int __ret = -1;
 910       _M_gcount = 0;
 911       sentry __cerb(*this, true);
 912       if (__cerb)
 913         {
 914           try
 915             {
 916               __streambuf_type* __sb = this->rdbuf();
 917               if (__sb)
 918                 {
 919                   if (__sb->pubsync() == -1)
 920                     this->setstate(ios_base::badbit);
 921                   else
 922                     __ret = 0;
 923                 }
 924             }
 925           catch(exception& __fail)
 926             {
 927               // 27.6.1.3 paragraph 1
 928               // Turn this on without causing an ios::failure to be thrown.
 929               this->setstate(ios_base::badbit);
 930               if ((this->exceptions() & ios_base::badbit) != 0)
 931                 __throw_exception_again;
 932             }
 933         }
 934       return __ret;
 935     }
 936
 937   template<typename _CharT, typename _Traits>
 938     typename basic_istream<_CharT, _Traits>::pos_type
 939     basic_istream<_CharT, _Traits>::
 940     tellg(void)
 941     {
 942       pos_type __ret = pos_type(-1);
 943       _M_gcount = 0;
 944       sentry __cerb(*this, true);
 945       if (__cerb)
 946         {
 947           try
 948             {
 949              __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
 950             }
 951           catch(exception& __fail)
 952             {
 953               // 27.6.1.3 paragraph 1
 954               // Turn this on without causing an ios::failure to be thrown.
 955               this->setstate(ios_base::badbit);
 956               if ((this->exceptions() & ios_base::badbit) != 0)
 957                 __throw_exception_again;
 958             }
 959         }
 960       return __ret;
 961     }
 962
 963
 964   template<typename _CharT, typename _Traits>
 965     basic_istream<_CharT, _Traits>&
 966     basic_istream<_CharT, _Traits>::
 967     seekg(pos_type __pos)
 968     {
 969       _M_gcount = 0;
 970       sentry __cerb(*this, true);
 971       if (__cerb)
 972         {
 973           try
 974             {
 975 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 976 // 136.  seekp, seekg setting wrong streams?
 977               pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
 978
 979 // 129. Need error indication from seekp() and seekg()
 980               if (__err == pos_type(off_type(-1)))
 981                 this->setstate(ios_base::failbit);
 982 #endif
 983             }
 984           catch(exception& __fail)
 985             {
 986               // 27.6.1.3 paragraph 1
 987               // Turn this on without causing an ios::failure to be thrown.
 988               this->setstate(ios_base::badbit);
 989               if ((this->exceptions() & ios_base::badbit) != 0)
 990                 __throw_exception_again;
 991             }
 992         }
 993       return *this;
 994     }
 995
 996   template<typename _CharT, typename _Traits>
 997     basic_istream<_CharT, _Traits>&
 998     basic_istream<_CharT, _Traits>::
 999     seekg(off_type __off, ios_base::seekdir __dir)
1000     {
1001       _M_gcount = 0;
1002       sentry __cerb(*this, true);
1003       if (__cerb)
1004         {
1005           try
1006             {
1007 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1008 // 136.  seekp, seekg setting wrong streams?
1009               pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
1010                                                          ios_base::in);
1011
1012 // 129. Need error indication from seekp() and seekg()
1013               if (__err == pos_type(off_type(-1)))
1014                 this->setstate(ios_base::failbit);
1015 #endif
1016             }
1017           catch(exception& __fail)
1018             {
1019               // 27.6.1.3 paragraph 1
1020               // Turn this on without causing an ios::failure to be thrown.
1021               this->setstate(ios_base::badbit);
1022               if ((this->exceptions() & ios_base::badbit) != 0)
1023                 __throw_exception_again;
1024             }
1025         }
1026       return *this;
1027     }
1028
1029   // 27.6.1.2.3 Character extraction templates
1030   template<typename _CharT, typename _Traits>
1031     basic_istream<_CharT, _Traits>&
1032     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
1033     {
1034       typedef basic_istream<_CharT, _Traits>            __istream_type;
1035       typename __istream_type::sentry __cerb(__in, false);
1036       if (__cerb)
1037         {
1038           try
1039             { __in.get(__c); }
1040           catch(exception& __fail)
1041             {
1042               // 27.6.1.2.1 Common requirements.
1043               // Turn this on without causing an ios::failure to be thrown.
1044               __in.setstate(ios_base::badbit);
1045               if ((__in.exceptions() & ios_base::badbit) != 0)
1046                 __throw_exception_again;
1047             }
1048         }
1049       else
1050         __in.setstate(ios_base::failbit);
1051       return __in;
1052     }
1053
1054   template<typename _CharT, typename _Traits>
1055     basic_istream<_CharT, _Traits>&
1056     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
1057     {
1058       typedef basic_istream<_CharT, _Traits>            __istream_type;
1059       typedef typename __istream_type::__streambuf_type __streambuf_type;
1060       typedef typename _Traits::int_type                int_type;
1061       typedef _CharT                                    char_type;
1062       typedef ctype<_CharT>                             __ctype_type;
1063       streamsize __extracted = 0;
1064
1065       typename __istream_type::sentry __cerb(__in, false);
1066       if (__cerb)
1067         {
1068           try
1069             {
1070               // Figure out how many characters to extract.
1071               streamsize __num = __in.width();
1072               if (__num == 0)
1073                 __num = numeric_limits<streamsize>::max();
1074
1075               const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1076               const int_type __eof = _Traits::eof();
1077               __streambuf_type* __sb = __in.rdbuf();
1078               int_type __c = __sb->sgetc();
1079
1080               while (__extracted < __num - 1
1081                      && __c != __eof && !__ctype.is(ctype_base::space, __c))
1082                 {
1083                   *__s++ = __c;
1084                   ++__extracted;
1085                   __c = __sb->snextc();
1086                 }
1087               if (__c == __eof)
1088                 __in.setstate(ios_base::eofbit);
1089
1090 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1091 //68.  Extractors for char* should store null at end
1092               *__s = char_type();
1093 #endif
1094               __in.width(0);
1095             }
1096           catch(exception& __fail)
1097             {
1098               // 27.6.1.2.1 Common requirements.
1099               // Turn this on without causing an ios::failure to be thrown.
1100               __in.setstate(ios_base::badbit);
1101               if ((__in.exceptions() & ios_base::badbit) != 0)
1102                 __throw_exception_again;
1103             }
1104         }
1105       if (!__extracted)
1106         __in.setstate(ios_base::failbit);
1107       return __in;
1108     }
1109
1110   // 27.6.1.4 Standard basic_istream manipulators
1111   template<typename _CharT, typename _Traits>
1112     basic_istream<_CharT,_Traits>&
1113     ws(basic_istream<_CharT,_Traits>& __in)
1114     {
1115       typedef basic_istream<_CharT, _Traits>            __istream_type;
1116       typedef typename __istream_type::__streambuf_type __streambuf_type;
1117       typedef typename __istream_type::__ctype_type     __ctype_type;
1118       typedef typename __istream_type::int_type         __int_type;
1119
1120       const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1121       const __int_type __eof = _Traits::eof();
1122       __streambuf_type* __sb = __in.rdbuf();
1123       __int_type __c = __sb->sgetc();
1124
1125       while (__c != __eof && __ctype.is(ctype_base::space, __c))
1126         __c = __sb->snextc();
1127       if (__c == __eof)
1128         __in.setstate(ios_base::eofbit);
1129
1130       return __in;
1131     }
1132
1133   // 21.3.7.9 basic_string::getline and operators
1134   template<typename _CharT, typename _Traits, typename _Alloc>
1135     basic_istream<_CharT, _Traits>&
1136     operator>>(basic_istream<_CharT, _Traits>& __in,
1137                basic_string<_CharT, _Traits, _Alloc>& __str)
1138     {
1139       typedef basic_istream<_CharT, _Traits>            __istream_type;
1140       typedef typename __istream_type::int_type         __int_type;
1141       typedef typename __istream_type::__streambuf_type __streambuf_type;
1142       typedef typename __istream_type::__ctype_type     __ctype_type;
1143       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
1144       typedef typename __string_type::size_type         __size_type;
1145       __size_type __extracted = 0;
1146
1147       typename __istream_type::sentry __cerb(__in, false);
1148       if (__cerb)
1149         {
1150           __str.erase();
1151           streamsize __w = __in.width();
1152           __size_type __n;
1153           __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
1154
1155           const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1156           const __int_type __eof = _Traits::eof();
1157           __streambuf_type* __sb = __in.rdbuf();
1158           __int_type __c = __sb->sgetc();
1159
1160           while (__extracted < __n
1161                  && __c != __eof && !__ctype.is(ctype_base::space, __c))
1162             {
1163               __str += _Traits::to_char_type(__c);
1164               ++__extracted;
1165               __c = __sb->snextc();
1166             }
1167           if (__c == __eof)
1168             __in.setstate(ios_base::eofbit);
1169           __in.width(0);
1170         }
1171 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1172 //211.  operator>>(istream&, string&) doesn't set failbit
1173       if (!__extracted)
1174         __in.setstate (ios_base::failbit);
1175 #endif
1176       return __in;
1177     }
1178
1179   template<typename _CharT, typename _Traits, typename _Alloc>
1180     basic_istream<_CharT, _Traits>&
1181     getline(basic_istream<_CharT, _Traits>& __in,
1182             basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1183     {
1184       typedef basic_istream<_CharT, _Traits>            __istream_type;
1185       typedef typename __istream_type::int_type         __int_type;
1186       typedef typename __istream_type::__streambuf_type __streambuf_type;
1187       typedef typename __istream_type::__ctype_type     __ctype_type;
1188       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
1189       typedef typename __string_type::size_type         __size_type;
1190
1191       __size_type __extracted = 0;
1192       bool __testdelim = false;
1193       typename __istream_type::sentry __cerb(__in, true);
1194       if (__cerb)
1195         {
1196           __str.erase();
1197           __size_type __n = __str.max_size();
1198
1199           __int_type __idelim = _Traits::to_int_type(__delim);
1200           __streambuf_type* __sb = __in.rdbuf();
1201           __int_type __c = __sb->sbumpc();
1202           const __int_type __eof = _Traits::eof();
1203           __testdelim = _Traits::eq_int_type(__c, __idelim);
1204
1205           while (__extracted <= __n
1206                  && !_Traits::eq_int_type(__c, __eof)
1207                  && !__testdelim)
1208             {
1209               __str += _Traits::to_char_type(__c);
1210               ++__extracted;
1211               __c = __sb->sbumpc();
1212               __testdelim = _Traits::eq_int_type(__c, __idelim);
1213             }
1214           if (_Traits::eq_int_type(__c, __eof))
1215             __in.setstate(ios_base::eofbit);
1216         }
1217       if (!__extracted && !__testdelim)
1218         __in.setstate(ios_base::failbit);
1219       return __in;
1220     }
1221
1222   template<class _CharT, class _Traits, class _Alloc>
1223     inline basic_istream<_CharT,_Traits>&
1224     getline(basic_istream<_CharT, _Traits>& __in,
1225             basic_string<_CharT,_Traits,_Alloc>& __str)
1226     { return getline(__in, __str, __in.widen('\n')); }
1227
1228   // Inhibit implicit instantiations for required instantiations,
1229   // which are defined via explicit instantiations elsewhere.
1230   // NB:  This syntax is a GNU extension.
1231   extern template class basic_istream<char>;
1232   extern template istream& ws(istream&);
1233   extern template istream& operator>>(istream&, char&);
1234   extern template istream& operator>>(istream&, char*);
1235   extern template istream& operator>>(istream&, unsigned char&);
1236   extern template istream& operator>>(istream&, signed char&);
1237   extern template istream& operator>>(istream&, unsigned char*);
1238   extern template istream& operator>>(istream&, signed char*);
1239
1240 #ifdef _GLIBCPP_USE_WCHAR_T
1241   extern template class basic_istream<wchar_t>;
1242   extern template wistream& ws(wistream&);
1243   extern template wistream& operator>>(wistream&, wchar_t&);
1244   extern template wistream& operator>>(wistream&, wchar_t*);
1245 #endif
1246 } // namespace std