X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=libstdc%2B%2B-v3%2Finclude%2Fbits%2Fstreambuf.tcc;h=554d06178997e1a0fb1cf29c2784041a7a2de63b;hb=86a940c6087fcf3e23586a30dc4e8354dce6a1d0;hp=d03b7bca104ee88ba6d51ce9921d6e37524b67dd;hpb=1d487acac02f71846ad17cadad3e4cb1cca9f799;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/libstdc++-v3/include/bits/streambuf.tcc b/libstdc++-v3/include/bits/streambuf.tcc
index d03b7bca104..554d0617899 100644
--- a/libstdc++-v3/include/bits/streambuf.tcc
+++ b/libstdc++-v3/include/bits/streambuf.tcc
@@ -1,6 +1,7 @@
 // Stream buffer classes -*- C++ -*-
 
-// Copyright (C) 1997-1999, 2000 Free Software Foundation, Inc.
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+// Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
 // software; you can redistribute it and/or modify it under the
@@ -31,231 +32,132 @@
 // ISO C++ 14882: 27.5  Stream buffers
 //
 
-#ifndef _CPP_BITS_STREAMBUF_TCC
-#define _CPP_BITS_STREAMBUF_TCC 1
+#ifndef _STREAMBUF_TCC
+#define _STREAMBUF_TCC 1
 
-namespace std {
-
-  template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>::int_type
-    basic_streambuf<_CharT, _Traits>::
-    sbumpc()
-    {
-      int_type __ret;
-      if (_M_in_cur && _M_in_cur < _M_in_end)
-	{
-	  char_type __c = *gptr();
-	  ++_M_in_cur;
-	  if (_M_buf_unified &&  _M_mode & ios_base::out)
-	    ++_M_out_cur;
-	  __ret = traits_type::to_int_type(__c);
-	}
-      else 
-	__ret = this->uflow();
-      return __ret;
-    }
-
-  template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>::int_type
-    basic_streambuf<_CharT, _Traits>::
-    sputbackc(char_type __c) 
-    {
-      int_type __ret;
-      bool __testpos = _M_in_cur && _M_in_beg < _M_in_cur;
-      bool __testne = _M_in_cur && !traits_type::eq(__c, this->gptr()[-1]);
-      if (!__testpos || __testne)
-	__ret = pbackfail(traits_type::to_int_type(__c));
-      else 
-	{
-	  --_M_in_cur;
-	  if (_M_buf_unified && _M_mode & ios_base::out)
-	    --_M_out_cur;
-	  __ret = traits_type::to_int_type(*this->gptr());
-	}
-      return __ret;
-    }
-  
-  template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>::int_type
-    basic_streambuf<_CharT, _Traits>::
-    sungetc()
-    {
-      int_type __ret;
-      if (_M_in_cur && _M_in_beg < _M_in_cur)
-	{
-	  --_M_in_cur;
-	  if (_M_buf_unified && _M_mode & ios_base::out)
-	    --_M_out_cur;
-	  __ret = traits_type::to_int_type(*_M_in_cur);
-	}
-      else 
-	__ret = this->pbackfail();
-      return __ret;
-    }
-
-  // Don't test against _M_buf + _M_buf_size, because _M_buf reflects
-  // allocated space, and on certain (rare but entirely legal)
-  // situations, there will be no allocated space yet the internal
-  // buffers will still be valid. (This happens if setp is used to set
-  // the internal buffer to say some externally-allocated sequence.)
-  template<typename _CharT, typename _Traits>
-    basic_streambuf<_CharT, _Traits>::int_type
-    basic_streambuf<_CharT, _Traits>::
-    sputc(char_type __c)
-    {
-      int_type __ret;
-
-      if (_M_out_cur && _M_out_cur < _M_out_beg + _M_buf_size)
-	{
-	  *_M_out_cur = __c;
-	  _M_out_cur_move(1);
-	  __ret = traits_type::to_int_type(__c);
-	}
-      else
-	__ret = this->overflow(traits_type::to_int_type(__c));
-      return __ret;
-    }
+#pragma GCC system_header
 
+namespace std
+{
   template<typename _CharT, typename _Traits>
     streamsize
     basic_streambuf<_CharT, _Traits>::
     xsgetn(char_type* __s, streamsize __n)
     {
-      bool __testout = _M_mode & ios_base::out;
       streamsize __ret = 0;
-
-      if (__n)
+      while (__ret < __n)
 	{
-	  while (__ret < __n)
+	  const size_t __buf_len = this->egptr() - this->gptr();
+	  if (__buf_len)
 	    {
-	      if (_M_in_cur < _M_in_end)
-		{
-		  size_t __len;
-		  if (_M_in_cur + __n - __ret <= _M_in_end)
-		    __len = __n - __ret;
-		  else
-		    __len = _M_in_end - _M_in_cur;
-		  traits_type::copy(__s, _M_in_cur, __len);
-		  __ret += __len;
-		  __s += __len;
-		  _M_in_cur += __len;
-		  if (_M_buf_unified && __testout)
-		    _M_out_cur += __len;
-		}
-	      
-	      if (__ret != __n)
-		{
-		  int_type __c = this->uflow();  
-		  if (traits_type::eq_int_type(__c, traits_type::eof()))
-                    break;
+	      const size_t __remaining = __n - __ret;
+	      const size_t __len = std::min(__buf_len, __remaining);
+	      traits_type::copy(__s, this->gptr(), __len);
+	      __ret += __len;
+	      __s += __len;
+	      this->gbump(__len);
+	    }
 
+	  if (__ret < __n)
+	    {
+	      const int_type __c = this->uflow();
+	      if (!traits_type::eq_int_type(__c, traits_type::eof()))
+		{
 		  traits_type::assign(*__s++, traits_type::to_char_type(__c));
-                  ++__ret;
+		  ++__ret;
 		}
+	      else
+		break;
 	    }
 	}
       return __ret;
     }
 
-  // Don't test against _M_buf + _M_buf_size, because _M_buf reflects
-  // allocated space, and on certain (rare but entirely legal)
-  // situations, there will be no allocated space yet the internal
-  // buffers will still be valid. (This happens if setp is used to set
-  // the internal buffer to say some externally-allocated sequence.)
   template<typename _CharT, typename _Traits>
     streamsize
     basic_streambuf<_CharT, _Traits>::
     xsputn(const char_type* __s, streamsize __n)
     {
       streamsize __ret = 0;
-
-      if (__n)
+      while (__ret < __n)
 	{
-	  while (__ret < __n)
+	  const size_t __buf_len = this->epptr() - this->pptr();
+	  if (__buf_len)
 	    {
-	      bool __testput = _M_out_cur < _M_out_beg + _M_buf_size;
-	      bool __testout = _M_mode & ios_base::out;
-	      if (!(__testput && __testout))
-		{
-		  int_type __c = traits_type::to_int_type(*__s);
-		  int_type __overfc = this->overflow(__c);
-		  if (traits_type::eq_int_type(__c, __overfc))
-		    {
-		      ++__ret;
-		      ++__s;
-		    }
-		  else
-		    break;
-		}
-	      
-	      if (__ret != __n)
+	      const size_t __remaining = __n - __ret;
+	      const size_t __len = std::min(__buf_len, __remaining);
+	      traits_type::copy(this->pptr(), __s, __len);
+	      __ret += __len;
+	      __s += __len;
+	      this->pbump(__len);
+	    }
+
+	  if (__ret < __n)
+	    {
+	      int_type __c = this->overflow(traits_type::to_int_type(*__s));
+	      if (!traits_type::eq_int_type(__c, traits_type::eof()))
 		{
-		  size_t __len;
-		  if (_M_out_cur + __n - __ret <= _M_out_beg + _M_buf_size)
-		    __len = __n - __ret;
-		  else
-		    __len = _M_out_beg + _M_buf_size - _M_out_cur;
-		  traits_type::copy(_M_out_cur, __s, __len);
-		  __ret += __len;
-		  __s += __len;
-		  _M_out_cur_move(__len);
+		  ++__ret;
+		  ++__s;
 		}
+	      else
+		break;
 	    }
 	}
       return __ret;
     }
 
-
   // Conceivably, this could be used to implement buffer-to-buffer
   // copies, if this was ever desired in an un-ambiguous way by the
   // standard. If so, then checks for __ios being zero would be
   // necessary.
   template<typename _CharT, typename _Traits>
     streamsize
-    _S_copy_streambufs(basic_ios<_CharT, _Traits>& __ios,
-		       basic_streambuf<_CharT, _Traits>* __sbin,
-		       basic_streambuf<_CharT, _Traits>* __sbout) 
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+		      basic_streambuf<_CharT, _Traits>* __sbout)
     {
-      typedef typename _Traits::int_type	int_type;
-
       streamsize __ret = 0;
-      streamsize __bufsize = __sbin->in_avail();
-      streamsize __xtrct;
-      bool __testout = __sbin->_M_mode & ios_base::out;
-      bool __testput = __sbout->_M_mode & ios_base::out;
-      try {
-	while (__testput && __bufsize != -1)
-	  {
-	    __xtrct = __sbout->sputn(__sbin->gptr(), __bufsize);
-	    __ret += __xtrct;
-	    __sbin->_M_in_cur += __xtrct;
-	    if (__testout && __sbin->_M_buf_unified)
-	      __sbin->_M_out_cur += __xtrct;
-	    if (__xtrct == __bufsize)
-	      {
-		int_type __c = __sbin->sgetc();
-		if (__c == _Traits::eof())
-		  {
-		    __ios.setstate(ios_base::eofbit);
-		    break;
-		  }
-		__bufsize = __sbin->in_avail();
-	      }
-	    else
-	      break;
-	  }
-      }
-      catch(exception& __fail) {
-	if ((__ios.exceptions() & ios_base::failbit) != 0)
-	  throw;
-      }
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+	{
+	  const size_t __n = __sbin->egptr() - __sbin->gptr();
+	  if (__n > 1)
+	    {
+	      const size_t __wrote = __sbout->sputn(__sbin->gptr(), __n);
+	      __sbin->gbump(__wrote);
+	      __ret += __wrote;
+	      if (__wrote < __n)
+		break;
+	      __c = __sbin->underflow();
+	    }
+	  else
+	    {
+	      __c = __sbout->sputc(_Traits::to_char_type(__c));
+	      if (_Traits::eq_int_type(__c, _Traits::eof()))
+		break;
+	      ++__ret;
+	      __c = __sbin->snextc();
+	    }
+	}
       return __ret;
     }
 
-} // namespace std
-
-#endif // _CPP_BITS_STREAMBUF_TCC
-
-
+  // Inhibit implicit instantiations for required instantiations,
+  // which are defined via explicit instantiations elsewhere.
+  // NB:  This syntax is a GNU extension.
+#if _GLIBCXX_EXTERN_TEMPLATE
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*, basic_streambuf<char>*);
 
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*);
+#endif
+#endif
+} // namespace std
 
+#endif