Merge basic-improvements-branch to trunk

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

15 files changed, 55 insertions, 55 deletions

diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc
index a8d43d024c2..00ec7ad9512 100644
--- a/libstdc++-v3/include/bits/deque.tcc
+++ b/libstdc++-v3/include/bits/deque.tcc
@@ -282,7 +282,7 @@ namespace std
       _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
                           forward_iterator_tag)
       {
-        size_type __n = distance(__first, __last);
+        size_type __n = std::distance(__first, __last);
         _M_initialize_map(__n);
       
         _Map_pointer __cur_node;
@@ -442,7 +442,7 @@ namespace std
                           _ForwardIterator __first, _ForwardIterator __last,
                           forward_iterator_tag)
       {
-        size_type __n = distance(__first, __last);
+        size_type __n = std::distance(__first, __last);
         if (__pos._M_cur == _M_start._M_cur)
         {
           iterator __new_start = _M_reserve_elements_at_front(__n);
@@ -758,7 +758,7 @@ namespace std
       else
       {
         size_type __new_map_size = 
-          _M_map_size + max(_M_map_size, __nodes_to_add) + 2;
+          _M_map_size + std::max(_M_map_size, __nodes_to_add) + 2;
     
         _Map_pointer __new_map = _M_allocate_map(__new_map_size);
         __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
diff --git a/libstdc++-v3/include/bits/fstream.tcc b/libstdc++-v3/include/bits/fstream.tcc
index 387f099ae98..e4bc382a74c 100644
--- a/libstdc++-v3/include/bits/fstream.tcc
+++ b/libstdc++-v3/include/bits/fstream.tcc
@@ -439,7 +439,7 @@ namespace std
 	  else
 	    {
 	      __ret = _M_file.seekoff(__off, ios_base::cur, __mode);
-	      __ret += max(_M_out_cur, _M_in_cur) - _M_filepos;
+	      __ret += std::max(_M_out_cur, _M_in_cur) - _M_filepos;
 	    }
 	}
       _M_last_overflowed = false;	
diff --git a/libstdc++-v3/include/bits/istream.tcc b/libstdc++-v3/include/bits/istream.tcc
index a6e49a923bd..3c64fbd89e5 100644
--- a/libstdc++-v3/include/bits/istream.tcc
+++ b/libstdc++-v3/include/bits/istream.tcc
@@ -724,7 +724,7 @@ namespace std
 	      __streambuf_type* __sb = this->rdbuf();
 	      int_type __c;
 	      
-	      __n = min(__n, numeric_limits<streamsize>::max());
+	      __n = std::min(__n, numeric_limits<streamsize>::max());
 	      while (_M_gcount < __n  
 		     && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
 		{
@@ -815,7 +815,7 @@ namespace std
 	      streamsize __num = this->rdbuf()->in_avail();
 	      if (__num >= 0)
 		{
-		  __num = min(__num, __n);
+		  __num = std::min(__num, __n);
 		  if (__num)
 		    _M_gcount = this->rdbuf()->sgetn(__s, __num);
 		}
diff --git a/libstdc++-v3/include/bits/locale_facets.tcc b/libstdc++-v3/include/bits/locale_facets.tcc
index ce6f3d7d5ff..75def8f5a61 100644
--- a/libstdc++-v3/include/bits/locale_facets.tcc
+++ b/libstdc++-v3/include/bits/locale_facets.tcc
@@ -1628,8 +1628,8 @@ namespace std
 	  // Find smallest matching string.
 	  size_t __minlen = 10;
 	  for (size_t __i2 = 0; __i2 < __nmatches; ++__i2)
-	    __minlen = min(__minlen, 
-			   __traits_type::length(__names[__matches[__i2]]));
+	    __minlen = std::min(__minlen, 
+				__traits_type::length(__names[__matches[__i2]]));
 	  
 	  if (__pos < __minlen && __beg != __end)
 	    {
diff --git a/libstdc++-v3/include/bits/sstream.tcc b/libstdc++-v3/include/bits/sstream.tcc
index 606705c02e9..b5848d858bd 100644
--- a/libstdc++-v3/include/bits/sstream.tcc
+++ b/libstdc++-v3/include/bits/sstream.tcc
@@ -91,7 +91,7 @@ namespace std
 	{
 	  if (!__testeof)
 	    {
-	      __size_type __len = max(_M_buf_size, _M_buf_size_opt);
+	      __size_type __len = std::max(_M_buf_size, _M_buf_size_opt);
 	      __len *= 2;
 
 	      if (__testwrite)
diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
index 009c409b6fb..719fb2714c7 100644
--- a/libstdc++-v3/include/bits/stl_algo.h
+++ b/libstdc++-v3/include/bits/stl_algo.h
@@ -1780,7 +1780,7 @@ __result, __binary_pred, _IterType());
 						      __pred,
 						      __len - __len / 2);
       rotate(__begin, __middle, __end);
-      advance(__begin, distance(__middle, __end));
+      advance(__begin, std::distance(__middle, __end));
       return __begin;
     }
 
@@ -1824,7 +1824,7 @@ __result, __binary_pred, _IterType());
 							  __len - __len / 2,
 							  __buffer, __buffer_size);
 	rotate(__begin, __middle, __end);
-	advance(__begin, distance(__middle, __end));
+	advance(__begin, std::distance(__middle, __end));
 	return __begin;
       }
     }
@@ -2271,7 +2271,7 @@ __result, __binary_pred, _IterType());
 	__first += __two_step;
       }
 
-      __step_size = min(_Distance(__last - __first), __step_size);
+      __step_size = std::min(_Distance(__last - __first), __step_size);
       merge(__first, __first + __step_size, __first + __step_size, __last,
 	    __result);
     }
@@ -2292,7 +2292,7 @@ __result, __binary_pred, _IterType());
 			 __comp);
 	__first += __two_step;
       }
-      __step_size = min(_Distance(__last - __first), __step_size);
+      __step_size = std::min(_Distance(__last - __first), __step_size);
 
       merge(__first, __first + __step_size,
 	    __first + __step_size, __last,
@@ -2781,7 +2781,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle;
 
@@ -2825,7 +2825,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle;
 
@@ -2866,7 +2866,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle;
 
@@ -2910,7 +2910,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_ForwardIteratorConcept<_ForwardIter>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle;
 
@@ -2958,7 +2958,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_SameTypeConcept<_Tp, _ValueType>)
       __glibcpp_function_requires(_LessThanComparableConcept<_Tp>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle, __left, __right;
 
@@ -3013,7 +3013,7 @@ __result, __binary_pred, _IterType());
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _ValueType, _Tp>)
       __glibcpp_function_requires(_BinaryPredicateConcept<_Compare, _Tp, _ValueType>)
 
-      _DistanceType __len = distance(__first, __last);
+      _DistanceType __len = std::distance(__first, __last);
       _DistanceType __half;
       _ForwardIter __middle, __left, __right;
 
@@ -3223,17 +3223,17 @@ __result, __binary_pred, _IterType());
 	__len11 = __len1 / 2;
 	advance(__first_cut, __len11);
 	__second_cut = lower_bound(__middle, __last, *__first_cut);
-	__len22 = distance(__middle, __second_cut);
+	__len22 = std::distance(__middle, __second_cut);
       }
       else {
 	__len22 = __len2 / 2;
 	advance(__second_cut, __len22);
 	__first_cut = upper_bound(__first, __middle, *__second_cut);
-	__len11 = distance(__first, __first_cut);
+	__len11 = std::distance(__first, __first_cut);
       }
       rotate(__first_cut, __middle, __second_cut);
       _BidirectionalIter __new_middle = __first_cut;
-      advance(__new_middle, distance(__middle, __second_cut));
+      advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22);
       __merge_without_buffer(__new_middle, __second_cut, __last,
@@ -3268,17 +3268,17 @@ __result, __binary_pred, _IterType());
 	__len11 = __len1 / 2;
 	advance(__first_cut, __len11);
 	__second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
-	__len22 = distance(__middle, __second_cut);
+	__len22 = std::distance(__middle, __second_cut);
       }
       else {
 	__len22 = __len2 / 2;
 	advance(__second_cut, __len22);
 	__first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
-	__len11 = distance(__first, __first_cut);
+	__len11 = std::distance(__first, __first_cut);
       }
       rotate(__first_cut, __middle, __second_cut);
       _BidirectionalIter __new_middle = __first_cut;
-      advance(__new_middle, distance(__middle, __second_cut));
+      advance(__new_middle, std::distance(__middle, __second_cut));
       __merge_without_buffer(__first, __first_cut, __new_middle,
 			     __len11, __len22, __comp);
       __merge_without_buffer(__new_middle, __second_cut, __last,
@@ -3313,7 +3313,7 @@ __result, __binary_pred, _IterType());
       }
       else {
 	rotate(__first, __middle, __last);
-	advance(__first, distance(__middle, __last));
+	advance(__first, std::distance(__middle, __last));
 	return __first;
       }
     }
@@ -3417,13 +3417,13 @@ __result, __binary_pred, _IterType());
 		  __len11 = __len1 / 2;
 		  advance(__first_cut, __len11);
 		  __second_cut = lower_bound(__middle, __last, *__first_cut);
-		  __len22 = distance(__middle, __second_cut);
+		  __len22 = std::distance(__middle, __second_cut);
 	    }
 	    else {
 		  __len22 = __len2 / 2;
 		  advance(__second_cut, __len22);
 		  __first_cut = upper_bound(__first, __middle, *__second_cut);
-		  __len11 = distance(__first, __first_cut);
+		  __len11 = std::distance(__first, __first_cut);
 	    }
 	    _BidirectionalIter __new_middle =
 		  __rotate_adaptive(__first_cut, __middle, __second_cut,
@@ -3469,13 +3469,13 @@ __result, __binary_pred, _IterType());
 		  __len11 = __len1 / 2;
 		  advance(__first_cut, __len11);
 		  __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
-		  __len22 = distance(__middle, __second_cut);
+		  __len22 = std::distance(__middle, __second_cut);
 	    }
 	    else {
 		  __len22 = __len2 / 2;
 		  advance(__second_cut, __len22);
 		  __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
-		  __len11 = distance(__first, __first_cut);
+		  __len11 = std::distance(__first, __first_cut);
 	    }
 	    _BidirectionalIter __new_middle =
 		  __rotate_adaptive(__first_cut, __middle, __second_cut,
@@ -3524,8 +3524,8 @@ __result, __binary_pred, _IterType());
       if (__first == __middle || __middle == __last)
 	return;
 
-      _DistanceType __len1 = distance(__first, __middle);
-      _DistanceType __len2 = distance(__middle, __last);
+      _DistanceType __len1 = std::distance(__first, __middle);
+      _DistanceType __len2 = std::distance(__middle, __last);
 
       _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
       if (__buf.begin() == 0)
@@ -3577,8 +3577,8 @@ __result, __binary_pred, _IterType());
       if (__first == __middle || __middle == __last)
 	return;
 
-      _DistanceType __len1 = distance(__first, __middle);
-      _DistanceType __len2 = distance(__middle, __last);
+      _DistanceType __len1 = std::distance(__first, __middle);
+      _DistanceType __len2 = std::distance(__middle, __last);
 
       _Temporary_buffer<_BidirectionalIter, _ValueType> __buf(__first, __last);
       if (__buf.begin() == 0)
@@ -4271,7 +4271,7 @@ __result, __binary_pred, _IterType());
 	return __last1;
       else {
 	_BidirectionalIter1 __result = __rresult.base();
-	advance(__result, -distance(__first2, __last2));
+	advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
     }
@@ -4301,7 +4301,7 @@ __result, __binary_pred, _IterType());
 	return __last1;
       else {
 	_BidirectionalIter1 __result = __rresult.base();
-	advance(__result, -distance(__first2, __last2));
+	advance(__result, -std::distance(__first2, __last2));
 	return __result;
       }
     }
diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index 6e488eae355..d19d1a012ea 100644
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -790,7 +790,7 @@ namespace std
   {
     const size_t __len1 = __last1 - __first1;
     const size_t __len2 = __last2 - __first2;
-    const int __result = memcmp(__first1, __first2, min(__len1, __len2));
+    const int __result = memcmp(__first1, __first2, std::min(__len1, __len2));
     return __result != 0 ? __result < 0 : __len1 < __len2;
   }
 
diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h
index 2c97d470582..da72b6460ab 100644
--- a/libstdc++-v3/include/bits/stl_bvector.h
+++ b/libstdc++-v3/include/bits/stl_bvector.h
@@ -410,7 +410,7 @@ template <typename _Alloc>
     template <class _ForwardIterator>
     void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
                              forward_iterator_tag) {
-      size_type __n = distance(__first, __last);
+      size_type __n = std::distance(__first, __last);
       _M_initialize(__n);
       copy(__first, __last, _M_start);
     }
@@ -430,14 +430,14 @@ template <typename _Alloc>
                          _ForwardIterator __first, _ForwardIterator __last,
                          forward_iterator_tag) {
       if (__first != __last) {
-        size_type __n = distance(__first, __last);
+        size_type __n = std::distance(__first, __last);
         if (capacity() - size() >= __n) {
           copy_backward(__position, end(), _M_finish + difference_type(__n));
           copy(__first, __last, __position);
           _M_finish += difference_type(__n);
         }
         else {
-          size_type __len = size() + max(size(), __n);
+          size_type __len = size() + std::max(size(), __n);
           _Bit_type * __q = _M_bit_alloc(__len);
           iterator __i = copy(begin(), __position, iterator(__q, 0));
           __i = copy(__first, __last, __i);
@@ -592,7 +592,7 @@ template <typename _Alloc>
     template <class _ForwardIterator>
     void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                        forward_iterator_tag) {
-      size_type __len = distance(__first, __last);
+      size_type __len = std::distance(__first, __last);
       if (__len < size())
         erase(copy(__first, __last, begin()), end());
       else {
@@ -677,7 +677,7 @@ template <typename _Alloc>
         _M_finish += difference_type(__n);
       }
       else {
-        size_type __len = size() + max(size(), __n);
+        size_type __len = size() + std::max(size(), __n);
         _Bit_type * __q = _M_bit_alloc(__len);
         iterator __i = copy(begin(), __position, iterator(__q, 0));
         fill_n(__i, __n, __x);
diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h
index 454fed31bf7..a32212dd717 100644
--- a/libstdc++-v3/include/bits/stl_deque.h
+++ b/libstdc++-v3/include/bits/stl_deque.h
@@ -497,7 +497,7 @@ namespace std
     size_t __num_nodes = 
       __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
   
-    _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);
+    _M_map_size = std::max((size_t) _S_initial_map_size, __num_nodes + 2);
     _M_map = _M_allocate_map(_M_map_size);
   
     // For "small" maps (needing less than _M_map_size nodes), allocation
@@ -1355,7 +1355,7 @@ namespace std
       _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     forward_iterator_tag)
       {
-        size_type __len = distance(__first, __last);
+        size_type __len = std::distance(__first, __last);
         if (__len > size()) {
           _ForwardIterator __mid = __first;
           advance(__mid, size());
diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h
index fcba3598df2..a13bc1aaaf0 100644
--- a/libstdc++-v3/include/bits/stl_list.h
+++ b/libstdc++-v3/include/bits/stl_list.h
@@ -629,7 +629,7 @@ namespace std
   
     /**  Returns the number of elements in the %list.  */
     size_type
-    size() const { return distance(begin(), end()); }
+    size() const { return std::distance(begin(), end()); }
   
     /**  Returns the size() of the largest possible %list.  */
     size_type
diff --git a/libstdc++-v3/include/bits/stl_tempbuf.h b/libstdc++-v3/include/bits/stl_tempbuf.h
index 7b88f9333ec..000e64a661a 100644
--- a/libstdc++-v3/include/bits/stl_tempbuf.h
+++ b/libstdc++-v3/include/bits/stl_tempbuf.h
@@ -118,7 +118,7 @@ public:
             _Trivial;
 
     try {
-      _M_len = distance(__first, __last);
+      _M_len = std::distance(__first, __last);
       _M_allocate_buffer();
       if (_M_len > 0)
         _M_initialize_buffer(*__first, _Trivial());
diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h
index 1e7fdf5db2d..42fd0b61b4d 100644
--- a/libstdc++-v3/include/bits/stl_tree.h
+++ b/libstdc++-v3/include/bits/stl_tree.h
@@ -1181,7 +1181,7 @@ namespace std
     _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
     {
       pair<iterator,iterator> __p = equal_range(__x);
-      size_type __n = distance(__p.first, __p.second);
+      size_type __n = std::distance(__p.first, __p.second);
       erase(__p.first, __p.second);
       return __n;
     }
@@ -1306,7 +1306,7 @@ namespace std
     count(const _Key& __k) const
     {
       pair<const_iterator, const_iterator> __p = equal_range(__k);
-      size_type __n = distance(__p.first, __p.second);
+      size_type __n = std::distance(__p.first, __p.second);
       return __n;
     }
 
diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h
index 53547322d65..83ed3c5f683 100644
--- a/libstdc++-v3/include/bits/stl_vector.h
+++ b/libstdc++-v3/include/bits/stl_vector.h
@@ -823,7 +823,7 @@ namespace std
         _M_range_initialize(_ForwardIterator __first,
 			    _ForwardIterator __last, forward_iterator_tag)
         {
-	  size_type __n = distance(__first, __last);
+	  size_type __n = std::distance(__first, __last);
 	  _M_start = _M_allocate(__n);
 	  _M_end_of_storage = _M_start + __n;
 	  _M_finish = uninitialized_copy(__first, __last, _M_start);
diff --git a/libstdc++-v3/include/bits/streambuf.tcc b/libstdc++-v3/include/bits/streambuf.tcc
index 5f57df583a7..73db2cdebfd 100644
--- a/libstdc++-v3/include/bits/streambuf.tcc
+++ b/libstdc++-v3/include/bits/streambuf.tcc
@@ -128,7 +128,7 @@ namespace std
 	  if (__buf_len > 0)
 	    {
 	      size_t __remaining = __n - __ret;
-	      size_t __len = min(__buf_len, __remaining);
+	      size_t __len = std::min(__buf_len, __remaining);
 	      traits_type::copy(__s, _M_in_cur, __len);
 	      __ret += __len;
 	      __s += __len;
@@ -167,7 +167,7 @@ namespace std
 	  if (__buf_len > 0)
 	    {
 	      off_type __remaining = __n - __ret;
-	      off_type __len = min(__buf_len, __remaining);
+	      off_type __len = std::min(__buf_len, __remaining);
 	      traits_type::copy(_M_out_cur, __s, __len);
 	      __ret += __len;
 	      __s += __len;
diff --git a/libstdc++-v3/include/bits/vector.tcc b/libstdc++-v3/include/bits/vector.tcc
index da5cf7edf83..4b22af0af15 100644
--- a/libstdc++-v3/include/bits/vector.tcc
+++ b/libstdc++-v3/include/bits/vector.tcc
@@ -191,7 +191,7 @@ namespace std
     _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
                   forward_iterator_tag)
     {
-      size_type __len = distance(__first, __last);
+      size_type __len = std::distance(__first, __last);
   
       if (__len > capacity())
       {
@@ -333,7 +333,7 @@ namespace std
         else
 	  {
 	    const size_type __old_size = size();
-	    const size_type __len = __old_size + max(__old_size, __n);
+	    const size_type __len = __old_size + std::max(__old_size, __n);
 	    iterator __new_start(_M_allocate(__len));
 	    iterator __new_finish(__new_start);
 	    try
@@ -381,7 +381,7 @@ namespace std
     {
       if (__first != __last)
       {
-        size_type __n = distance(__first, __last);
+        size_type __n = std::distance(__first, __last);
         if (size_type(_M_end_of_storage - _M_finish) >= __n)
         {
           const size_type __elems_after = end() - __position;
@@ -407,7 +407,7 @@ namespace std
         else
         {
           const size_type __old_size = size();
-          const size_type __len = __old_size + max(__old_size, __n);
+          const size_type __len = __old_size + std::max(__old_size, __n);
           iterator __new_start(_M_allocate(__len));
           iterator __new_finish(__new_start);
           try