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 size_t
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 if (!__testpos || !traits_type::eq(__c, this->gptr()[-1]))
00071 __ret = this->pbackfail(traits_type::to_int_type(__c));
00072 else
00073 {
00074 _M_in_cur_move(-1);
00075 __ret = traits_type::to_int_type(*this->gptr());
00076 }
00077 return __ret;
00078 }
00079
00080 template<typename _CharT, typename _Traits>
00081 typename basic_streambuf<_CharT, _Traits>::int_type
00082 basic_streambuf<_CharT, _Traits>::
00083 sungetc()
00084 {
00085 int_type __ret;
00086 if (_M_in_cur && _M_in_beg < _M_in_cur)
00087 {
00088 _M_in_cur_move(-1);
00089 __ret = traits_type::to_int_type(*_M_in_cur);
00090 }
00091 else
00092 __ret = this->pbackfail();
00093 return __ret;
00094 }
00095
00096
00097
00098
00099
00100
00101 template<typename _CharT, typename _Traits>
00102 typename basic_streambuf<_CharT, _Traits>::int_type
00103 basic_streambuf<_CharT, _Traits>::
00104 sputc(char_type __c)
00105 {
00106 int_type __ret;
00107 if (_M_out_buf_size())
00108 {
00109 *_M_out_cur = __c;
00110 _M_out_cur_move(1);
00111 __ret = traits_type::to_int_type(__c);
00112 }
00113 else
00114 __ret = this->overflow(traits_type::to_int_type(__c));
00115 return __ret;
00116 }
00117
00118 template<typename _CharT, typename _Traits>
00119 streamsize
00120 basic_streambuf<_CharT, _Traits>::
00121 xsgetn(char_type* __s, streamsize __n)
00122 {
00123 streamsize __ret = 0;
00124 while (__ret < __n)
00125 {
00126 size_t __buf_len = _M_in_end - _M_in_cur;
00127 if (__buf_len > 0)
00128 {
00129 size_t __remaining = __n - __ret;
00130 size_t __len = min(__buf_len, __remaining);
00131 traits_type::copy(__s, _M_in_cur, __len);
00132 __ret += __len;
00133 __s += __len;
00134 _M_in_cur_move(__len);
00135 }
00136
00137 if (__ret < __n)
00138 {
00139 int_type __c = this->uflow();
00140 if (!traits_type::eq_int_type(__c, traits_type::eof()))
00141 {
00142 traits_type::assign(*__s++, traits_type::to_char_type(__c));
00143 ++__ret;
00144 }
00145 else
00146 break;
00147 }
00148 }
00149 return __ret;
00150 }
00151
00152
00153
00154
00155
00156
00157 template<typename _CharT, typename _Traits>
00158 streamsize
00159 basic_streambuf<_CharT, _Traits>::
00160 xsputn(const char_type* __s, streamsize __n)
00161 {
00162 streamsize __ret = 0;
00163 while (__ret < __n)
00164 {
00165 off_type __buf_len = _M_out_buf_size();
00166 if (__buf_len > 0)
00167 {
00168 off_type __remaining = __n - __ret;
00169 off_type __len = min(__buf_len, __remaining);
00170 traits_type::copy(_M_out_cur, __s, __len);
00171 __ret += __len;
00172 __s += __len;
00173 _M_out_cur_move(__len);
00174 }
00175
00176 if (__ret < __n)
00177 {
00178 int_type __c = this->overflow(traits_type::to_int_type(*__s));
00179 if (!traits_type::eq_int_type(__c, traits_type::eof()))
00180 {
00181 ++__ret;
00182 ++__s;
00183 }
00184 else
00185 break;
00186 }
00187 }
00188 return __ret;
00189 }
00190
00191
00192
00193
00194
00195 template<typename _CharT, typename _Traits>
00196 streamsize
00197 __copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
00198 basic_streambuf<_CharT, _Traits>* __sbin,
00199 basic_streambuf<_CharT, _Traits>* __sbout)
00200 {
00201 typedef typename _Traits::int_type int_type;
00202
00203 streamsize __ret = 0;
00204 streamsize __bufsize = __sbin->in_avail();
00205 streamsize __xtrct;
00206 bool __testput = __sbout->_M_mode & ios_base::out;
00207 try
00208 {
00209 while (__testput && __bufsize != -1)
00210 {
00211 if (__bufsize != 0 && __sbin->gptr() != NULL
00212 && __sbin->gptr() + __bufsize <= __sbin->egptr())
00213 {
00214 __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize);
00215 __ret += __xtrct;
00216 __sbin->_M_in_cur_move(__xtrct);
00217 if (__xtrct != __bufsize)
00218 break;
00219 }
00220 else
00221 {
00222 size_t __size =
00223 __sbin->_M_buf_size_opt > 0 ? __sbin->_M_buf_size_opt : 1;
00224 _CharT* __buf =
00225 static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __size));
00226 streamsize __charsread = __sbin->sgetn(__buf, __size);
00227 __xtrct = __sbout->sputn(__buf, __charsread);
00228 __ret += __xtrct;
00229 if (__xtrct != __charsread)
00230 break;
00231 }
00232 if (_Traits::eq_int_type(__sbin->sgetc(), _Traits::eof()))
00233 break;
00234 __bufsize = __sbin->in_avail();
00235 }
00236 }
00237 catch(exception& __fail)
00238 {
00239 __ios.setstate(ios_base::failbit);
00240 if ((__ios.exceptions() & ios_base::failbit) != 0)
00241 __throw_exception_again;
00242 }
00243 return __ret;
00244 }
00245
00246
00247
00248
00249 extern template class basic_streambuf<char>;
00250 extern template
00251 streamsize
00252 __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
00253 basic_streambuf<char>*);
00254
00255 #ifdef _GLIBCPP_USE_WCHAR_T
00256 extern template class basic_streambuf<wchar_t>;
00257 extern template
00258 streamsize
00259 __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
00260 basic_streambuf<wchar_t>*);
00261 #endif
00262 }
00263
00264 #endif