+2006-10-17 Benjamin Kosnik <bkoz@redhat.com>
+
+ PR libstdc++/28514
+ * include/bits/cpp_type_traits.h (__detail): Uglify namespace.
+ * include/ext/rope: Remove global-scope anonymous namespace, use
+ nested __detail. Fixup resulting formatting issues.
+ * include/ext/ropeimpl.h: Same.
+ * include/tr1/hashtable_policy.h: Remove anonymous namespace
+ nesting for __detail.
+ * include/tr1/random: Revert anonymous namespace to nested
+ __detail namespace.
+ * include/tr1/random.tcc: Same.
+ * src/ext-inst.cc: Fixups for above.
+
2006-10-16 Douglas Gregor <doug.gregor@gmail.com>
* include/Makefile.am (tr1_headers): Add new tuple_defs.h.
_GLIBCXX_BEGIN_NAMESPACE(std)
-namespace detail
+namespace __detail
{
// NB: g++ can not compile these if declared within the class
// __is_pod itself.
__one __test_type(int _Tp::*);
template<typename _Tp>
__two& __test_type(...);
-} // namespace detail
+} // namespace __detail
template<bool>
struct __truth_type
{
enum
{
- __value = (sizeof(detail::__test_type<_Tp>(0))
- != sizeof(detail::__one))
+ __value = (sizeof(__detail::__test_type<_Tp>(0))
+ != sizeof(__detail::__one))
};
};
#include <ext/memory> // For uninitialized_copy_n
-namespace
-{
- enum { _S_max_rope_depth = 45 };
- enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
-} // anonymous namespace
-
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+ namespace __detail
+ {
+ enum { _S_max_rope_depth = 45 };
+ enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
+ } // namespace __detail
+
using std::size_t;
using std::ptrdiff_t;
using std::allocator;
class char_producer
{
public:
- virtual ~char_producer() {};
+ virtual ~char_producer() { };
virtual void
operator()(size_t __start_pos, size_t __len,
// compile-time would do. Hence this should all be private
// for now.
// The symmetry with char_producer is accidental and temporary.
- virtual ~_Rope_char_consumer() {};
+ virtual ~_Rope_char_consumer() { };
virtual bool
operator()(const _CharT* __buffer, size_t __len) = 0;
{ return *static_cast<const _Alloc*>(this); }
_Rope_rep_base(size_t __size, const allocator_type&)
- : _M_size(__size) {}
+ : _M_size(__size) { }
size_t _M_size;
# endif
{
public:
- _Tag _M_tag:8;
+ __detail::_Tag _M_tag:8;
bool _M_is_balanced:8;
unsigned char _M_depth;
__GC_CONST _CharT* _M_c_string;
using _Rope_rep_base<_CharT, _Alloc>::get_allocator;
- _Rope_RopeRep(_Tag __t, int __d, bool __b, size_t __size,
+ _Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_t __size,
allocator_type __a)
: _Rope_rep_base<_CharT, _Alloc>(__size, __a),
#ifndef __GC
#endif
#ifdef __GC
void
- _M_incr () {}
+ _M_incr () { }
#endif
static void
_S_free_string(__GC_CONST _CharT*, size_t __len,
__t->_M_free_tree();
}
# else /* __GC */
- void _M_unref_nonnil() {}
- void _M_ref_nonnil() {}
- static void _S_unref(_Rope_RopeRep*) {}
- static void _S_ref(_Rope_RopeRep*) {}
- static void _S_free_if_unref(_Rope_RopeRep*) {}
+ void _M_unref_nonnil() { }
+ void _M_ref_nonnil() { }
+ static void _S_unref(_Rope_RopeRep*) { }
+ static void _S_ref(_Rope_RopeRep*) { }
+ static void _S_free_if_unref(_Rope_RopeRep*) { }
# endif
protected:
_Rope_RopeRep&
_Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size,
allocator_type __a)
- : _Rope_RopeRep<_CharT, _Alloc>(_S_leaf, 0, true,
+ : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_leaf, 0, true,
__size, __a), _M_data(__d)
{
if (_S_is_basic_char_type((_CharT *)0))
_Rope_RopeConcatenation(_Rope_RopeRep<_CharT, _Alloc>* __l,
_Rope_RopeRep<_CharT, _Alloc>* __r,
allocator_type __a)
- : _Rope_RopeRep<_CharT, _Alloc>(::_S_concat,
+ : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_concat,
std::max(__l->_M_depth,
__r->_M_depth) + 1,
false,
_Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size,
bool __d, allocator_type __a)
- : _Rope_RopeRep<_CharT, _Alloc>(::_S_function, 0, true, __size, __a)
+ : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_function, 0, true, __size, __a)
, _M_fn(__f)
#ifndef __GC
, _M_delete_when_done(__d)
{
switch(_M_base->_M_tag)
{
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
{
char_producer<_CharT>* __fn =
((_Rope_RopeFunction<_CharT,_Alloc>*)_M_base)->_M_fn;
(*__fn)(__start_pos + _M_start, __req_len, __buffer);
}
break;
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
__GC_CONST _CharT* __s =
((_Rope_RopeLeaf<_CharT,_Alloc>*)_M_base)->_M_data;
#ifndef __GC
_M_base->_M_ref_nonnil();
#endif
- this->_M_tag = ::_S_substringfn;
+ this->_M_tag = __detail::_S_substringfn;
}
virtual ~_Rope_RopeSubstring() throw()
{
~_Rope_self_destruct_ptr()
{ _Rope_RopeRep<_CharT, _Alloc>::_S_unref(_M_ptr); }
#ifdef __EXCEPTIONS
- _Rope_self_destruct_ptr() : _M_ptr(0) {};
+ _Rope_self_destruct_ptr() : _M_ptr(0) { };
#else
- _Rope_self_destruct_ptr() {};
+ _Rope_self_destruct_ptr() { };
#endif
_Rope_self_destruct_ptr(_Rope_RopeRep<_CharT, _Alloc>* __p)
- : _M_ptr(__p) {}
+ : _M_ptr(__p) { }
_Rope_RopeRep<_CharT, _Alloc>&
operator*()
_My_rope* _M_root; // The whole rope.
public:
_Rope_char_ref_proxy(_My_rope* __r, size_t __p)
- : _M_pos(__p), _M_current(), _M_current_valid(false), _M_root(__r) {}
+ : _M_pos(__p), _M_current(), _M_current_valid(false), _M_root(__r) { }
_Rope_char_ref_proxy(const _Rope_char_ref_proxy& __x)
- : _M_pos(__x._M_pos), _M_current(__x._M_current), _M_current_valid(false),
- _M_root(__x._M_root) {}
+ : _M_pos(__x._M_pos), _M_current(__x._M_current),
+ _M_current_valid(false), _M_root(__x._M_root) { }
// Don't preserve cache if the reference can outlive the
// expression. We claim that's not possible without calling
// a copy constructor or generating reference to a proxy
// reference. We declare the latter to have undefined semantics.
_Rope_char_ref_proxy(_My_rope* __r, size_t __p, _CharT __c)
- : _M_pos(__p), _M_current(__c), _M_current_valid(true), _M_root(__r) {}
+ : _M_pos(__p), _M_current(__c), _M_current_valid(true), _M_root(__r) { }
inline operator _CharT () const;
rope<_CharT,_Alloc>* _M_root; // The whole rope.
public:
_Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x)
- : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+ : _M_pos(__x._M_pos), _M_root(__x._M_root) { }
_Rope_char_ptr_proxy(const _Rope_char_ptr_proxy& __x)
- : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+ : _M_pos(__x._M_pos), _M_root(__x._M_root) { }
- _Rope_char_ptr_proxy() {}
+ _Rope_char_ptr_proxy() { }
_Rope_char_ptr_proxy(_CharT* __x)
: _M_root(0), _M_pos(0) { }
static void _S_setcache_for_incr(_Rope_iterator_base& __x);
// As above, but assumes path
// cache is valid for previous posn.
- _Rope_iterator_base() {}
+ _Rope_iterator_base() { }
_Rope_iterator_base(_RopeRep* __root, size_t __pos)
- : _M_current_pos(__pos), _M_root(__root), _M_buf_ptr(0) {}
+ : _M_current_pos(__pos), _M_root(__root), _M_buf_ptr(0) { }
void _M_incr(size_t __n);
void _M_decr(size_t __n);
: _Rope_iterator_base<_CharT, _Alloc>(const_cast<_RopeRep*>(__root),
__pos)
// Only nonconst iterators modify root ref count
- {}
+ { }
public:
typedef _CharT reference; // Really a value. Returning a reference
// Would be a mess, since it would have
typedef const _CharT* pointer;
public:
- _Rope_const_iterator() {};
+ _Rope_const_iterator() { };
_Rope_const_iterator(const _Rope_const_iterator& __x)
: _Rope_iterator_base<_CharT,_Alloc>(__x) { }
protected:
typedef typename _Rope_iterator_base<_CharT, _Alloc>::_RopeRep _RopeRep;
rope<_CharT, _Alloc>* _M_root_rope;
- // root is treated as a cached version of this,
- // and is used to detect changes to the underlying
- // rope.
- // Root is included in the reference count.
- // This is necessary so that we can detect changes reliably.
- // Unfortunately, it requires careful bookkeeping for the
- // nonGC case.
+
+ // root is treated as a cached version of this, and is used to
+ // detect changes to the underlying rope.
+
+ // Root is included in the reference count. This is necessary
+ // so that we can detect changes reliably. Unfortunately, it
+ // requires careful bookkeeping for the nonGC case.
_Rope_iterator(rope<_CharT, _Alloc>* __r, size_t __pos)
: _Rope_iterator_base<_CharT, _Alloc>(__r->_M_tree_ptr, __pos),
_M_root_rope(__r)
typedef _Rope_char_ref_proxy<_CharT, _Alloc> reference;
typedef _Rope_char_ref_proxy<_CharT, _Alloc>* pointer;
- public:
rope<_CharT, _Alloc>&
container()
{ return *_M_root_rope; }
// The one in _Base may not be visible due to template rules.
_Rope_base(_RopeRep* __t, const allocator_type&)
- : _M_tree_ptr(__t) {}
+ : _M_tree_ptr(__t) { }
- _Rope_base(const allocator_type&) {}
+ _Rope_base(const allocator_type&) { }
// The only data member of a rope:
_RopeRep *_M_tree_ptr;
{ _RopeRep::_S_ref(__t); }
#else /* __GC */
- static void _S_unref(_RopeRep*) {}
- static void _S_ref(_RopeRep*) {}
+ static void _S_unref(_RopeRep*) { }
+ static void _S_ref(_RopeRep*) { }
#endif
#ifdef __GC
_CharT* __buffer);
static const unsigned long
- _S_min_len[::_S_max_rope_depth + 1];
+ _S_min_len[__detail::_S_max_rope_depth + 1];
static bool
_S_is_balanced(_RopeRep* __r)
const allocator_type& __a = allocator_type());
rope(const allocator_type& __a = allocator_type())
- : _Base(0, __a) {}
+ : _Base(0, __a) { }
- // Construct a rope from a function that can compute its members
+ // Construct a rope from a function that can compute its members
rope(char_producer<_CharT> *__fn, size_t __len, bool __delete_fn,
const allocator_type& __a = allocator_type())
: _Base(__a)
pop_back()
{
_RopeRep* __old = this->_M_tree_ptr;
- this->_M_tree_ptr =
- _S_substring(this->_M_tree_ptr,
- 0, this->_M_tree_ptr->_M_size - 1);
+ this->_M_tree_ptr = _S_substring(this->_M_tree_ptr,
+ 0, this->_M_tree_ptr->_M_size - 1);
_S_unref(__old);
}
{
if (0 == this->_M_tree_ptr)
return;
- if (::_S_leaf == this->_M_tree_ptr->_M_tag &&
+ if (__detail::_S_leaf == this->_M_tree_ptr->_M_tag &&
((_RopeLeaf*)this->_M_tree_ptr)->_M_data ==
this->_M_tree_ptr->_M_c_string)
{
size_type
max_size() const
{
- return _S_min_len[int(::_S_max_rope_depth) - 1] - 1;
+ return _S_min_len[int(__detail::_S_max_rope_depth) - 1] - 1;
// Guarantees that the result can be sufficirntly
// balanced. Longer ropes will probably still work,
// but it's harder to make guarantees.
template<class _CharT2, class _Alloc2>
friend rope<_CharT2, _Alloc2>
operator+(const rope<_CharT2, _Alloc2>& __left, _CharT2 __right);
- // The symmetric cases are intentionally omitted, since they're presumed
- // to be less common, and we don't handle them as well.
- // The following should really be templatized.
- // The first argument should be an input iterator or
- // forward iterator with value_type _CharT.
+ // The symmetric cases are intentionally omitted, since they're
+ // presumed to be less common, and we don't handle them as well.
+
+ // The following should really be templatized. The first
+ // argument should be an input iterator or forward iterator with
+ // value_type _CharT.
rope&
append(const _CharT* __iter, size_t __n)
{
return (*this)[__pos];
}
- void resize(size_type __n, _CharT __c) {}
- void resize(size_type __n) {}
- void reserve(size_type __res_arg = 0) {}
+ void resize(size_type __n, _CharT __c) { }
+ void resize(size_type __n) { }
+ void reserve(size_type __res_arg = 0) { }
size_type
capacity() const
__x._M_current_pos + __n); }
template <class _CharT, class _Alloc>
- inline _Rope_iterator<_CharT,_Alloc>
+ inline _Rope_iterator<_CharT, _Alloc>
operator+(ptrdiff_t __n, const _Rope_iterator<_CharT, _Alloc>& __x)
{ return _Rope_iterator<_CharT, _Alloc>(__x._M_root_rope,
__x._M_current_pos + __n); }
template <class _CharT, class _Alloc>
- inline rope<_CharT,_Alloc>
+ inline rope<_CharT, _Alloc>
operator+(const rope<_CharT, _Alloc>& __left,
const rope<_CharT, _Alloc>& __right)
{
- return rope<_CharT, _Alloc>(rope<_CharT, _Alloc>::
- _S_concat(__left._M_tree_ptr,
- __right._M_tree_ptr));
// Inlining this should make it possible to keep __left and
// __right in registers.
+ typedef rope<_CharT, _Alloc> rope_type;
+ return rope_type(rope_type::_S_concat(__left._M_tree_ptr,
+ __right._M_tree_ptr));
}
template <class _CharT, class _Alloc>
operator+(const rope<_CharT, _Alloc>& __left,
const _CharT* __right)
{
- size_t __rlen = rope<_CharT,_Alloc>::_S_char_ptr_len(__right);
- return rope<_CharT, _Alloc>(rope<_CharT, _Alloc>::
- _S_concat_char_iter(__left._M_tree_ptr,
+ typedef rope<_CharT, _Alloc> rope_type;
+ size_t __rlen = rope_type::_S_char_ptr_len(__right);
+ return rope_type(rope_type::_S_concat_char_iter(__left._M_tree_ptr,
__right, __rlen));
}
inline rope<_CharT, _Alloc>
operator+(const rope<_CharT, _Alloc>& __left, _CharT __right)
{
- return rope<_CharT, _Alloc>(rope<_CharT, _Alloc>::
- _S_concat_char_iter(__left._M_tree_ptr,
+ typedef rope<_CharT, _Alloc> rope_type;
+ return rope_type(rope_type::_S_concat_char_iter(__left._M_tree_ptr,
&__right, 1));
}
operator()(const crope& __str) const
{
size_t __size = __str.size();
-
if (0 == __size)
return 0;
return 13 * __str[0] + 5 * __str[__size - 1] + __size;
operator()(const wrope& __str) const
{
size_t __size = __str.size();
-
if (0 == __size)
return 0;
return 13 * __str[0] + 5 * __str[__size - 1] + __size;
switch(__leaf->_M_tag)
{
- case ::_S_leaf:
+ case __detail::_S_leaf:
__x._M_buf_start = ((_Rope_RopeLeaf<_CharT, _Alloc>*)__leaf)->_M_data;
__x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
__x._M_buf_end = __x._M_buf_start + __leaf->_M_size;
break;
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
{
size_t __len = _S_iterator_buf_len;
size_t __buf_start_pos = __leaf_pos;
_Rope_iterator_base<_CharT, _Alloc>::
_S_setcache(_Rope_iterator_base<_CharT, _Alloc>& __x)
{
- const _RopeRep* __path[int(::_S_max_rope_depth) + 1];
+ const _RopeRep* __path[int(__detail::_S_max_rope_depth) + 1];
const _RopeRep* __curr_rope;
int __curr_depth = -1; /* index into path */
size_t __curr_start_pos = 0;
__path[__curr_depth] = __curr_rope;
switch(__curr_rope->_M_tag)
{
- case ::_S_leaf:
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_leaf:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
__x._M_leaf_pos = __curr_start_pos;
goto done;
- case ::_S_concat:
+ case __detail::_S_concat:
{
_Rope_RopeConcatenation<_CharT, _Alloc>* __c =
(_Rope_RopeConcatenation<_CharT, _Alloc>*)__curr_rope;
__current_node = __c->_M_right;
__x._M_path_end[++__current_index] = __current_node;
__dirns |= 1;
- while (::_S_concat == __current_node->_M_tag)
+ while (__detail::_S_concat == __current_node->_M_tag)
{
++__current_index;
if (int(_S_path_cache_len) == __current_index)
{
switch(_M_tag)
{
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_Rope_RopeLeaf<_CharT, _Alloc>* __l
= (_Rope_RopeLeaf<_CharT, _Alloc>*)this;
_L_deallocate(__l, 1);
break;
}
- case ::_S_concat:
+ case __detail::_S_concat:
{
_Rope_RopeConcatenation<_CharT,_Alloc>* __c
= (_Rope_RopeConcatenation<_CharT, _Alloc>*)this;
_C_deallocate(__c, 1);
break;
}
- case ::_S_function:
+ case __detail::_S_function:
{
_Rope_RopeFunction<_CharT, _Alloc>* __f
= (_Rope_RopeFunction<_CharT, _Alloc>*)this;
_F_deallocate(__f, 1);
break;
}
- case ::_S_substringfn:
+ case __detail::_S_substringfn:
{
_Rope_RopeSubstring<_CharT, _Alloc>* __ss =
(_Rope_RopeSubstring<_CharT, _Alloc>*)this;
if (__depth > 20
&& (__result->_M_size < 1000
- || __depth > size_t(::_S_max_rope_depth)))
+ || __depth > size_t(__detail::_S_max_rope_depth)))
{
_RopeRep* __balanced;
if (0 == __r)
return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
__r->get_allocator());
- if (__r->_M_tag == ::_S_leaf
+ if (__r->_M_tag == __detail::_S_leaf
&& __r->_M_size + __slen <= size_t(_S_copy_max))
{
__result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
return __result;
}
- if (::_S_concat == __r->_M_tag
- && ::_S_leaf == ((_RopeConcatenation*) __r)->_M_right->_M_tag)
+ if (__detail::_S_concat == __r->_M_tag
+ && __detail::_S_leaf == ((_RopeConcatenation*) __r)->_M_right->_M_tag)
{
_RopeLeaf* __right =
(_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
return __r;
}
if (__orig_size + __slen <= size_t(_S_copy_max)
- && ::_S_leaf == __r->_M_tag)
+ && __detail::_S_leaf == __r->_M_tag)
{
__result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s,
__slen);
return __result;
}
- if (::_S_concat == __r->_M_tag)
+ if (__detail::_S_concat == __r->_M_tag)
{
_RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)
__r)->_M_right);
- if (::_S_leaf == __right->_M_tag
+ if (__detail::_S_leaf == __right->_M_tag
&& __right->_M_size + __slen <= size_t(_S_copy_max))
{
_RopeRep* __new_right =
__left->_M_ref_nonnil();
return __left;
}
- if (::_S_leaf == __right->_M_tag)
+ if (__detail::_S_leaf == __right->_M_tag)
{
- if (::_S_leaf == __left->_M_tag)
+ if (__detail::_S_leaf == __left->_M_tag)
{
if (__right->_M_size + __left->_M_size <= size_t(_S_copy_max))
return _S_leaf_concat_char_iter((_RopeLeaf*)__left,
((_RopeLeaf*)__right)->_M_data,
__right->_M_size);
}
- else if (::_S_concat == __left->_M_tag
- && ::_S_leaf == ((_RopeConcatenation*)
+ else if (__detail::_S_concat == __left->_M_tag
+ && __detail::_S_leaf == ((_RopeConcatenation*)
__left)->_M_right->_M_tag)
{
_RopeLeaf* __leftright =
switch(__base->_M_tag)
{
- case ::_S_concat:
+ case __detail::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__base;
_RopeRep* __left = __c->_M_left;
__result = _S_concat(__left_result, __right_result);
return __result;
}
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__base;
_RopeLeaf* __result;
#endif
return __result;
}
- case ::_S_substringfn:
+ case __detail::_S_substringfn:
// Avoid introducing multiple layers of substring nodes.
{
_RopeSubstring* __old = (_RopeSubstring*)__base;
} // *** else fall through: ***
}
- case ::_S_function:
+ case __detail::_S_function:
{
_RopeFunction* __f = (_RopeFunction*)__base;
_CharT* __section;
return true;
switch(__r->_M_tag)
{
- case ::_S_concat:
+ case __detail::_S_concat:
{
_RopeConcatenation* __conc = (_RopeConcatenation*)__r;
_RopeRep* __left = __conc->_M_left;
}
}
return true;
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
return __c(__l->_M_data + __begin, __end - __begin);
}
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
{
_RopeFunction* __f = (_RopeFunction*)__r;
size_t __len = __end - __begin;
return __buffer;
switch(__r->_M_tag)
{
- case ::_S_concat:
+ case __detail::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__r;
_RopeRep* __left = __c->_M_left;
_CharT* __rest = _S_flatten(__left, __buffer);
return _S_flatten(__right, __rest);
}
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
return copy_n(__l->_M_data, __l->_M_size, __buffer).second;
}
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
// We don't yet do anything with substring nodes.
// This needs to be fixed before ropefiles will work well.
{
switch (__r->_M_tag)
{
- case ::_S_leaf:
+ case __detail::_S_leaf:
__kind = "Leaf";
break;
- case ::_S_function:
+ case __detail::_S_function:
__kind = "Function";
break;
- case ::_S_substringfn:
+ case __detail::_S_substringfn:
__kind = "Function representing substring";
break;
default:
template <class _CharT, class _Alloc>
const unsigned long
rope<_CharT, _Alloc>::
- _S_min_len[int(::_S_max_rope_depth) + 1] = {
+ _S_min_len[int(__detail::_S_max_rope_depth) + 1] = {
/* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21,
/* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377,
/* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181,
rope<_CharT, _Alloc>::
_S_balance(_RopeRep* __r)
{
- _RopeRep* __forest[int(::_S_max_rope_depth) + 1];
+ _RopeRep* __forest[int(__detail::_S_max_rope_depth) + 1];
_RopeRep* __result = 0;
int __i;
// Invariant:
// __forest[__i]._M_depth = __i
// References from forest are included in refcount.
- for (__i = 0; __i <= int(::_S_max_rope_depth); ++__i)
+ for (__i = 0; __i <= int(__detail::_S_max_rope_depth); ++__i)
__forest[__i] = 0;
try
{
_S_add_to_forest(__r, __forest);
- for (__i = 0; __i <= int(::_S_max_rope_depth); ++__i)
+ for (__i = 0; __i <= int(__detail::_S_max_rope_depth); ++__i)
if (0 != __forest[__i])
{
#ifndef __GC
}
catch(...)
{
- for(__i = 0; __i <= int(::_S_max_rope_depth); __i++)
+ for(__i = 0; __i <= int(__detail::_S_max_rope_depth); __i++)
_S_unref(__forest[__i]);
__throw_exception_again;
}
- if (__result->_M_depth > int(::_S_max_rope_depth))
+ if (__result->_M_depth > int(__detail::_S_max_rope_depth))
__throw_length_error(__N("rope::_S_balance"));
return(__result);
}
__forest[__i]->_M_unref_nonnil();
__forest[__i] = 0;
}
- if (__i == int(::_S_max_rope_depth)
+ if (__i == int(__detail::_S_max_rope_depth)
|| __insertee->_M_size < _S_min_len[__i+1])
{
__forest[__i] = __insertee;
{
switch(__r->_M_tag)
{
- case ::_S_concat:
+ case __detail::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__r;
_RopeRep* __left = __c->_M_left;
__r = __left;
}
break;
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
return __l->_M_data[__i];
}
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
{
_RopeFunction* __f = (_RopeFunction*)__r;
_CharT __result;
rope<_CharT, _Alloc>::
_S_fetch_ptr(_RopeRep* __r, size_type __i)
{
- _RopeRep* __clrstack[::_S_max_rope_depth];
+ _RopeRep* __clrstack[__detail::_S_max_rope_depth];
size_t __csptr = 0;
for(;;)
return 0;
switch(__r->_M_tag)
{
- case ::_S_concat:
+ case __detail::_S_concat:
{
_RopeConcatenation* __c = (_RopeConcatenation*)__r;
_RopeRep* __left = __c->_M_left;
__r = __left;
}
break;
- case ::_S_leaf:
+ case __detail::_S_leaf:
{
_RopeLeaf* __l = (_RopeLeaf*)__r;
if (__l->_M_c_string != __l->_M_data && __l->_M_c_string != 0)
}
return __l->_M_data + __i;
}
- case ::_S_function:
- case ::_S_substringfn:
+ case __detail::_S_function:
+ case __detail::_S_substringfn:
return 0;
}
}
return -1;
__left_len = __left->_M_size;
__right_len = __right->_M_size;
- if (::_S_leaf == __left->_M_tag)
+ if (__detail::_S_leaf == __left->_M_tag)
{
_RopeLeaf* __l = (_RopeLeaf*) __left;
- if (::_S_leaf == __right->_M_tag)
+ if (__detail::_S_leaf == __right->_M_tag)
{
_RopeLeaf* __r = (_RopeLeaf*) __right;
return lexicographical_compare_3way(__l->_M_data,
{
const_iterator __lstart(__left, 0);
const_iterator __lend(__left, __left_len);
- if (::_S_leaf == __right->_M_tag)
+ if (__detail::_S_leaf == __right->_M_tag)
{
_RopeLeaf* __r = (_RopeLeaf*) __right;
return lexicographical_compare_3way(__lstart, __lend,
return _S_empty_c_str;
}
__GC_CONST _CharT* __old_c_string = this->_M_tree_ptr->_M_c_string;
- if (::_S_leaf == this->_M_tree_ptr->_M_tag
+ if (__detail::_S_leaf == this->_M_tree_ptr->_M_tag
&& 0 != __old_c_string)
return(__old_c_string);
size_t __s = size();
_GLIBCXX_BEGIN_NAMESPACE(tr1)
namespace __detail
{
-namespace
-{
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
(unsigned long)18446744073709551557ull,
(unsigned long)18446744073709551557ull
};
-} // anonymous namespace
// Auxiliary types used for all instantiations of _Hashtable: nodes
// and iterators.
/*
* Implementation-space details.
*/
- namespace
+ namespace __detail
{
template<typename _UIntType, int __w,
bool = __w < std::numeric_limits<_UIntType>::digits>
typedef __gnu_cxx::__conditional_type<(sizeof(unsigned) == 4),
unsigned, unsigned long>::__type _UInt32Type;
- } // anonymous namespace
/*
* An adaptor class for converting the output of any Generator into
/ result_type(_M_g.max() - _M_g.min());
return __return_value;
}
-
+ } // namespace __detail
/**
* Produces random numbers on a given disribution function using a un uniform
public:
typedef _Engine engine_type;
- typedef _Adaptor<_Engine, _Dist> engine_value_type;
+ typedef __detail::_Adaptor<_Engine, _Dist> engine_value_type;
typedef _Dist distribution_type;
typedef typename _Dist::result_type result_type;
typedef typename __gnu_cxx::__enable_if<
is_arithmetic<result_type>::value, result_type>::__type _IsValidType;
- public:
/**
* Constructs a variate generator with the uniform random number
* generator @p __eng for the random distribution @p __dist.
*/
result_type
min() const
- { return (__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
+ { return (__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0) ? 1 : 0; }
/**
* Gets the largest possible value in the output range.
void
seed(_Gen& __g, false_type);
- private:
_UIntType _M_x;
};
result_type
max() const
- { return _Shift<_UIntType, __w>::__value - 1; }
+ { return __detail::_Shift<_UIntType, __w>::__value - 1; }
result_type
operator()();
void
seed(_Gen& __g, false_type);
- private:
_UIntType _M_x[state_size];
int _M_p;
};
static const int long_lag = __r;
static const int short_lag = __s;
- public:
/**
* Constructs a default-initialized % subtract_with_carry random number
* generator.
void
seed(_Gen& __g, false_type);
- private:
typedef typename __gnu_cxx::__add_unsigned<_IntType>::__type _UIntType;
_UIntType _M_x[long_lag];
static const int long_lag = __r;
static const int short_lag = __s;
- public:
/**
* Constructs a default-initialized % subtract_with_carry_01 random
* number generator.
void
seed(_Gen& __g, false_type);
- private:
void
_M_initialize_npows();
static const int __n = (__w + 31) / 32;
+ typedef __detail::_UInt32Type _UInt32Type;
_UInt32Type _M_x[long_lag][__n];
_RealType _M_npows[__n];
_UInt32Type _M_carry;
/*
* (Further) implementation-space details.
*/
- namespace
+ namespace __detail
{
// General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid
// integer overflow.
__calc(_Tp __x)
{ return __a * __x + __c; }
};
- } // anonymous namespace
-
+ } // namespace __detail
/**
* Seeds the LCR with integral value @p __x0, adjusted so that the
linear_congruential<_UIntType, __a, __c, __m>::
seed(unsigned long __x0)
{
- if ((__mod<_UIntType, 1, 0, __m>(__c) == 0)
- && (__mod<_UIntType, 1, 0, __m>(__x0) == 0))
- _M_x = __mod<_UIntType, 1, 0, __m>(1);
+ if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
+ && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
+ _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
else
- _M_x = __mod<_UIntType, 1, 0, __m>(__x0);
+ _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
}
/**
seed(_Gen& __g, false_type)
{
_UIntType __x0 = __g();
- if ((__mod<_UIntType, 1, 0, __m>(__c) == 0)
- && (__mod<_UIntType, 1, 0, __m>(__x0) == 0))
- _M_x = __mod<_UIntType, 1, 0, __m>(1);
+ if ((__detail::__mod<_UIntType, 1, 0, __m>(__c) == 0)
+ && (__detail::__mod<_UIntType, 1, 0, __m>(__x0) == 0))
+ _M_x = __detail::__mod<_UIntType, 1, 0, __m>(1);
else
- _M_x = __mod<_UIntType, 1, 0, __m>(__x0);
+ _M_x = __detail::__mod<_UIntType, 1, 0, __m>(__x0);
}
/**
linear_congruential<_UIntType, __a, __c, __m>::
operator()()
{
- _M_x = __mod<_UIntType, __a, __c, __m>(_M_x);
+ _M_x = __detail::__mod<_UIntType, __a, __c, __m>(_M_x);
return _M_x;
}
__b, __t, __c, __l>::
seed(unsigned long __value)
{
- _M_x[0] = __mod<_UIntType, 1, 0,
- _Shift<_UIntType, __w>::__value>(__value);
+ _M_x[0] = __detail::__mod<_UIntType, 1, 0,
+ __detail::_Shift<_UIntType, __w>::__value>(__value);
for (int __i = 1; __i < state_size; ++__i)
{
__x ^= __x >> (__w - 2);
__x *= 1812433253ul;
__x += __i;
- _M_x[__i] = __mod<_UIntType, 1, 0,
- _Shift<_UIntType, __w>::__value>(__x);
+ _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
+ __detail::_Shift<_UIntType, __w>::__value>(__x);
}
_M_p = state_size;
}
seed(_Gen& __gen, false_type)
{
for (int __i = 0; __i < state_size; ++__i)
- _M_x[__i] = __mod<_UIntType, 1, 0,
- _Shift<_UIntType, __w>::__value>(__gen());
+ _M_x[__i] = __detail::__mod<_UIntType, 1, 0,
+ __detail::_Shift<_UIntType, __w>::__value>(__gen());
_M_p = state_size;
}
__lcg(__value);
for (int __i = 0; __i < long_lag; ++__i)
- _M_x[__i] = __mod<_UIntType, 1, 0, modulus>(__lcg());
+ _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__lcg());
_M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
_M_p = 0;
_UIntType __factor = 1;
for (int __j = 0; __j < __n; ++__j)
{
- __tmp += __mod<_UInt32Type, 1, 0, 0>(__gen()) * __factor;
- __factor *= _Shift<_UIntType, 32>::__value;
+ __tmp += __detail::__mod<__detail::_UInt32Type, 1, 0, 0>(__gen()) * __factor;
+ __factor *= __detail::_Shift<_UIntType, 32>::__value;
}
- _M_x[__i] = __mod<_UIntType, 1, 0, modulus>(__tmp);
+ _M_x[__i] = __detail::__mod<_UIntType, 1, 0, modulus>(__tmp);
}
_M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
_M_p = 0;
for (int __i = 0; __i < long_lag; ++__i)
{
for (int __j = 0; __j < __n - 1; ++__j)
- _M_x[__i][__j] = __mod<_UInt32Type, 1, 0, 0>(__gen());
- _M_x[__i][__n - 1] = __mod<_UInt32Type, 1, 0,
- _Shift<_UInt32Type, __w % 32>::__value>(__gen());
+ _M_x[__i][__j] = __detail::__mod<_UInt32Type, 1, 0, 0>(__gen());
+ _M_x[__i][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
+ __detail::_Shift<_UInt32Type, __w % 32>::__value>(__gen());
}
_M_carry = 1;
else
__new_carry = 1;
- _M_x[_M_p][__n - 1] = __mod<_UInt32Type, 1, 0,
- _Shift<_UInt32Type, __w % 32>::__value>
+ _M_x[_M_p][__n - 1] = __detail::__mod<_UInt32Type, 1, 0,
+ __detail::_Shift<_UInt32Type, __w % 32>::__value>
(_M_x[__ps][__n - 1] - _M_x[_M_p][__n - 1] - _M_carry);
_M_carry = __new_carry;
const result_type __m1 =
std::min(result_type(_M_b1.max() - _M_b1.min()),
- _Shift<result_type, __w - __s1>::__value - 1);
+ __detail::_Shift<result_type, __w - __s1>::__value - 1);
const result_type __m2 =
std::min(result_type(_M_b2.max() - _M_b2.min()),
- _Shift<result_type, __w - __s2>::__value - 1);
+ __detail::_Shift<result_type, __w - __s2>::__value - 1);
// NB: In TR1 s1 is not required to be >= s2.
if (__s1 < __s2)
#include <ext/rope>
#include <ext/stdio_filebuf.h>
-namespace
-{
- const int min_len = _S_max_rope_depth + 1;
-}
-
_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+ namespace
+ {
+ const int min_len = __detail::_S_max_rope_depth + 1;
+ }
+
template
const unsigned long
rope<char, std::allocator<char> >::_S_min_len[min_len];
OSDN Git Service
