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> 2003-07-04 Benjamin Kosnik <bkoz@redhat.com>
* include/Makefile.am: Update target_ to host_. * 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) __valarray_get_storage(size_t __n)
{ {
return static_cast<_Tp*__restrict__> return static_cast<_Tp*__restrict__>
(__valarray_get_memory(__n * sizeof(_Tp))); (std::__valarray_get_memory(__n * sizeof(_Tp)));
} }
// Return memory to the system // Return memory to the system
@ -87,7 +87,7 @@ namespace std
// For fundamental types, it suffices to say 'memset()' // For fundamental types, it suffices to say 'memset()'
inline static void inline static void
_S_do_it(_Tp* __restrict__ __b, _Tp* __restrict__ __e) _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> template<typename _Tp>
@ -149,7 +149,7 @@ namespace std
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e, _S_do_it(const _Tp* __restrict__ __b, const _Tp* __restrict__ __e,
_Tp* __restrict__ __o) _Tp* __restrict__ __o)
{ memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); } { std::memcpy(__o, __b, (__e - __b)*sizeof(_Tp)); }
}; };
template<typename _Tp> template<typename _Tp>
@ -231,7 +231,7 @@ namespace std
{ {
inline static void inline static void
_S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) _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[<>] // Copy a plain array __a[<__n>] into a play array __b[<>]
@ -379,30 +379,30 @@ namespace std
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) __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> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) __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> template<typename _Tp>
inline void inline void
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i, __valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
size_t __n, const _Tp& __t) 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[<>] // Copy a plain array __a[<__n>] into a play array __b[<>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) __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>] // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) __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>] // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
template<typename _Tp> template<typename _Tp>
@ -416,7 +416,7 @@ namespace std
inline void inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1, __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
_Array<_Tp> __b, size_t __s2) _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>] // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
@ -424,14 +424,14 @@ namespace std
inline void inline void
__valarray_copy(_Array<_Tp> __a, _Array<size_t> __i, __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
_Array<_Tp> __b, size_t __n) _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>]] // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
template<typename _Tp> template<typename _Tp>
inline void inline void
__valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
_Array<size_t> __i) _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 // Copy the __n first elements of an indexed array __src[<__i>] into
// another indexed array __dst[<__j>]. // another indexed array __dst[<__j>].
@ -440,15 +440,15 @@ namespace std
__valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i, __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
_Array<_Tp> __dst, _Array<size_t> __j) _Array<_Tp> __dst, _Array<size_t> __j)
{ {
__valarray_copy(__src._M_data, __n, __i._M_data, std::__valarray_copy(__src._M_data, __n, __i._M_data,
__dst._M_data, __j._M_data); __dst._M_data, __j._M_data);
} }
template<typename _Tp> template<typename _Tp>
inline inline
_Array<_Tp>::_Array (size_t __n) _Array<_Tp>::_Array (size_t __n)
: _M_data(__valarray_get_storage<_Tp>(__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> template<typename _Tp>
inline inline
@ -462,7 +462,7 @@ namespace std
inline inline
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s) _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
: _M_data(__valarray_get_storage<_Tp>(__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> template<typename _Tp>
inline _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, pointer __tmp = _M_allocate_and_copy(__n,
this->_M_start, this->_M_start,
this->_M_finish); this->_M_finish);
_Destroy(this->_M_start, this->_M_finish); std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp; this->_M_start = __tmp;
@ -93,7 +93,7 @@ namespace std
size_type __n = __position - begin(); size_type __n = __position - begin();
if (this->_M_finish != this->_M_end_of_storage && __position == end()) 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; ++this->_M_finish;
} }
else else
@ -107,9 +107,9 @@ namespace std
erase(iterator __position) erase(iterator __position)
{ {
if (__position + 1 != end()) if (__position + 1 != end())
copy(__position + 1, end(), __position); std::copy(__position + 1, end(), __position);
--this->_M_finish; --this->_M_finish;
_Destroy(this->_M_finish); std::_Destroy(this->_M_finish);
return __position; return __position;
} }
@ -119,7 +119,7 @@ namespace std
erase(iterator __first, iterator __last) erase(iterator __first, iterator __last)
{ {
iterator __i(copy(__last, end(), __first)); iterator __i(copy(__last, end(), __first));
_Destroy(__i, end()); std::_Destroy(__i, end());
this->_M_finish = this->_M_finish - (__last - __first); this->_M_finish = this->_M_finish - (__last - __first);
return __first; return __first;
} }
@ -135,7 +135,7 @@ namespace std
if (__xlen > capacity()) if (__xlen > capacity())
{ {
pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end()); 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, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp; this->_M_start = __tmp;
@ -144,12 +144,12 @@ namespace std
else if (size() >= __xlen) else if (size() >= __xlen)
{ {
iterator __i(copy(__x.begin(), __x.end(), begin())); iterator __i(copy(__x.begin(), __x.end(), begin()));
_Destroy(__i, end()); std::_Destroy(__i, end());
} }
else else
{ {
copy(__x.begin(), __x.begin() + size(), this->_M_start); std::copy(__x.begin(), __x.begin() + size(), this->_M_start);
uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_finish); std::uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_finish);
} }
this->_M_finish = this->_M_start + __xlen; this->_M_finish = this->_M_start + __xlen;
} }
@ -168,9 +168,9 @@ namespace std
} }
else if (__n > size()) else if (__n > size())
{ {
fill(begin(), end(), __val); std::fill(begin(), end(), __val);
this->_M_finish this->_M_finish
= uninitialized_fill_n(this->_M_finish, __n - size(), __val); = std::uninitialized_fill_n(this->_M_finish, __n - size(), __val);
} }
else else
erase(fill_n(begin(), __n, __val), end()); erase(fill_n(begin(), __n, __val), end());
@ -201,7 +201,7 @@ namespace std
if (__len > capacity()) if (__len > capacity())
{ {
pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); 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, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __tmp; this->_M_start = __tmp;
@ -210,15 +210,15 @@ namespace std
else if (size() >= __len) else if (size() >= __len)
{ {
iterator __new_finish(copy(__first, __last, this->_M_start)); iterator __new_finish(copy(__first, __last, this->_M_start));
_Destroy(__new_finish, end()); std::_Destroy(__new_finish, end());
this->_M_finish = __new_finish.base(); this->_M_finish = __new_finish.base();
} }
else else
{ {
_ForwardIterator __mid = __first; _ForwardIterator __mid = __first;
advance(__mid, size()); std::advance(__mid, size());
copy(__first, __mid, this->_M_start); std::copy(__first, __mid, this->_M_start);
this->_M_finish = uninitialized_copy(__mid, __last, this->_M_finish); 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) 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; ++this->_M_finish;
_Tp __x_copy = __x; _Tp __x_copy = __x;
copy_backward(__position, std::copy_backward(__position,
iterator(this->_M_finish-2), iterator(this->_M_finish-2),
iterator(this->_M_finish-1)); iterator(this->_M_finish-1));
*__position = __x_copy; *__position = __x_copy;
} }
else else
@ -245,22 +245,22 @@ namespace std
iterator __new_finish(__new_start); iterator __new_finish(__new_start);
try try
{ {
__new_finish = uninitialized_copy(iterator(this->_M_start), __new_finish = std::uninitialized_copy(iterator(this->_M_start),
__position, __position,
__new_start); __new_start);
_Construct(__new_finish.base(), __x); std::_Construct(__new_finish.base(), __x);
++__new_finish; ++__new_finish;
__new_finish = uninitialized_copy(__position, __new_finish = std::uninitialized_copy(__position,
iterator(this->_M_finish), iterator(this->_M_finish),
__new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
_Destroy(__new_start,__new_finish); std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(),__len); _M_deallocate(__new_start.base(),__len);
__throw_exception_again; __throw_exception_again;
} }
_Destroy(begin(), end()); std::_Destroy(begin(), end());
_M_deallocate(this->_M_start, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base(); this->_M_start = __new_start.base();
@ -277,10 +277,10 @@ namespace std
{ {
if (_M_finish != _M_end_of_storage) if (_M_finish != _M_end_of_storage)
{ {
_Construct(_M_finish, *(_M_finish - 1)); std::_Construct(_M_finish, *(_M_finish - 1));
++_M_finish; ++_M_finish;
copy_backward(__position, iterator(_M_finish - 2), std::copy_backward(__position, iterator(_M_finish - 2),
iterator(_M_finish - 1)); iterator(_M_finish - 1));
*__position = value_type(); *__position = value_type();
} }
else else
@ -291,20 +291,20 @@ namespace std
pointer __new_finish = __new_start; pointer __new_finish = __new_start;
try try
{ {
__new_finish = uninitialized_copy(iterator(_M_start), __position, __new_finish = std::uninitialized_copy(iterator(_M_start), __position,
__new_start); __new_start);
_Construct(__new_finish); std::_Construct(__new_finish);
++__new_finish; ++__new_finish;
__new_finish = uninitialized_copy(__position, iterator(_M_finish), __new_finish = std::uninitialized_copy(__position, iterator(_M_finish),
__new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
_Destroy(__new_start,__new_finish); std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start,__len); _M_deallocate(__new_start,__len);
__throw_exception_again; __throw_exception_again;
} }
_Destroy(begin(), end()); std::_Destroy(begin(), end());
_M_deallocate(_M_start, _M_end_of_storage - _M_start); _M_deallocate(_M_start, _M_end_of_storage - _M_start);
_M_start = __new_start; _M_start = __new_start;
_M_finish = __new_finish; _M_finish = __new_finish;
@ -327,22 +327,22 @@ namespace std
iterator __old_finish(this->_M_finish); iterator __old_finish(this->_M_finish);
if (__elems_after > __n) if (__elems_after > __n)
{ {
uninitialized_copy(this->_M_finish - __n, std::uninitialized_copy(this->_M_finish - __n,
this->_M_finish, this->_M_finish,
this->_M_finish); this->_M_finish);
this->_M_finish += __n; this->_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish); std::copy_backward(__position, __old_finish - __n, __old_finish);
fill(__position, __position + __n, __x_copy); std::fill(__position, __position + __n, __x_copy);
} }
else else
{ {
uninitialized_fill_n(this->_M_finish, std::uninitialized_fill_n(this->_M_finish,
__n - __elems_after, __n - __elems_after,
__x_copy); __x_copy);
this->_M_finish += __n - __elems_after; 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; this->_M_finish += __elems_after;
fill(__position, __old_finish, __x_copy); std::fill(__position, __old_finish, __x_copy);
} }
} }
else else
@ -353,19 +353,19 @@ namespace std
iterator __new_finish(__new_start); iterator __new_finish(__new_start);
try try
{ {
__new_finish = uninitialized_copy(begin(), __position, __new_finish = std::uninitialized_copy(begin(), __position,
__new_start); __new_start);
__new_finish = uninitialized_fill_n(__new_finish, __n, __x); __new_finish = std::uninitialized_fill_n(__new_finish, __n, __x);
__new_finish = uninitialized_copy(__position, end(), __new_finish = std::uninitialized_copy(__position, end(),
__new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
_Destroy(__new_start,__new_finish); std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(),__len); _M_deallocate(__new_start.base(),__len);
__throw_exception_again; __throw_exception_again;
} }
_Destroy(this->_M_start, this->_M_finish); std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base(); this->_M_start = __new_start.base();
@ -404,22 +404,22 @@ namespace std
iterator __old_finish(this->_M_finish); iterator __old_finish(this->_M_finish);
if (__elems_after > __n) if (__elems_after > __n)
{ {
uninitialized_copy(this->_M_finish - __n, std::uninitialized_copy(this->_M_finish - __n,
this->_M_finish, this->_M_finish,
this->_M_finish); this->_M_finish);
this->_M_finish += __n; this->_M_finish += __n;
copy_backward(__position, __old_finish - __n, __old_finish); std::copy_backward(__position, __old_finish - __n, __old_finish);
copy(__first, __last, __position); std::copy(__first, __last, __position);
} }
else else
{ {
_ForwardIterator __mid = __first; _ForwardIterator __mid = __first;
advance(__mid, __elems_after); std::advance(__mid, __elems_after);
uninitialized_copy(__mid, __last, this->_M_finish); std::uninitialized_copy(__mid, __last, this->_M_finish);
this->_M_finish += __n - __elems_after; 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; this->_M_finish += __elems_after;
copy(__first, __mid, __position); std::copy(__first, __mid, __position);
} }
} }
else else
@ -430,20 +430,20 @@ namespace std
iterator __new_finish(__new_start); iterator __new_finish(__new_start);
try try
{ {
__new_finish = uninitialized_copy(iterator(this->_M_start), __new_finish = std::uninitialized_copy(iterator(this->_M_start),
__position, __new_start); __position, __new_start);
__new_finish = uninitialized_copy(__first, __last, __new_finish); __new_finish = std::uninitialized_copy(__first, __last, __new_finish);
__new_finish = uninitialized_copy(__position, __new_finish = std::uninitialized_copy(__position,
iterator(this->_M_finish), iterator(this->_M_finish),
__new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
_Destroy(__new_start,__new_finish); std::_Destroy(__new_start,__new_finish);
_M_deallocate(__new_start.base(), __len); _M_deallocate(__new_start.base(), __len);
__throw_exception_again; __throw_exception_again;
} }
_Destroy(this->_M_start, this->_M_finish); std::_Destroy(this->_M_start, this->_M_finish);
_M_deallocate(this->_M_start, _M_deallocate(this->_M_start,
this->_M_end_of_storage - this->_M_start); this->_M_end_of_storage - this->_M_start);
this->_M_start = __new_start.base(); this->_M_start = __new_start.base();