deque.tcc: Fully qualify standard functions with std::, thus avoiding Koenig lookup.

2003-07-04  Paolo Carlini  <pcarlini@unitus.it>

	* include/bits/deque.tcc: Fully qualify standard
	functions with std::, thus avoiding Koenig lookup.
	* include/bits/gslice_array.h: Likewise.
	* include/bits/indirect_array.h: Likewise.
	* include/bits/list.tcc: Likewise.
	* include/bits/mask_array.h: Likewise.
	* include/bits/slice_array.h: Likewise.

From-SVN: r68937

libstdc++-v3/ChangeLog

+2003-07-04  Paolo Carlini  <pcarlini@unitus.it>
+
+	* include/bits/deque.tcc: Fully qualify standard
+	functions with std::, thus avoiding Koenig lookup.
+	* include/bits/gslice_array.h: Likewise.
+	* include/bits/indirect_array.h: Likewise.
+	* include/bits/list.tcc: Likewise.
+	* include/bits/mask_array.h: Likewise.
+	* include/bits/slice_array.h: Likewise.
+
 2003-07-04  Gawain Bolton  <gbolton@free.fr>
 
 	* include/bits/stl_tree.h: Performance and memory usage

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

@@ -72,11 +72,11 @@ namespace std
       if (&__x != this)
       {
         if (__len >= __x.size())
-          erase(copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
+          erase(std::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
         else
         {
           const_iterator __mid = __x.begin() + difference_type(__len);
-          copy(__x.begin(), __mid, this->_M_start);
+          std::copy(__x.begin(), __mid, this->_M_start);
           insert(this->_M_finish, __mid, __x.end());
         }
       }
@@ -114,12 +114,12 @@ namespace std
       size_type __index = __position - this->_M_start;
       if (__index < (size() >> 1))
       {
-        copy_backward(this->_M_start, __position, __next);
+        std::copy_backward(this->_M_start, __position, __next);
         pop_front();
       }
       else
       {
-        copy(__next, this->_M_finish, __position);
+        std::copy(__next, this->_M_finish, __position);
         pop_back();
       }
       return this->_M_start + __index;
@@ -141,17 +141,17 @@ namespace std
         difference_type __elems_before = __first - this->_M_start;
         if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
         {
-          copy_backward(this->_M_start, __first, __last);
+          std::copy_backward(this->_M_start, __first, __last);
           iterator __new_start = this->_M_start + __n;
-          _Destroy(this->_M_start, __new_start);
+          std::_Destroy(this->_M_start, __new_start);
           _M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
           this->_M_start = __new_start;
         }
         else
         {
-          copy(__last, this->_M_finish, __first);
+          std::copy(__last, this->_M_finish, __first);
           iterator __new_finish = this->_M_finish - __n;
-          _Destroy(__new_finish, this->_M_finish);
+          std::_Destroy(__new_finish, this->_M_finish);
           _M_destroy_nodes(__new_finish._M_node + 1,
 			   this->_M_finish._M_node + 1);
           this->_M_finish = __new_finish;
@@ -169,18 +169,18 @@ namespace std
            __node < this->_M_finish._M_node;
            ++__node)
       {
-        _Destroy(*__node, *__node + _S_buffer_size());
+        std::_Destroy(*__node, *__node + _S_buffer_size());
         _M_deallocate_node(*__node);
       }
     
       if (this->_M_start._M_node != this->_M_finish._M_node)
       {
-        _Destroy(this->_M_start._M_cur, this->_M_start._M_last);
-        _Destroy(this->_M_finish._M_first, this->_M_finish._M_cur);
+        std::_Destroy(this->_M_start._M_cur, this->_M_start._M_last);
+        std::_Destroy(this->_M_finish._M_first, this->_M_finish._M_cur);
         _M_deallocate_node(this->_M_finish._M_first);
       }
       else
-        _Destroy(this->_M_start._M_cur, this->_M_finish._M_cur);
+        std::_Destroy(this->_M_start._M_cur, this->_M_finish._M_cur);
     
       this->_M_finish = this->_M_start;
     }
@@ -210,7 +210,7 @@ namespace std
         iterator __new_start = _M_reserve_elements_at_front(__n);
         try
           {
-            uninitialized_fill(__new_start, this->_M_start, __x);
+            std::uninitialized_fill(__new_start, this->_M_start, __x);
             this->_M_start = __new_start;
           }
         catch(...)
@@ -224,7 +224,7 @@ namespace std
         iterator __new_finish = _M_reserve_elements_at_back(__n);
         try
           {
-            uninitialized_fill(this->_M_finish, __new_finish, __x);
+            std::uninitialized_fill(this->_M_finish, __new_finish, __x);
             this->_M_finish = __new_finish;
           }
         catch(...)
@@ -249,14 +249,14 @@ namespace std
           for (__cur = this->_M_start._M_node;
 	       __cur < this->_M_finish._M_node;
 	       ++__cur)
-            uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
-          uninitialized_fill(this->_M_finish._M_first,
+            std::uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
+          std::uninitialized_fill(this->_M_finish._M_first,
 				  this->_M_finish._M_cur,
 				  __value);
         }
       catch(...)
         {
-          _Destroy(this->_M_start, iterator(*__cur, __cur));
+          std::_Destroy(this->_M_start, iterator(*__cur, __cur));
           __throw_exception_again;
         }
     }
@@ -299,15 +299,15 @@ namespace std
                  ++__cur_node)
             {
               _ForwardIterator __mid = __first;
-              advance(__mid, _S_buffer_size());
-              uninitialized_copy(__first, __mid, *__cur_node);
+              std::advance(__mid, _S_buffer_size());
+              std::uninitialized_copy(__first, __mid, *__cur_node);
               __first = __mid;
             }
-            uninitialized_copy(__first, __last, this->_M_finish._M_first);
+            std::uninitialized_copy(__first, __last, this->_M_finish._M_first);
           }
         catch(...)
           {
-            _Destroy(this->_M_start, iterator(*__cur_node, __cur_node));
+            std::_Destroy(this->_M_start, iterator(*__cur_node, __cur_node));
             __throw_exception_again;
           }
       }
@@ -323,7 +323,7 @@ namespace std
       *(this->_M_finish._M_node + 1) = _M_allocate_node();
       try
         {
-          _Construct(this->_M_finish._M_cur, __t_copy);
+          std::_Construct(this->_M_finish._M_cur, __t_copy);
           this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
           this->_M_finish._M_cur = this->_M_finish._M_first;
         }
@@ -347,7 +347,7 @@ namespace std
         {
           this->_M_start._M_set_node(this->_M_start._M_node - 1);
           this->_M_start._M_cur = this->_M_start._M_last - 1;
-          _Construct(this->_M_start._M_cur, __t_copy);
+          std::_Construct(this->_M_start._M_cur, __t_copy);
         }
       catch(...)
         {
@@ -365,7 +365,7 @@ namespace std
       _M_deallocate_node(this->_M_finish._M_first);
       this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
       this->_M_finish._M_cur = this->_M_finish._M_last - 1;
-      _Destroy(this->_M_finish._M_cur);
+      std::_Destroy(this->_M_finish._M_cur);
     }
     
   // Called only if _M_start._M_cur == _M_start._M_last - 1.  Note that 
@@ -376,7 +376,7 @@ namespace std
     void deque<_Tp,_Alloc>::
     _M_pop_front_aux()
     {
-      _Destroy(this->_M_start._M_cur);
+      std::_Destroy(this->_M_start._M_cur);
       _M_deallocate_node(this->_M_start._M_first);
       this->_M_start._M_set_node(this->_M_start._M_node + 1);
       this->_M_start._M_cur = this->_M_start._M_first;
@@ -390,7 +390,7 @@ namespace std
                           _InputIterator __first, _InputIterator __last,
                           input_iterator_tag)
       {
-        copy(__first, __last, inserter(*this, __pos));
+        std::copy(__first, __last, std::inserter(*this, __pos));
       }
     
   template <typename _Tp, typename _Alloc>
@@ -407,7 +407,7 @@ namespace std
           iterator __new_start = _M_reserve_elements_at_front(__n);
           try
             {
-              uninitialized_copy(__first, __last, __new_start);
+              std::uninitialized_copy(__first, __last, __new_start);
               this->_M_start = __new_start;
             }
           catch(...)
@@ -421,7 +421,7 @@ namespace std
           iterator __new_finish = _M_reserve_elements_at_back(__n);
           try
             {
-              uninitialized_copy(__first, __last, this->_M_finish);
+              std::uninitialized_copy(__first, __last, this->_M_finish);
               this->_M_finish = __new_finish;
             }
           catch(...)
@@ -452,7 +452,7 @@ namespace std
         __pos = this->_M_start + __index;
         iterator __pos1 = __pos;
         ++__pos1;
-        copy(__front2, __pos1, __front1);
+        std::copy(__front2, __pos1, __front1);
       }
       else
       {
@@ -462,7 +462,7 @@ namespace std
         iterator __back2 = __back1;
         --__back2;
         __pos = this->_M_start + __index;
-        copy_backward(__pos, __back2, __back1);
+        std::copy_backward(__pos, __back2, __back1);
       }
       *__pos = __x_copy;
       return __pos;
@@ -486,17 +486,17 @@ namespace std
             if (__elems_before >= difference_type(__n))
             {
               iterator __start_n = this->_M_start + difference_type(__n);
-              uninitialized_copy(this->_M_start, __start_n, __new_start);
+              std::uninitialized_copy(this->_M_start, __start_n, __new_start);
               this->_M_start = __new_start;
-              copy(__start_n, __pos, __old_start);
+              std::copy(__start_n, __pos, __old_start);
               fill(__pos - difference_type(__n), __pos, __x_copy);
             }
             else
             {
-              __uninitialized_copy_fill(this->_M_start, __pos, __new_start, 
+              std::__uninitialized_copy_fill(this->_M_start, __pos, __new_start, 
 					     this->_M_start, __x_copy);
               this->_M_start = __new_start;
-              fill(__old_start, __pos, __x_copy);
+              std::fill(__old_start, __pos, __x_copy);
             }
           }
         catch(...)
@@ -517,18 +517,18 @@ namespace std
             if (__elems_after > difference_type(__n))
             {
               iterator __finish_n = this->_M_finish - difference_type(__n);
-              uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
+              std::uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
               this->_M_finish = __new_finish;
-              copy_backward(__pos, __finish_n, __old_finish);
-              fill(__pos, __pos + difference_type(__n), __x_copy);
+              std::copy_backward(__pos, __finish_n, __old_finish);
+              std::fill(__pos, __pos + difference_type(__n), __x_copy);
             }
             else
             {
-              __uninitialized_fill_copy(this->_M_finish,
+              std::__uninitialized_fill_copy(this->_M_finish,
 					     __pos + difference_type(__n),
 					     __x_copy, __pos, this->_M_finish);
               this->_M_finish = __new_finish;
-              fill(__pos, __old_finish, __x_copy);
+              std::fill(__pos, __old_finish, __x_copy);
             }
           }
         catch(...)
@@ -560,19 +560,19 @@ namespace std
               if (__elemsbefore >= difference_type(__n))
               {
                 iterator __start_n = this->_M_start + difference_type(__n); 
-                uninitialized_copy(this->_M_start, __start_n, __new_start);
+                std::uninitialized_copy(this->_M_start, __start_n, __new_start);
                 this->_M_start = __new_start;
-                copy(__start_n, __pos, __old_start);
-                copy(__first, __last, __pos - difference_type(__n));
+                std::copy(__start_n, __pos, __old_start);
+                std::copy(__first, __last, __pos - difference_type(__n));
               }
               else
               {
                 _ForwardIterator __mid = __first;
-                advance(__mid, difference_type(__n) - __elemsbefore);
-                __uninitialized_copy_copy(this->_M_start, __pos,
+                std::advance(__mid, difference_type(__n) - __elemsbefore);
+                std::__uninitialized_copy_copy(this->_M_start, __pos,
 					       __first, __mid, __new_start);
                 this->_M_start = __new_start;
-                copy(__mid, __last, __old_start);
+                std::copy(__mid, __last, __old_start);
               }
             }
           catch(...)
@@ -593,21 +593,21 @@ namespace std
               if (__elemsafter > difference_type(__n))
               {
                 iterator __finish_n = this->_M_finish - difference_type(__n);
-                uninitialized_copy(__finish_n,
+                std::uninitialized_copy(__finish_n,
 					this->_M_finish,
 					this->_M_finish);
                 this->_M_finish = __new_finish;
-                copy_backward(__pos, __finish_n, __old_finish);
-                copy(__first, __last, __pos);
+                std::copy_backward(__pos, __finish_n, __old_finish);
+                std::copy(__first, __last, __pos);
               }
               else
               {
                 _ForwardIterator __mid = __first;
-                advance(__mid, __elemsafter);
-                __uninitialized_copy_copy(__mid, __last, __pos,
+                std::advance(__mid, __elemsafter);
+                std::__uninitialized_copy_copy(__mid, __last, __pos,
 					       this->_M_finish, this->_M_finish);
                 this->_M_finish = __new_finish;
-                copy(__first, __mid, __pos);
+                std::copy(__first, __mid, __pos);
               }
             }
           catch(...)
@@ -679,11 +679,11 @@ namespace std
 	  = this->_M_map + (this->_M_map_size - __new_num_nodes) / 2 
 	  + (__add_at_front ? __nodes_to_add : 0);
         if (__new_nstart < this->_M_start._M_node)
-          copy(this->_M_start._M_node,
+          std::copy(this->_M_start._M_node,
 		    this->_M_finish._M_node + 1,
 		    __new_nstart);
         else
-          copy_backward(this->_M_start._M_node,
+          std::copy_backward(this->_M_start._M_node,
 			     this->_M_finish._M_node + 1, 
 			     __new_nstart + __old_num_nodes);
       }
@@ -695,7 +695,7 @@ namespace std
         _Map_pointer __new_map = _M_allocate_map(__new_map_size);
         __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
                              + (__add_at_front ? __nodes_to_add : 0);
-        copy(this->_M_start._M_node,
+        std::copy(this->_M_start._M_node,
 		  this->_M_finish._M_node + 1,
 		  __new_nstart);
         _M_deallocate_map(this->_M_map, this->_M_map_size);

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

@@ -116,7 +116,7 @@ namespace std {
     inline void
     gslice_array<_Tp>::operator=(const _Tp& __t) const
     { 
-      __valarray_fill(_M_array, _Array<size_t>(_M_index),
+      std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
 			   _M_index.size(), __t); 
     }
 
@@ -124,7 +124,7 @@ namespace std {
     inline void
     gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
     {
-      __valarray_copy(_Array<_Tp>(__v), __v.size(),
+      std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
 			   _M_array, _Array<size_t>(_M_index));
     }
 
@@ -133,7 +133,7 @@ namespace std {
       inline void
       gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
       {
-	__valarray_copy (__e, _M_index.size(), _M_array,
+	std::__valarray_copy (__e, _M_index.size(), _M_array,
 			      _Array<size_t>(_M_index));
       }
 

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

@@ -118,7 +118,7 @@ namespace std
      inline indirect_array<_Tp>&
      indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a)
      {
-       __valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
+       std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index);
        return *this;
      }
 
@@ -126,18 +126,18 @@ namespace std
   template<typename _Tp>
      inline void
      indirect_array<_Tp>::operator=(const _Tp& __t) const
-     { __valarray_fill(_M_array, _M_index, _M_sz, __t); }
+     { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); }
 
   template<typename _Tp>
      inline void
      indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const
-     { __valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
+     { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); }
 
   template<typename _Tp>
      template<class _Dom>
        inline void
        indirect_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
-       { __valarray_copy(__e, _M_sz, _M_array, _M_index); }
+       { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); }
 
 #undef _DEFINE_VALARRAY_OPERATOR
 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\

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

@@ -74,7 +74,7 @@ namespace std
       {
         _Node* __tmp = __cur;
         __cur = static_cast<_Node*>(__cur->_M_next);
-        _Destroy(&__tmp->_M_data);
+        std::_Destroy(&__tmp->_M_data);
         _M_put_node(__tmp);
       }
       this->_M_node->_M_next = this->_M_node;
@@ -104,7 +104,7 @@ namespace std
       _Node* __n = static_cast<_Node*>(__position._M_node);
       __prev_node->_M_next = __next_node;
       __next_node->_M_prev = __prev_node;
-      _Destroy(&__n->_M_data);
+      std::_Destroy(&__n->_M_data);
       _M_put_node(__n);
       return iterator(static_cast<_Node*>(__next_node));
     }

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

@@ -114,18 +114,18 @@ namespace std {
   template<typename _Tp>
     inline void
     mask_array<_Tp>::operator=(const _Tp& __t) const
-    { __valarray_fill(_M_array, _M_sz, _M_mask, __t); }
+    { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); }
     
   template<typename _Tp>
     inline void
     mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const
-    { __valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }
+    { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); }
 
   template<typename _Tp>
     template<class _Ex>
       inline void
       mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const
-      { __valarray_copy(__e, __e.size(), _M_array, _M_mask); }
+      { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); }
 
 #undef _DEFINE_VALARRAY_OPERATOR
 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\

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

@@ -157,7 +157,7 @@ namespace std
     inline slice_array<_Tp>&
     slice_array<_Tp>::operator=(const slice_array<_Tp>& __a)
     {
-      __valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
+      std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
 			   _M_array, _M_stride);
       return *this;
     }
@@ -165,18 +165,18 @@ namespace std
   template<typename _Tp>
     inline void
     slice_array<_Tp>::operator=(const _Tp& __t) const
-    { __valarray_fill(_M_array, _M_sz, _M_stride, __t); }
+    { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); }
     
   template<typename _Tp>
     inline void
     slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
-    { __valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); }
+    { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); }
     
   template<typename _Tp>
   template<class _Dom>
     inline void
     slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const
-    { __valarray_copy(__e, _M_sz, _M_array, _M_stride); }
+    { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); }
 
 #undef _DEFINE_VALARRAY_OPERATOR
 #define _DEFINE_VALARRAY_OPERATOR(_Op,_Name)				\