00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 #ifndef _CPP_BITS_STREAMBUF_TCC
00036 #define _CPP_BITS_STREAMBUF_TCC 1
00037 
00038 #pragma GCC system_header
00039 
00040 namespace std 
00041 {
00042   template<typename _CharT, typename _Traits>
00043     const typename basic_streambuf<_CharT, _Traits>::int_type
00044     basic_streambuf<_CharT, _Traits>::_S_pback_size;
00045 
00046   template<typename _CharT, typename _Traits>
00047     typename basic_streambuf<_CharT, _Traits>::int_type
00048     basic_streambuf<_CharT, _Traits>::
00049     sbumpc()
00050     {
00051       int_type __ret;
00052       if (_M_in_cur && _M_in_cur < _M_in_end)
00053     {
00054       char_type __c = *(this->gptr());
00055       _M_in_cur_move(1);
00056       __ret = traits_type::to_int_type(__c);
00057     }
00058       else 
00059     __ret = this->uflow();
00060       return __ret;
00061     }
00062 
00063   template<typename _CharT, typename _Traits>
00064     typename basic_streambuf<_CharT, _Traits>::int_type
00065     basic_streambuf<_CharT, _Traits>::
00066     sputbackc(char_type __c) 
00067     {
00068       int_type __ret;
00069       bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
00070       bool __testne = _M_in_cur && !traits_type::eq(__c, this->gptr()[-1]);
00071       if (!__testpos || __testne)
00072     __ret = pbackfail(traits_type::to_int_type(__c));
00073       else 
00074     {
00075       _M_in_cur_move(-1);
00076       __ret = traits_type::to_int_type(*this->gptr());
00077     }
00078       return __ret;
00079     }
00080   
00081   template<typename _CharT, typename _Traits>
00082     typename basic_streambuf<_CharT, _Traits>::int_type
00083     basic_streambuf<_CharT, _Traits>::
00084     sungetc()
00085     {
00086       int_type __ret;
00087       if (_M_in_cur && _M_in_beg < _M_in_cur)
00088     {
00089       _M_in_cur_move(-1);
00090       __ret = traits_type::to_int_type(*_M_in_cur);
00091     }
00092       else 
00093     __ret = this->pbackfail();
00094       return __ret;
00095     }
00096 
00097   
00098   
00099   
00100   
00101   
00102   template<typename _CharT, typename _Traits>
00103     typename basic_streambuf<_CharT, _Traits>::int_type
00104     basic_streambuf<_CharT, _Traits>::
00105     sputc(char_type __c)
00106     {
00107       int_type __ret;
00108       if (_M_out_buf_size())
00109     {
00110       *_M_out_cur = __c;
00111       _M_out_cur_move(1);
00112       __ret = traits_type::to_int_type(__c);
00113     }
00114       else
00115     __ret = this->overflow(traits_type::to_int_type(__c));
00116       return __ret;
00117     }
00118 
00119   template<typename _CharT, typename _Traits>
00120     streamsize
00121     basic_streambuf<_CharT, _Traits>::
00122     xsgetn(char_type* __s, streamsize __n)
00123     {
00124       streamsize __ret = 0;
00125       while (__ret < __n)
00126     {
00127       size_t __buf_len = _M_in_end - _M_in_cur;
00128       if (__buf_len > 0)
00129         {
00130           size_t __remaining = __n - __ret;
00131           size_t __len = min(__buf_len, __remaining);
00132           traits_type::copy(__s, _M_in_cur, __len);
00133           __ret += __len;
00134           __s += __len;
00135           _M_in_cur_move(__len);
00136         }
00137       
00138       if (__ret < __n)
00139         {
00140           int_type __c = this->uflow();  
00141           if (__c != traits_type::eof())
00142         {
00143           traits_type::assign(*__s++, traits_type::to_char_type(__c));
00144           ++__ret;
00145         }
00146           else
00147         break;
00148         }
00149     }
00150       return __ret;
00151     }
00152 
00153   
00154   
00155   
00156   
00157   
00158   template<typename _CharT, typename _Traits>
00159     streamsize
00160     basic_streambuf<_CharT, _Traits>::
00161     xsputn(const char_type* __s, streamsize __n)
00162     {
00163       streamsize __ret = 0;
00164       while (__ret < __n)
00165     {
00166       off_type __buf_len = _M_out_buf_size();
00167       if (__buf_len > 0)
00168         {
00169           off_type __remaining = __n - __ret;
00170           off_type __len = min(__buf_len, __remaining);
00171           traits_type::copy(_M_out_cur, __s, __len);
00172           __ret += __len;
00173           __s += __len;
00174           _M_out_cur_move(__len);
00175         }
00176 
00177       if (__ret < __n)
00178         {
00179           int_type __c = this->overflow(traits_type::to_int_type(*__s));
00180           if (__c != traits_type::eof())
00181         {
00182           ++__ret;
00183           ++__s;
00184         }
00185           else
00186         break;
00187         }
00188     }
00189       return __ret;
00190     }
00191 
00192   
00193   
00194   
00195   
00196   template<typename _CharT, typename _Traits>
00197     streamsize
00198     __copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
00199               basic_streambuf<_CharT, _Traits>* __sbin,
00200               basic_streambuf<_CharT, _Traits>* __sbout) 
00201   {
00202       typedef typename _Traits::int_type    int_type;
00203 
00204       streamsize __ret = 0;
00205       streamsize __bufsize = __sbin->in_avail();
00206       streamsize __xtrct;
00207       bool __testput = __sbout->_M_mode & ios_base::out;
00208       try 
00209     {
00210       while (__testput && __bufsize != -1)
00211         {
00212           __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize);
00213           __ret += __xtrct;
00214           __sbin->_M_in_cur_move(__xtrct);
00215           if (__xtrct == __bufsize)
00216         {
00217           if (__sbin->sgetc() == _Traits::eof())
00218             break;
00219           __bufsize = __sbin->in_avail();
00220         }
00221           else
00222         break;
00223         }
00224     }
00225       catch(exception& __fail) 
00226     {
00227       __ios.setstate(ios_base::failbit);
00228       if ((__ios.exceptions() & ios_base::failbit) != 0)
00229         __throw_exception_again;
00230     }
00231       return __ret;
00232     }
00233 
00234   
00235   
00236   
00237   extern template class basic_streambuf<char>;
00238   extern template
00239     streamsize
00240     __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
00241               basic_streambuf<char>*); 
00242 
00243   extern template class basic_streambuf<wchar_t>;
00244   extern template
00245     streamsize
00246     __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
00247               basic_streambuf<wchar_t>*); 
00248 } 
00249 
00250 #endif