libstdc++-v3/include/bits/streambuf.tcc

   1 // Stream buffer classes -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
   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.5  Stream buffers
  33 //
  34
  35 #ifndef _CPP_BITS_STREAMBUF_TCC
  36 #define _CPP_BITS_STREAMBUF_TCC 1
  37
  38 #pragma GCC system_header
  39
  40 namespace std
  41 {
  42   template<typename _CharT, typename _Traits>
  43     typename basic_streambuf<_CharT, _Traits>::int_type
  44     basic_streambuf<_CharT, _Traits>::
  45     sbumpc()
  46     {
  47       int_type __ret;
  48       if (_M_in_cur < _M_in_end)
  49         {
  50           char_type __c = *this->_M_in_cur;
  51           _M_move_in_cur(1);
  52           __ret = traits_type::to_int_type(__c);
  53         }
  54       else
  55         __ret = this->uflow();
  56       return __ret;
  57     }
  58
  59   template<typename _CharT, typename _Traits>
  60     typename basic_streambuf<_CharT, _Traits>::int_type
  61     basic_streambuf<_CharT, _Traits>::
  62     sputbackc(char_type __c)
  63     {
  64       int_type __ret;
  65       const bool __testpos = _M_in_beg < _M_in_cur;
  66       if (!__testpos || !traits_type::eq(__c, this->_M_in_cur[-1]))
  67         __ret = this->pbackfail(traits_type::to_int_type(__c));
  68       else
  69         {
  70           _M_move_in_cur(-1);
  71           __ret = traits_type::to_int_type(*this->_M_in_cur);
  72         }
  73       return __ret;
  74     }
  75
  76   template<typename _CharT, typename _Traits>
  77     typename basic_streambuf<_CharT, _Traits>::int_type
  78     basic_streambuf<_CharT, _Traits>::
  79     sungetc()
  80     {
  81       int_type __ret;
  82       if (_M_in_beg < _M_in_cur)
  83         {
  84           _M_move_in_cur(-1);
  85           __ret = traits_type::to_int_type(*_M_in_cur);
  86         }
  87       else
  88         __ret = this->pbackfail();
  89       return __ret;
  90     }
  91
  92   template<typename _CharT, typename _Traits>
  93     typename basic_streambuf<_CharT, _Traits>::int_type
  94     basic_streambuf<_CharT, _Traits>::
  95     sputc(char_type __c)
  96     {
  97       int_type __ret;
  98       if (_M_out_cur < _M_out_end)
  99         {
 100           *_M_out_cur = __c;
 101           _M_move_out_cur(1);
 102           __ret = traits_type::to_int_type(__c);
 103         }
 104       else
 105         __ret = this->overflow(traits_type::to_int_type(__c));
 106       return __ret;
 107     }
 108
 109   template<typename _CharT, typename _Traits>
 110     streamsize
 111     basic_streambuf<_CharT, _Traits>::
 112     xsgetn(char_type* __s, streamsize __n)
 113     {
 114       streamsize __ret = 0;
 115       while (__ret < __n)
 116         {
 117           const size_t __buf_len = _M_in_end - _M_in_cur;
 118           if (__buf_len)
 119             {
 120               const size_t __remaining = __n - __ret;
 121               const size_t __len = std::min(__buf_len, __remaining);
 122               traits_type::copy(__s, _M_in_cur, __len);
 123               __ret += __len;
 124               __s += __len;
 125               _M_move_in_cur(__len);
 126             }
 127
 128           if (__ret < __n)
 129             {
 130               const int_type __c = this->uflow();
 131               if (!traits_type::eq_int_type(__c, traits_type::eof()))
 132                 {
 133                   traits_type::assign(*__s++, traits_type::to_char_type(__c));
 134                   ++__ret;
 135                 }
 136               else
 137                 break;
 138             }
 139         }
 140       return __ret;
 141     }
 142
 143   template<typename _CharT, typename _Traits>
 144     streamsize
 145     basic_streambuf<_CharT, _Traits>::
 146     xsputn(const char_type* __s, streamsize __n)
 147     {
 148       streamsize __ret = 0;
 149       while (__ret < __n)
 150         {
 151           const size_t __buf_len = _M_out_end - _M_out_cur;
 152           if (__buf_len)
 153             {
 154               const size_t __remaining = __n - __ret;
 155               const size_t __len = std::min(__buf_len, __remaining);
 156               traits_type::copy(_M_out_cur, __s, __len);
 157               __ret += __len;
 158               __s += __len;
 159               _M_move_out_cur(__len);
 160             }
 161
 162           if (__ret < __n)
 163             {
 164               int_type __c = this->overflow(traits_type::to_int_type(*__s));
 165               if (!traits_type::eq_int_type(__c, traits_type::eof()))
 166                 {
 167                   ++__ret;
 168                   ++__s;
 169                 }
 170               else
 171                 break;
 172             }
 173         }
 174       return __ret;
 175     }
 176
 177   // Conceivably, this could be used to implement buffer-to-buffer
 178   // copies, if this was ever desired in an un-ambiguous way by the
 179   // standard. If so, then checks for __ios being zero would be
 180   // necessary.
 181   template<typename _CharT, typename _Traits>
 182     streamsize
 183     __copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
 184                       basic_streambuf<_CharT, _Traits>* __sbin,
 185                       basic_streambuf<_CharT, _Traits>* __sbout)
 186     {
 187       streamsize __ret = 0;
 188       try
 189         {
 190           typename _Traits::int_type __c = __sbin->sgetc();
 191           while (!_Traits::eq_int_type(__c, _Traits::eof()))
 192             {
 193               const size_t __n = __sbin->_M_in_end - __sbin->_M_in_cur;
 194               if (__n > 1)
 195                 {
 196                   const size_t __wrote = __sbout->sputn(__sbin->_M_in_cur,
 197                                                         __n);
 198                   __sbin->_M_move_in_cur(__wrote);
 199                   __ret += __wrote;
 200                   if (__wrote < __n)
 201                     break;
 202                   __c = __sbin->underflow();
 203                 }
 204               else
 205                 {
 206                   __c = __sbout->sputc(_Traits::to_char_type(__c));
 207                   if (_Traits::eq_int_type(__c, _Traits::eof()))
 208                     break;
 209                   ++__ret;
 210                   __c = __sbin->snextc();
 211                 }
 212             }
 213         }
 214       catch(exception& __fail)
 215         {
 216           __ios.setstate(ios_base::failbit);
 217           if ((__ios.exceptions() & ios_base::failbit) != 0)
 218             __throw_exception_again;
 219         }
 220       return __ret;
 221     }
 222
 223   // Inhibit implicit instantiations for required instantiations,
 224   // which are defined via explicit instantiations elsewhere.
 225   // NB:  This syntax is a GNU extension.
 226 #if _GLIBCPP_EXTERN_TEMPLATE
 227   extern template class basic_streambuf<char>;
 228   extern template
 229     streamsize
 230     __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
 231                       basic_streambuf<char>*);
 232
 233 #ifdef _GLIBCPP_USE_WCHAR_T
 234   extern template class basic_streambuf<wchar_t>;
 235   extern template
 236     streamsize
 237     __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
 238                       basic_streambuf<wchar_t>*);
 239 #endif
 240 #endif
 241 } // namespace std
 242
 243 #endif