FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

valarray_array.h: Fully qualify standard functions with std::, thus avoiding Koenig lookup.

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

	* include/bits/valarray_array.h: Fully qualify standard
	functions with std::, thus avoiding Koenig lookup.
	* include/bits/vector.tcc: Likewise.

From-SVN: r68927
This commit is contained in:
Paolo Carlini 2003-07-04 20:14:27 +02:00 • committed by Paolo Carlini
parent a30335e9c4
commit 2f8058688a
3 changed files with 95 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,9 @@
2003-07-04 Paolo Carlini <pcarlini@unitus.it>
* include/bits/valarray_array.h: Fully qualify standard
functions with std::, thus avoiding Koenig lookup.
* include/bits/vector.tcc: Likewise.
2003-07-04 Benjamin Kosnik <bkoz@redhat.com>
* include/Makefile.am: Update target_ to host_.

32
libstdc++-v3/include/bits/valarray_array.h
View file

@ -61,7 +61,7 @@ namespace std
__valarray_get_storage(size_t __n)
{
return static_cast<_Tp*__restrict__>
(__valarray_get_memory(__n * sizeof(_Tp)));
(std::__valarray_get_memory(__n * sizeof(_Tp)));
}
// Return memory to the system
@ -87,7 +87,7 @@ namespace std
// For fundamental types, it suffices to say 'memset()'
inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e)
{ memset(__b, 0, (__e - __b)*sizeof(_Tp)); }
{ std::memset(__b, 0, (__e - __b)*sizeof(_Tp)); }
};
template<typename _Tp>
@ -149,7 +149,7 @@ namespace std
inline static void
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
_Tp* __restrict__ __o)
{ memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
{ std::memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
};
template<typename _Tp>
@ -231,7 +231,7 @@ namespace std
{
inline static void
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
{ memcpy (__b, __a, __n * sizeof (_Tp)); }
{ std::memcpy (__b, __a, __n * sizeof (_Tp)); }
};
// Copy a plain array __a[<__n>] into a play array __b[<>]
@ -379,30 +379,30 @@ namespace std
template<typename _Tp>
inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
{ __valarray_fill (__a._M_data, __n, __t); }
{ std::__valarray_fill (__a._M_data, __n, __t); }
template<typename _Tp>
inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
{ __valarray_fill (__a._M_data, __n, __s, __t); }
{ std::__valarray_fill (__a._M_data, __n, __s, __t); }
template<typename _Tp>
inline void
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
size_t __n, const _Tp& __t)
{ __valarray_fill (__a._M_data, __i._M_data, __n, __t); }
{ std::__valarray_fill (__a._M_data, __i._M_data, __n, __t); }
// Copy a plain array __a[<__n>] into a play array __b[<>]
template<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
{ __valarray_copy(__a._M_data, __n, __b._M_data); }
{ std::__valarray_copy(__a._M_data, __n, __b._M_data); }
// Copy strided array __a[<__n : __s>] in plain __b[<__n>]
template<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
{ __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
{ std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
// Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
template<typename _Tp>
@ -416,7 +416,7 @@ namespace std
inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
_Array<_Tp> __b, size_t __s2)
{ __valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
{ std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
// Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
@ -424,14 +424,14 @@ namespace std
inline void
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
_Array<_Tp> __b, size_t __n)
{ __valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
{ std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
// Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
template<typename _Tp>
inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
_Array<size_t> __i)
{ __valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
{ std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
// Copy the __n first elements of an indexed array __src[<__i>] into
// another indexed array __dst[<__j>].
@ -440,15 +440,15 @@ namespace std
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
_Array<_Tp> __dst, _Array<size_t> __j)
{
__valarray_copy(__src._M_data, __n, __i._M_data,
__dst._M_data, __j._M_data);
std::__valarray_copy(__src._M_data, __n, __i._M_data,
__dst._M_data, __j._M_data);
}
template<typename _Tp>
inline
_Array<_Tp>::_Array (size_t __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
@ -462,7 +462,7 @@ namespace std
inline
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
: _M_data(__valarray_get_storage<_Tp>(__s))
{ __valarray_copy_construct(__b, __s, _M_data); }
{ std::__valarray_copy_construct(__b, __s, _M_data); }
template<typename _Tp>
inline _Tp*

146
libstdc++-v3/include/bits/vector.tcc
View file

@ -76,7 +76,7 @@ namespace std
pointer __tmp = _M_allocate_and_copy(__n,
this->_M_start,
this->_M_finish);
_Destroy(this->_M_start, this->_M_finish);
std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp;
@ -93,7 +93,7 @@ namespace std
size_type __n = __position - begin();
if (this->_M_finish != this->_M_end_of_storage && __position == end())
{
_Construct(this->_M_finish, __x);
std::_Construct(this->_M_finish, __x);
++this->_M_finish;
}
else
@ -107,9 +107,9 @@ namespace std
erase(iterator __position)
{
if (__position + 1 != end())
copy(__position + 1, end(), __position);
std::copy(__position + 1, end(), __position);
--this->_M_finish;
_Destroy(this->_M_finish);
std::_Destroy(this->_M_finish);
return __position;
}
@ -119,7 +119,7 @@ namespace std
erase(iterator __first, iterator __last)
{
iterator __i(copy(__last, end(), __first));
_Destroy(__i, end());
std::_Destroy(__i, end());
this->_M_finish = this->_M_finish - (__last - __first);
return __first;
}
@ -135,7 +135,7 @@ namespace std
if (__xlen > capacity())
{
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
_Destroy(this->_M_start, this->_M_finish);
std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp;
@ -144,12 +144,12 @@ namespace std
else if (size() >= __xlen)
{
iterator __i(copy(__x.begin(), __x.end(), begin()));
_Destroy(__i, end());
std::_Destroy(__i, end());
}
else
{
copy(__x.begin(), __x.begin() + size(), this->_M_start);
uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_finish);
std::copy(__x.begin(), __x.begin() + size(), this->_M_start);
std::uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_finish);
}
this->_M_finish = this->_M_start + __xlen;
}
@ -168,9 +168,9 @@ namespace std
}
else if (__n > size())
{
fill(begin(), end(), __val);
std::fill(begin(), end(), __val);
this->_M_finish
= uninitialized_fill_n(this->_M_finish, __n - size(), __val);
= std::uninitialized_fill_n(this->_M_finish, __n - size(), __val);
}
else
erase(fill_n(begin(), __n, __val), end());
@ -201,7 +201,7 @@ namespace std
if (__len > capacity())
{
pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
_Destroy(this->_M_start, this->_M_finish);
std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp;
@ -210,15 +210,15 @@ namespace std
else if (size() >= __len)
{
iterator __new_finish(copy(__first, __last, this->_M_start));
_Destroy(__new_finish, end());
std::_Destroy(__new_finish, end());
this->_M_finish = __new_finish.base();
}
else
{
_ForwardIterator __mid = __first;
advance(__mid, size());
copy(__first, __mid, this->_M_start);
this->_M_finish = uninitialized_copy(__mid, __last, this->_M_finish);
std::advance(__mid, size());
std::copy(__first, __mid, this->_M_start);
this->_M_finish = std::uninitialized_copy(__mid, __last, this->_M_finish);
}
}
@ -229,12 +229,12 @@ namespace std
{
if (this->_M_finish != this->_M_end_of_storage)
{
_Construct(this->_M_finish, *(this->_M_finish - 1));
std::_Construct(this->_M_finish, *(this->_M_finish - 1));
++this->_M_finish;
_Tp __x_copy = __x;
copy_backward(__position,
iterator(this->_M_finish-2),
iterator(this->_M_finish-1));
std::copy_backward(__position,
iterator(this->_M_finish-2),
iterator(this->_M_finish-1));
*__position = __x_copy;
}
else
@ -245,22 +245,22 @@ namespace std
iterator __new_finish(__new_start);
try
{
__new_finish = uninitialized_copy(iterator(this->_M_start),
__position,
__new_start);
_Construct(__new_finish.base(), __x);
__new_finish = std::uninitialized_copy(iterator(this->_M_start),
__position,
__new_start);
std::_Construct(__new_finish.base(), __x);
++__new_finish;
__new_finish = uninitialized_copy(__position,
iterator(this->_M_finish),
__new_finish);
__new_finish = std::uninitialized_copy(__position,
iterator(this->_M_finish),
__new_finish);
}
catch(...)
{
_Destroy(__new_start,__new_finish);
std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(),__len);
__throw_exception_again;
}
_Destroy(begin(), end());
std::_Destroy(begin(), end());
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base();
@ -277,10 +277,10 @@ namespace std
{
if (_M_finish != _M_end_of_storage)
{
_Construct(_M_finish, *(_M_finish - 1));
std::_Construct(_M_finish, *(_M_finish - 1));
++_M_finish;
copy_backward(__position, iterator(_M_finish - 2),
iterator(_M_finish - 1));
std::copy_backward(__position, iterator(_M_finish - 2),
iterator(_M_finish - 1));
*__position = value_type();
}
else
@ -291,20 +291,20 @@ namespace std
pointer __new_finish = __new_start;
try
{
__new_finish = uninitialized_copy(iterator(_M_start), __position,
__new_start);
_Construct(__new_finish);
__new_finish = std::uninitialized_copy(iterator(_M_start), __position,
__new_start);
std::_Construct(__new_finish);
++__new_finish;
__new_finish = uninitialized_copy(__position, iterator(_M_finish),
__new_finish);
__new_finish = std::uninitialized_copy(__position, iterator(_M_finish),
__new_finish);
}
catch(...)
{
_Destroy(__new_start,__new_finish);
std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start,__len);
__throw_exception_again;
}
_Destroy(begin(), end());
std::_Destroy(begin(), end());
_M_deallocate(_M_start, _M_end_of_storage - _M_start);
_M_start = __new_start;
_M_finish = __new_finish;
@ -327,22 +327,22 @@ namespace std
iterator __old_finish(this->_M_finish);
if (__elems_after > __n)
{
uninitialized_copy(this->_M_finish - __n,
this->_M_finish,
this->_M_finish);
std::uninitialized_copy(this->_M_finish - __n,
this->_M_finish,
this->_M_finish);
this->_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish);
fill(__position, __position + __n, __x_copy);
std::copy_backward(__position, __old_finish - __n, __old_finish);
std::fill(__position, __position + __n, __x_copy);
}
else
{
uninitialized_fill_n(this->_M_finish,
__n - __elems_after,
__x_copy);
std::uninitialized_fill_n(this->_M_finish,
__n - __elems_after,
__x_copy);
this->_M_finish += __n - __elems_after;
uninitialized_copy(__position, __old_finish, this->_M_finish);
std::uninitialized_copy(__position, __old_finish, this->_M_finish);
this->_M_finish += __elems_after;
fill(__position, __old_finish, __x_copy);
std::fill(__position, __old_finish, __x_copy);
}
}
else
@ -353,19 +353,19 @@ namespace std
iterator __new_finish(__new_start);
try
{
__new_finish = uninitialized_copy(begin(), __position,
__new_start);
__new_finish = uninitialized_fill_n(__new_finish, __n, __x);
__new_finish = uninitialized_copy(__position, end(),
__new_finish);
__new_finish = std::uninitialized_copy(begin(), __position,
__new_start);
__new_finish = std::uninitialized_fill_n(__new_finish, __n, __x);
__new_finish = std::uninitialized_copy(__position, end(),
__new_finish);
}
catch(...)
{
_Destroy(__new_start,__new_finish);
std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(),__len);
__throw_exception_again;
}
_Destroy(this->_M_start, this->_M_finish);
std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base();
@ -404,22 +404,22 @@ namespace std
iterator __old_finish(this->_M_finish);
if (__elems_after > __n)
{
uninitialized_copy(this->_M_finish - __n,
this->_M_finish,
this->_M_finish);
std::uninitialized_copy(this->_M_finish - __n,
this->_M_finish,
this->_M_finish);
this->_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish);
copy(__first, __last, __position);
std::copy_backward(__position, __old_finish - __n, __old_finish);
std::copy(__first, __last, __position);
}
else
{
_ForwardIterator __mid = __first;
advance(__mid, __elems_after);
uninitialized_copy(__mid, __last, this->_M_finish);
std::advance(__mid, __elems_after);
std::uninitialized_copy(__mid, __last, this->_M_finish);
this->_M_finish += __n - __elems_after;
uninitialized_copy(__position, __old_finish, this->_M_finish);
std::uninitialized_copy(__position, __old_finish, this->_M_finish);
this->_M_finish += __elems_after;
copy(__first, __mid, __position);
std::copy(__first, __mid, __position);
}
}
else
@ -430,20 +430,20 @@ namespace std
iterator __new_finish(__new_start);
try
{
__new_finish = uninitialized_copy(iterator(this->_M_start),
__position, __new_start);
__new_finish = uninitialized_copy(__first, __last, __new_finish);
__new_finish = uninitialized_copy(__position,
iterator(this->_M_finish),
__new_finish);
__new_finish = std::uninitialized_copy(iterator(this->_M_start),
__position, __new_start);
__new_finish = std::uninitialized_copy(__first, __last, __new_finish);
__new_finish = std::uninitialized_copy(__position,
iterator(this->_M_finish),
__new_finish);
}
catch(...)
{
_Destroy(__new_start,__new_finish);
std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(), __len);
__throw_exception_again;
}
_Destroy(this->_M_start, this->_M_finish);
std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base();