LCOV - app.info - /tools/gcc-4.5/include/c++/4.5.2/bits/istream.tcc

LCOV - code coverage report
| Current view: | directory - tools/gcc-4.5/include/c++/4.5.2/bits - istream.tcc (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 14 | 0 | 0.0 %
| Date: | 2012-04-07 | Functions: | 1 | 0 | 0.0 %

           1                 : // istream classes -*- C++ -*-
           2                 :
           3                 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
           4                 : // 2006, 2007, 2008, 2009
           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 3, 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                 : // Under Section 7 of GPL version 3, you are granted additional
          19                 : // permissions described in the GCC Runtime Library Exception, version
          20                 : // 3.1, as published by the Free Software Foundation.
          21                 :
          22                 : // You should have received a copy of the GNU General Public License and
          23                 : // a copy of the GCC Runtime Library Exception along with this program;
          24                 : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
          25                 : // <http://www.gnu.org/licenses/>.
          26                 :
          27                 : /** @file istream.tcc
          28                 :  *  This is an internal header file, included by other library headers.
          29                 :  *  You should not attempt to use it directly.
          30                 :  */
          31                 :
          32                 : //
          33                 : // ISO C++ 14882: 27.6.1  Input streams
          34                 : //
          35                 :
          36                 : #ifndef _ISTREAM_TCC
          37                 : #define _ISTREAM_TCC 1
          38                 :
          39                 : #pragma GCC system_header
          40                 :
          41                 : #include <cxxabi-forced.h>
          42                 :
          43                 : _GLIBCXX_BEGIN_NAMESPACE(std)
          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               0 :       basic_istream<_CharT, _Traits>::
          87                 :       _M_extract(_ValueT& __v)
          88                 :       {
          89               0 :         sentry __cerb(*this, false);
          90               0 :         if (__cerb)
          91                 :           {
          92               0 :             ios_base::iostate __err = ios_base::goodbit;
          93                 :             __try
          94                 :               {
          95               0 :                 const __num_get_type& __ng = __check_facet(this->_M_num_get);
          96               0 :                 __ng.get(*this, 0, *this, __err, __v);
          97                 :               }
          98               0 :             __catch(__cxxabiv1::__forced_unwind&)
          99                 :               {
         100               0 :                 this->_M_setstate(ios_base::badbit);
         101               0 :                 __throw_exception_again;
         102                 :               }
         103               0 :             __catch(...)
         104               0 :               { this->_M_setstate(ios_base::badbit); }
         105               0 :             if (__err)
         106               0 :               this->setstate(__err);
         107                 :           }
         108               0 :         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                 :       sentry __cerb(*this, true);
         717                 :       if (__cerb)
         718                 :         {
         719                 :           ios_base::iostate __err = ios_base::goodbit;
         720                 :           __try
         721                 :             {
         722                 :               const int_type __eof = traits_type::eof();
         723                 :               __streambuf_type* __sb = this->rdbuf();
         724                 :               if (!__sb
         725                 :                   || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
         726                 :                 __err |= ios_base::badbit;
         727                 :             }
         728                 :           __catch(__cxxabiv1::__forced_unwind&)
         729                 :             {
         730                 :               this->_M_setstate(ios_base::badbit);
         731                 :               __throw_exception_again;
         732                 :             }
         733                 :           __catch(...)
         734                 :             { this->_M_setstate(ios_base::badbit); }
         735                 :           if (__err)
         736                 :             this->setstate(__err);
         737                 :         }
         738                 :       return *this;
         739                 :     }
         740                 :
         741                 :   template<typename _CharT, typename _Traits>
         742                 :     basic_istream<_CharT, _Traits>&
         743                 :     basic_istream<_CharT, _Traits>::
         744                 :     unget(void)
         745                 :     {
         746                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         747                 :       // 60. What is a formatted input function?
         748                 :       _M_gcount = 0;
         749                 :       sentry __cerb(*this, true);
         750                 :       if (__cerb)
         751                 :         {
         752                 :           ios_base::iostate __err = ios_base::goodbit;
         753                 :           __try
         754                 :             {
         755                 :               const int_type __eof = traits_type::eof();
         756                 :               __streambuf_type* __sb = this->rdbuf();
         757                 :               if (!__sb
         758                 :                   || traits_type::eq_int_type(__sb->sungetc(), __eof))
         759                 :                 __err |= ios_base::badbit;
         760                 :             }
         761                 :           __catch(__cxxabiv1::__forced_unwind&)
         762                 :             {
         763                 :               this->_M_setstate(ios_base::badbit);
         764                 :               __throw_exception_again;
         765                 :             }
         766                 :           __catch(...)
         767                 :             { this->_M_setstate(ios_base::badbit); }
         768                 :           if (__err)
         769                 :             this->setstate(__err);
         770                 :         }
         771                 :       return *this;
         772                 :     }
         773                 :
         774                 :   template<typename _CharT, typename _Traits>
         775                 :     int
         776                 :     basic_istream<_CharT, _Traits>::
         777                 :     sync(void)
         778                 :     {
         779                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         780                 :       // DR60.  Do not change _M_gcount.
         781                 :       int __ret = -1;
         782                 :       sentry __cerb(*this, true);
         783                 :       if (__cerb)
         784                 :         {
         785                 :           ios_base::iostate __err = ios_base::goodbit;
         786                 :           __try
         787                 :             {
         788                 :               __streambuf_type* __sb = this->rdbuf();
         789                 :               if (__sb)
         790                 :                 {
         791                 :                   if (__sb->pubsync() == -1)
         792                 :                     __err |= ios_base::badbit;
         793                 :                   else
         794                 :                     __ret = 0;
         795                 :                 }
         796                 :             }
         797                 :           __catch(__cxxabiv1::__forced_unwind&)
         798                 :             {
         799                 :               this->_M_setstate(ios_base::badbit);
         800                 :               __throw_exception_again;
         801                 :             }
         802                 :           __catch(...)
         803                 :             { this->_M_setstate(ios_base::badbit); }
         804                 :           if (__err)
         805                 :             this->setstate(__err);
         806                 :         }
         807                 :       return __ret;
         808                 :     }
         809                 :
         810                 :   template<typename _CharT, typename _Traits>
         811                 :     typename basic_istream<_CharT, _Traits>::pos_type
         812                 :     basic_istream<_CharT, _Traits>::
         813                 :     tellg(void)
         814                 :     {
         815                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         816                 :       // DR60.  Do not change _M_gcount.
         817                 :       pos_type __ret = pos_type(-1);
         818                 :       __try
         819                 :         {
         820                 :           if (!this->fail())
         821                 :             __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
         822                 :                                               ios_base::in);
         823                 :         }
         824                 :       __catch(__cxxabiv1::__forced_unwind&)
         825                 :         {
         826                 :           this->_M_setstate(ios_base::badbit);
         827                 :           __throw_exception_again;
         828                 :         }
         829                 :       __catch(...)
         830                 :         { this->_M_setstate(ios_base::badbit); }
         831                 :       return __ret;
         832                 :     }
         833                 :
         834                 :   template<typename _CharT, typename _Traits>
         835                 :     basic_istream<_CharT, _Traits>&
         836                 :     basic_istream<_CharT, _Traits>::
         837                 :     seekg(pos_type __pos)
         838                 :     {
         839                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         840                 :       // DR60.  Do not change _M_gcount.
         841                 :       ios_base::iostate __err = ios_base::goodbit;
         842                 :       __try
         843                 :         {
         844                 :           if (!this->fail())
         845                 :             {
         846                 :               // 136.  seekp, seekg setting wrong streams?
         847                 :               const pos_type __p = this->rdbuf()->pubseekpos(__pos,
         848                 :                                                              ios_base::in);
         849                 :
         850                 :               // 129.  Need error indication from seekp() and seekg()
         851                 :               if (__p == pos_type(off_type(-1)))
         852                 :                 __err |= ios_base::failbit;
         853                 :             }
         854                 :         }
         855                 :       __catch(__cxxabiv1::__forced_unwind&)
         856                 :         {
         857                 :           this->_M_setstate(ios_base::badbit);
         858                 :           __throw_exception_again;
         859                 :         }
         860                 :       __catch(...)
         861                 :         { this->_M_setstate(ios_base::badbit); }
         862                 :       if (__err)
         863                 :         this->setstate(__err);
         864                 :       return *this;
         865                 :     }
         866                 :
         867                 :   template<typename _CharT, typename _Traits>
         868                 :     basic_istream<_CharT, _Traits>&
         869                 :     basic_istream<_CharT, _Traits>::
         870                 :     seekg(off_type __off, ios_base::seekdir __dir)
         871                 :     {
         872                 :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
         873                 :       // DR60.  Do not change _M_gcount.
         874                 :       ios_base::iostate __err = ios_base::goodbit;
         875                 :       __try
         876                 :         {
         877                 :           if (!this->fail())
         878                 :             {
         879                 :               // 136.  seekp, seekg setting wrong streams?
         880                 :               const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
         881                 :                                                              ios_base::in);
         882                 :
         883                 :               // 129.  Need error indication from seekp() and seekg()
         884                 :               if (__p == pos_type(off_type(-1)))
         885                 :                 __err |= ios_base::failbit;
         886                 :             }
         887                 :         }
         888                 :       __catch(__cxxabiv1::__forced_unwind&)
         889                 :         {
         890                 :           this->_M_setstate(ios_base::badbit);
         891                 :           __throw_exception_again;
         892                 :         }
         893                 :       __catch(...)
         894                 :         { this->_M_setstate(ios_base::badbit); }
         895                 :       if (__err)
         896                 :         this->setstate(__err);
         897                 :       return *this;
         898                 :     }
         899                 :
         900                 :   // 27.6.1.2.3 Character extraction templates
         901                 :   template<typename _CharT, typename _Traits>
         902                 :     basic_istream<_CharT, _Traits>&
         903                 :     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
         904                 :     {
         905                 :       typedef basic_istream<_CharT, _Traits>              __istream_type;
         906                 :       typedef typename __istream_type::int_type         __int_type;
         907                 :
         908                 :       typename __istream_type::sentry __cerb(__in, false);
         909                 :       if (__cerb)
         910                 :         {
         911                 :           ios_base::iostate __err = ios_base::goodbit;
         912                 :           __try
         913                 :             {
         914                 :               const __int_type __cb = __in.rdbuf()->sbumpc();
         915                 :               if (!_Traits::eq_int_type(__cb, _Traits::eof()))
         916                 :                 __c = _Traits::to_char_type(__cb);
         917                 :               else
         918                 :                 __err |= (ios_base::eofbit | ios_base::failbit);
         919                 :             }
         920                 :           __catch(__cxxabiv1::__forced_unwind&)
         921                 :             {
         922                 :               __in._M_setstate(ios_base::badbit);
         923                 :               __throw_exception_again;
         924                 :             }
         925                 :           __catch(...)
         926                 :             { __in._M_setstate(ios_base::badbit); }
         927                 :           if (__err)
         928                 :             __in.setstate(__err);
         929                 :         }
         930                 :       return __in;
         931                 :     }
         932                 :
         933                 :   template<typename _CharT, typename _Traits>
         934                 :     basic_istream<_CharT, _Traits>&
         935                 :     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
         936                 :     {
         937                 :       typedef basic_istream<_CharT, _Traits>              __istream_type;
         938                 :       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
         939                 :       typedef typename _Traits::int_type                int_type;
         940                 :       typedef _CharT                                    char_type;
         941                 :       typedef ctype<_CharT>                               __ctype_type;
         942                 :
         943                 :       streamsize __extracted = 0;
         944                 :       ios_base::iostate __err = ios_base::goodbit;
         945                 :       typename __istream_type::sentry __cerb(__in, false);
         946                 :       if (__cerb)
         947                 :         {
         948                 :           __try
         949                 :             {
         950                 :               // Figure out how many characters to extract.
         951                 :               streamsize __num = __in.width();
         952                 :               if (__num <= 0)
         953                 :                 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
         954                 :
         955                 :               const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
         956                 :
         957                 :               const int_type __eof = _Traits::eof();
         958                 :               __streambuf_type* __sb = __in.rdbuf();
         959                 :               int_type __c = __sb->sgetc();
         960                 :
         961                 :               while (__extracted < __num - 1
         962                 :                      && !_Traits::eq_int_type(__c, __eof)
         963                 :                      && !__ct.is(ctype_base::space,
         964                 :                                  _Traits::to_char_type(__c)))
         965                 :                 {
         966                 :                   *__s++ = _Traits::to_char_type(__c);
         967                 :                   ++__extracted;
         968                 :                   __c = __sb->snextc();
         969                 :                 }
         970                 :               if (_Traits::eq_int_type(__c, __eof))
         971                 :                 __err |= ios_base::eofbit;
         972                 :
         973                 :               // _GLIBCXX_RESOLVE_LIB_DEFECTS
         974                 :               // 68.  Extractors for char* should store null at end
         975                 :               *__s = char_type();
         976                 :               __in.width(0);
         977                 :             }
         978                 :           __catch(__cxxabiv1::__forced_unwind&)
         979                 :             {
         980                 :               __in._M_setstate(ios_base::badbit);
         981                 :               __throw_exception_again;
         982                 :             }
         983                 :           __catch(...)
         984                 :             { __in._M_setstate(ios_base::badbit); }
         985                 :         }
         986                 :       if (!__extracted)
         987                 :         __err |= ios_base::failbit;
         988                 :       if (__err)
         989                 :         __in.setstate(__err);
         990                 :       return __in;
         991                 :     }
         992                 :
         993                 :   // 27.6.1.4 Standard basic_istream manipulators
         994                 :   template<typename _CharT, typename _Traits>
         995                 :     basic_istream<_CharT, _Traits>&
         996                 :     ws(basic_istream<_CharT, _Traits>& __in)
         997                 :     {
         998                 :       typedef basic_istream<_CharT, _Traits>              __istream_type;
         999                 :       typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
        1000                 :       typedef typename __istream_type::int_type         __int_type;
        1001                 :       typedef ctype<_CharT>                               __ctype_type;
        1002                 :
        1003                 :       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
        1004                 :       const __int_type __eof = _Traits::eof();
        1005                 :       __streambuf_type* __sb = __in.rdbuf();
        1006                 :       __int_type __c = __sb->sgetc();
        1007                 :
        1008                 :       while (!_Traits::eq_int_type(__c, __eof)
        1009                 :              && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
        1010                 :         __c = __sb->snextc();
        1011                 :
        1012                 :        if (_Traits::eq_int_type(__c, __eof))
        1013                 :          __in.setstate(ios_base::eofbit);
        1014                 :       return __in;
        1015                 :     }
        1016                 :
        1017                 :   // Inhibit implicit instantiations for required instantiations,
        1018                 :   // which are defined via explicit instantiations elsewhere.
        1019                 :   // NB:  This syntax is a GNU extension.
        1020                 : #if _GLIBCXX_EXTERN_TEMPLATE
        1021                 :   extern template class basic_istream<char>;
        1022                 :   extern template istream& ws(istream&);
        1023                 :   extern template istream& operator>>(istream&, char&);
        1024                 :   extern template istream& operator>>(istream&, char*);
        1025                 :   extern template istream& operator>>(istream&, unsigned char&);
        1026                 :   extern template istream& operator>>(istream&, signed char&);
        1027                 :   extern template istream& operator>>(istream&, unsigned char*);
        1028                 :   extern template istream& operator>>(istream&, signed char*);
        1029                 :
        1030                 :   extern template istream& istream::_M_extract(unsigned short&);
        1031                 :   extern template istream& istream::_M_extract(unsigned int&);
        1032                 :   extern template istream& istream::_M_extract(long&);
        1033                 :   extern template istream& istream::_M_extract(unsigned long&);
        1034                 :   extern template istream& istream::_M_extract(bool&);
        1035                 : #ifdef _GLIBCXX_USE_LONG_LONG
        1036                 :   extern template istream& istream::_M_extract(long long&);
        1037                 :   extern template istream& istream::_M_extract(unsigned long long&);
        1038                 : #endif
        1039                 :   extern template istream& istream::_M_extract(float&);
        1040                 :   extern template istream& istream::_M_extract(double&);
        1041                 :   extern template istream& istream::_M_extract(long double&);
        1042                 :   extern template istream& istream::_M_extract(void*&);
        1043                 :
        1044                 :   extern template class basic_iostream<char>;
        1045                 :
        1046                 : #ifdef _GLIBCXX_USE_WCHAR_T
        1047                 :   extern template class basic_istream<wchar_t>;
        1048                 :   extern template wistream& ws(wistream&);
        1049                 :   extern template wistream& operator>>(wistream&, wchar_t&);
        1050                 :   extern template wistream& operator>>(wistream&, wchar_t*);
        1051                 :
        1052                 :   extern template wistream& wistream::_M_extract(unsigned short&);
        1053                 :   extern template wistream& wistream::_M_extract(unsigned int&);
        1054                 :   extern template wistream& wistream::_M_extract(long&);
        1055                 :   extern template wistream& wistream::_M_extract(unsigned long&);
        1056                 :   extern template wistream& wistream::_M_extract(bool&);
        1057                 : #ifdef _GLIBCXX_USE_LONG_LONG
        1058                 :   extern template wistream& wistream::_M_extract(long long&);
        1059                 :   extern template wistream& wistream::_M_extract(unsigned long long&);
        1060                 : #endif
        1061                 :   extern template wistream& wistream::_M_extract(float&);
        1062                 :   extern template wistream& wistream::_M_extract(double&);
        1063                 :   extern template wistream& wistream::_M_extract(long double&);
        1064                 :   extern template wistream& wistream::_M_extract(void*&);
        1065                 :
        1066                 :   extern template class basic_iostream<wchar_t>;
        1067                 : #endif
        1068                 : #endif
        1069                 :
        1070                 : _GLIBCXX_END_NAMESPACE
        1071                 :
        1072                 : #endif

Generated by: LCOV version 1.7