Skip to content

R
riscv-gcc-1
Commit 95cefe5f by Paolo Carlini Committed by Paolo Carlini
Options

hashtable_policy.h: Uglify all the names. 

2006-09-19  Paolo Carlini  <pcarlini@suse.de>

	* include/tr1/hashtable_policy.h: Uglify all the names.
	* include/tr1/hashtable: Likewise.
	* include/tr1/unordered_map: Likewise.
	* include/tr1/unordered_set: Likewise.
	* include/tr1/functional: Uglify struct hash names.
	* include/tr1/cmath: Uglify namespace detail to __detail.

From-SVN: r117052
parent b5387733
Showing with 206 additions and 183 deletions
libstdc++-v3/ChangeLog
2006-09-19 Paolo Carlini <pcarlini@suse.de>
* include/tr1/hashtable_policy.h: Uglify all the names.
* include/tr1/hashtable: Likewise.
* include/tr1/unordered_map: Likewise.
* include/tr1/unordered_set: Likewise.
* include/tr1/functional: Uglify struct hash names.
* include/tr1/cmath: Uglify namespace detail to __detail.
2006-09-18 Benjamin Kosnik <bkoz@redhat.com> 2006-09-18 Benjamin Kosnik <bkoz@redhat.com>
* testsuite/util/regression/res_mng: Remove. * testsuite/util/regression/res_mng: Remove.
......
libstdc++-v3/include/tr1/cmath
...@@ -368,21 +368,23 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1) ...@@ -368,21 +368,23 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
using std::atan; using std::atan;
// Workaround for c++/21682. // Workaround for c++/21682.
namespace detail namespace __detail
{ {
template<typename _Tp, typename _Up> template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value inline typename
|| std::__is_floating<_Up>::__value, __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
typename std::tr1::__promote_2<_Tp, _Up>::__type>::__type || std::__is_floating<_Up>::__value,
atan2(_Tp __y, _Up __x) typename
{ std::tr1::__promote_2<_Tp, _Up>::__type>::__type
typedef typename std::tr1::__promote_2<_Tp, _Up>::__type __type; atan2(_Tp __y, _Up __x)
return std::atan2(__type(__y), __type(__x)); {
} typedef typename std::tr1::__promote_2<_Tp, _Up>::__type __type;
} // namespace detail return std::atan2(__type(__y), __type(__x));
}
} // namespace __detail
using std::atan2; using std::atan2;
using detail::atan2; using __detail::atan2;
inline float inline float
atanh(float __x) atanh(float __x)
......
libstdc++-v3/include/tr1/unordered_map
...@@ -43,120 +43,124 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1) ...@@ -43,120 +43,124 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
// XXX When we get typedef templates these class definitions // XXX When we get typedef templates these class definitions
// will be unnecessary. // will be unnecessary.
template<class Key, class T, template<class _Key, class _Tp,
class Hash = hash<Key>, class _Hash = hash<_Key>,
class Pred = std::equal_to<Key>, class _Pred = std::equal_to<_Key>,
class Alloc = std::allocator<std::pair<const Key, T> >, class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool cache_hash_code = false> bool __cache_hash_code = false>
class unordered_map class unordered_map
: public hashtable<Key, std::pair<const Key, T>, Alloc, : public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred, std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, false, true> __cache_hash_code, false, true>
{ {
typedef hashtable<Key, std::pair<const Key, T>, Alloc, typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred, std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, false, true> __cache_hash_code, false, true>
Base; _Base;
public: public:
typedef typename Base::size_type size_type; typedef typename _Base::size_type size_type;
typedef typename Base::hasher hasher; typedef typename _Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename _Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type; typedef typename _Base::allocator_type allocator_type;
explicit explicit
unordered_map(size_type n = 10, unordered_map(size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(), : _Base(__n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), __detail::_Default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ } { }
template<typename InputIterator> template<typename _InputIterator>
unordered_map(InputIterator f, InputIterator l, unordered_map(_InputIterator __f, _InputIterator __l,
size_type n = 10, size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base (f, l, n, hf, detail::mod_range_hashing(), : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), __detail::_Default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ } { }
}; };
template<class Key, class T, template<class _Key, class _Tp,
class Hash = hash<Key>, class _Hash = hash<_Key>,
class Pred = std::equal_to<Key>, class _Pred = std::equal_to<_Key>,
class Alloc = std::allocator<std::pair<const Key, T> >, class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool cache_hash_code = false> bool __cache_hash_code = false>
class unordered_multimap class unordered_multimap
: public hashtable <Key, std::pair<const Key, T>, : public _Hashtable<_Key, std::pair<const _Key, _Tp>,
Alloc, _Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred, std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, false, false> __cache_hash_code, false, false>
{ {
typedef hashtable <Key, std::pair<const Key, T>, typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
Alloc, _Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred, std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, false, false> __cache_hash_code, false, false>
Base; _Base;
public: public:
typedef typename Base::size_type size_type; typedef typename _Base::size_type size_type;
typedef typename Base::hasher hasher; typedef typename _Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename _Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type; typedef typename _Base::allocator_type allocator_type;
explicit explicit
unordered_multimap(size_type n = 10, unordered_multimap(size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base (n, hf, detail::mod_range_hashing(), : _Base(__n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), __detail::_Default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ } { }
template<typename InputIterator> template<typename _InputIterator>
unordered_multimap(InputIterator f, InputIterator l, unordered_multimap(_InputIterator __f, _InputIterator __l,
typename Base::size_type n = 0, typename _Base::size_type __n = 0,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base (f, l, n, hf, detail::mod_range_hashing(), : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), __detail::_Default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ } { }
}; };
template<class Key, class T, class Hash, class Pred, class Alloc, template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool cache_hash_code> bool __cache_hash_code>
inline void inline void
swap(unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& x, swap(unordered_map<_Key, _Tp, _Hash, _Pred,
unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& y) _Alloc, __cache_hash_code>& __x,
{ x.swap(y); } unordered_map<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
template<class Key, class T, class Hash, class Pred, class Alloc, { __x.swap(__y); }
bool cache_hash_code>
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void inline void
swap(unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& x, swap(unordered_multimap<_Key, _Tp, _Hash, _Pred,
unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& y) _Alloc, __cache_hash_code>& __x,
{ x.swap(y); } unordered_multimap<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE _GLIBCXX_END_NAMESPACE
} }
......
libstdc++-v3/include/tr1/unordered_set
...@@ -43,114 +43,122 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1) ...@@ -43,114 +43,122 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
// XXX When we get typedef templates these class definitions // XXX When we get typedef templates these class definitions
// will be unnecessary. // will be unnecessary.
template<class Value, template<class _Value,
class Hash = hash<Value>, class _Hash = hash<_Value>,
class Pred = std::equal_to<Value>, class _Pred = std::equal_to<_Value>,
class Alloc = std::allocator<Value>, class _Alloc = std::allocator<_Value>,
bool cache_hash_code = false> bool __cache_hash_code = false>
class unordered_set class unordered_set
: public hashtable<Value, Value, Alloc, : public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<Value>, Pred, std::_Identity<_Value>, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, true, true> __cache_hash_code, true, true>
{ {
typedef hashtable<Value, Value, Alloc, typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<Value>, Pred, std::_Identity<_Value>, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, true, true> __cache_hash_code, true, true>
Base; _Base;
public: public:
typedef typename Base::size_type size_type; typedef typename _Base::size_type size_type;
typedef typename Base::hasher hasher; typedef typename _Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename _Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type; typedef typename _Base::allocator_type allocator_type;
explicit explicit
unordered_set(size_type n = 10, unordered_set(size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(), : _Base(__n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a) __detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ } { }
template<typename InputIterator> template<typename _InputIterator>
unordered_set(InputIterator f, InputIterator l, unordered_set(_InputIterator __f, _InputIterator __l,
size_type n = 10, size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base(f, l, n, hf, detail::mod_range_hashing(), : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a) __detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ } { }
}; };
template<class Value, template<class _Value,
class Hash = hash<Value>, class _Hash = hash<_Value>,
class Pred = std::equal_to<Value>, class _Pred = std::equal_to<_Value>,
class Alloc = std::allocator<Value>, class _Alloc = std::allocator<_Value>,
bool cache_hash_code = false> bool __cache_hash_code = false>
class unordered_multiset class unordered_multiset
: public hashtable <Value, Value, Alloc, : public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<Value>, Pred, std::_Identity<_Value>, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, true, false> __cache_hash_code, true, false>
{ {
typedef hashtable<Value, Value, Alloc, typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<Value>, Pred, std::_Identity<_Value>, _Pred,
Hash, detail::mod_range_hashing, _Hash, __detail::_Mod_range_hashing,
detail::default_ranged_hash, __detail::_Default_ranged_hash,
detail::prime_rehash_policy, __detail::_Prime_rehash_policy,
cache_hash_code, true, false> __cache_hash_code, true, false>
Base; _Base;
public: public:
typedef typename Base::size_type size_type; typedef typename _Base::size_type size_type;
typedef typename Base::hasher hasher; typedef typename _Base::hasher hasher;
typedef typename Base::key_equal key_equal; typedef typename _Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type; typedef typename _Base::allocator_type allocator_type;
explicit explicit
unordered_multiset(size_type n = 10, unordered_multiset(size_type __n = 10,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(), : _Base(__n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a) __detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ } { }
template<typename InputIterator> template<typename _InputIterator>
unordered_multiset(InputIterator f, InputIterator l, unordered_multiset(_InputIterator __f, _InputIterator __l,
typename Base::size_type n = 0, typename _Base::size_type __n = 0,
const hasher& hf = hasher(), const hasher& __hf = hasher(),
const key_equal& eql = key_equal(), const key_equal& __eql = key_equal(),
const allocator_type& a = allocator_type()) const allocator_type& __a = allocator_type())
: Base(f, l, n, hf, detail::mod_range_hashing(), : _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a) __detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ } { }
}; };
template<class Value, class Hash, class Pred, class Alloc, template<class _Value, class _Hash, class _Pred, class _Alloc,
bool cache_hash_code> bool __cache_hash_code>
inline void inline void
swap (unordered_set<Value, Hash, Pred, Alloc, cache_hash_code>& x, swap (unordered_set<_Value, _Hash, _Pred,
unordered_set<Value, Hash, Pred, Alloc, cache_hash_code>& y) _Alloc, __cache_hash_code>& __x,
{ x.swap(y); } unordered_set<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
template<class Value, class Hash, class Pred, class Alloc, { __x.swap(__y); }
bool cache_hash_code>
template<class _Value, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void inline void
swap(unordered_multiset<Value, Hash, Pred, Alloc, cache_hash_code>& x, swap(unordered_multiset<_Value, _Hash, _Pred,
unordered_multiset<Value, Hash, Pred, Alloc, cache_hash_code>& y) _Alloc, __cache_hash_code>& __x,
{ x.swap(y); } unordered_multiset<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE _GLIBCXX_END_NAMESPACE
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment