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