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

	* include/std/std_complex.h: Fully qualify standard
	functions with std::, thus avoiding Koenig lookup.
	* include/std/std_memory.h: Likewise.
	* include/std/std_valarray.h: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@68982 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 40 insertions, 40 deletions

diff --git a/libstdc++-v3/include/std/std_valarray.h b/libstdc++-v3/include/std/std_valarray.h
index d5bdd557483..4656dc3b753 100644
--- a/libstdc++-v3/include/std/std_valarray.h
+++ b/libstdc++-v3/include/std/std_valarray.h
@@ -248,32 +248,32 @@ namespace std
     inline 
     valarray<_Tp>::valarray(size_t __n) 
 	: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
-    { __valarray_default_construct(_M_data, _M_data + __n); }
+    { std::__valarray_default_construct(_M_data, _M_data + __n); }
 
   template<typename _Tp>
     inline
     valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
       : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
-    { __valarray_fill_construct(_M_data, _M_data + __n, __t); }
+    { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
 
   template<typename _Tp>
     inline
     valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
       : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
-    { __valarray_copy_construct(__p, __p + __n, _M_data); }
+    { std::__valarray_copy_construct(__p, __p + __n, _M_data); }
 
   template<typename _Tp>
     inline
     valarray<_Tp>::valarray(const valarray<_Tp>& __v)
       : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
-    { __valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); }
+    { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); }
 
   template<typename _Tp>
     inline
     valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
       : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
     {
-      __valarray_copy
+      std::__valarray_copy
 	(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
     }
 
@@ -283,7 +283,7 @@ namespace std
       : _M_size(__ga._M_index.size()),
 	_M_data(__valarray_get_storage<_Tp>(_M_size))
     {
-      __valarray_copy
+      std::__valarray_copy
 	(__ga._M_array, _Array<size_t>(__ga._M_index),
 	 _Array<_Tp>(_M_data), _M_size);
     }
@@ -293,7 +293,7 @@ namespace std
     valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
       : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
     {
-      __valarray_copy
+      std::__valarray_copy
 	(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
     }
 
@@ -302,7 +302,7 @@ namespace std
     valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
       : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
     {
-      __valarray_copy
+      std::__valarray_copy
 	(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
     }
 
@@ -310,21 +310,21 @@ namespace std
     inline
     valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
       : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
-    { __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
+    { std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); }
 
   template<typename _Tp>
     inline
     valarray<_Tp>::~valarray()
     {
-      __valarray_destroy_elements(_M_data, _M_data + _M_size);
-      __valarray_release_memory(_M_data);
+      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
+      std::__valarray_release_memory(_M_data);
     }
 
   template<typename _Tp>
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const valarray<_Tp>& __v)
     {
-      __valarray_copy(__v._M_data, _M_size, _M_data);
+      std::__valarray_copy(__v._M_data, _M_size, _M_data);
       return *this;
     }
 
@@ -332,7 +332,7 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const _Tp& __t)
     {
-      __valarray_fill(_M_data, _M_size, __t);
+      std::__valarray_fill(_M_data, _M_size, __t);
       return *this;
     }
 
@@ -340,8 +340,8 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
     {
-      __valarray_copy(__sa._M_array, __sa._M_sz,
-		      __sa._M_stride, _Array<_Tp>(_M_data));
+      std::__valarray_copy(__sa._M_array, __sa._M_sz,
+			   __sa._M_stride, _Array<_Tp>(_M_data));
       return *this;
     }
 
@@ -349,8 +349,8 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
     {
-      __valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
-		      _Array<_Tp>(_M_data), _M_size);
+      std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
+			   _Array<_Tp>(_M_data), _M_size);
       return *this;
     }
 
@@ -358,8 +358,8 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
     {
-      __valarray_copy(__ma._M_array, __ma._M_mask,
-		      _Array<_Tp>(_M_data), _M_size);
+      std::__valarray_copy(__ma._M_array, __ma._M_mask,
+			   _Array<_Tp>(_M_data), _M_size);
       return *this;
     }
 
@@ -367,8 +367,8 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
     {
-      __valarray_copy(__ia._M_array, __ia._M_index,
-		       _Array<_Tp>(_M_data), _M_size);
+      std::__valarray_copy(__ia._M_array, __ia._M_index,
+			   _Array<_Tp>(_M_data), _M_size);
       return *this;
     }
 
@@ -376,8 +376,8 @@ namespace std
     inline valarray<_Tp>&
     valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
     {
-      __valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
-	return *this;
+      std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
+      return *this;
     }
 
   template<typename _Tp>
@@ -460,7 +460,7 @@ namespace std
     inline _Tp
     valarray<_Tp>::sum() const
     {
-      return __valarray_sum(_M_data, _M_data + _M_size);
+      return std::__valarray_sum(_M_data, _M_data + _M_size);
     }
 
 //   template<typename _Tp>
@@ -477,21 +477,21 @@ namespace std
        _Tp* const __a = static_cast<_Tp*>
          (__builtin_alloca(sizeof(_Tp) * _M_size));
        if (__n == 0)                          // no shift
-         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
+         std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
        else if (__n > 0)         // __n > 0: shift left
          {                 
            if (size_t(__n) > _M_size)
-             __valarray_default_construct(__a, __a + __n);
+             std::__valarray_default_construct(__a, __a + __n);
            else
              {
-               __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
-               __valarray_default_construct(__a+_M_size-__n, __a + _M_size);
+               std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
+               std::__valarray_default_construct(__a+_M_size-__n, __a + _M_size);
              }
          }
        else                        // __n < 0: shift right
          {                          
-           __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
-           __valarray_default_construct(__a, __a - __n);
+           std::__valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
+           std::__valarray_default_construct(__a, __a - __n);
          }
        return valarray<_Tp> (__a, _M_size);
      }
@@ -503,17 +503,17 @@ namespace std
        _Tp* const __a = static_cast<_Tp*>
          (__builtin_alloca (sizeof(_Tp) * _M_size));
        if (__n == 0)               // no cshift
-         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
+         std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a);
        else if (__n > 0)           // cshift left
          {               
-           __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
-           __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
+           std::__valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
+           std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
          }
        else                        // cshift right
          {                       
-           __valarray_copy_construct
+           std::__valarray_copy_construct
              (_M_data + _M_size+__n, _M_data + _M_size, __a);
-           __valarray_copy_construct
+           std::__valarray_copy_construct
              (_M_data, _M_data + _M_size+__n, __a - __n);
          }
        return valarray<_Tp>(__a, _M_size);
@@ -526,28 +526,28 @@ namespace std
       // This complication is so to make valarray<valarray<T> > work
       // even though it is not required by the standard.  Nobody should
       // be saying valarray<valarray<T> > anyway.  See the specs.
-      __valarray_destroy_elements(_M_data, _M_data + _M_size);
+      std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
       if (_M_size != __n)
 	{
-	  __valarray_release_memory(_M_data);
+	  std::__valarray_release_memory(_M_data);
 	  _M_size = __n;
 	  _M_data = __valarray_get_storage<_Tp>(__n);
 	}
-      __valarray_fill_construct(_M_data, _M_data + __n, __c);
+      std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
     }
     
   template<typename _Tp>
     inline _Tp
     valarray<_Tp>::min() const
     {
-      return *min_element (_M_data, _M_data+_M_size);
+      return *std::min_element (_M_data, _M_data+_M_size);
     }
 
   template<typename _Tp>
     inline _Tp
     valarray<_Tp>::max() const
     {
-      return *max_element (_M_data, _M_data+_M_size);
+      return *std::max_element (_M_data, _M_data+_M_size);
     }
   
   template<class _Tp>