Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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