c++config (_GLIBCXX_STD): New.

2004-04-16  Benjamin Kosnik  <bkoz@redhat.com>

	* include/bits/c++config (_GLIBCXX_STD): New.
	* src/list.cc: Use it.
	* include/std/std_bitset.h: Same.
	* include/bits/vector.tcc: Same.
	* include/bits/stl_set.h: Same.
	* include/bits/stl_multiset.h: Same.
	* include/bits/stl_multimap.h: Same.
	* include/bits/stl_map.h: Same.
	* include/bits/stl_list.h: Same.
	* include/bits/stl_vector.h: Same.
	* include/bits/stl_bvector.h: Same.
	* include/bits/stl_deque.h: Same.
	* include/bits/deque.tcc: Same.
	* include/bits/list.tcc: Same.
	* include/debug/vector: Same.
	* include/debug/set.h: Same.
	* include/debug/multiset.h: Same.
	* include/debug/multimap.h: Same.
	* include/debug/map.h: Same.
	* include/debug/list: Same.
	* include/debug/deque: Same.
	* include/debug/bitset: Same.
	* include/debug/formatter.h (__gnu_debug): Remove using directive.
	Add using declaration for std::type_info.
	* include/debug/safe_iterator.h: Add using declaration for
	std::iterator_traits and std::pair.
	* src/debug_list.cc: New.
	* src/Makefile.am: Add debug_list.cc.
	* src/Makefile.in: Regenerate.
	* config/linker-map.gnu: Add _List_node_base exports for std and
	__gnu_norm.

	* include/bits/stl_bvector.h (_Bvector_base): Use _Bvector_impl
	idiom that other containers use.
	* testsuite/23_containers/vector/bool/clear_allocator.cc: New.

From-SVN: r80763

libstdc++-v3/ChangeLog

+2004-04-16  Benjamin Kosnik  <bkoz@redhat.com>
+	
+	* include/bits/c++config (_GLIBCXX_STD): New.
+	* src/list.cc: Use it.
+	* include/std/std_bitset.h: Same.
+	* include/bits/vector.tcc: Same.
+	* include/bits/stl_set.h: Same.
+	* include/bits/stl_multiset.h: Same.
+	* include/bits/stl_multimap.h: Same.
+	* include/bits/stl_map.h: Same.
+	* include/bits/stl_list.h: Same.
+	* include/bits/stl_vector.h: Same.
+	* include/bits/stl_bvector.h: Same.
+	* include/bits/stl_deque.h: Same.
+	* include/bits/deque.tcc: Same.
+	* include/bits/list.tcc: Same.
+	* include/debug/vector: Same.
+	* include/debug/set.h: Same.
+	* include/debug/multiset.h: Same.
+	* include/debug/multimap.h: Same.
+	* include/debug/map.h: Same.
+	* include/debug/list: Same.
+	* include/debug/deque: Same.
+	* include/debug/bitset: Same.	
+	* include/debug/formatter.h (__gnu_debug): Remove using directive.
+	Add using declaration for std::type_info.
+	* include/debug/safe_iterator.h: Add using declaration for
+	std::iterator_traits and std::pair.
+	* src/debug_list.cc: New.
+	* src/Makefile.am: Add debug_list.cc.
+	* src/Makefile.in: Regenerate.
+	* config/linker-map.gnu: Add _List_node_base exports for std and
+	__gnu_norm.
+
+	* include/bits/stl_bvector.h (_Bvector_base): Use _Bvector_impl
+	idiom that other containers use.
+	* testsuite/23_containers/vector/bool/clear_allocator.cc: New.
+			
 2004-04-16  Paolo Carlini  <pcarlini@suse.de>
 
 	PR libstdc++/14975

libstdc++-v3/Makefile.in

@@ -44,7 +44,7 @@ DIST_COMMON = README $(am__configure_deps) $(srcdir)/../config.guess \
 	$(top_srcdir)/configure $(top_srcdir)/fragment.am \
 	$(top_srcdir)/scripts/check_survey.in \
 	$(top_srcdir)/scripts/testsuite_flags.in ../ABOUT-NLS \
-	../COPYING ../COPYING.LIB ../ChangeLog ../README \
+	../COPYING ../COPYING.LIB ../ChangeLog ../README ../compile \
 	../config.guess ../config.rpath ../config.sub ../install-sh \
 	../ltcf-c.sh ../ltcf-cxx.sh ../ltcf-gcj.sh ../ltconfig \
 	../ltmain.sh ../missing ../mkinstalldirs ../ylwrap ChangeLog \

libstdc++-v3/config/linker-map.gnu

@@ -55,6 +55,11 @@ GLIBCXX_3.4 {
       std::locale::_S_normalize_category*;
       std::locale::_[T-Za-z]*;
       std::[A-Zm-z]*;
+      std::_List_node_base::hook*;
+      std::_List_node_base::swap*;
+      std::_List_node_base::unhook*;
+      std::_List_node_base::reverse*;
+      std::_List_node_base::transfer*;
       std::__throw_*;
       std::__basic_file*;
       std::__timepunct*;
@@ -66,10 +71,14 @@ GLIBCXX_3.4 {
       std::__moneypunct_cache*;
       std::__numpunct_cache*;
       std::__timepunct_cache*;
-      __gnu_norm::*;
       __gnu_debug::_Safe_iterator_base*;
       __gnu_debug::_Safe_sequence_base*;
-      __gnu_debug::_Error_formatter*
+      __gnu_debug::_Error_formatter*;
+      __gnu_norm::_List_node_base::hook*;
+      __gnu_norm::_List_node_base::swap*;
+      __gnu_norm::_List_node_base::unhook*;
+      __gnu_norm::_List_node_base::reverse*;
+      __gnu_norm::_List_node_base::transfer*
     };
 
     # Names not in an 'extern' block are mangled names.

libstdc++-v3/include/bits/c++config

 // Predefined symbols and macros -*- C++ -*-
 
-// 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
@@ -51,27 +51,30 @@
 # define _GLIBCXX_EXTERN_TEMPLATE 1
 #endif
 
-// To enable debug mode.
-namespace __gnu_norm 
-{ 
-  using namespace std; 
-}
-
+// Debug mode support. Debug mode basic_string is not allowed to be
+// associated with std, because of locale and exception link
+// dependence.
 namespace __gnu_debug_def { }
 
 namespace __gnu_debug 
 { 
-  using namespace __gnu_debug_def __attribute__ ((strong));
+  using namespace __gnu_debug_def;
 }
 
+#ifdef _GLIBCXX_DEBUG
+# define _GLIBCXX_STD __gnu_norm
+namespace __gnu_norm 
+{ 
+  using namespace std; 
+}
 namespace std
 {
-#ifdef _GLIBCXX_DEBUG
   using namespace __gnu_debug_def __attribute__ ((strong));
+}
 #else
-  using namespace __gnu_norm __attribute__ ((strong));
+# define _GLIBCXX_STD std
 #endif
-}
+
 
 // The remainder of the prewritten config is automatic; all the
 // user hooks are listed above.

libstdc++-v3/include/bits/deque.tcc

@@ -61,7 +61,7 @@
 #ifndef _DEQUE_TCC
 #define _DEQUE_TCC 1
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   template <typename _Tp, typename _Alloc>
     deque<_Tp,_Alloc>&
@@ -714,6 +714,6 @@ namespace __gnu_norm
       this->_M_impl._M_start._M_set_node(__new_nstart);
       this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
     }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif

libstdc++-v3/include/bits/list.tcc

@@ -61,7 +61,7 @@
 #ifndef _LIST_TCC
 #define _LIST_TCC 1
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   template<typename _Tp, typename _Alloc>
     void
@@ -371,7 +371,7 @@ namespace __gnu_norm
 	    swap( *(__fill-1) );
 	  }
       }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _LIST_TCC */
 

libstdc++-v3/include/bits/stl_bvector.h

-// bit_vector and vector<bool> specialization -*- C++ -*-
+// vector<bool> specialization -*- C++ -*-
 
 // Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
 //
@@ -61,7 +61,7 @@
 #ifndef _BVECTOR_H
 #define _BVECTOR_H 1
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   typedef unsigned long _Bit_type;
   enum { _S_word_bit = int(CHAR_BIT * sizeof(_Bit_type)) };
@@ -322,7 +322,8 @@ namespace __gnu_norm
       return *this;
     }
 
-    const_iterator operator+(difference_type __i) const {
+    const_iterator 
+    operator+(difference_type __i) const {
       const_iterator __tmp = *this;
       return __tmp += __i;
     }
@@ -345,47 +346,52 @@ namespace __gnu_norm
 
   template<class _Alloc>
     class _Bvector_base
-    : public _Alloc::template rebind<_Bit_type>::other
     {
       typedef typename _Alloc::template rebind<_Bit_type>::other
         _Bit_alloc_type;
+      
+      struct _Bvector_impl : public _Bit_alloc_type
+      {
+	_Bit_iterator 	_M_start;
+	_Bit_iterator 	_M_finish;
+	_Bit_type* 	_M_end_of_storage;
+	_Bvector_impl(const _Bit_alloc_type& __a)
+	: _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
+	{ }
+      };
 
     public:
       typedef _Alloc allocator_type;
 
       allocator_type
       get_allocator() const
-      { return *static_cast<const _Bit_alloc_type*>(this); }
+      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
 
-      _Bvector_base(const allocator_type& __a)
-      : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0) { }
+      _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }
 
       ~_Bvector_base() { this->_M_deallocate(); }
 
     protected:
+      _Bvector_impl _M_impl;
+
       _Bit_type*
-      _M_bit_alloc(size_t __n)
-      { return _Bit_alloc_type::allocate((__n + _S_word_bit - 1)
-					 / _S_word_bit); }
+      _M_allocate(size_t __n)
+      { return _M_impl.allocate((__n + _S_word_bit - 1) / _S_word_bit); }
 
       void
       _M_deallocate()
       {
-	if (_M_start._M_p)
-	  _Bit_alloc_type::deallocate(_M_start._M_p,
-				      _M_end_of_storage - _M_start._M_p);
+	if (_M_impl._M_start._M_p)
+	  _M_impl.deallocate(_M_impl._M_start._M_p,
+			    _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
       }
-
-      _Bit_iterator _M_start;
-      _Bit_iterator _M_finish;
-      _Bit_type* _M_end_of_storage;
     };
-} // namespace __gnu_norm
+} // namespace std
 
 // Declare a partial specialization of vector<T, Alloc>.
 #include <bits/stl_vector.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   /**
    *  @brief  A specialization of vector for booleans which offers fixed time
@@ -429,41 +435,40 @@ template<typename _Alloc>
     { return _Bvector_base<_Alloc>::get_allocator(); }
 
   protected:
-    using _Bvector_base<_Alloc>::_M_bit_alloc;
+    using _Bvector_base<_Alloc>::_M_allocate;
     using _Bvector_base<_Alloc>::_M_deallocate;
-    using _Bvector_base<_Alloc>::_M_start;
-    using _Bvector_base<_Alloc>::_M_finish;
-    using _Bvector_base<_Alloc>::_M_end_of_storage;
 
   protected:
     void _M_initialize(size_type __n)
     {
-      _Bit_type* __q = this->_M_bit_alloc(__n);
-      this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
-      this->_M_start = iterator(__q, 0);
-      this->_M_finish = this->_M_start + difference_type(__n);
+      _Bit_type* __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = __q 
+	                               + (__n + _S_word_bit - 1) / _S_word_bit;
+      this->_M_impl._M_start = iterator(__q, 0);
+      this->_M_impl._M_finish = this->_M_start + difference_type(__n);
     }
 
     void _M_insert_aux(iterator __position, bool __x)
     {
-      if (this->_M_finish._M_p != this->_M_end_of_storage)
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
 	{
-	  std::copy_backward(__position, this->_M_finish, this->_M_finish + 1);
+	  std::copy_backward(__position, this->_M_impl._M_finish, 
+			     this->_M_impl._M_finish + 1);
 	  *__position = __x;
-	  ++this->_M_finish;
+	  ++this->_M_impl._M_finish;
 	}
       else
 	{
 	  const size_type __len = size() ? 2 * size()
 	                                 : static_cast<size_type>(_S_word_bit);
-	  _Bit_type * __q = this->_M_bit_alloc(__len);
+	  _Bit_type * __q = this->_M_allocate(__len);
 	  iterator __i = std::copy(begin(), __position, iterator(__q, 0));
 	  *__i++ = __x;
-	  this->_M_finish = std::copy(__position, end(), __i);
+	  this->_M_impl._M_finish = std::copy(__position, end(), __i);
 	  this->_M_deallocate();
-	  this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
+	  this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
 				    / _S_word_bit;
-	  this->_M_start = iterator(__q, 0);
+	  this->_M_impl._M_start = iterator(__q, 0);
 	}
     }
 
@@ -471,9 +476,9 @@ template<typename _Alloc>
     void _M_initialize_range(_InputIterator __first, _InputIterator __last,
                              input_iterator_tag)
     {
-      this->_M_start = iterator();
-      this->_M_finish = iterator();
-      this->_M_end_of_storage = 0;
+      this->_M_impl._M_start = iterator();
+      this->_M_impl._M_finish = iterator();
+      this->_M_impl._M_end_of_storage = 0;
       for ( ; __first != __last; ++__first)
         push_back(*__first);
     }
@@ -484,13 +489,12 @@ template<typename _Alloc>
     {
       const size_type __n = std::distance(__first, __last);
       _M_initialize(__n);
-      std::copy(__first, __last, this->_M_start);
+      std::copy(__first, __last, this->_M_impl._M_start);
     }
 
     template<class _InputIterator>
-    void _M_insert_range(iterator __pos,
-                         _InputIterator __first, _InputIterator __last,
-                         input_iterator_tag)
+    void _M_insert_range(iterator __pos, _InputIterator __first, 
+			 _InputIterator __last, input_iterator_tag)
     {
       for ( ; __first != __last; ++__first)
 	{
@@ -500,9 +504,8 @@ template<typename _Alloc>
     }
 
     template<class _ForwardIterator>
-    void _M_insert_range(iterator __position,
-                         _ForwardIterator __first, _ForwardIterator __last,
-                         forward_iterator_tag)
+    void _M_insert_range(iterator __position, _ForwardIterator __first, 
+			 _ForwardIterator __last, forward_iterator_tag)
     {
       if (__first != __last)
 	{
@@ -510,37 +513,37 @@ template<typename _Alloc>
 	  if (capacity() - size() >= __n)
 	    {
 	      std::copy_backward(__position, end(),
-				 this->_M_finish + difference_type(__n));
+			       this->_M_impl._M_finish + difference_type(__n));
 	      std::copy(__first, __last, __position);
-	      this->_M_finish += difference_type(__n);
+	      this->_M_impl._M_finish += difference_type(__n);
 	    }
 	  else
 	    {
 	      const size_type __len = size() + std::max(size(), __n);
-	      _Bit_type * __q = this->_M_bit_alloc(__len);
+	      _Bit_type * __q = this->_M_allocate(__len);
 	      iterator __i = std::copy(begin(), __position, iterator(__q, 0));
 	      __i = std::copy(__first, __last, __i);
-	      this->_M_finish = std::copy(__position, end(), __i);
+	      this->_M_impl._M_finish = std::copy(__position, end(), __i);
 	      this->_M_deallocate();
-	      this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
-		                        / _S_word_bit;
-	      this->_M_start = iterator(__q, 0);
+	      this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
+		                                / _S_word_bit;
+	      this->_M_impl._M_start = iterator(__q, 0);
 	    }
 	}
     }
 
   public:
     iterator begin()
-    { return this->_M_start; }
+    { return this->_M_impl._M_start; }
 
     const_iterator begin() const
-    { return this->_M_start; }
+    { return this->_M_impl._M_start; }
 
     iterator end()
-    { return this->_M_finish; }
+    { return this->_M_impl._M_finish; }
 
     const_iterator end() const
-    { return this->_M_finish; }
+    { return this->_M_impl._M_finish; }
 
     reverse_iterator rbegin()
     { return reverse_iterator(end()); }
@@ -561,7 +564,7 @@ template<typename _Alloc>
     { return size_type(-1); }
 
     size_type capacity() const
-    { return size_type(const_iterator(this->_M_end_of_storage, 0)
+    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
 		       - begin()); }
     bool empty() const
     { return begin() == end(); }
@@ -587,45 +590,49 @@ template<typename _Alloc>
     explicit vector(const allocator_type& __a = allocator_type())
       : _Bvector_base<_Alloc>(__a) { }
 
-    vector(size_type __n, bool __value,
+    vector(size_type __n, bool __value, 
 	   const allocator_type& __a = allocator_type())
-      : _Bvector_base<_Alloc>(__a)
+    : _Bvector_base<_Alloc>(__a)
     {
       _M_initialize(__n);
-      std::fill(this->_M_start._M_p, this->_M_end_of_storage, __value ? ~0 : 0);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, 
+		__value ? ~0 : 0);
     }
 
     explicit vector(size_type __n)
-      : _Bvector_base<_Alloc>(allocator_type())
+    : _Bvector_base<_Alloc>(allocator_type())
     {
       _M_initialize(__n);
-      std::fill(this->_M_start._M_p, this->_M_end_of_storage, 0);
+      std::fill(this->_M_impl._M_start._M_p, 
+		this->_M_impl._M_end_of_storage, 0);
     }
 
     vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
     {
       _M_initialize(__x.size());
-      std::copy(__x.begin(), __x.end(), this->_M_start);
+      std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
     }
 
     // Check whether it's an integral type.  If so, it's not an iterator.
-
     template<class _Integer>
     void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
     {
       _M_initialize(__n);
-      std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+      std::fill(this->_M_impl._M_start._M_p, 
+		this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
     }
 
     template<class _InputIterator>
-    void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
-                                __false_type)
-    { _M_initialize_range(__first, __last, std::__iterator_category(__first)); }
+      void 
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+			     __false_type)
+      { _M_initialize_range(__first, __last, 
+			    std::__iterator_category(__first)); }
 
     template<class _InputIterator>
-    vector(_InputIterator __first, _InputIterator __last,
-             const allocator_type& __a = allocator_type())
-      : _Bvector_base<_Alloc>(__a)
+      vector(_InputIterator __first, _InputIterator __last,
+	     const allocator_type& __a = allocator_type())
+    : _Bvector_base<_Alloc>(__a)
     {
       typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
       _M_initialize_dispatch(__first, __last, _Integral());
@@ -643,7 +650,7 @@ template<typename _Alloc>
 	  _M_initialize(__x.size());
 	}
       std::copy(__x.begin(), __x.end(), begin());
-      this->_M_finish = begin() + difference_type(__x.size());
+      this->_M_impl._M_finish = begin() + difference_type(__x.size());
       return *this;
     }
 
@@ -656,13 +663,15 @@ template<typename _Alloc>
     {
       if (__n > size())
 	{
-	  std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+	  std::fill(this->_M_impl._M_start._M_p, 
+		    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
 	  insert(end(), __n - size(), __x);
 	}
       else
 	{
 	  erase(begin() + __n, end());
-	  std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
+	  std::fill(this->_M_impl._M_start._M_p, 
+		    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
 	}
     }
 
@@ -720,11 +729,12 @@ template<typename _Alloc>
 	__throw_length_error(__N("vector::reserve"));
       if (this->capacity() < __n)
 	{
-	  _Bit_type* __q = this->_M_bit_alloc(__n);
-	  this->_M_finish = std::copy(begin(), end(), iterator(__q, 0));
+	  _Bit_type* __q = this->_M_allocate(__n);
+	  this->_M_impl._M_finish = std::copy(begin(), end(), 
+					      iterator(__q, 0));
 	  this->_M_deallocate();
-	  this->_M_start = iterator(__q, 0);
-	  this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
+	  this->_M_impl._M_start = iterator(__q, 0);
+	  this->_M_impl._M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
 	}
     }
 
@@ -742,17 +752,18 @@ template<typename _Alloc>
 
     void push_back(bool __x)
     {
-      if (this->_M_finish._M_p != this->_M_end_of_storage)
-        *this->_M_finish++ = __x;
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+        *this->_M_impl._M_finish++ = __x;
       else
         _M_insert_aux(end(), __x);
     }
 
     void swap(vector<bool, _Alloc>& __x)
     {
-      std::swap(this->_M_start, __x._M_start);
-      std::swap(this->_M_finish, __x._M_finish);
-      std::swap(this->_M_end_of_storage, __x._M_end_of_storage);
+      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+      std::swap(this->_M_impl._M_end_of_storage, 
+		__x._M_impl._M_end_of_storage);
     }
 
     // [23.2.5]/1, third-to-last entry in synopsis listing
@@ -766,9 +777,9 @@ template<typename _Alloc>
     iterator insert(iterator __position, bool __x = bool())
     {
       const difference_type __n = __position - begin();
-      if (this->_M_finish._M_p != this->_M_end_of_storage
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
 	  && __position == end())
-        *this->_M_finish++ = __x;
+        *this->_M_impl._M_finish++ = __x;
       else
         _M_insert_aux(__position, __x);
       return begin() + __n;
@@ -803,22 +814,22 @@ template<typename _Alloc>
       if (capacity() - size() >= __n)
 	{
 	  std::copy_backward(__position, end(),
-			     this->_M_finish + difference_type(__n));
+			     this->_M_impl._M_finish + difference_type(__n));
 	  std::fill(__position, __position + difference_type(__n), __x);
-	  this->_M_finish += difference_type(__n);
+	  this->_M_impl._M_finish += difference_type(__n);
 	}
       else
 	{
 	  const size_type __len = size() + std::max(size(), __n);
-	  _Bit_type * __q = this->_M_bit_alloc(__len);
+	  _Bit_type * __q = this->_M_allocate(__len);
 	  iterator __i = std::copy(begin(), __position, iterator(__q, 0));
 	  std::fill_n(__i, __n, __x);
-	  this->_M_finish = std::copy(__position, end(),
-				      __i + difference_type(__n));
+	  this->_M_impl._M_finish = std::copy(__position, end(),
+					      __i + difference_type(__n));
 	  this->_M_deallocate();
-	  this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
-	                            / _S_word_bit;
-	  this->_M_start = iterator(__q, 0);
+	  this->_M_impl._M_end_of_storage = __q + (__len + _S_word_bit - 1)
+	                                    / _S_word_bit;
+	  this->_M_impl._M_start = iterator(__q, 0);
 	}
     }
 
@@ -826,19 +837,19 @@ template<typename _Alloc>
     { _M_fill_insert(__position, __n, __x); }
 
     void pop_back()
-    { --this->_M_finish; }
+    { --this->_M_impl._M_finish; }
 
     iterator erase(iterator __position)
     {
       if (__position + 1 != end())
         std::copy(__position + 1, end(), __position);
-      --this->_M_finish;
+      --this->_M_impl._M_finish;
       return __position;
     }
 
     iterator erase(iterator __first, iterator __last)
     {
-      this->_M_finish = std::copy(__last, end(), __first);
+      this->_M_impl._M_finish = std::copy(__last, end(), __first);
       return __first;
     }
 
@@ -852,14 +863,14 @@ template<typename _Alloc>
 
     void flip()
     {
-      for (_Bit_type * __p = this->_M_start._M_p;
-	   __p != this->_M_end_of_storage; ++__p)
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
+	   __p != this->_M_impl._M_end_of_storage; ++__p)
         *__p = ~*__p;
     }
 
     void clear()
     { erase(begin(), end()); }
   };
-} // namespace __gnu_norm
+} // namespace std
 
 #endif

libstdc++-v3/include/bits/stl_deque.h

@@ -65,7 +65,7 @@
 #include <bits/stl_iterator_base_types.h>
 #include <bits/stl_iterator_base_funcs.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   /**
    *  @if maint
@@ -1496,6 +1496,6 @@ namespace __gnu_norm
     inline void
     swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
     { __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _DEQUE_H */

libstdc++-v3/include/bits/stl_list.h

@@ -63,7 +63,7 @@
 
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   // Supporting structures are split into common and templated types; the
   // latter publicly inherits from the former in an effort to reduce code
@@ -1247,7 +1247,7 @@ namespace __gnu_norm
     inline void
     swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
     { __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _LIST_H */
 

libstdc++-v3/include/bits/stl_map.h

@@ -63,7 +63,7 @@
 
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   /**
    *  @brief A standard container made up of (key,value) pairs, which can be
@@ -689,6 +689,6 @@ namespace __gnu_norm
     inline void
     swap(map<_Key,_Tp,_Compare,_Alloc>& __x, map<_Key,_Tp,_Compare,_Alloc>& __y)
     { __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _MAP_H */

libstdc++-v3/include/bits/stl_multimap.h

@@ -63,7 +63,7 @@
 
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   // Forward declaration of operators < and ==, needed for friend declaration.
 
@@ -673,6 +673,6 @@ namespace __gnu_norm
     swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
          multimap<_Key,_Tp,_Compare,_Alloc>& __y)
     { __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _MULTIMAP_H */

libstdc++-v3/include/bits/stl_multiset.h

@@ -63,7 +63,7 @@
 
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
 
   // Forward declaration of operators < and ==, needed for friend declaration.
@@ -580,6 +580,6 @@ namespace __gnu_norm
 	 multiset<_Key,_Compare,_Alloc>& __y)
     { __x.swap(__y); }
 
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _MULTISET_H */

libstdc++-v3/include/bits/stl_set.h

@@ -63,7 +63,7 @@
 
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   // Forward declarations of operators < and ==, needed for friend declaration.
   template<class _Key, class _Compare = less<_Key>,
@@ -588,6 +588,6 @@ namespace __gnu_norm
     swap(set<_Key,_Compare,_Alloc>& __x, set<_Key,_Compare,_Alloc>& __y)
     { __x.swap(__y); }
 
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _SET_H */

libstdc++-v3/include/bits/stl_vector.h

@@ -65,7 +65,7 @@
 #include <bits/functexcept.h>
 #include <bits/concept_check.h>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   /**
    *  @if maint
@@ -927,6 +927,6 @@ namespace __gnu_norm
     inline void
     swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y)
     { __x.swap(__y); }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _VECTOR_H */

libstdc++-v3/include/bits/vector.tcc

@@ -61,7 +61,7 @@
 #ifndef _VECTOR_TCC
 #define _VECTOR_TCC 1
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   template<typename _Tp, typename _Alloc>
     void
@@ -409,6 +409,6 @@ namespace __gnu_norm
         }
       }
     }
-} // namespace __gnu_norm
+} // namespace std
 
 #endif /* _VECTOR_TCC */

libstdc++-v3/include/debug/bitset

 // Debugging bitset implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -39,9 +39,10 @@ namespace __gnu_debug_def
 {
   template<size_t _Nb>
     class bitset
-    : public __gnu_norm::bitset<_Nb>, public __gnu_debug::_Safe_sequence_base
+    : public _GLIBCXX_STD::bitset<_Nb>, 
+      public __gnu_debug::_Safe_sequence_base
     {
-      typedef  __gnu_norm::bitset<_Nb>		_Base;
+      typedef _GLIBCXX_STD::bitset<_Nb> _Base;
       typedef __gnu_debug::_Safe_sequence_base  _Safe_base;
 
     public:

libstdc++-v3/include/debug/deque

 // Debugging deque implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -39,10 +39,10 @@ namespace __gnu_debug_def
 {
   template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
     class deque
-    : public  __gnu_norm::deque<_Tp, _Allocator>,
-    public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
+    : public _GLIBCXX_STD::deque<_Tp, _Allocator>,
+      public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
     {
-      typedef  __gnu_norm::deque<_Tp, _Allocator> _Base;
+      typedef  _GLIBCXX_STD::deque<_Tp, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<deque> _Safe_base;
 
     public:

libstdc++-v3/include/debug/formatter.h

 // Debug-mode error formatting implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -36,7 +36,7 @@
 
 namespace __gnu_debug
 {
-  using namespace std;
+  using std::type_info;
 
   /** Determine if the two types are the same. */
   template<typename _Type1, typename _Type2>

libstdc++-v3/include/debug/list

 // Debugging list implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,10 +40,10 @@ namespace __gnu_debug_def
 {
   template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
     class list
-    : public __gnu_norm::list<_Tp, _Allocator>,
+    : public _GLIBCXX_STD::list<_Tp, _Allocator>,
       public __gnu_debug::_Safe_sequence<list<_Tp, _Allocator> >
     {
-      typedef __gnu_norm::list<_Tp, _Allocator> _Base;
+      typedef _GLIBCXX_STD::list<_Tp, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<list>  _Safe_base;
 
     public:
@@ -76,7 +76,7 @@ namespace __gnu_debug_def
       template<class _InputIterator>
       list(_InputIterator __first, _InputIterator __last,
 	   const _Allocator& __a = _Allocator())
-	: _Base(__gnu_debug::__check_valid_range(__first, __last), __last, __a)
+      : _Base(__gnu_debug::__check_valid_range(__first, __last), __last, __a)
       { }
 
 

libstdc++-v3/include/debug/map.h

 // Debugging map implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,10 +40,10 @@ namespace __gnu_debug_def
   template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
     class map
-    : public __gnu_norm::map<_Key, _Tp, _Compare, _Allocator>,
+    : public _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator>,
       public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
     {
-      typedef __gnu_norm::map<_Key, _Tp, _Compare, _Allocator> _Base;
+      typedef _GLIBCXX_STD::map<_Key, _Tp, _Compare, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<map> _Safe_base;
 
     public:

libstdc++-v3/include/debug/multimap.h

 // Debugging multimap implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,10 +40,10 @@ namespace __gnu_debug_def
   template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
     class multimap
-    : public __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator>,
+    : public _GLIBCXX_STD::multimap<_Key, _Tp, _Compare, _Allocator>,
     public __gnu_debug::_Safe_sequence<multimap<_Key,_Tp,_Compare,_Allocator> >
     {
-      typedef __gnu_norm::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+      typedef _GLIBCXX_STD::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<multimap> _Safe_base;
 
     public:

libstdc++-v3/include/debug/multiset.h

 // Debugging multiset implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,10 +40,10 @@ namespace __gnu_debug_def
   template<typename _Key, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<_Key> >
     class multiset
-    : public __gnu_norm::multiset<_Key, _Compare, _Allocator>,
+    : public _GLIBCXX_STD::multiset<_Key, _Compare, _Allocator>,
       public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
     {
-      typedef __gnu_norm::multiset<_Key, _Compare, _Allocator> _Base;
+      typedef _GLIBCXX_STD::multiset<_Key, _Compare, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<multiset> _Safe_base;
 
     public:

libstdc++-v3/include/debug/safe_iterator.h

 // Safe iterator implementation  -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -38,6 +38,9 @@
 
 namespace __gnu_debug
 {
+  using std::iterator_traits;
+  using std::pair;
+
   /** Iterators that derive from _Safe_iterator_base but that aren't
    *  _Safe_iterators can be determined singular or non-singular via
    *  _Safe_iterator_base.

libstdc++-v3/include/debug/set.h

 // Debugging set implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -40,10 +40,10 @@ namespace __gnu_debug_def
   template<typename _Key, typename _Compare = std::less<_Key>,
 	   typename _Allocator = std::allocator<_Key> >
     class set
-    : public __gnu_norm::set<_Key,_Compare,_Allocator>,
+    : public _GLIBCXX_STD::set<_Key,_Compare,_Allocator>,
       public __gnu_debug::_Safe_sequence<set<_Key, _Compare, _Allocator> >
     {
-      typedef __gnu_norm::set<_Key,_Compare,_Allocator> _Base;
+      typedef _GLIBCXX_STD::set<_Key,_Compare,_Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<set> _Safe_base;
 
     public:

libstdc++-v3/include/debug/vector

 // Debugging vector implementation -*- C++ -*-
 
-// Copyright (C) 2003
+// Copyright (C) 2003, 2004
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -41,10 +41,10 @@ namespace __gnu_debug_def
   template<typename _Tp,
 	   typename _Allocator = std::allocator<_Tp> >
     class vector
-    : public __gnu_norm::vector<_Tp, _Allocator>,
+    : public _GLIBCXX_STD::vector<_Tp, _Allocator>,
       public __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> >
     {
-      typedef __gnu_norm::vector<_Tp, _Allocator> _Base;
+      typedef _GLIBCXX_STD::vector<_Tp, _Allocator> _Base;
       typedef __gnu_debug::_Safe_sequence<vector>              _Safe_base;
 
       typedef typename _Base::const_iterator _Base_const_iterator;

libstdc++-v3/include/std/std_bitset.h

@@ -59,12 +59,11 @@
 #include <ostream>     // For ostream (operator<<)
 #include <istream>     // For istream (operator>>)
 
-
 #define _GLIBCXX_BITSET_BITS_PER_WORD  numeric_limits<unsigned long>::digits
 #define _GLIBCXX_BITSET_WORDS(__n) \
  ((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1)/_GLIBCXX_BITSET_BITS_PER_WORD)
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   /**
    *  @if maint
@@ -1218,7 +1217,7 @@ namespace __gnu_norm
       return __os << __tmp;
     }
   //@}
-} // namespace __gnu_norm
+} // namespace std
 
 #undef _GLIBCXX_BITSET_WORDS
 #undef _GLIBCXX_BITSET_BITS_PER_WORD

libstdc++-v3/src/Makefile.am

@@ -101,6 +101,7 @@ sources = \
 	complex_io.cc \
 	ctype.cc \
 	debug.cc \
+	debug_list.cc \
 	functexcept.cc \
 	globals_locale.cc \
 	globals_io.cc \

libstdc++-v3/src/Makefile.in

@@ -59,12 +59,12 @@ am__objects_1 = atomicity.lo codecvt_members.lo collate_members.lo \
 	numeric_members.lo time_members.lo
 am__objects_2 = basic_file.lo c++locale.lo
 am__objects_3 = allocator.lo codecvt.lo complex_io.lo ctype.lo \
-	debug.lo functexcept.lo globals_locale.lo globals_io.lo ios.lo \
-	ios_failure.lo ios_init.lo ios_locale.lo limits.lo list.lo \
-	locale.lo locale_init.lo locale_facets.lo localename.lo \
-	stdexcept.lo strstream.lo tree.lo allocator-inst.lo \
-	concept-inst.lo fstream-inst.lo ext-inst.lo io-inst.lo \
-	istream-inst.lo locale-inst.lo locale-misc-inst.lo \
+	debug.lo debug_list.lo functexcept.lo globals_locale.lo \
+	globals_io.lo ios.lo ios_failure.lo ios_init.lo ios_locale.lo \
+	limits.lo list.lo locale.lo locale_init.lo locale_facets.lo \
+	localename.lo stdexcept.lo strstream.lo tree.lo \
+	allocator-inst.lo concept-inst.lo fstream-inst.lo ext-inst.lo \
+	io-inst.lo istream-inst.lo locale-inst.lo locale-misc-inst.lo \
 	misc-inst.lo ostream-inst.lo sstream-inst.lo streambuf-inst.lo \
 	string-inst.lo valarray-inst.lo wlocale-inst.lo \
 	wstring-inst.lo $(am__objects_1) $(am__objects_2)
@@ -299,6 +299,7 @@ sources = \
 	complex_io.cc \
 	ctype.cc \
 	debug.cc \
+	debug_list.cc \
 	functexcept.cc \
 	globals_locale.cc \
 	globals_io.cc \

libstdc++-v3/src/debug_list.cc

+// Debugging mode support code for list -*- C++ -*-
+
+// Copyright (C) 2004 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
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction.  Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License.  This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+#define _GLIBCXX_DEBUG
+
+#include <bits/c++config.h>
+
+#include "list.cc"

libstdc++-v3/src/list.cc

@@ -55,7 +55,7 @@
 
 #include <list>
 
-namespace __gnu_norm
+namespace _GLIBCXX_STD
 {
   void
   _List_node_base::swap(_List_node_base& __x, _List_node_base& __y)
@@ -121,7 +121,7 @@ namespace __gnu_norm
   }
 
   void
-  _List_node_base::hook(_List_node_base * const __position)
+  _List_node_base::hook(_List_node_base* const __position)
   {
     this->_M_next = __position;
     this->_M_prev = __position->_M_prev;
@@ -137,5 +137,5 @@ namespace __gnu_norm
     __prev_node->_M_next = __next_node;
     __next_node->_M_prev = __prev_node;
   }
-} // namespace __gnu_norm
+} // namespace std
 

libstdc++-v3/testsuite/23_containers/vector/bool/clear_allocator.cc

+// Copyright (C) 2004 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
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+ 
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+ 
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING.  If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+#include <vector>
+#include <ext/new_allocator.h>
+
+using namespace std;
+using __gnu_cxx::new_allocator;
+
+template<typename T>
+  class clear_alloc : public new_allocator<T> 
+  {
+  public:
+
+    template <typename T1>
+      struct rebind 
+      { typedef clear_alloc<T1> other; };
+
+    virtual void clear() throw()
+    { }
+
+    clear_alloc() throw()
+    { }
+    
+    clear_alloc(clear_alloc const& _wa) throw()
+    { }
+    
+    template<typename T1>
+      clear_alloc(clear_alloc<T1> const& _wa) throw()
+      { }
+
+    virtual ~clear_alloc() throw()
+    { this->clear(); }
+
+    T* allocate(typename new_allocator<T>::size_type n, const void *hint = 0)
+    {
+      this->clear();
+      return new_allocator<T>::allocate(n, hint);
+    }
+    
+    void deallocate(T *ptr, typename new_allocator<T>::size_type n)
+    {
+      this->clear();
+      new_allocator<T>::deallocate(ptr, n);
+    }
+  };
+
+template<typename Container>
+  void Check_Container()
+  {
+    Container* pic = new Container;
+    int x = 230;
+    
+    while (x--)
+      {
+	pic->push_back(x);
+      }
+    
+    pic->get_allocator();
+    
+    // The following has led to infinite recursions or cores.
+    pic->clear();
+
+    delete pic;
+  }
+
+
+int main()
+{
+  Check_Container<std::vector<bool, clear_alloc<bool> > >();
+  return 0;
+}
+