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

   1 // istream classes -*- C++ -*-
   2
   3 // Copyright (C) 1997-2015 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file bits/istream.tcc
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{istream}
  28  */
  29
  30 //
  31 // ISO C++ 14882: 27.6.1  Input streams
  32 //
  33
  34 #ifndef _ISTREAM_TCC
  35 #define _ISTREAM_TCC 1
  36
  37 #pragma GCC system_header
  38
  39 #include <bits/cxxabi_forced.h>
  40
  41 namespace std _GLIBCXX_VISIBILITY(default)
  42 {
  43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  44
  45   template<typename _CharT, typename _Traits>
  46     basic_istream<_CharT, _Traits>::sentry::
  47     sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
  48     {
  49       ios_base::iostate __err = ios_base::goodbit;
  50       if (__in.good())
  51         {
  52           if (__in.tie())
  53             __in.tie()->flush();
  54           if (!__noskip && bool(__in.flags() & ios_base::skipws))
  55             {
  56               const __int_type __eof = traits_type::eof();
  57               __streambuf_type* __sb = __in.rdbuf();
  58               __int_type __c = __sb->sgetc();
  59
  60               const __ctype_type& __ct = __check_facet(__in._M_ctype);
  61               while (!traits_type::eq_int_type(__c, __eof)
  62                      && __ct.is(ctype_base::space,
  63                                 traits_type::to_char_type(__c)))
  64                 __c = __sb->snextc();
  65
  66               // _GLIBCXX_RESOLVE_LIB_DEFECTS
  67               // 195. Should basic_istream::sentry's constructor ever
  68               // set eofbit?
  69               if (traits_type::eq_int_type(__c, __eof))
  70                 __err |= ios_base::eofbit;
  71             }
  72         }
  73
  74       if (__in.good() && __err == ios_base::goodbit)
  75         _M_ok = true;
  76       else
  77         {
  78           __err |= ios_base::failbit;
  79           __in.setstate(__err);
  80         }
  81     }
  82
  83   template<typename _CharT, typename _Traits>
  84     template<typename _ValueT>
  85       basic_istream<_CharT, _Traits>&
  86       basic_istream<_CharT, _Traits>::
  87       _M_extract(_ValueT& __v)
  88       {
  89         sentry __cerb(*this, false);
  90         if (__cerb)
  91           {
  92             ios_base::iostate __err = ios_base::goodbit;
  93             __try
  94               {
  95                 const __num_get_type& __ng = __check_facet(this->_M_num_get);
  96                 __ng.get(*this, 0, *this, __err, __v);
  97               }
  98             __catch(__cxxabiv1::__forced_unwind&)
  99               {
 100                 this->_M_setstate(ios_base::badbit);
 101                 __throw_exception_again;
 102               }
 103             __catch(...)
 104               { this->_M_setstate(ios_base::badbit); }
 105             if (__err)
 106               this->setstate(__err);
 107           }
 108         return *this;
 109       }
 110
 111   template<typename _CharT, typename _Traits>
 112     basic_istream<_CharT, _Traits>&
 113     basic_istream<_CharT, _Traits>::
 114     operator>>(short& __n)
 115     {
 116       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 117       // 118. basic_istream uses nonexistent num_get member functions.
 118       sentry __cerb(*this, false);
 119       if (__cerb)
 120         {
 121           ios_base::iostate __err = ios_base::goodbit;
 122           __try
 123             {
 124               long __l;
 125               const __num_get_type& __ng = __check_facet(this->_M_num_get);
 126               __ng.get(*this, 0, *this, __err, __l);
 127
 128               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 129               // 696. istream::operator>>(int&) broken.
 130               if (__l < __gnu_cxx::__numeric_traits<short>::__min)
 131                 {
 132                   __err |= ios_base::failbit;
 133                   __n = __gnu_cxx::__numeric_traits<short>::__min;
 134                 }
 135               else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
 136                 {
 137                   __err |= ios_base::failbit;
 138                   __n = __gnu_cxx::__numeric_traits<short>::__max;
 139                 }
 140               else
 141                 __n = short(__l);
 142             }
 143           __catch(__cxxabiv1::__forced_unwind&)
 144             {
 145               this->_M_setstate(ios_base::badbit);
 146               __throw_exception_again;
 147             }
 148           __catch(...)
 149             { this->_M_setstate(ios_base::badbit); }
 150           if (__err)
 151             this->setstate(__err);
 152         }
 153       return *this;
 154     }
 155
 156   template<typename _CharT, typename _Traits>
 157     basic_istream<_CharT, _Traits>&
 158     basic_istream<_CharT, _Traits>::
 159     operator>>(int& __n)
 160     {
 161       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 162       // 118. basic_istream uses nonexistent num_get member functions.
 163       sentry __cerb(*this, false);
 164       if (__cerb)
 165         {
 166           ios_base::iostate __err = ios_base::goodbit;
 167           __try
 168             {
 169               long __l;
 170               const __num_get_type& __ng = __check_facet(this->_M_num_get);
 171               __ng.get(*this, 0, *this, __err, __l);
 172
 173               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 174               // 696. istream::operator>>(int&) broken.
 175               if (__l < __gnu_cxx::__numeric_traits<int>::__min)
 176                 {
 177                   __err |= ios_base::failbit;
 178                   __n = __gnu_cxx::__numeric_traits<int>::__min;
 179                 }
 180               else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
 181                 {
 182                   __err |= ios_base::failbit;
 183                   __n = __gnu_cxx::__numeric_traits<int>::__max;
 184                 }
 185               else
 186                 __n = int(__l);
 187             }
 188           __catch(__cxxabiv1::__forced_unwind&)
 189             {
 190               this->_M_setstate(ios_base::badbit);
 191               __throw_exception_again;
 192             }
 193           __catch(...)
 194             { this->_M_setstate(ios_base::badbit); }
 195           if (__err)
 196             this->setstate(__err);
 197         }
 198       return *this;
 199     }
 200
 201   template<typename _CharT, typename _Traits>
 202     basic_istream<_CharT, _Traits>&
 203     basic_istream<_CharT, _Traits>::
 204     operator>>(__streambuf_type* __sbout)
 205     {
 206       ios_base::iostate __err = ios_base::goodbit;
 207       sentry __cerb(*this, false);
 208       if (__cerb && __sbout)
 209         {
 210           __try
 211             {
 212               bool __ineof;
 213               if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
 214                 __err |= ios_base::failbit;
 215               if (__ineof)
 216                 __err |= ios_base::eofbit;
 217             }
 218           __catch(__cxxabiv1::__forced_unwind&)
 219             {
 220               this->_M_setstate(ios_base::failbit);
 221               __throw_exception_again;
 222             }
 223           __catch(...)
 224             { this->_M_setstate(ios_base::failbit); }
 225         }
 226       else if (!__sbout)
 227         __err |= ios_base::failbit;
 228       if (__err)
 229         this->setstate(__err);
 230       return *this;
 231     }
 232
 233   template<typename _CharT, typename _Traits>
 234     typename basic_istream<_CharT, _Traits>::int_type
 235     basic_istream<_CharT, _Traits>::
 236     get(void)
 237     {
 238       const int_type __eof = traits_type::eof();
 239       int_type __c = __eof;
 240       _M_gcount = 0;
 241       ios_base::iostate __err = ios_base::goodbit;
 242       sentry __cerb(*this, true);
 243       if (__cerb)
 244         {
 245           __try
 246             {
 247               __c = this->rdbuf()->sbumpc();
 248               // 27.6.1.1 paragraph 3
 249               if (!traits_type::eq_int_type(__c, __eof))
 250                 _M_gcount = 1;
 251               else
 252                 __err |= ios_base::eofbit;
 253             }
 254           __catch(__cxxabiv1::__forced_unwind&)
 255             {
 256               this->_M_setstate(ios_base::badbit);
 257               __throw_exception_again;
 258             }
 259           __catch(...)
 260             { this->_M_setstate(ios_base::badbit); }
 261         }
 262       if (!_M_gcount)
 263         __err |= ios_base::failbit;
 264       if (__err)
 265         this->setstate(__err);
 266       return __c;
 267     }
 268
 269   template<typename _CharT, typename _Traits>
 270     basic_istream<_CharT, _Traits>&
 271     basic_istream<_CharT, _Traits>::
 272     get(char_type& __c)
 273     {
 274       _M_gcount = 0;
 275       ios_base::iostate __err = ios_base::goodbit;
 276       sentry __cerb(*this, true);
 277       if (__cerb)
 278         {
 279           __try
 280             {
 281               const int_type __cb = this->rdbuf()->sbumpc();
 282               // 27.6.1.1 paragraph 3
 283               if (!traits_type::eq_int_type(__cb, traits_type::eof()))
 284                 {
 285                   _M_gcount = 1;
 286                   __c = traits_type::to_char_type(__cb);
 287                 }
 288               else
 289                 __err |= ios_base::eofbit;
 290             }
 291           __catch(__cxxabiv1::__forced_unwind&)
 292             {
 293               this->_M_setstate(ios_base::badbit);
 294               __throw_exception_again;
 295             }
 296           __catch(...)
 297             { this->_M_setstate(ios_base::badbit); }
 298         }
 299       if (!_M_gcount)
 300         __err |= ios_base::failbit;
 301       if (__err)
 302         this->setstate(__err);
 303       return *this;
 304     }
 305
 306   template<typename _CharT, typename _Traits>
 307     basic_istream<_CharT, _Traits>&
 308     basic_istream<_CharT, _Traits>::
 309     get(char_type* __s, streamsize __n, char_type __delim)
 310     {
 311       _M_gcount = 0;
 312       ios_base::iostate __err = ios_base::goodbit;
 313       sentry __cerb(*this, true);
 314       if (__cerb)
 315         {
 316           __try
 317             {
 318               const int_type __idelim = traits_type::to_int_type(__delim);
 319               const int_type __eof = traits_type::eof();
 320               __streambuf_type* __sb = this->rdbuf();
 321               int_type __c = __sb->sgetc();
 322
 323               while (_M_gcount + 1 < __n
 324                      && !traits_type::eq_int_type(__c, __eof)
 325                      && !traits_type::eq_int_type(__c, __idelim))
 326                 {
 327                   *__s++ = traits_type::to_char_type(__c);
 328                   ++_M_gcount;
 329                   __c = __sb->snextc();
 330                 }
 331               if (traits_type::eq_int_type(__c, __eof))
 332                 __err |= ios_base::eofbit;
 333             }
 334           __catch(__cxxabiv1::__forced_unwind&)
 335             {
 336               this->_M_setstate(ios_base::badbit);
 337               __throw_exception_again;
 338             }
 339           __catch(...)
 340             { this->_M_setstate(ios_base::badbit); }
 341         }
 342       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 343       // 243. get and getline when sentry reports failure.
 344       if (__n > 0)
 345         *__s = char_type();
 346       if (!_M_gcount)
 347         __err |= ios_base::failbit;
 348       if (__err)
 349         this->setstate(__err);
 350       return *this;
 351     }
 352
 353   template<typename _CharT, typename _Traits>
 354     basic_istream<_CharT, _Traits>&
 355     basic_istream<_CharT, _Traits>::
 356     get(__streambuf_type& __sb, char_type __delim)
 357     {
 358       _M_gcount = 0;
 359       ios_base::iostate __err = ios_base::goodbit;
 360       sentry __cerb(*this, true);
 361       if (__cerb)
 362         {
 363           __try
 364             {
 365               const int_type __idelim = traits_type::to_int_type(__delim);
 366               const int_type __eof = traits_type::eof();
 367               __streambuf_type* __this_sb = this->rdbuf();
 368               int_type __c = __this_sb->sgetc();
 369               char_type __c2 = traits_type::to_char_type(__c);
 370
 371               while (!traits_type::eq_int_type(__c, __eof)
 372                      && !traits_type::eq_int_type(__c, __idelim)
 373                      && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
 374                 {
 375                   ++_M_gcount;
 376                   __c = __this_sb->snextc();
 377                   __c2 = traits_type::to_char_type(__c);
 378                 }
 379               if (traits_type::eq_int_type(__c, __eof))
 380                 __err |= ios_base::eofbit;
 381             }
 382           __catch(__cxxabiv1::__forced_unwind&)
 383             {
 384               this->_M_setstate(ios_base::badbit);
 385               __throw_exception_again;
 386             }
 387           __catch(...)
 388             { this->_M_setstate(ios_base::badbit); }
 389         }
 390       if (!_M_gcount)
 391         __err |= ios_base::failbit;
 392       if (__err)
 393         this->setstate(__err);
 394       return *this;
 395     }
 396
 397   template<typename _CharT, typename _Traits>
 398     basic_istream<_CharT, _Traits>&
 399     basic_istream<_CharT, _Traits>::
 400     getline(char_type* __s, streamsize __n, char_type __delim)
 401     {
 402       _M_gcount = 0;
 403       ios_base::iostate __err = ios_base::goodbit;
 404       sentry __cerb(*this, true);
 405       if (__cerb)
 406         {
 407           __try
 408             {
 409               const int_type __idelim = traits_type::to_int_type(__delim);
 410               const int_type __eof = traits_type::eof();
 411               __streambuf_type* __sb = this->rdbuf();
 412               int_type __c = __sb->sgetc();
 413
 414               while (_M_gcount + 1 < __n
 415                      && !traits_type::eq_int_type(__c, __eof)
 416                      && !traits_type::eq_int_type(__c, __idelim))
 417                 {
 418                   *__s++ = traits_type::to_char_type(__c);
 419                   __c = __sb->snextc();
 420                   ++_M_gcount;
 421                 }
 422               if (traits_type::eq_int_type(__c, __eof))
 423                 __err |= ios_base::eofbit;
 424               else
 425                 {
 426                   if (traits_type::eq_int_type(__c, __idelim))
 427                     {
 428                       __sb->sbumpc();
 429                       ++_M_gcount;
 430                     }
 431                   else
 432                     __err |= ios_base::failbit;
 433                 }
 434             }
 435           __catch(__cxxabiv1::__forced_unwind&)
 436             {
 437               this->_M_setstate(ios_base::badbit);
 438               __throw_exception_again;
 439             }
 440           __catch(...)
 441             { this->_M_setstate(ios_base::badbit); }
 442         }
 443       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 444       // 243. get and getline when sentry reports failure.
 445       if (__n > 0)
 446         *__s = char_type();
 447       if (!_M_gcount)
 448         __err |= ios_base::failbit;
 449       if (__err)
 450         this->setstate(__err);
 451       return *this;
 452     }
 453
 454   // We provide three overloads, since the first two are much simpler
 455   // than the general case. Also, the latter two can thus adopt the
 456   // same "batchy" strategy used by getline above.
 457   template<typename _CharT, typename _Traits>
 458     basic_istream<_CharT, _Traits>&
 459     basic_istream<_CharT, _Traits>::
 460     ignore(void)
 461     {
 462       _M_gcount = 0;
 463       sentry __cerb(*this, true);
 464       if (__cerb)
 465         {
 466           ios_base::iostate __err = ios_base::goodbit;
 467           __try
 468             {
 469               const int_type __eof = traits_type::eof();
 470               __streambuf_type* __sb = this->rdbuf();
 471
 472               if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
 473                 __err |= ios_base::eofbit;
 474               else
 475                 _M_gcount = 1;
 476             }
 477           __catch(__cxxabiv1::__forced_unwind&)
 478             {
 479               this->_M_setstate(ios_base::badbit);
 480               __throw_exception_again;
 481             }
 482           __catch(...)
 483             { this->_M_setstate(ios_base::badbit); }
 484           if (__err)
 485             this->setstate(__err);
 486         }
 487       return *this;
 488     }
 489
 490   template<typename _CharT, typename _Traits>
 491     basic_istream<_CharT, _Traits>&
 492     basic_istream<_CharT, _Traits>::
 493     ignore(streamsize __n)
 494     {
 495       _M_gcount = 0;
 496       sentry __cerb(*this, true);
 497       if (__cerb && __n > 0)
 498         {
 499           ios_base::iostate __err = ios_base::goodbit;
 500           __try
 501             {
 502               const int_type __eof = traits_type::eof();
 503               __streambuf_type* __sb = this->rdbuf();
 504               int_type __c = __sb->sgetc();
 505
 506               // N.B. On LFS-enabled platforms streamsize is still 32 bits
 507               // wide: if we want to implement the standard mandated behavior
 508               // for n == max() (see 27.6.1.3/24) we are at risk of signed
 509               // integer overflow: thus these contortions. Also note that,
 510               // by definition, when more than 2G chars are actually ignored,
 511               // _M_gcount (the return value of gcount, that is) cannot be
 512               // really correct, being unavoidably too small.
 513               bool __large_ignore = false;
 514               while (true)
 515                 {
 516                   while (_M_gcount < __n
 517                          && !traits_type::eq_int_type(__c, __eof))
 518                     {
 519                       ++_M_gcount;
 520                       __c = __sb->snextc();
 521                     }
 522                   if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
 523                       && !traits_type::eq_int_type(__c, __eof))
 524                     {
 525                       _M_gcount =
 526                         __gnu_cxx::__numeric_traits<streamsize>::__min;
 527                       __large_ignore = true;
 528                     }
 529                   else
 530                     break;
 531                 }
 532
 533               if (__large_ignore)
 534                 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
 535
 536               if (traits_type::eq_int_type(__c, __eof))
 537                 __err |= ios_base::eofbit;
 538             }
 539           __catch(__cxxabiv1::__forced_unwind&)
 540             {
 541               this->_M_setstate(ios_base::badbit);
 542               __throw_exception_again;
 543             }
 544           __catch(...)
 545             { this->_M_setstate(ios_base::badbit); }
 546           if (__err)
 547             this->setstate(__err);
 548         }
 549       return *this;
 550     }
 551
 552   template<typename _CharT, typename _Traits>
 553     basic_istream<_CharT, _Traits>&
 554     basic_istream<_CharT, _Traits>::
 555     ignore(streamsize __n, int_type __delim)
 556     {
 557       _M_gcount = 0;
 558       sentry __cerb(*this, true);
 559       if (__cerb && __n > 0)
 560         {
 561           ios_base::iostate __err = ios_base::goodbit;
 562           __try
 563             {
 564               const int_type __eof = traits_type::eof();
 565               __streambuf_type* __sb = this->rdbuf();
 566               int_type __c = __sb->sgetc();
 567
 568               // See comment above.
 569               bool __large_ignore = false;
 570               while (true)
 571                 {
 572                   while (_M_gcount < __n
 573                          && !traits_type::eq_int_type(__c, __eof)
 574                          && !traits_type::eq_int_type(__c, __delim))
 575                     {
 576                       ++_M_gcount;
 577                       __c = __sb->snextc();
 578                     }
 579                   if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
 580                       && !traits_type::eq_int_type(__c, __eof)
 581                       && !traits_type::eq_int_type(__c, __delim))
 582                     {
 583                       _M_gcount =
 584                         __gnu_cxx::__numeric_traits<streamsize>::__min;
 585                       __large_ignore = true;
 586                     }
 587                   else
 588                     break;
 589                 }
 590
 591               if (__large_ignore)
 592                 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
 593
 594               if (traits_type::eq_int_type(__c, __eof))
 595                 __err |= ios_base::eofbit;
 596               else if (traits_type::eq_int_type(__c, __delim))
 597                 {
 598                   if (_M_gcount
 599                       < __gnu_cxx::__numeric_traits<streamsize>::__max)
 600                     ++_M_gcount;
 601                   __sb->sbumpc();
 602                 }
 603             }
 604           __catch(__cxxabiv1::__forced_unwind&)
 605             {
 606               this->_M_setstate(ios_base::badbit);
 607               __throw_exception_again;
 608             }
 609           __catch(...)
 610             { this->_M_setstate(ios_base::badbit); }
 611           if (__err)
 612             this->setstate(__err);
 613         }
 614       return *this;
 615     }
 616
 617   template<typename _CharT, typename _Traits>
 618     typename basic_istream<_CharT, _Traits>::int_type
 619     basic_istream<_CharT, _Traits>::
 620     peek(void)
 621     {
 622       int_type __c = traits_type::eof();
 623       _M_gcount = 0;
 624       sentry __cerb(*this, true);
 625       if (__cerb)
 626         {
 627           ios_base::iostate __err = ios_base::goodbit;
 628           __try
 629             {
 630               __c = this->rdbuf()->sgetc();
 631               if (traits_type::eq_int_type(__c, traits_type::eof()))
 632                 __err |= ios_base::eofbit;
 633             }
 634           __catch(__cxxabiv1::__forced_unwind&)
 635             {
 636               this->_M_setstate(ios_base::badbit);
 637               __throw_exception_again;
 638             }
 639           __catch(...)
 640             { this->_M_setstate(ios_base::badbit); }
 641           if (__err)
 642             this->setstate(__err);
 643         }
 644       return __c;
 645     }
 646
 647   template<typename _CharT, typename _Traits>
 648     basic_istream<_CharT, _Traits>&
 649     basic_istream<_CharT, _Traits>::
 650     read(char_type* __s, streamsize __n)
 651     {
 652       _M_gcount = 0;
 653       sentry __cerb(*this, true);
 654       if (__cerb)
 655         {
 656           ios_base::iostate __err = ios_base::goodbit;
 657           __try
 658             {
 659               _M_gcount = this->rdbuf()->sgetn(__s, __n);
 660               if (_M_gcount != __n)
 661                 __err |= (ios_base::eofbit | ios_base::failbit);
 662             }
 663           __catch(__cxxabiv1::__forced_unwind&)
 664             {
 665               this->_M_setstate(ios_base::badbit);
 666               __throw_exception_again;
 667             }
 668           __catch(...)
 669             { this->_M_setstate(ios_base::badbit); }
 670           if (__err)
 671             this->setstate(__err);
 672         }
 673       return *this;
 674     }
 675
 676   template<typename _CharT, typename _Traits>
 677     streamsize
 678     basic_istream<_CharT, _Traits>::
 679     readsome(char_type* __s, streamsize __n)
 680     {
 681       _M_gcount = 0;
 682       sentry __cerb(*this, true);
 683       if (__cerb)
 684         {
 685           ios_base::iostate __err = ios_base::goodbit;
 686           __try
 687             {
 688               // Cannot compare int_type with streamsize generically.
 689               const streamsize __num = this->rdbuf()->in_avail();
 690               if (__num > 0)
 691                 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
 692               else if (__num == -1)
 693                 __err |= ios_base::eofbit;
 694             }
 695           __catch(__cxxabiv1::__forced_unwind&)
 696             {
 697               this->_M_setstate(ios_base::badbit);
 698               __throw_exception_again;
 699             }
 700           __catch(...)
 701             { this->_M_setstate(ios_base::badbit); }
 702           if (__err)
 703             this->setstate(__err);
 704         }
 705       return _M_gcount;
 706     }
 707
 708   template<typename _CharT, typename _Traits>
 709     basic_istream<_CharT, _Traits>&
 710     basic_istream<_CharT, _Traits>::
 711     putback(char_type __c)
 712     {
 713       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 714       // 60. What is a formatted input function?
 715       _M_gcount = 0;
 716       // Clear eofbit per N3168.
 717       this->clear(this->rdstate() & ~ios_base::eofbit);
 718       sentry __cerb(*this, true);
 719       if (__cerb)
 720         {
 721           ios_base::iostate __err = ios_base::goodbit;
 722           __try
 723             {
 724               const int_type __eof = traits_type::eof();
 725               __streambuf_type* __sb = this->rdbuf();
 726               if (!__sb
 727                   || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
 728                 __err |= ios_base::badbit;
 729             }
 730           __catch(__cxxabiv1::__forced_unwind&)
 731             {
 732               this->_M_setstate(ios_base::badbit);
 733               __throw_exception_again;
 734             }
 735           __catch(...)
 736             { this->_M_setstate(ios_base::badbit); }
 737           if (__err)
 738             this->setstate(__err);
 739         }
 740       return *this;
 741     }
 742
 743   template<typename _CharT, typename _Traits>
 744     basic_istream<_CharT, _Traits>&
 745     basic_istream<_CharT, _Traits>::
 746     unget(void)
 747     {
 748       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 749       // 60. What is a formatted input function?
 750       _M_gcount = 0;
 751       // Clear eofbit per N3168.
 752       this->clear(this->rdstate() & ~ios_base::eofbit);
 753       sentry __cerb(*this, true);
 754       if (__cerb)
 755         {
 756           ios_base::iostate __err = ios_base::goodbit;
 757           __try
 758             {
 759               const int_type __eof = traits_type::eof();
 760               __streambuf_type* __sb = this->rdbuf();
 761               if (!__sb
 762                   || traits_type::eq_int_type(__sb->sungetc(), __eof))
 763                 __err |= ios_base::badbit;
 764             }
 765           __catch(__cxxabiv1::__forced_unwind&)
 766             {
 767               this->_M_setstate(ios_base::badbit);
 768               __throw_exception_again;
 769             }
 770           __catch(...)
 771             { this->_M_setstate(ios_base::badbit); }
 772           if (__err)
 773             this->setstate(__err);
 774         }
 775       return *this;
 776     }
 777
 778   template<typename _CharT, typename _Traits>
 779     int
 780     basic_istream<_CharT, _Traits>::
 781     sync(void)
 782     {
 783       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 784       // DR60.  Do not change _M_gcount.
 785       int __ret = -1;
 786       sentry __cerb(*this, true);
 787       if (__cerb)
 788         {
 789           ios_base::iostate __err = ios_base::goodbit;
 790           __try
 791             {
 792               __streambuf_type* __sb = this->rdbuf();
 793               if (__sb)
 794                 {
 795                   if (__sb->pubsync() == -1)
 796                     __err |= ios_base::badbit;
 797                   else
 798                     __ret = 0;
 799                 }
 800             }
 801           __catch(__cxxabiv1::__forced_unwind&)
 802             {
 803               this->_M_setstate(ios_base::badbit);
 804               __throw_exception_again;
 805             }
 806           __catch(...)
 807             { this->_M_setstate(ios_base::badbit); }
 808           if (__err)
 809             this->setstate(__err);
 810         }
 811       return __ret;
 812     }
 813
 814   template<typename _CharT, typename _Traits>
 815     typename basic_istream<_CharT, _Traits>::pos_type
 816     basic_istream<_CharT, _Traits>::
 817     tellg(void)
 818     {
 819       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 820       // DR60.  Do not change _M_gcount.
 821       pos_type __ret = pos_type(-1);
 822       sentry __cerb(*this, true);
 823       if (__cerb)
 824         {
 825           __try
 826             {
 827               if (!this->fail())
 828                 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
 829                                                   ios_base::in);
 830             }
 831           __catch(__cxxabiv1::__forced_unwind&)
 832             {
 833               this->_M_setstate(ios_base::badbit);
 834               __throw_exception_again;
 835             }
 836           __catch(...)
 837             { this->_M_setstate(ios_base::badbit); }
 838         }
 839       return __ret;
 840     }
 841
 842   template<typename _CharT, typename _Traits>
 843     basic_istream<_CharT, _Traits>&
 844     basic_istream<_CharT, _Traits>::
 845     seekg(pos_type __pos)
 846     {
 847       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 848       // DR60.  Do not change _M_gcount.
 849       // Clear eofbit per N3168.
 850       this->clear(this->rdstate() & ~ios_base::eofbit);
 851       sentry __cerb(*this, true);
 852       if (__cerb)
 853         {
 854           ios_base::iostate __err = ios_base::goodbit;
 855           __try
 856             {
 857               if (!this->fail())
 858                 {
 859                   // 136.  seekp, seekg setting wrong streams?
 860                   const pos_type __p = this->rdbuf()->pubseekpos(__pos,
 861                                                                  ios_base::in);
 862
 863                   // 129.  Need error indication from seekp() and seekg()
 864                   if (__p == pos_type(off_type(-1)))
 865                     __err |= ios_base::failbit;
 866                 }
 867             }
 868           __catch(__cxxabiv1::__forced_unwind&)
 869             {
 870               this->_M_setstate(ios_base::badbit);
 871               __throw_exception_again;
 872             }
 873           __catch(...)
 874             { this->_M_setstate(ios_base::badbit); }
 875           if (__err)
 876             this->setstate(__err);
 877         }
 878       return *this;
 879     }
 880
 881   template<typename _CharT, typename _Traits>
 882     basic_istream<_CharT, _Traits>&
 883     basic_istream<_CharT, _Traits>::
 884     seekg(off_type __off, ios_base::seekdir __dir)
 885     {
 886       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 887       // DR60.  Do not change _M_gcount.
 888       // Clear eofbit per N3168.
 889       this->clear(this->rdstate() & ~ios_base::eofbit);
 890       sentry __cerb(*this, true);
 891       if (__cerb)
 892         {
 893           ios_base::iostate __err = ios_base::goodbit;
 894           __try
 895             {
 896               if (!this->fail())
 897                 {
 898                   // 136.  seekp, seekg setting wrong streams?
 899                   const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
 900                                                                  ios_base::in);
 901
 902                   // 129.  Need error indication from seekp() and seekg()
 903                   if (__p == pos_type(off_type(-1)))
 904                     __err |= ios_base::failbit;
 905                 }
 906             }
 907           __catch(__cxxabiv1::__forced_unwind&)
 908             {
 909               this->_M_setstate(ios_base::badbit);
 910               __throw_exception_again;
 911             }
 912           __catch(...)
 913             { this->_M_setstate(ios_base::badbit); }
 914           if (__err)
 915             this->setstate(__err);
 916         }
 917       return *this;
 918     }
 919
 920   // 27.6.1.2.3 Character extraction templates
 921   template<typename _CharT, typename _Traits>
 922     basic_istream<_CharT, _Traits>&
 923     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
 924     {
 925       typedef basic_istream<_CharT, _Traits>            __istream_type;
 926       typedef typename __istream_type::int_type         __int_type;
 927
 928       typename __istream_type::sentry __cerb(__in, false);
 929       if (__cerb)
 930         {
 931           ios_base::iostate __err = ios_base::goodbit;
 932           __try
 933             {
 934               const __int_type __cb = __in.rdbuf()->sbumpc();
 935               if (!_Traits::eq_int_type(__cb, _Traits::eof()))
 936                 __c = _Traits::to_char_type(__cb);
 937               else
 938                 __err |= (ios_base::eofbit | ios_base::failbit);
 939             }
 940           __catch(__cxxabiv1::__forced_unwind&)
 941             {
 942               __in._M_setstate(ios_base::badbit);
 943               __throw_exception_again;
 944             }
 945           __catch(...)
 946             { __in._M_setstate(ios_base::badbit); }
 947           if (__err)
 948             __in.setstate(__err);
 949         }
 950       return __in;
 951     }
 952
 953   template<typename _CharT, typename _Traits>
 954     basic_istream<_CharT, _Traits>&
 955     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
 956     {
 957       typedef basic_istream<_CharT, _Traits>            __istream_type;
 958       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
 959       typedef typename _Traits::int_type                int_type;
 960       typedef _CharT                                    char_type;
 961       typedef ctype<_CharT>                             __ctype_type;
 962
 963       streamsize __extracted = 0;
 964       ios_base::iostate __err = ios_base::goodbit;
 965       typename __istream_type::sentry __cerb(__in, false);
 966       if (__cerb)
 967         {
 968           __try
 969             {
 970               // Figure out how many characters to extract.
 971               streamsize __num = __in.width();
 972               if (__num <= 0)
 973                 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
 974
 975               const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
 976
 977               const int_type __eof = _Traits::eof();
 978               __streambuf_type* __sb = __in.rdbuf();
 979               int_type __c = __sb->sgetc();
 980
 981               while (__extracted < __num - 1
 982                      && !_Traits::eq_int_type(__c, __eof)
 983                      && !__ct.is(ctype_base::space,
 984                                  _Traits::to_char_type(__c)))
 985                 {
 986                   *__s++ = _Traits::to_char_type(__c);
 987                   ++__extracted;
 988                   __c = __sb->snextc();
 989                 }
 990               if (_Traits::eq_int_type(__c, __eof))
 991                 __err |= ios_base::eofbit;
 992
 993               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 994               // 68.  Extractors for char* should store null at end
 995               *__s = char_type();
 996               __in.width(0);
 997             }
 998           __catch(__cxxabiv1::__forced_unwind&)
 999             {
1000               __in._M_setstate(ios_base::badbit);
1001               __throw_exception_again;
1002             }
1003           __catch(...)
1004             { __in._M_setstate(ios_base::badbit); }
1005         }
1006       if (!__extracted)
1007         __err |= ios_base::failbit;
1008       if (__err)
1009         __in.setstate(__err);
1010       return __in;
1011     }
1012
1013   // 27.6.1.4 Standard basic_istream manipulators
1014   template<typename _CharT, typename _Traits>
1015     basic_istream<_CharT, _Traits>&
1016     ws(basic_istream<_CharT, _Traits>& __in)
1017     {
1018       typedef basic_istream<_CharT, _Traits>            __istream_type;
1019       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
1020       typedef typename __istream_type::int_type         __int_type;
1021       typedef ctype<_CharT>                             __ctype_type;
1022
1023       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1024       const __int_type __eof = _Traits::eof();
1025       __streambuf_type* __sb = __in.rdbuf();
1026       __int_type __c = __sb->sgetc();
1027
1028       while (!_Traits::eq_int_type(__c, __eof)
1029              && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1030         __c = __sb->snextc();
1031
1032        if (_Traits::eq_int_type(__c, __eof))
1033          __in.setstate(ios_base::eofbit);
1034       return __in;
1035     }
1036
1037   // Inhibit implicit instantiations for required instantiations,
1038   // which are defined via explicit instantiations elsewhere.
1039 #if _GLIBCXX_EXTERN_TEMPLATE
1040   extern template class basic_istream<char>;
1041   extern template istream& ws(istream&);
1042   extern template istream& operator>>(istream&, char&);
1043   extern template istream& operator>>(istream&, char*);
1044   extern template istream& operator>>(istream&, unsigned char&);
1045   extern template istream& operator>>(istream&, signed char&);
1046   extern template istream& operator>>(istream&, unsigned char*);
1047   extern template istream& operator>>(istream&, signed char*);
1048
1049   extern template istream& istream::_M_extract(unsigned short&);
1050   extern template istream& istream::_M_extract(unsigned int&);
1051   extern template istream& istream::_M_extract(long&);
1052   extern template istream& istream::_M_extract(unsigned long&);
1053   extern template istream& istream::_M_extract(bool&);
1054 #ifdef _GLIBCXX_USE_LONG_LONG
1055   extern template istream& istream::_M_extract(long long&);
1056   extern template istream& istream::_M_extract(unsigned long long&);
1057 #endif
1058   extern template istream& istream::_M_extract(float&);
1059   extern template istream& istream::_M_extract(double&);
1060   extern template istream& istream::_M_extract(long double&);
1061   extern template istream& istream::_M_extract(void*&);
1062
1063   extern template class basic_iostream<char>;
1064
1065 #ifdef _GLIBCXX_USE_WCHAR_T
1066   extern template class basic_istream<wchar_t>;
1067   extern template wistream& ws(wistream&);
1068   extern template wistream& operator>>(wistream&, wchar_t&);
1069   extern template wistream& operator>>(wistream&, wchar_t*);
1070
1071   extern template wistream& wistream::_M_extract(unsigned short&);
1072   extern template wistream& wistream::_M_extract(unsigned int&);
1073   extern template wistream& wistream::_M_extract(long&);
1074   extern template wistream& wistream::_M_extract(unsigned long&);
1075   extern template wistream& wistream::_M_extract(bool&);
1076 #ifdef _GLIBCXX_USE_LONG_LONG
1077   extern template wistream& wistream::_M_extract(long long&);
1078   extern template wistream& wistream::_M_extract(unsigned long long&);
1079 #endif
1080   extern template wistream& wistream::_M_extract(float&);
1081   extern template wistream& wistream::_M_extract(double&);
1082   extern template wistream& wistream::_M_extract(long double&);
1083   extern template wistream& wistream::_M_extract(void*&);
1084
1085   extern template class basic_iostream<wchar_t>;
1086 #endif
1087 #endif
1088
1089 _GLIBCXX_END_NAMESPACE_VERSION
1090 } // namespace std
1091
1092 #endif