1 files changed, 100 insertions, 54 deletions

diff --git a/contrib/libstdc++/include/bits/streambuf_iterator.h b/contrib/libstdc++/include/bits/streambuf_iterator.h
index d482aba825601..970933578c734 100644
--- a/contrib/libstdc++/include/bits/streambuf_iterator.h
+++ b/contrib/libstdc++/include/bits/streambuf_iterator.h
@@ -1,6 +1,6 @@
 // Streambuf iterators
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -33,177 +33,223 @@
  *  You should not attempt to use it directly.
  */
 
-#ifndef _CPP_BITS_STREAMBUF_ITERATOR_H
-#define _CPP_BITS_STREAMBUF_ITERATOR_H 1
+#ifndef _STREAMBUF_ITERATOR_H
+#define _STREAMBUF_ITERATOR_H 1
 
 #pragma GCC system_header
 
 #include <streambuf>
+#include <debug/debug.h>
 
 // NB: Should specialize copy, find algorithms for streambuf iterators.
 
 namespace std
 {
   // 24.5.3 Template class istreambuf_iterator
+  /// Provides input iterator semantics for streambufs.
   template<typename _CharT, typename _Traits>
     class istreambuf_iterator
     : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
-    		      _CharT*, _CharT&>
+		      _CharT*, _CharT&>
     {
     public:
       // Types:
-      typedef _CharT                         		char_type;
-      typedef _Traits                        		traits_type;
-      typedef typename _Traits::int_type     		int_type;
-      typedef basic_streambuf<_CharT, _Traits> 		streambuf_type;
-      typedef basic_istream<_CharT, _Traits>         	istream_type;
+      //@{
+      /// Public typedefs
+      typedef _CharT					char_type;
+      typedef _Traits					traits_type;
+      typedef typename _Traits::int_type		int_type;
+      typedef basic_streambuf<_CharT, _Traits>		streambuf_type;
+      typedef basic_istream<_CharT, _Traits>		istream_type;
+      //@}
 
     private:
-      // 24.5.3 istreambuf_iterator 
-      // p 1 
+      // 24.5.3 istreambuf_iterator
+      // p 1
       // If the end of stream is reached (streambuf_type::sgetc()
       // returns traits_type::eof()), the iterator becomes equal to
       // the "end of stream" iterator value.
       // NB: This implementation assumes the "end of stream" value
       // is EOF, or -1.
-      mutable streambuf_type* 	_M_sbuf;  
-      int_type 			_M_c;
+      mutable streambuf_type*	_M_sbuf;
+      int_type			_M_c;
 
     public:
-      istreambuf_iterator() throw() 
+      ///  Construct end of input stream iterator.
+      istreambuf_iterator() throw()
       : _M_sbuf(0), _M_c(traits_type::eof()) { }
-      
+
+      ///  Construct start of input stream iterator.
       istreambuf_iterator(istream_type& __s) throw()
       : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
 
+      ///  Construct start of streambuf iterator.
       istreambuf_iterator(streambuf_type* __s) throw()
       : _M_sbuf(__s), _M_c(traits_type::eof()) { }
-       
-      // NB: The result of operator*() on an end of stream is undefined.
-      char_type 
+
+      ///  Return the current character pointed to by iterator.  This returns
+      ///  streambuf.sgetc().  It cannot be assigned.  NB: The result of
+      ///  operator*() on an end of stream is undefined.
+      char_type
       operator*() const
-      { return traits_type::to_char_type(_M_get()); }
-	
-      istreambuf_iterator& 
+      {
+#ifdef _GLIBCXX_DEBUG_PEDANTIC
+	// Dereferencing a past-the-end istreambuf_iterator is a
+	// libstdc++ extension
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_deref_istreambuf)
+				._M_iterator(*this));
+#endif
+	return traits_type::to_char_type(_M_get());
+      }
+
+      /// Advance the iterator.  Calls streambuf.sbumpc().
+      istreambuf_iterator&
       operator++()
-      { 
+      {
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_inc_istreambuf)
+				._M_iterator(*this));
 	const int_type __eof = traits_type::eof();
 	if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
 	  _M_sbuf = 0;
 	else
 	  _M_c = __eof;
-	return *this; 
+	return *this;
       }
 
+      /// Advance the iterator.  Calls streambuf.sbumpc().
       istreambuf_iterator
       operator++(int)
       {
+	__glibcxx_requires_cond(!_M_at_eof(),
+				_M_message(__gnu_debug::__msg_inc_istreambuf)
+				._M_iterator(*this));
+
 	const int_type __eof = traits_type::eof();
 	istreambuf_iterator __old = *this;
 	if (_M_sbuf
-	    && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()), 
+	    && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
 					__eof))
 	  _M_sbuf = 0;
 	else
 	  _M_c = __eof;
-	return __old; 
+	return __old;
       }
 
-#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
+      // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 110 istreambuf_iterator::equal not const
       // NB: there is also number 111 (NAD, Future) pending on this function.
-      bool 
+      /// Return true both iterators are end or both are not end.
+      bool
       equal(const istreambuf_iterator& __b) const
       {
-	const int_type __eof = traits_type::eof();
-	bool __thiseof = traits_type::eq_int_type(_M_get(), __eof);
-	bool __beof = traits_type::eq_int_type(__b._M_get(), __eof);
+	const bool __thiseof = _M_at_eof();
+	const bool __beof = __b._M_at_eof();
 	return (__thiseof && __beof || (!__thiseof && !__beof));
       }
-#endif
 
     private:
-      int_type 
+      int_type
       _M_get() const
-      { 
+      {
 	const int_type __eof = traits_type::eof();
 	int_type __ret = __eof;
 	if (_M_sbuf)
-	  { 
+	  {
 	    if (!traits_type::eq_int_type(_M_c, __eof))
 	      __ret = _M_c;
-	    else 
-	      if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), __eof))
-		_M_sbuf = 0;
+	    else if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
+					      __eof))
+	      _M_sbuf = 0;
 	  }
 	return __ret;
       }
+
+      bool
+      _M_at_eof() const
+      {
+	const int_type __eof = traits_type::eof();
+	return traits_type::eq_int_type(_M_get(), __eof);
+      }
     };
 
   template<typename _CharT, typename _Traits>
-    inline bool 
+    inline bool
     operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
 	       const istreambuf_iterator<_CharT, _Traits>& __b)
     { return __a.equal(__b); }
 
   template<typename _CharT, typename _Traits>
-    inline bool 
+    inline bool
     operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
 	       const istreambuf_iterator<_CharT, _Traits>& __b)
     { return !__a.equal(__b); }
 
+  /// Provides output iterator semantics for streambufs.
   template<typename _CharT, typename _Traits>
     class ostreambuf_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
     {
     public:
       // Types:
+      //@{
+      /// Public typedefs
       typedef _CharT                           char_type;
       typedef _Traits                          traits_type;
       typedef basic_streambuf<_CharT, _Traits> streambuf_type;
       typedef basic_ostream<_CharT, _Traits>   ostream_type;
+      //@}
 
     private:
-      streambuf_type* 	_M_sbuf;
-      bool 		_M_failed;
+      streambuf_type*	_M_sbuf;
+      bool		_M_failed;
 
     public:
+      ///  Construct output iterator from ostream.
       ostreambuf_iterator(ostream_type& __s) throw ()
       : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
-      
+
+      ///  Construct output iterator from streambuf.
       ostreambuf_iterator(streambuf_type* __s) throw ()
       : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
 
-      ostreambuf_iterator& 
+      ///  Write character to streambuf.  Calls streambuf.sputc().
+      ostreambuf_iterator&
       operator=(_CharT __c)
       {
-	if (!_M_failed && 
+	if (!_M_failed &&
 	    _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
 	  _M_failed = true;
 	return *this;
       }
 
-      ostreambuf_iterator& 
-      operator*() throw()
+      /// Return *this.
+      ostreambuf_iterator&
+      operator*()
       { return *this; }
 
-      ostreambuf_iterator& 
-      operator++(int) throw()
+      /// Return *this.
+      ostreambuf_iterator&
+      operator++(int)
       { return *this; }
 
-      ostreambuf_iterator& 
-      operator++() throw()
+      /// Return *this.
+      ostreambuf_iterator&
+      operator++()
       { return *this; }
 
-      bool 
+      /// Return true if previous operator=() failed.
+      bool
       failed() const throw()
       { return _M_failed; }
 
-      ostreambuf_iterator& 
+      ostreambuf_iterator&
       _M_put(const _CharT* __ws, streamsize __len)
       {
-	if (__builtin_expect(!_M_failed, true) && 
-	    __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false))
+	if (__builtin_expect(!_M_failed, true)
+	    && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+				false))
 	  _M_failed = true;
 	return *this;
       }