home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / c++ / bits / istream.tcc < prev    next >
Encoding:
Text File  |  2003-12-15  |  34.4 KB  |  1,242 lines
  1. // istream classes -*- C++ -*-
  2.  
  3. // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
  4. // Free Software Foundation, Inc.
  5. //
  6. // This file is part of the GNU ISO C++ Library.  This library is free
  7. // software; you can redistribute it and/or modify it under the
  8. // terms of the GNU General Public License as published by the
  9. // Free Software Foundation; either version 2, or (at your option)
  10. // any later version.
  11.  
  12. // This library is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. // GNU General Public License for more details.
  16.  
  17. // You should have received a copy of the GNU General Public License along
  18. // with this library; see the file COPYING.  If not, write to the Free
  19. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20. // USA.
  21.  
  22. // As a special exception, you may use this file as part of a free software
  23. // library without restriction.  Specifically, if other files instantiate
  24. // templates or use macros or inline functions from this file, or you compile
  25. // this file and link it with other files to produce an executable, this
  26. // file does not by itself cause the resulting executable to be covered by
  27. // the GNU General Public License.  This exception does not however
  28. // invalidate any other reasons why the executable file might be covered by
  29. // the GNU General Public License.
  30.  
  31. //
  32. // ISO C++ 14882: 27.6.2  Output streams
  33. //
  34.  
  35. #pragma GCC system_header
  36.  
  37. #include <locale>
  38. #include <ostream> // For flush()
  39.  
  40. namespace std 
  41. {
  42.   template<typename _CharT, typename _Traits>
  43.     basic_istream<_CharT, _Traits>::sentry::
  44.     sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
  45.     {
  46.       if (__in.good()) 
  47.     {
  48.       if (__in.tie())
  49.         __in.tie()->flush();
  50.       if (!__noskipws && (__in.flags() & ios_base::skipws))
  51.         {      
  52.           const __int_type __eof = traits_type::eof();
  53.           __streambuf_type* __sb = __in.rdbuf();
  54.           __int_type __c = __sb->sgetc();
  55.  
  56.           if (__in._M_check_facet(__in._M_fctype))
  57.         while (!traits_type::eq_int_type(__c, __eof)
  58.                && __in._M_fctype->is(ctype_base::space, 
  59.                          traits_type::to_char_type(__c)))
  60.           __c = __sb->snextc();
  61.  
  62. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  63. //195.  Should basic_istream::sentry's constructor ever set eofbit? 
  64.           if (traits_type::eq_int_type(__c, __eof))
  65.         __in.setstate(ios_base::eofbit);
  66. #endif
  67.         }
  68.     }
  69.  
  70.       if (__in.good())
  71.     _M_ok = true;
  72.       else
  73.     {
  74.       _M_ok = false;
  75.       __in.setstate(ios_base::failbit);
  76.     }
  77.     }
  78.  
  79.   template<typename _CharT, typename _Traits>
  80.     basic_istream<_CharT, _Traits>& 
  81.     basic_istream<_CharT, _Traits>::
  82.     operator>>(__istream_type& (*__pf)(__istream_type&))
  83.     {
  84.       __pf(*this);
  85.       return *this;
  86.     }
  87.  
  88.   template<typename _CharT, typename _Traits>
  89.     basic_istream<_CharT, _Traits>& 
  90.     basic_istream<_CharT, _Traits>::
  91.     operator>>(__ios_type& (*__pf)(__ios_type&))
  92.     {
  93.       __pf(*this);
  94.       return *this;
  95.     }
  96.   
  97.   template<typename _CharT, typename _Traits>
  98.     basic_istream<_CharT, _Traits>& 
  99.     basic_istream<_CharT, _Traits>::
  100.     operator>>(ios_base& (*__pf)(ios_base&))
  101.     {
  102.       __pf(*this);
  103.       return *this;
  104.     }
  105.   
  106.   template<typename _CharT, typename _Traits>
  107.     basic_istream<_CharT, _Traits>& 
  108.     basic_istream<_CharT, _Traits>::
  109.     operator>>(bool& __n)
  110.     {
  111.       sentry __cerb(*this, false);
  112.       if (__cerb) 
  113.     {
  114.       try 
  115.         {
  116.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  117.           if (_M_check_facet(_M_fnumget))
  118.         _M_fnumget->get(*this, 0, *this, __err, __n);
  119.           this->setstate(__err);
  120.         }
  121.       catch(exception& __fail)
  122.         {
  123.           // 27.6.1.2.1 Common requirements.
  124.           // Turn this on without causing an ios::failure to be thrown.
  125.           this->setstate(ios_base::badbit);
  126.           if ((this->exceptions() & ios_base::badbit) != 0)
  127.         __throw_exception_again;
  128.         }
  129.     }
  130.       return *this;
  131.     }
  132.  
  133.   template<typename _CharT, typename _Traits>
  134.     basic_istream<_CharT, _Traits>& 
  135.     basic_istream<_CharT, _Traits>::
  136.     operator>>(short& __n)
  137.     {
  138.       sentry __cerb(*this, false);
  139.       if (__cerb) 
  140.     {
  141.       try 
  142.         {
  143.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  144.           long __l;
  145.           if (_M_check_facet(_M_fnumget))
  146.         _M_fnumget->get(*this, 0, *this, __err, __l);
  147. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  148.           // 118. basic_istream uses nonexistent num_get member functions.
  149.           if (!(__err & ios_base::failbit)
  150.           && (numeric_limits<short>::min() <= __l 
  151.               && __l <= numeric_limits<short>::max()))
  152.         __n = __l;
  153.           else
  154.                 __err |= ios_base::failbit;
  155. #endif
  156.           this->setstate(__err);
  157.         }
  158.       catch(exception& __fail)
  159.         {
  160.           // 27.6.1.2.1 Common requirements.
  161.           // Turn this on without causing an ios::failure to be thrown.
  162.           this->setstate(ios_base::badbit);
  163.           if ((this->exceptions() & ios_base::badbit) != 0)
  164.         __throw_exception_again;
  165.         }
  166.     }
  167.       return *this;
  168.     }
  169.  
  170.   template<typename _CharT, typename _Traits>
  171.     basic_istream<_CharT, _Traits>& 
  172.     basic_istream<_CharT, _Traits>::
  173.     operator>>(unsigned short& __n)
  174.     {
  175.       sentry __cerb(*this, false);
  176.       if (__cerb) 
  177.     {
  178.       try 
  179.         {
  180.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  181.           if (_M_check_facet(_M_fnumget))
  182.         _M_fnumget->get(*this, 0, *this, __err, __n);
  183.           this->setstate(__err);
  184.         }
  185.       catch(exception& __fail)
  186.         {
  187.           // 27.6.1.2.1 Common requirements.
  188.           // Turn this on without causing an ios::failure to be thrown.
  189.           this->setstate(ios_base::badbit);
  190.           if ((this->exceptions() & ios_base::badbit) != 0)
  191.         __throw_exception_again;
  192.         }
  193.     }
  194.       return *this;
  195.     }
  196.  
  197.   template<typename _CharT, typename _Traits>
  198.     basic_istream<_CharT, _Traits>& 
  199.     basic_istream<_CharT, _Traits>::
  200.     operator>>(int& __n)
  201.     {
  202.       sentry __cerb(*this, false);
  203.       if (__cerb) 
  204.     {
  205.       try 
  206.         {
  207.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  208.           long __l;
  209.           if (_M_check_facet(_M_fnumget))
  210.         _M_fnumget->get(*this, 0, *this, __err, __l);
  211. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  212.           // 118. basic_istream uses nonexistent num_get member functions.
  213.           if (!(__err & ios_base::failbit)
  214.           && (numeric_limits<int>::min() <= __l 
  215.               && __l <= numeric_limits<int>::max()))
  216.         __n = __l;
  217.           else
  218.                 __err |= ios_base::failbit;
  219. #endif
  220.           this->setstate(__err);
  221.         }
  222.       catch(exception& __fail)
  223.         {
  224.           // 27.6.1.2.1 Common requirements.
  225.           // Turn this on without causing an ios::failure to be thrown.
  226.           this->setstate(ios_base::badbit);
  227.           if ((this->exceptions() & ios_base::badbit) != 0)
  228.         __throw_exception_again;
  229.         }
  230.     }
  231.       return *this;
  232.     }
  233.  
  234.   template<typename _CharT, typename _Traits>
  235.     basic_istream<_CharT, _Traits>& 
  236.     basic_istream<_CharT, _Traits>::
  237.     operator>>(unsigned int& __n)
  238.     {
  239.       sentry __cerb(*this, false);
  240.       if (__cerb) 
  241.     {
  242.       try 
  243.         {
  244.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  245.           if (_M_check_facet(_M_fnumget))
  246.         _M_fnumget->get(*this, 0, *this, __err, __n);
  247.           this->setstate(__err);
  248.         }
  249.       catch(exception& __fail)
  250.         {
  251.           // 27.6.1.2.1 Common requirements.
  252.           // Turn this on without causing an ios::failure to be thrown.
  253.           this->setstate(ios_base::badbit);
  254.           if ((this->exceptions() & ios_base::badbit) != 0)
  255.         __throw_exception_again;
  256.         }
  257.     }
  258.       return *this;
  259.     }
  260.  
  261.   template<typename _CharT, typename _Traits>
  262.     basic_istream<_CharT, _Traits>& 
  263.     basic_istream<_CharT, _Traits>::
  264.     operator>>(long& __n)
  265.     {
  266.       sentry __cerb(*this, false);
  267.       if (__cerb) 
  268.     {
  269.       try 
  270.         {
  271.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  272.           if (_M_check_facet(_M_fnumget))
  273.         _M_fnumget->get(*this, 0, *this, __err, __n);
  274.           this->setstate(__err);
  275.         }
  276.       catch(exception& __fail)
  277.         {
  278.           // 27.6.1.2.1 Common requirements.
  279.           // Turn this on without causing an ios::failure to be thrown.
  280.           this->setstate(ios_base::badbit);
  281.           if ((this->exceptions() & ios_base::badbit) != 0)
  282.         __throw_exception_again;
  283.         }
  284.     }
  285.       return *this;
  286.     }
  287.  
  288.   template<typename _CharT, typename _Traits>
  289.     basic_istream<_CharT, _Traits>& 
  290.     basic_istream<_CharT, _Traits>::
  291.     operator>>(unsigned long& __n)
  292.     {
  293.       sentry __cerb(*this, false);
  294.       if (__cerb) 
  295.     {
  296.       try 
  297.         {
  298.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  299.           if (_M_check_facet(_M_fnumget))
  300.         _M_fnumget->get(*this, 0, *this, __err, __n);
  301.           this->setstate(__err);
  302.         }
  303.       catch(exception& __fail)
  304.         {
  305.           // 27.6.1.2.1 Common requirements.
  306.           // Turn this on without causing an ios::failure to be thrown.
  307.           this->setstate(ios_base::badbit);
  308.           if ((this->exceptions() & ios_base::badbit) != 0)
  309.         __throw_exception_again;
  310.         }
  311.     }
  312.       return *this;
  313.     }
  314.  
  315. #ifdef _GLIBCPP_USE_LONG_LONG
  316.   template<typename _CharT, typename _Traits>
  317.     basic_istream<_CharT, _Traits>& 
  318.     basic_istream<_CharT, _Traits>::
  319.     operator>>(long long& __n)
  320.     {
  321.       sentry __cerb(*this, false);
  322.       if (__cerb) 
  323.     {
  324.       try 
  325.         {
  326.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  327.           if (_M_check_facet(_M_fnumget))
  328.         _M_fnumget->get(*this, 0, *this, __err, __n);
  329.           this->setstate(__err);
  330.         }
  331.       catch(exception& __fail)
  332.         {
  333.           // 27.6.1.2.1 Common requirements.
  334.           // Turn this on without causing an ios::failure to be thrown.
  335.           this->setstate(ios_base::badbit);
  336.           if ((this->exceptions() & ios_base::badbit) != 0)
  337.           __throw_exception_again;
  338.         }
  339.     }
  340.       return *this;
  341.     }
  342.  
  343.   template<typename _CharT, typename _Traits>
  344.     basic_istream<_CharT, _Traits>& 
  345.     basic_istream<_CharT, _Traits>::
  346.     operator>>(unsigned long long& __n)
  347.     {
  348.       sentry __cerb(*this, false);
  349.       if (__cerb) 
  350.     {
  351.       try 
  352.         {
  353.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  354.           if (_M_check_facet(_M_fnumget))
  355.         _M_fnumget->get(*this, 0, *this, __err, __n);
  356.           this->setstate(__err);
  357.         }
  358.       catch(exception& __fail)
  359.         {
  360.           // 27.6.1.2.1 Common requirements.
  361.           // Turn this on without causing an ios::failure to be thrown.
  362.           this->setstate(ios_base::badbit);
  363.           if ((this->exceptions() & ios_base::badbit) != 0)
  364.         __throw_exception_again;
  365.         }
  366.     }
  367.       return *this;
  368.     }
  369. #endif
  370.  
  371.   template<typename _CharT, typename _Traits>
  372.     basic_istream<_CharT, _Traits>& 
  373.     basic_istream<_CharT, _Traits>::
  374.     operator>>(float& __n)
  375.     {
  376.       sentry __cerb(*this, false);
  377.       if (__cerb) 
  378.     {
  379.       try 
  380.         {
  381.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  382.           if (_M_check_facet(_M_fnumget))
  383.         _M_fnumget->get(*this, 0, *this, __err, __n);
  384.           this->setstate(__err);
  385.         }
  386.       catch(exception& __fail)
  387.         {
  388.           // 27.6.1.2.1 Common requirements.
  389.           // Turn this on without causing an ios::failure to be thrown.
  390.           this->setstate(ios_base::badbit);
  391.           if ((this->exceptions() & ios_base::badbit) != 0)
  392.         __throw_exception_again;
  393.         }
  394.     }
  395.       return *this;
  396.     }
  397.  
  398.   template<typename _CharT, typename _Traits>
  399.     basic_istream<_CharT, _Traits>& 
  400.     basic_istream<_CharT, _Traits>::
  401.     operator>>(double& __n)
  402.     {
  403.       sentry __cerb(*this, false);
  404.       if (__cerb) 
  405.     {
  406.       try 
  407.         {
  408.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  409.           if (_M_check_facet(_M_fnumget))
  410.         _M_fnumget->get(*this, 0, *this, __err, __n);
  411.           this->setstate(__err);
  412.         }
  413.       catch(exception& __fail)
  414.         {
  415.           // 27.6.1.2.1 Common requirements.
  416.           // Turn this on without causing an ios::failure to be thrown.
  417.           this->setstate(ios_base::badbit);
  418.           if ((this->exceptions() & ios_base::badbit) != 0)
  419.         __throw_exception_again;
  420.         }
  421.     }
  422.       return *this;
  423.     }
  424.  
  425.   template<typename _CharT, typename _Traits>
  426.     basic_istream<_CharT, _Traits>& 
  427.     basic_istream<_CharT, _Traits>::
  428.     operator>>(long double& __n)
  429.     {
  430.       sentry __cerb(*this, false);
  431.       if (__cerb) 
  432.     {
  433.       try 
  434.         {
  435.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  436.           if (_M_check_facet(_M_fnumget))
  437.         _M_fnumget->get(*this, 0, *this, __err, __n);
  438.           this->setstate(__err);
  439.         }
  440.       catch(exception& __fail)
  441.         {
  442.           // 27.6.1.2.1 Common requirements.
  443.           // Turn this on without causing an ios::failure to be thrown.
  444.           this->setstate(ios_base::badbit);
  445.           if ((this->exceptions() & ios_base::badbit) != 0)
  446.         __throw_exception_again;
  447.         }
  448.     }
  449.       return *this;
  450.     }
  451.  
  452.   template<typename _CharT, typename _Traits>
  453.     basic_istream<_CharT, _Traits>& 
  454.     basic_istream<_CharT, _Traits>::
  455.     operator>>(void*& __n)
  456.     {
  457.       sentry __cerb(*this, false);
  458.       if (__cerb) 
  459.     {
  460.       try 
  461.         {
  462.           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
  463.           if (_M_check_facet(_M_fnumget))
  464.         _M_fnumget->get(*this, 0, *this, __err, __n);
  465.           this->setstate(__err);
  466.         }
  467.       catch(exception& __fail)
  468.         {
  469.           // 27.6.1.2.1 Common requirements.
  470.           // Turn this on without causing an ios::failure to be thrown.
  471.           this->setstate(ios_base::badbit);
  472.           if ((this->exceptions() & ios_base::badbit) != 0)
  473.         __throw_exception_again;
  474.         }
  475.     }
  476.       return *this;
  477.     }
  478.  
  479.   template<typename _CharT, typename _Traits>
  480.     basic_istream<_CharT, _Traits>& 
  481.     basic_istream<_CharT, _Traits>::
  482.     operator>>(__streambuf_type* __sbout)
  483.     {
  484.        sentry __cerb(*this, false);
  485.        if (__cerb)
  486.      {
  487.        try
  488.          {
  489.            streamsize __xtrct = 0;
  490.            if (__sbout)
  491.          {
  492.            __streambuf_type* __sbin = this->rdbuf();
  493.            __xtrct = __copy_streambufs(*this, __sbin, __sbout);
  494.          }
  495.            if (!__sbout || !__xtrct)
  496.          this->setstate(ios_base::failbit);
  497.          }
  498.        catch(exception& __fail)
  499.          {
  500.            // 27.6.2.5.1 Common requirements.
  501.            // Turn this on without causing an ios::failure to be thrown.
  502.            this->setstate(ios_base::badbit);
  503.            if ((this->exceptions() & ios_base::badbit) != 0)
  504.          __throw_exception_again;
  505.          }
  506.      }
  507.        return *this;
  508.     }
  509.  
  510.   template<typename _CharT, typename _Traits>
  511.     typename basic_istream<_CharT, _Traits>::int_type
  512.     basic_istream<_CharT, _Traits>::
  513.     get(void)
  514.     {
  515.       const int_type __eof = traits_type::eof();
  516.       int_type __c = __eof;
  517.       _M_gcount = 0;
  518.       sentry __cerb(*this, true);
  519.       if (__cerb) 
  520.     {
  521.       try 
  522.         {
  523.           __c = this->rdbuf()->sbumpc();
  524.           // 27.6.1.1 paragraph 3
  525.           if (!traits_type::eq_int_type(__c, __eof))
  526.         _M_gcount = 1;
  527.           else
  528.         this->setstate(ios_base::eofbit | ios_base::failbit);
  529.         }
  530.       catch(exception& __fail)
  531.         {
  532.           // 27.6.1.3 paragraph 1
  533.           // Turn this on without causing an ios::failure to be thrown.
  534.           this->setstate(ios_base::badbit);
  535.           if ((this->exceptions() & ios_base::badbit) != 0)
  536.         __throw_exception_again;
  537.         }
  538.     }
  539.       return __c;
  540.     }
  541.  
  542.   template<typename _CharT, typename _Traits>
  543.     basic_istream<_CharT, _Traits>&
  544.     basic_istream<_CharT, _Traits>::
  545.     get(char_type& __c)
  546.     {
  547.       _M_gcount = 0;
  548.       sentry __cerb(*this, true);
  549.       if (__cerb) 
  550.     {
  551.        try 
  552.         {
  553.           const int_type __eof = traits_type::eof();
  554.           int_type __bufval = this->rdbuf()->sbumpc();
  555.           // 27.6.1.1 paragraph 3
  556.           if (!traits_type::eq_int_type(__bufval, __eof))
  557.         {
  558.           _M_gcount = 1;
  559.           __c = traits_type::to_char_type(__bufval);
  560.         }
  561.           else
  562.         this->setstate(ios_base::eofbit | ios_base::failbit);
  563.         }
  564.       catch(exception& __fail)
  565.         {
  566.           // 27.6.1.3 paragraph 1
  567.           // Turn this on without causing an ios::failure to be thrown.
  568.           this->setstate(ios_base::badbit);
  569.           if ((this->exceptions() & ios_base::badbit) != 0)
  570.         __throw_exception_again;
  571.         }
  572.     }
  573.       return *this;
  574.     }
  575.  
  576.   template<typename _CharT, typename _Traits>
  577.     basic_istream<_CharT, _Traits>&
  578.     basic_istream<_CharT, _Traits>::
  579.     get(char_type* __s, streamsize __n, char_type __delim)
  580.     {
  581.       _M_gcount = 0;
  582.       sentry __cerb(*this, true);
  583.       if (__cerb) 
  584.     {
  585.       try 
  586.         {
  587.           const int_type __idelim = traits_type::to_int_type(__delim);
  588.           const int_type __eof = traits_type::eof();
  589.           __streambuf_type* __sb = this->rdbuf();
  590.           int_type __c = __sb->sgetc();    
  591.           
  592.           while (_M_gcount + 1 < __n 
  593.              && !traits_type::eq_int_type(__c, __eof)
  594.              && !traits_type::eq_int_type(__c, __idelim))
  595.         {
  596.           *__s++ = traits_type::to_char_type(__c);
  597.           __c = __sb->snextc();
  598.           ++_M_gcount;
  599.         }
  600.           if (traits_type::eq_int_type(__c, __eof))
  601.         this->setstate(ios_base::eofbit);
  602.         }
  603.       catch(exception& __fail)
  604.         {
  605.           // 27.6.1.3 paragraph 1
  606.           // Turn this on without causing an ios::failure to be thrown.
  607.           this->setstate(ios_base::badbit);
  608.           if ((this->exceptions() & ios_base::badbit) != 0)
  609.         __throw_exception_again;
  610.         }
  611.     }
  612.       *__s = char_type();
  613.       if (!_M_gcount)
  614.     this->setstate(ios_base::failbit);
  615.       return *this;
  616.     }
  617.  
  618.   template<typename _CharT, typename _Traits>
  619.     basic_istream<_CharT, _Traits>&
  620.     basic_istream<_CharT, _Traits>::
  621.     get(__streambuf_type& __sb, char_type __delim)
  622.     {
  623.       _M_gcount = 0;
  624.       sentry __cerb(*this, true);
  625.       if (__cerb) 
  626.     {
  627.       try 
  628.         {
  629.           const int_type __idelim = traits_type::to_int_type(__delim);
  630.           const int_type __eof = traits_type::eof();          
  631.           __streambuf_type* __this_sb = this->rdbuf();
  632.           int_type __c = __this_sb->sgetc();
  633.           char_type __c2 = traits_type::to_char_type(__c);
  634.           
  635.           while (!traits_type::eq_int_type(__c, __eof) 
  636.              && !traits_type::eq_int_type(__c, __idelim) 
  637.              && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  638.         {
  639.           ++_M_gcount;
  640.           __c = __this_sb->snextc();
  641.           __c2 = traits_type::to_char_type(__c);
  642.         }
  643.           if (traits_type::eq_int_type(__c, __eof))
  644.         this->setstate(ios_base::eofbit);
  645.         }
  646.       catch(exception& __fail)
  647.         {
  648.           // 27.6.1.3 paragraph 1
  649.           // Turn this on without causing an ios::failure to be thrown.
  650.           this->setstate(ios_base::badbit);
  651.           if ((this->exceptions() & ios_base::badbit) != 0)
  652.         __throw_exception_again;
  653.         }
  654.     }
  655.       if (!_M_gcount)
  656.     this->setstate(ios_base::failbit);
  657.       return *this;
  658.     }
  659.  
  660.   template<typename _CharT, typename _Traits>
  661.     basic_istream<_CharT, _Traits>&
  662.     basic_istream<_CharT, _Traits>::
  663.     getline(char_type* __s, streamsize __n, char_type __delim)
  664.     {
  665.       _M_gcount = 0;
  666.       sentry __cerb(*this, true);
  667.       if (__cerb) 
  668.     {
  669.           try 
  670.         {
  671.           const int_type __idelim = traits_type::to_int_type(__delim);
  672.           const int_type __eof = traits_type::eof();
  673.           __streambuf_type* __sb = this->rdbuf();
  674.           int_type __c = __sb->sgetc();
  675.         
  676.           while (_M_gcount + 1 < __n 
  677.              && !traits_type::eq_int_type(__c, __eof)
  678.              && !traits_type::eq_int_type(__c, __idelim))
  679.         {
  680.           *__s++ = traits_type::to_char_type(__c);
  681.           __c = __sb->snextc();
  682.           ++_M_gcount;
  683.         }
  684.           if (traits_type::eq_int_type(__c, __eof))
  685.         this->setstate(ios_base::eofbit);
  686.           else
  687.         {
  688.           if (traits_type::eq_int_type(__c, __idelim))
  689.             {
  690.               __sb->sbumpc();
  691.               ++_M_gcount;
  692.             }
  693.           else
  694.             this->setstate(ios_base::failbit);
  695.         }
  696.         }
  697.       catch(exception& __fail)
  698.         {
  699.           // 27.6.1.3 paragraph 1
  700.           // Turn this on without causing an ios::failure to be thrown.
  701.           this->setstate(ios_base::badbit);
  702.           if ((this->exceptions() & ios_base::badbit) != 0)
  703.         __throw_exception_again;
  704.         }
  705.     }
  706.       *__s = char_type();
  707.       if (!_M_gcount)
  708.     this->setstate(ios_base::failbit);
  709.       return *this;
  710.     }
  711.   
  712.   template<typename _CharT, typename _Traits>
  713.     basic_istream<_CharT, _Traits>&
  714.     basic_istream<_CharT, _Traits>::
  715.     ignore(streamsize __n, int_type __delim)
  716.     {
  717.       _M_gcount = 0;
  718.       sentry __cerb(*this, true);
  719.       if (__cerb) 
  720.     {
  721.       try 
  722.         {
  723.           const int_type __eof = traits_type::eof();
  724.           __streambuf_type* __sb = this->rdbuf();
  725.           int_type __c;
  726.           
  727.           __n = min(__n, numeric_limits<streamsize>::max());
  728.           while (_M_gcount < __n  
  729.              && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
  730.         {
  731.           ++_M_gcount;
  732.           if (traits_type::eq_int_type(__c, __delim))
  733.             break;
  734.         }
  735.           if (traits_type::eq_int_type(__c, __eof))
  736.         this->setstate(ios_base::eofbit);
  737.         }
  738.       catch(exception& __fail)
  739.         {
  740.           // 27.6.1.3 paragraph 1
  741.           // Turn this on without causing an ios::failure to be thrown.
  742.           this->setstate(ios_base::badbit);
  743.           if ((this->exceptions() & ios_base::badbit) != 0)
  744.         __throw_exception_again;
  745.         }
  746.     }
  747.       return *this;
  748.     }
  749.   
  750.   template<typename _CharT, typename _Traits>
  751.     typename basic_istream<_CharT, _Traits>::int_type
  752.     basic_istream<_CharT, _Traits>::
  753.     peek(void)
  754.     {
  755.       int_type __c = traits_type::eof();
  756.       _M_gcount = 0;
  757.       sentry __cerb(*this, true);
  758.       if (__cerb)
  759.     {
  760.       try 
  761.         { __c = this->rdbuf()->sgetc(); }
  762.       catch(exception& __fail)
  763.         {
  764.           // 27.6.1.3 paragraph 1
  765.           // Turn this on without causing an ios::failure to be thrown.
  766.           this->setstate(ios_base::badbit);
  767.           if ((this->exceptions() & ios_base::badbit) != 0)
  768.         __throw_exception_again;
  769.         }
  770.     } 
  771.       return __c;
  772.     }
  773.  
  774.   template<typename _CharT, typename _Traits>
  775.     basic_istream<_CharT, _Traits>&
  776.     basic_istream<_CharT, _Traits>::
  777.     read(char_type* __s, streamsize __n)
  778.     {
  779.       _M_gcount = 0;
  780.       sentry __cerb(*this, true);
  781.       if (__cerb) 
  782.     {
  783.       try 
  784.         {
  785.           _M_gcount = this->rdbuf()->sgetn(__s, __n);
  786.           if (_M_gcount != __n)
  787.         this->setstate(ios_base::eofbit | ios_base::failbit);
  788.         }        
  789.       catch(exception& __fail)
  790.         {
  791.           // 27.6.1.3 paragraph 1
  792.           // Turn this on without causing an ios::failure to be thrown.
  793.           this->setstate(ios_base::badbit);
  794.           if ((this->exceptions() & ios_base::badbit) != 0)
  795.         __throw_exception_again;
  796.         }
  797.     }
  798.       else
  799.     this->setstate(ios_base::failbit);
  800.       return *this;
  801.     }
  802.   
  803.   template<typename _CharT, typename _Traits>
  804.     streamsize 
  805.     basic_istream<_CharT, _Traits>::
  806.     readsome(char_type* __s, streamsize __n)
  807.     {
  808.       _M_gcount = 0;
  809.       sentry __cerb(*this, true);
  810.       if (__cerb) 
  811.     {
  812.       try 
  813.         {
  814.           streamsize __num = this->rdbuf()->in_avail();
  815.           if (__num > 0)
  816.         {
  817.           __num = min(__num, __n);
  818.           if (__num)
  819.             _M_gcount = this->rdbuf()->sgetn(__s, __num);
  820.         }
  821.           else
  822.         this->setstate(ios_base::eofbit);            
  823.         }
  824.       catch(exception& __fail)
  825.         {
  826.           // 27.6.1.3 paragraph 1
  827.           // Turn this on without causing an ios::failure to be thrown.
  828.           this->setstate(ios_base::badbit);
  829.           if ((this->exceptions() & ios_base::badbit) != 0)
  830.         __throw_exception_again;
  831.         }
  832.     }
  833.       else
  834.     this->setstate(ios_base::failbit);
  835.       return _M_gcount;
  836.     }
  837.       
  838.   template<typename _CharT, typename _Traits>
  839.     basic_istream<_CharT, _Traits>&
  840.     basic_istream<_CharT, _Traits>::
  841.     putback(char_type __c)
  842.     {
  843.       sentry __cerb(*this, true);
  844.       if (__cerb) 
  845.     {
  846.       try 
  847.         {
  848.           const int_type __eof = traits_type::eof();
  849.           __streambuf_type* __sb = this->rdbuf();
  850.           if (!__sb 
  851.           || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  852.         this->setstate(ios_base::badbit);            
  853.         }
  854.       catch(exception& __fail)
  855.         {
  856.           // 27.6.1.3 paragraph 1
  857.           // Turn this on without causing an ios::failure to be thrown.
  858.           this->setstate(ios_base::badbit);
  859.           if ((this->exceptions() & ios_base::badbit) != 0)
  860.         __throw_exception_again;
  861.         }
  862.     }
  863.       else
  864.     this->setstate(ios_base::failbit);
  865.       return *this;
  866.     }
  867.   
  868.   template<typename _CharT, typename _Traits>
  869.     basic_istream<_CharT, _Traits>&
  870.     basic_istream<_CharT, _Traits>::
  871.     unget(void)
  872.     {
  873.       _M_gcount = 0;
  874.       sentry __cerb(*this, true);
  875.       if (__cerb) 
  876.     {
  877.       try 
  878.         {
  879.           const int_type __eof = traits_type::eof();
  880.           __streambuf_type* __sb = this->rdbuf();
  881.           if (!__sb 
  882.           || traits_type::eq_int_type(__sb->sungetc(), __eof))
  883.         this->setstate(ios_base::badbit);            
  884.         }
  885.       catch(exception& __fail)
  886.         {
  887.           // 27.6.1.3 paragraph 1
  888.           // Turn this on without causing an ios::failure to be thrown.
  889.           this->setstate(ios_base::badbit);
  890.           if ((this->exceptions() & ios_base::badbit) != 0)
  891.         __throw_exception_again;
  892.         }
  893.     }
  894.       else
  895.     this->setstate(ios_base::failbit);
  896.       return *this;
  897.     }
  898.   
  899.   template<typename _CharT, typename _Traits>
  900.     int
  901.     basic_istream<_CharT, _Traits>::
  902.     sync(void)
  903.     {
  904.       int __ret = -1;
  905.       _M_gcount = 0;
  906.       sentry __cerb(*this, true);
  907.       if (__cerb) 
  908.     {
  909.       try 
  910.         {
  911.           __streambuf_type* __sb = this->rdbuf();
  912.           if (__sb)
  913.         {
  914.           if (__sb->pubsync() == -1)
  915.             this->setstate(ios_base::badbit);            
  916.           else 
  917.             __ret = 0;
  918.         }
  919.         }
  920.       catch(exception& __fail)
  921.         {
  922.           // 27.6.1.3 paragraph 1
  923.           // Turn this on without causing an ios::failure to be thrown.
  924.           this->setstate(ios_base::badbit);
  925.           if ((this->exceptions() & ios_base::badbit) != 0)
  926.         __throw_exception_again;
  927.         }
  928.     }
  929.       return __ret;
  930.     }
  931.   
  932.   template<typename _CharT, typename _Traits>
  933.     typename basic_istream<_CharT, _Traits>::pos_type
  934.     basic_istream<_CharT, _Traits>::
  935.     tellg(void)
  936.     {
  937.       pos_type __ret = pos_type(-1);
  938.       _M_gcount = 0;
  939.       sentry __cerb(*this, true);
  940.       if (__cerb) 
  941.     {
  942.       try 
  943.         {
  944.          __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
  945.         }
  946.       catch(exception& __fail)
  947.         {
  948.           // 27.6.1.3 paragraph 1
  949.           // Turn this on without causing an ios::failure to be thrown.
  950.           this->setstate(ios_base::badbit);
  951.           if ((this->exceptions() & ios_base::badbit) != 0)
  952.         __throw_exception_again;
  953.         }
  954.     }
  955.       return __ret;
  956.     }
  957.  
  958.  
  959.   template<typename _CharT, typename _Traits>
  960.     basic_istream<_CharT, _Traits>&
  961.     basic_istream<_CharT, _Traits>::
  962.     seekg(pos_type __pos)
  963.     {
  964.       _M_gcount = 0;
  965.       sentry __cerb(*this, true);
  966.       if (__cerb) 
  967.     {
  968.       try 
  969.         {
  970. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  971. // 136.  seekp, seekg setting wrong streams?
  972.           pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
  973.  
  974. // 129. Need error indication from seekp() and seekg()
  975.           if (__err == pos_type(off_type(-1)))
  976.         this->setstate(ios_base::failbit);
  977. #endif
  978.         }
  979.       catch(exception& __fail)
  980.         {
  981.           // 27.6.1.3 paragraph 1
  982.           // Turn this on without causing an ios::failure to be thrown.
  983.           this->setstate(ios_base::badbit);
  984.           if ((this->exceptions() & ios_base::badbit) != 0)
  985.         __throw_exception_again;
  986.         }
  987.     }
  988.       return *this;
  989.     }
  990.  
  991.   template<typename _CharT, typename _Traits>
  992.     basic_istream<_CharT, _Traits>&
  993.     basic_istream<_CharT, _Traits>::
  994.     seekg(off_type __off, ios_base::seekdir __dir)
  995.     {
  996.       _M_gcount = 0;
  997.       sentry __cerb(*this, true);
  998.       if (__cerb) 
  999.     {
  1000.       try 
  1001.         {
  1002. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  1003. // 136.  seekp, seekg setting wrong streams?
  1004.           pos_type __err = this->rdbuf()->pubseekoff(__off, __dir, 
  1005.                              ios_base::in);
  1006.  
  1007. // 129. Need error indication from seekp() and seekg()
  1008.           if (__err == pos_type(off_type(-1)))
  1009.         this->setstate(ios_base::failbit);
  1010. #endif
  1011.         }
  1012.       catch(exception& __fail)
  1013.         {
  1014.           // 27.6.1.3 paragraph 1
  1015.           // Turn this on without causing an ios::failure to be thrown.
  1016.           this->setstate(ios_base::badbit);
  1017.           if ((this->exceptions() & ios_base::badbit) != 0)
  1018.         __throw_exception_again;
  1019.         }
  1020.     }
  1021.       return *this;
  1022.     }
  1023.  
  1024.   // 27.6.1.2.3 Character extraction templates
  1025.   template<typename _CharT, typename _Traits>
  1026.     basic_istream<_CharT, _Traits>&
  1027.     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
  1028.     {
  1029.       typedef basic_istream<_CharT, _Traits>         __istream_type;
  1030.       typename __istream_type::sentry __cerb(__in, false);
  1031.       if (__cerb)
  1032.     {
  1033.       try 
  1034.         { __in.get(__c); }
  1035.       catch(exception& __fail)
  1036.         {
  1037.           // 27.6.1.2.1 Common requirements.
  1038.           // Turn this on without causing an ios::failure to be thrown.
  1039.           __in.setstate(ios_base::badbit);
  1040.           if ((__in.exceptions() & ios_base::badbit) != 0)
  1041.         __throw_exception_again;
  1042.         }
  1043.     }
  1044.       else
  1045.     __in.setstate(ios_base::failbit);
  1046.       return __in;
  1047.     }
  1048.  
  1049.   template<typename _CharT, typename _Traits>
  1050.     basic_istream<_CharT, _Traits>&
  1051.     operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
  1052.     {
  1053.       typedef basic_istream<_CharT, _Traits>         __istream_type;
  1054.       typedef typename __istream_type::__streambuf_type __streambuf_type;
  1055.       typedef typename _Traits::int_type         int_type;
  1056.       typedef _CharT                             char_type;
  1057.       typedef ctype<_CharT>                 __ctype_type;
  1058.       streamsize __extracted = 0;
  1059.  
  1060.       typename __istream_type::sentry __cerb(__in, false);
  1061.       if (__cerb)
  1062.     {
  1063.       try 
  1064.         {
  1065.           // Figure out how many characters to extract.
  1066.           streamsize __num = __in.width();
  1067.           if (__num == 0)
  1068.         __num = numeric_limits<streamsize>::max();
  1069.           
  1070.           const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
  1071.           const int_type __eof = _Traits::eof();
  1072.           __streambuf_type* __sb = __in.rdbuf();
  1073.           int_type __c = __sb->sgetc();
  1074.           
  1075.           while (__extracted < __num - 1 
  1076.              && __c != __eof && !__ctype.is(ctype_base::space, __c))
  1077.         {
  1078.           *__s++ = __c;
  1079.           ++__extracted;
  1080.           __c = __sb->snextc();
  1081.         }
  1082.           if (__c == __eof)
  1083.         __in.setstate(ios_base::eofbit);
  1084.  
  1085. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  1086. //68.  Extractors for char* should store null at end
  1087.           *__s = char_type();
  1088. #endif
  1089.           __in.width(0);
  1090.         }
  1091.       catch(exception& __fail)
  1092.         {
  1093.           // 27.6.1.2.1 Common requirements.
  1094.           // Turn this on without causing an ios::failure to be thrown.
  1095.           __in.setstate(ios_base::badbit);
  1096.           if ((__in.exceptions() & ios_base::badbit) != 0)
  1097.         __throw_exception_again;
  1098.         }
  1099.     }
  1100.       if (!__extracted)
  1101.     __in.setstate(ios_base::failbit);
  1102.       return __in;
  1103.     }
  1104.  
  1105.   // 27.6.1.4 Standard basic_istream manipulators
  1106.   template<typename _CharT, typename _Traits>
  1107.     basic_istream<_CharT,_Traits>& 
  1108.     ws(basic_istream<_CharT,_Traits>& __in)
  1109.     {
  1110.       typedef basic_istream<_CharT, _Traits>         __istream_type;
  1111.       typedef typename __istream_type::__streambuf_type __streambuf_type;
  1112.       typedef typename __istream_type::__ctype_type     __ctype_type;
  1113.       typedef typename __istream_type::int_type     __int_type;
  1114.  
  1115.       const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
  1116.       const __int_type __eof = _Traits::eof();          
  1117.       __streambuf_type* __sb = __in.rdbuf();
  1118.       __int_type __c = __sb->sgetc();
  1119.  
  1120.       while (__c != __eof && __ctype.is(ctype_base::space, __c))
  1121.     __c = __sb->snextc();
  1122.       if (__c == __eof)
  1123.     __in.setstate(ios_base::eofbit);
  1124.  
  1125.       return __in;
  1126.     }
  1127.  
  1128.   // 21.3.7.9 basic_string::getline and operators
  1129.   template<typename _CharT, typename _Traits, typename _Alloc>
  1130.     basic_istream<_CharT, _Traits>&
  1131.     operator>>(basic_istream<_CharT, _Traits>& __in,
  1132.            basic_string<_CharT, _Traits, _Alloc>& __str)
  1133.     {
  1134.       typedef basic_istream<_CharT, _Traits>         __istream_type;
  1135.       typedef typename __istream_type::int_type     __int_type;
  1136.       typedef typename __istream_type::__streambuf_type __streambuf_type;
  1137.       typedef typename __istream_type::__ctype_type     __ctype_type;
  1138.       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
  1139.       typedef typename __string_type::size_type        __size_type;
  1140.       __size_type __extracted = 0;
  1141.  
  1142.       typename __istream_type::sentry __cerb(__in, false);
  1143.       if (__cerb) 
  1144.     {
  1145.       __str.erase();
  1146.       streamsize __w = __in.width();
  1147.       __size_type __n;
  1148.       __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
  1149.  
  1150.       const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
  1151.       const __int_type __eof = _Traits::eof();
  1152.       __streambuf_type* __sb = __in.rdbuf();
  1153.       __int_type __c = __sb->sgetc();
  1154.       
  1155.       while (__extracted < __n 
  1156.          && __c != __eof && !__ctype.is(ctype_base::space, __c))
  1157.         {
  1158.           __str += _Traits::to_char_type(__c);
  1159.           ++__extracted;
  1160.           __c = __sb->snextc();
  1161.         }
  1162.       if (__c == __eof)
  1163.         __in.setstate(ios_base::eofbit);
  1164.       __in.width(0);
  1165.     }
  1166. #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
  1167. //211.  operator>>(istream&, string&) doesn't set failbit
  1168.       if (!__extracted)
  1169.     __in.setstate (ios_base::failbit);
  1170. #endif
  1171.       return __in;
  1172.     }
  1173.  
  1174.   template<typename _CharT, typename _Traits, typename _Alloc>
  1175.     basic_istream<_CharT, _Traits>&
  1176.     getline(basic_istream<_CharT, _Traits>& __in,
  1177.         basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
  1178.     {
  1179.       typedef basic_istream<_CharT, _Traits>         __istream_type;
  1180.       typedef typename __istream_type::int_type     __int_type;
  1181.       typedef typename __istream_type::__streambuf_type __streambuf_type;
  1182.       typedef typename __istream_type::__ctype_type     __ctype_type;
  1183.       typedef basic_string<_CharT, _Traits, _Alloc>     __string_type;
  1184.       typedef typename __string_type::size_type        __size_type;
  1185.  
  1186.       __size_type __extracted = 0;
  1187.       bool __testdelim = false;
  1188.       typename __istream_type::sentry __cerb(__in, true);
  1189.       if (__cerb) 
  1190.     {
  1191.       __str.erase();
  1192.       __size_type __n = __str.max_size();
  1193.  
  1194.       __int_type __idelim = _Traits::to_int_type(__delim);
  1195.       __streambuf_type* __sb = __in.rdbuf();
  1196.       __int_type __c = __sb->sbumpc();
  1197.       const __int_type __eof = _Traits::eof();
  1198.       __testdelim = _Traits::eq_int_type(__c, __idelim);
  1199.  
  1200.       while (__extracted <= __n 
  1201.          && !_Traits::eq_int_type(__c, __eof)
  1202.          && !__testdelim)
  1203.         {
  1204.           __str += _Traits::to_char_type(__c);
  1205.           ++__extracted;
  1206.           __c = __sb->sbumpc();
  1207.           __testdelim = _Traits::eq_int_type(__c, __idelim);
  1208.         }
  1209.       if (_Traits::eq_int_type(__c, __eof))
  1210.         __in.setstate(ios_base::eofbit);
  1211.     }
  1212.       if (!__extracted && !__testdelim)
  1213.     __in.setstate(ios_base::failbit);
  1214.       return __in;
  1215.     }
  1216.  
  1217.   template<class _CharT, class _Traits, class _Alloc>
  1218.     inline basic_istream<_CharT,_Traits>&
  1219.     getline(basic_istream<_CharT, _Traits>& __in, 
  1220.         basic_string<_CharT,_Traits,_Alloc>& __str)
  1221.     { return getline(__in, __str, __in.widen('\n')); }
  1222.  
  1223.   // Inhibit implicit instantiations for required instantiations,
  1224.   // which are defined via explicit instantiations elsewhere.  
  1225.   // NB:  This syntax is a GNU extension.
  1226.   extern template class basic_istream<char>;
  1227.   extern template istream& ws(istream&);
  1228.   extern template istream& operator>>(istream&, char&);
  1229.   extern template istream& operator>>(istream&, char*);
  1230.   extern template istream& operator>>(istream&, unsigned char&);
  1231.   extern template istream& operator>>(istream&, signed char&);
  1232.   extern template istream& operator>>(istream&, unsigned char*);
  1233.   extern template istream& operator>>(istream&, signed char*);
  1234.  
  1235. #ifdef _GLIBCPP_USE_WCHAR_T
  1236.   extern template class basic_istream<wchar_t>;
  1237.   extern template wistream& ws(wistream&);
  1238.   extern template wistream& operator>>(wistream&, wchar_t&);
  1239.   extern template wistream& operator>>(wistream&, wchar_t*);
  1240. #endif
  1241. } // namespace std
  1242.