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

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