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 > 0)
 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 > 0)
 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               const 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       typedef typename _Traits::int_type        int_type;
 188
 189       streamsize __ret = 0;
 190       try
 191         {
 192           for (;;)
 193             {
 194               streamsize __xtrct;
 195               const size_t __avail = __sbin->_M_in_end
 196                                      - __sbin->_M_in_cur;
 197               if (__avail)
 198                 {
 199                   __xtrct = __sbout->sputn(__sbin->_M_in_cur, __avail);
 200                   __ret += __xtrct;
 201                   __sbin->_M_move_in_cur(__xtrct);
 202                   if (__xtrct != __avail)
 203                     break;
 204                 }
 205               else
 206                 {
 207                   streamsize __charsread;
 208                   const size_t __size = __sbout->_M_out_end
 209                                         - __sbout->_M_out_cur;
 210                   if (__size)
 211                     {
 212                       _CharT* __buf =
 213                         static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
 214                                                               * __size));
 215                       // Since the next sputn cannot fail sgetn can be
 216                       // safely used.
 217                       __charsread = __sbin->sgetn(__buf, __size);
 218                       __xtrct = __sbout->sputn(__buf, __charsread);
 219                     }
 220                   else
 221                     {
 222                       __xtrct = __charsread = 0;
 223                       const int_type __c = __sbin->sgetc();
 224                       if (!_Traits::eq_int_type(__c, _Traits::eof()))
 225                         {
 226                           ++__charsread;
 227                           if (_Traits::eq_int_type(__sbout->overflow(__c),
 228                                                    _Traits::eof()))
 229                             break;
 230                           ++__xtrct;
 231                           __sbin->sbumpc();
 232                         }
 233                     }
 234                   __ret += __xtrct;
 235                   if (__xtrct != __charsread)
 236                     break;
 237                 }
 238               if (_Traits::eq_int_type(__sbin->sgetc(), _Traits::eof()))
 239                 break;
 240             }
 241         }
 242       catch(exception& __fail)
 243         {
 244           __ios.setstate(ios_base::failbit);
 245           if ((__ios.exceptions() & ios_base::failbit) != 0)
 246             __throw_exception_again;
 247         }
 248       return __ret;
 249     }
 250
 251   // Inhibit implicit instantiations for required instantiations,
 252   // which are defined via explicit instantiations elsewhere.
 253   // NB:  This syntax is a GNU extension.
 254 #if _GLIBCPP_EXTERN_TEMPLATE
 255   extern template class basic_streambuf<char>;
 256   extern template
 257     streamsize
 258     __copy_streambufs(basic_ios<char>&, basic_streambuf<char>*,
 259                       basic_streambuf<char>*);
 260
 261 #ifdef _GLIBCPP_USE_WCHAR_T
 262   extern template class basic_streambuf<wchar_t>;
 263   extern template
 264     streamsize
 265     __copy_streambufs(basic_ios<wchar_t>&, basic_streambuf<wchar_t>*,
 266                       basic_streambuf<wchar_t>*);
 267 #endif
 268 #endif
 269 } // namespace std
 270
 271 #endif