libstdc++-v3/src/c++98/istream.cc

   1 // Input streams -*- C++ -*-
   2
   3 // Copyright (C) 2004-2016 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 //
  26 // ISO C++ 14882: 27.6.1  Input streams
  27 //
  28
  29 #include <istream>
  30
  31 namespace std _GLIBCXX_VISIBILITY(default)
  32 {
  33 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  34
  35   template<>
  36     basic_istream<char>&
  37     basic_istream<char>::
  38     getline(char_type* __s, streamsize __n, char_type __delim)
  39     {
  40       _M_gcount = 0;
  41       ios_base::iostate __err = ios_base::goodbit;
  42       sentry __cerb(*this, true);
  43       if (__cerb)
  44         {
  45           __try
  46             {
  47               const int_type __idelim = traits_type::to_int_type(__delim);
  48               const int_type __eof = traits_type::eof();
  49               __streambuf_type* __sb = this->rdbuf();
  50               int_type __c = __sb->sgetc();
  51
  52               while (_M_gcount + 1 < __n
  53                      && !traits_type::eq_int_type(__c, __eof)
  54                      && !traits_type::eq_int_type(__c, __idelim))
  55                 {
  56                   streamsize __size = std::min(streamsize(__sb->egptr()
  57                                                           - __sb->gptr()),
  58                                                streamsize(__n - _M_gcount
  59                                                           - 1));
  60                   if (__size > 1)
  61                     {
  62                       const char_type* __p = traits_type::find(__sb->gptr(),
  63                                                                __size,
  64                                                                __delim);
  65                       if (__p)
  66                         __size = __p - __sb->gptr();
  67                       traits_type::copy(__s, __sb->gptr(), __size);
  68                       __s += __size;
  69                       __sb->__safe_gbump(__size);
  70                       _M_gcount += __size;
  71                       __c = __sb->sgetc();
  72                     }
  73                   else
  74                     {
  75                       *__s++ = traits_type::to_char_type(__c);
  76                       ++_M_gcount;
  77                       __c = __sb->snextc();
  78                     }
  79                 }
  80
  81               if (traits_type::eq_int_type(__c, __eof))
  82                 __err |= ios_base::eofbit;
  83               else if (traits_type::eq_int_type(__c, __idelim))
  84                 {
  85                   ++_M_gcount;
  86                   __sb->sbumpc();
  87                 }
  88               else
  89                 __err |= ios_base::failbit;
  90             }
  91           __catch(__cxxabiv1::__forced_unwind&)
  92             {
  93               this->_M_setstate(ios_base::badbit);
  94               __throw_exception_again;
  95             }
  96           __catch(...)
  97             { this->_M_setstate(ios_base::badbit); }
  98         }
  99       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 100       // 243. get and getline when sentry reports failure.
 101       if (__n > 0)
 102         *__s = char_type();
 103       if (!_M_gcount)
 104         __err |= ios_base::failbit;
 105       if (__err)
 106         this->setstate(__err);
 107       return *this;
 108     }
 109
 110   template<>
 111     basic_istream<char>&
 112     basic_istream<char>::
 113     ignore(streamsize __n, int_type __delim)
 114     {
 115       if (traits_type::eq_int_type(__delim, traits_type::eof()))
 116         return ignore(__n);
 117
 118       _M_gcount = 0;
 119       sentry __cerb(*this, true);
 120       if (__n > 0 && __cerb)
 121         {
 122           ios_base::iostate __err = ios_base::goodbit;
 123           __try
 124             {
 125               const char_type __cdelim = traits_type::to_char_type(__delim);
 126               const int_type __eof = traits_type::eof();
 127               __streambuf_type* __sb = this->rdbuf();
 128               int_type __c = __sb->sgetc();
 129
 130               bool __large_ignore = false;
 131               while (true)
 132                 {
 133                   while (_M_gcount < __n
 134                          && !traits_type::eq_int_type(__c, __eof)
 135                          && !traits_type::eq_int_type(__c, __delim))
 136                     {
 137                       streamsize __size = std::min(streamsize(__sb->egptr()
 138                                                               - __sb->gptr()),
 139                                                    streamsize(__n - _M_gcount));
 140                       if (__size > 1)
 141                         {
 142                           const char_type* __p = traits_type::find(__sb->gptr(),
 143                                                                    __size,
 144                                                                    __cdelim);
 145                           if (__p)
 146                             __size = __p - __sb->gptr();
 147                           __sb->__safe_gbump(__size);
 148                           _M_gcount += __size;
 149                           __c = __sb->sgetc();
 150                         }
 151                       else
 152                         {
 153                           ++_M_gcount;
 154                           __c = __sb->snextc();
 155                         }
 156                     }
 157                   if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
 158                       && !traits_type::eq_int_type(__c, __eof)
 159                       && !traits_type::eq_int_type(__c, __delim))
 160                     {
 161                       _M_gcount =
 162                         __gnu_cxx::__numeric_traits<streamsize>::__min;
 163                       __large_ignore = true;
 164                     }
 165                   else
 166                     break;
 167                 }
 168
 169               if (__large_ignore)
 170                 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
 171
 172               if (traits_type::eq_int_type(__c, __eof))
 173                 __err |= ios_base::eofbit;
 174               else if (traits_type::eq_int_type(__c, __delim))
 175                 {
 176                   if (_M_gcount
 177                       < __gnu_cxx::__numeric_traits<streamsize>::__max)
 178                     ++_M_gcount;
 179                   __sb->sbumpc();
 180                 }
 181             }
 182           __catch(__cxxabiv1::__forced_unwind&)
 183             {
 184               this->_M_setstate(ios_base::badbit);
 185               __throw_exception_again;
 186             }
 187           __catch(...)
 188             { this->_M_setstate(ios_base::badbit); }
 189           if (__err)
 190             this->setstate(__err);
 191         }
 192       return *this;
 193     }
 194
 195   template<>
 196     basic_istream<char>&
 197     operator>>(basic_istream<char>& __in, char* __s)
 198     {
 199       typedef basic_istream<char>               __istream_type;
 200       typedef __istream_type::int_type          __int_type;
 201       typedef __istream_type::char_type         __char_type;
 202       typedef __istream_type::traits_type       __traits_type;
 203       typedef __istream_type::__streambuf_type  __streambuf_type;
 204       typedef __istream_type::__ctype_type      __ctype_type;
 205
 206       streamsize __extracted = 0;
 207       ios_base::iostate __err = ios_base::goodbit;
 208       __istream_type::sentry __cerb(__in, false);
 209       if (__cerb)
 210         {
 211           __try
 212             {
 213               // Figure out how many characters to extract.
 214               streamsize __num = __in.width();
 215               if (__num <= 0)
 216                 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
 217
 218               const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
 219
 220               const __int_type __eof = __traits_type::eof();
 221               __streambuf_type* __sb = __in.rdbuf();
 222               __int_type __c = __sb->sgetc();
 223
 224               while (__extracted < __num - 1
 225                      && !__traits_type::eq_int_type(__c, __eof)
 226                      && !__ct.is(ctype_base::space,
 227                                  __traits_type::to_char_type(__c)))
 228                 {
 229                   streamsize __size = std::min(streamsize(__sb->egptr()
 230                                                           - __sb->gptr()),
 231                                                streamsize(__num - __extracted
 232                                                           - 1));
 233                   if (__size > 1)
 234                     {
 235                       __size = (__ct.scan_is(ctype_base::space,
 236                                              __sb->gptr() + 1,
 237                                              __sb->gptr() + __size)
 238                                 - __sb->gptr());
 239                       __traits_type::copy(__s, __sb->gptr(), __size);
 240                       __s += __size;
 241                       __sb->__safe_gbump(__size);
 242                       __extracted += __size;
 243                       __c = __sb->sgetc();
 244                     }
 245                   else
 246                     {
 247                       *__s++ = __traits_type::to_char_type(__c);
 248                       ++__extracted;
 249                       __c = __sb->snextc();
 250                     }
 251                 }
 252
 253               if (__traits_type::eq_int_type(__c, __eof))
 254                 __err |= ios_base::eofbit;
 255
 256               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 257               // 68.  Extractors for char* should store null at end
 258               *__s = __char_type();
 259               __in.width(0);
 260             }
 261           __catch(__cxxabiv1::__forced_unwind&)
 262             {
 263               __in._M_setstate(ios_base::badbit);
 264               __throw_exception_again;
 265             }
 266           __catch(...)
 267             { __in._M_setstate(ios_base::badbit); }
 268         }
 269       if (!__extracted)
 270         __err |= ios_base::failbit;
 271       if (__err)
 272         __in.setstate(__err);
 273       return __in;
 274     }
 275
 276 #ifdef _GLIBCXX_USE_WCHAR_T
 277   template<>
 278     basic_istream<wchar_t>&
 279     basic_istream<wchar_t>::
 280     getline(char_type* __s, streamsize __n, char_type __delim)
 281     {
 282       _M_gcount = 0;
 283       ios_base::iostate __err = ios_base::goodbit;
 284       sentry __cerb(*this, true);
 285       if (__cerb)
 286         {
 287           __try
 288             {
 289               const int_type __idelim = traits_type::to_int_type(__delim);
 290               const int_type __eof = traits_type::eof();
 291               __streambuf_type* __sb = this->rdbuf();
 292               int_type __c = __sb->sgetc();
 293
 294               while (_M_gcount + 1 < __n
 295                      && !traits_type::eq_int_type(__c, __eof)
 296                      && !traits_type::eq_int_type(__c, __idelim))
 297                 {
 298                   streamsize __size = std::min(streamsize(__sb->egptr()
 299                                                           - __sb->gptr()),
 300                                                streamsize(__n - _M_gcount
 301                                                           - 1));
 302                   if (__size > 1)
 303                     {
 304                       const char_type* __p = traits_type::find(__sb->gptr(),
 305                                                                __size,
 306                                                                __delim);
 307                       if (__p)
 308                         __size = __p - __sb->gptr();
 309                       traits_type::copy(__s, __sb->gptr(), __size);
 310                       __s += __size;
 311                       __sb->__safe_gbump(__size);
 312                       _M_gcount += __size;
 313                       __c = __sb->sgetc();
 314                     }
 315                   else
 316                     {
 317                       *__s++ = traits_type::to_char_type(__c);
 318                       ++_M_gcount;
 319                       __c = __sb->snextc();
 320                     }
 321                 }
 322
 323               if (traits_type::eq_int_type(__c, __eof))
 324                 __err |= ios_base::eofbit;
 325               else if (traits_type::eq_int_type(__c, __idelim))
 326                 {
 327                   ++_M_gcount;
 328                   __sb->sbumpc();
 329                 }
 330               else
 331                 __err |= ios_base::failbit;
 332             }
 333           __catch(__cxxabiv1::__forced_unwind&)
 334             {
 335               this->_M_setstate(ios_base::badbit);
 336               __throw_exception_again;
 337             }
 338           __catch(...)
 339             { this->_M_setstate(ios_base::badbit); }
 340         }
 341       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 342       // 243. get and getline when sentry reports failure.
 343       if (__n > 0)
 344         *__s = char_type();
 345       if (!_M_gcount)
 346         __err |= ios_base::failbit;
 347       if (__err)
 348         this->setstate(__err);
 349       return *this;
 350     }
 351
 352   template<>
 353     basic_istream<wchar_t>&
 354     basic_istream<wchar_t>::
 355     ignore(streamsize __n, int_type __delim)
 356     {
 357       if (traits_type::eq_int_type(__delim, traits_type::eof()))
 358         return ignore(__n);
 359
 360       _M_gcount = 0;
 361       sentry __cerb(*this, true);
 362       if (__n > 0 && __cerb)
 363         {
 364           ios_base::iostate __err = ios_base::goodbit;
 365           __try
 366             {
 367               const char_type __cdelim = traits_type::to_char_type(__delim);
 368               const int_type __eof = traits_type::eof();
 369               __streambuf_type* __sb = this->rdbuf();
 370               int_type __c = __sb->sgetc();
 371
 372               bool __large_ignore = false;
 373               while (true)
 374                 {
 375                   while (_M_gcount < __n
 376                          && !traits_type::eq_int_type(__c, __eof)
 377                          && !traits_type::eq_int_type(__c, __delim))
 378                     {
 379                       streamsize __size = std::min(streamsize(__sb->egptr()
 380                                                               - __sb->gptr()),
 381                                                    streamsize(__n - _M_gcount));
 382                       if (__size > 1)
 383                         {
 384                           const char_type* __p = traits_type::find(__sb->gptr(),
 385                                                                    __size,
 386                                                                    __cdelim);
 387                           if (__p)
 388                             __size = __p - __sb->gptr();
 389                           __sb->__safe_gbump(__size);
 390                           _M_gcount += __size;
 391                           __c = __sb->sgetc();
 392                         }
 393                       else
 394                         {
 395                           ++_M_gcount;
 396                           __c = __sb->snextc();
 397                         }
 398                     }
 399                   if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
 400                       && !traits_type::eq_int_type(__c, __eof)
 401                       && !traits_type::eq_int_type(__c, __delim))
 402                     {
 403                       _M_gcount =
 404                         __gnu_cxx::__numeric_traits<streamsize>::__min;
 405                       __large_ignore = true;
 406                     }
 407                   else
 408                     break;
 409                 }
 410
 411               if (__large_ignore)
 412                 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
 413
 414               if (traits_type::eq_int_type(__c, __eof))
 415                 __err |= ios_base::eofbit;
 416               else if (traits_type::eq_int_type(__c, __delim))
 417                 {
 418                   if (_M_gcount
 419                       < __gnu_cxx::__numeric_traits<streamsize>::__max)
 420                     ++_M_gcount;
 421                   __sb->sbumpc();
 422                 }
 423             }
 424           __catch(__cxxabiv1::__forced_unwind&)
 425             {
 426               this->_M_setstate(ios_base::badbit);
 427               __throw_exception_again;
 428             }
 429           __catch(...)
 430             { this->_M_setstate(ios_base::badbit); }
 431           if (__err)
 432             this->setstate(__err);
 433         }
 434       return *this;
 435     }
 436 #endif
 437
 438
 439 _GLIBCXX_END_NAMESPACE_VERSION
 440 } // namespace