home *** CD-ROM | disk | FTP | other *** search
/ Beginning C++ Through Gam…rogramming (2nd Edition) / BCGP2E.ISO / bloodshed / devcpp-4.9.9.2_setup.exe / sstream.tcc < prev    next >
Text File  |  2005-01-29  |  8KB  |  226 lines
  1. // String based streams -*- C++ -*-
  2.  
  3. // Copyright (C) 1997, 1998, 1999, 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.7  String-based streams
  33. //
  34.  
  35. #ifndef _SSTREAM_TCC
  36. #define _SSTREAM_TCC 1
  37.  
  38. #pragma GCC system_header
  39.  
  40. #include <sstream>
  41.  
  42. namespace std
  43. {
  44.   template <class _CharT, class _Traits, class _Alloc>
  45.     typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
  46.     basic_stringbuf<_CharT, _Traits, _Alloc>::
  47.     pbackfail(int_type __c)
  48.     {
  49.       int_type __ret = traits_type::eof();
  50.       const bool __testeof = traits_type::eq_int_type(__c, __ret);
  51.  
  52.       if (this->eback() < this->gptr())
  53.     {
  54.       const bool __testeq = traits_type::eq(traits_type::to_char_type(__c),
  55.                         this->gptr()[-1]);
  56.       this->gbump(-1);
  57.  
  58.       // Try to put back __c into input sequence in one of three ways.
  59.       // Order these tests done in is unspecified by the standard.
  60.       if (!__testeof && __testeq)
  61.         __ret = __c;
  62.       else if (__testeof)
  63.         __ret = traits_type::not_eof(__c);
  64.       else
  65.         {
  66.           *this->gptr() = traits_type::to_char_type(__c);
  67.           __ret = __c;
  68.         }
  69.     }
  70.       return __ret;
  71.     }
  72.  
  73.   template <class _CharT, class _Traits, class _Alloc>
  74.     typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
  75.     basic_stringbuf<_CharT, _Traits, _Alloc>::
  76.     overflow(int_type __c)
  77.     {
  78.       const bool __testout = this->_M_mode & ios_base::out;
  79.       if (__builtin_expect(!__testout, false))
  80.     return traits_type::eof();
  81.  
  82.       const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
  83.       if (__builtin_expect(__testeof, false))
  84.     return traits_type::not_eof(__c);
  85.  
  86.       const __size_type __capacity = _M_string.capacity();
  87.       const __size_type __max_size = _M_string.max_size();
  88.       const bool __testput = this->pptr() < this->epptr();
  89.       if (__builtin_expect(!__testput && __capacity == __max_size, false))
  90.     return traits_type::eof();
  91.  
  92.       // Try to append __c into output sequence in one of two ways.
  93.       // Order these tests done in is unspecified by the standard.
  94.       if (!__testput)
  95.     {
  96.       // NB: Start ostringstream buffers at 512 chars. This is an
  97.       // experimental value (pronounced "arbitrary" in some of the
  98.       // hipper english-speaking countries), and can be changed to
  99.       // suit particular needs.
  100.       // Then, in virtue of DR 169 (TC) we are allowed to grow more
  101.       // than one char.
  102.       const __size_type __opt_len = std::max(__size_type(2 * __capacity),
  103.                          __size_type(512));
  104.       const __size_type __len = std::min(__opt_len, __max_size);
  105.       __string_type __tmp;
  106.       __tmp.reserve(__len);
  107.       __tmp.assign(_M_string.data(), this->epptr() - this->pbase());
  108.       _M_string.swap(__tmp);
  109.       _M_sync(const_cast<char_type*>(_M_string.data()),
  110.           this->gptr() - this->eback(), this->pptr() - this->pbase());
  111.     }
  112.       return this->sputc(traits_type::to_char_type(__c));
  113.     }
  114.  
  115.   template <class _CharT, class _Traits, class _Alloc>
  116.     typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
  117.     basic_stringbuf<_CharT, _Traits, _Alloc>::
  118.     underflow()
  119.     {
  120.       int_type __ret = traits_type::eof();
  121.       const bool __testin = this->_M_mode & ios_base::in;
  122.       if (__testin)
  123.     {
  124.       // Update egptr() to match the actual string end.
  125.       _M_update_egptr();
  126.       if (this->gptr() < this->egptr())
  127.         __ret = traits_type::to_int_type(*this->gptr());
  128.     }
  129.       return __ret;
  130.     }
  131.  
  132.   template <class _CharT, class _Traits, class _Alloc>
  133.     typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
  134.     basic_stringbuf<_CharT, _Traits, _Alloc>::
  135.     seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
  136.     {
  137.       pos_type __ret =  pos_type(off_type(-1));
  138.       bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
  139.       bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
  140.       const bool __testboth = __testin && __testout && __way != ios_base::cur;
  141.       __testin &= !(__mode & ios_base::out);
  142.       __testout &= !(__mode & ios_base::in);
  143.  
  144.       if (_M_string.capacity() && (__testin || __testout || __testboth))
  145.     {
  146.       char_type* __beg = __testin ? this->eback() : this->pbase();
  147.  
  148.       _M_update_egptr();
  149.  
  150.       off_type __newoffi = 0;
  151.       off_type __newoffo = 0;
  152.       if (__way == ios_base::cur)
  153.         {
  154.           __newoffi = this->gptr() - __beg;
  155.           __newoffo = this->pptr() - __beg;
  156.         }
  157.       else if (__way == ios_base::end)
  158.         __newoffo = __newoffi = this->egptr() - __beg;
  159.  
  160.       if ((__testin || __testboth)
  161.           && __newoffi + __off >= 0
  162.           && this->egptr() - __beg >= __newoffi + __off)
  163.         {
  164.           this->gbump((__beg + __newoffi + __off) - this->gptr());
  165.           __ret = pos_type(__newoffi);
  166.         }
  167.       if ((__testout || __testboth)
  168.           && __newoffo + __off >= 0
  169.           && this->egptr() - __beg >= __newoffo + __off)
  170.         {
  171.           this->pbump((__beg + __newoffo + __off) - this->pptr());
  172.           __ret = pos_type(__newoffo);
  173.         }
  174.     }
  175.       return __ret;
  176.     }
  177.  
  178.   template <class _CharT, class _Traits, class _Alloc>
  179.     typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
  180.     basic_stringbuf<_CharT, _Traits, _Alloc>::
  181.     seekpos(pos_type __sp, ios_base::openmode __mode)
  182.     {
  183.       pos_type __ret =  pos_type(off_type(-1));
  184.       if (_M_string.capacity())
  185.     {
  186.       off_type __pos (__sp);
  187.       const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
  188.       const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
  189.       char_type* __beg = __testin ? this->eback() : this->pbase();
  190.  
  191.       _M_update_egptr();
  192.  
  193.       const bool __testpos = 0 <= __pos
  194.                              && __pos <=  this->egptr() - __beg;
  195.       if ((__testin || __testout) && __testpos)
  196.         {
  197.           if (__testin)
  198.         this->gbump((__beg + __pos) - this->gptr());
  199.           if (__testout)
  200.                 this->pbump((__beg + __pos) - this->pptr());
  201.           __ret = pos_type(off_type(__pos));
  202.         }
  203.     }
  204.       return __ret;
  205.     }
  206.  
  207.   // Inhibit implicit instantiations for required instantiations,
  208.   // which are defined via explicit instantiations elsewhere.
  209.   // NB:  This syntax is a GNU extension.
  210. #if _GLIBCXX_EXTERN_TEMPLATE
  211.   extern template class basic_stringbuf<char>;
  212.   extern template class basic_istringstream<char>;
  213.   extern template class basic_ostringstream<char>;
  214.   extern template class basic_stringstream<char>;
  215.  
  216. #ifdef _GLIBCXX_USE_WCHAR_T
  217.   extern template class basic_stringbuf<wchar_t>;
  218.   extern template class basic_istringstream<wchar_t>;
  219.   extern template class basic_ostringstream<wchar_t>;
  220.   extern template class basic_stringstream<wchar_t>;
  221. #endif
  222. #endif
  223. } // namespace std
  224.  
  225. #endif
  226.