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