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

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