This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[v3] Last std:: qualification for today...
- From: Paolo Carlini <pcarlini at unitus dot it>
- To: gcc-patches at gcc dot gnu dot org
- Date: Fri, 04 Jul 2003 22:44:16 +0200
- Subject: [v3] Last std:: qualification for today...
Hi,
this completes the include/bits directory. Tested x86-linux.
Paolo.
///////
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.
diff -urN libstdc++-v3-orig/include/bits/deque.tcc libstdc++-v3/include/bits/deque.tcc
--- libstdc++-v3-orig/include/bits/deque.tcc 2003-06-10 23:52:23.000000000 +0200
+++ libstdc++-v3/include/bits/deque.tcc 2003-07-04 21:17:13.000000000 +0200
@@ -72,11 +72,11 @@
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 @@
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 @@
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 @@
__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 @@
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 @@
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 @@
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,
- this->_M_finish._M_cur,
- __value);
+ 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 @@
++__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 @@
*(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 @@
{
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 @@
_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 @@
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 @@
_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 @@
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 @@
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 @@
__pos = this->_M_start + __index;
iterator __pos1 = __pos;
++__pos1;
- copy(__front2, __pos1, __front1);
+ std::copy(__front2, __pos1, __front1);
}
else
{
@@ -462,7 +462,7 @@
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 @@
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,
- this->_M_start, __x_copy);
+ 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 @@
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,
- __pos + difference_type(__n),
- __x_copy, __pos, 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 @@
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,
- __first, __mid, __new_start);
+ 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 @@
if (__elemsafter > 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);
- 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,
- this->_M_finish, this->_M_finish);
+ 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,13 +679,13 @@
= 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,
- this->_M_finish._M_node + 1,
- __new_nstart);
+ std::copy(this->_M_start._M_node,
+ this->_M_finish._M_node + 1,
+ __new_nstart);
else
- copy_backward(this->_M_start._M_node,
- this->_M_finish._M_node + 1,
- __new_nstart + __old_num_nodes);
+ std::copy_backward(this->_M_start._M_node,
+ this->_M_finish._M_node + 1,
+ __new_nstart + __old_num_nodes);
}
else
{
@@ -695,9 +695,9 @@
_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,
- this->_M_finish._M_node + 1,
- __new_nstart);
+ 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);
this->_M_map = __new_map;
diff -urN libstdc++-v3-orig/include/bits/gslice_array.h libstdc++-v3/include/bits/gslice_array.h
--- libstdc++-v3-orig/include/bits/gslice_array.h 2002-08-05 04:09:27.000000000 +0200
+++ libstdc++-v3/include/bits/gslice_array.h 2003-07-04 21:20:26.000000000 +0200
@@ -116,16 +116,16 @@
inline void
gslice_array<_Tp>::operator=(const _Tp& __t) const
{
- __valarray_fill(_M_array, _Array<size_t>(_M_index),
- _M_index.size(), __t);
+ std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
+ _M_index.size(), __t);
}
template<typename _Tp>
inline void
gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
{
- __valarray_copy(_Array<_Tp>(__v), __v.size(),
- _M_array, _Array<size_t>(_M_index));
+ std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
+ _M_array, _Array<size_t>(_M_index));
}
template<typename _Tp>
@@ -133,8 +133,8 @@
inline void
gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
{
- __valarray_copy (__e, _M_index.size(), _M_array,
- _Array<size_t>(_M_index));
+ std::__valarray_copy (__e, _M_index.size(), _M_array,
+ _Array<size_t>(_M_index));
}
#undef _DEFINE_VALARRAY_OPERATOR
diff -urN libstdc++-v3-orig/include/bits/indirect_array.h libstdc++-v3/include/bits/indirect_array.h
--- libstdc++-v3-orig/include/bits/indirect_array.h 2002-08-05 04:09:27.000000000 +0200
+++ libstdc++-v3/include/bits/indirect_array.h 2003-07-04 21:21:09.000000000 +0200
@@ -118,7 +118,7 @@
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 @@
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) \
diff -urN libstdc++-v3-orig/include/bits/list.tcc libstdc++-v3/include/bits/list.tcc
--- libstdc++-v3-orig/include/bits/list.tcc 2003-06-10 23:52:23.000000000 +0200
+++ libstdc++-v3/include/bits/list.tcc 2003-07-04 21:22:43.000000000 +0200
@@ -74,7 +74,7 @@
{
_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 @@
_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));
}
diff -urN libstdc++-v3-orig/include/bits/locale_classes.h libstdc++-v3/include/bits/locale_classes.h
--- libstdc++-v3-orig/include/bits/locale_classes.h 2003-06-27 09:25:37.000000000 +0200
+++ libstdc++-v3/include/bits/locale_classes.h 2003-07-04 21:23:41.000000000 +0200
@@ -348,7 +348,7 @@
{
bool __ret = true;
for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
- __ret &= (strcmp(_M_names[__i], _M_names[__i + 1]) == 0);
+ __ret &= (std::strcmp(_M_names[__i], _M_names[__i + 1]) == 0);
return __ret;
}
@@ -386,7 +386,7 @@
{
delete [] _M_impl->_M_names[__i];
char* __new = new char[2];
- strcpy(__new, "*");
+ std::strcpy(__new, "*");
_M_impl->_M_names[__i] = __new;
}
}
diff -urN libstdc++-v3-orig/include/bits/mask_array.h libstdc++-v3/include/bits/mask_array.h
--- libstdc++-v3-orig/include/bits/mask_array.h 2002-08-05 04:09:27.000000000 +0200
+++ libstdc++-v3/include/bits/mask_array.h 2003-07-04 21:25:47.000000000 +0200
@@ -114,18 +114,18 @@
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) \
diff -urN libstdc++-v3-orig/include/bits/slice_array.h libstdc++-v3/include/bits/slice_array.h
--- libstdc++-v3-orig/include/bits/slice_array.h 2002-12-10 08:32:04.000000000 +0100
+++ libstdc++-v3/include/bits/slice_array.h 2003-07-04 21:26:16.000000000 +0200
@@ -157,26 +157,26 @@
inline slice_array<_Tp>&
slice_array<_Tp>::operator=(const slice_array<_Tp>& __a)
{
- __valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
- _M_array, _M_stride);
+ std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride,
+ _M_array, _M_stride);
return *this;
}
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) \