+2007-05-04 Paolo Carlini <pcarlini@suse.de>
+
+ * include/bits/stl_construct.h (_Destroy(_ForwardIterator,
+ _ForwardIterator __last, _Allocator)): Change the last parameter
+ to _Allocator&.
+ * include/bits/stl_uninitialized.h (__uninitialized_copy_a,
+ __uninitialized_fill_a, __uninitialized_fill_n_a,
+ __uninitialized_fill_copy, __uninitialized_copy_fill,
+ __uninitialized_copy_copy): Likewise.
+ * include/ext/rope: Adjust everywhere.
+ * include/ext/ropeimpl.h: Likewise.
+
2007-05-03 Benjamin Kosnik <bkoz@redhat.com>
* include/std/type_traits (enable_if): New.
template<typename _ForwardIterator, typename _Allocator>
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
- _Allocator __alloc)
+ _Allocator& __alloc)
{
for (; __first != __last; ++__first)
__alloc.destroy(&*__first);
template<typename _ForwardIterator, typename _Tp>
inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
- allocator<_Tp>)
+ allocator<_Tp>&)
{
_Destroy(__first, __last);
}
typename _Allocator>
_ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
- _ForwardIterator __result,
- _Allocator __alloc)
+ _ForwardIterator __result, _Allocator& __alloc)
{
_ForwardIterator __cur = __result;
try
template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
inline _ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
- _ForwardIterator __result,
- allocator<_Tp>)
+ _ForwardIterator __result, allocator<_Tp>&)
{ return std::uninitialized_copy(__first, __last, __result); }
template<typename _ForwardIterator, typename _Tp, typename _Allocator>
void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
- const _Tp& __x, _Allocator __alloc)
+ const _Tp& __x, _Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
template<typename _ForwardIterator, typename _Tp, typename _Tp2>
inline void
__uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
- const _Tp& __x, allocator<_Tp2>)
+ const _Tp& __x, allocator<_Tp2>&)
{ std::uninitialized_fill(__first, __last, __x); }
template<typename _ForwardIterator, typename _Size, typename _Tp,
typename _Allocator>
void
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
- const _Tp& __x,
- _Allocator __alloc)
+ const _Tp& __x, _Allocator& __alloc)
{
_ForwardIterator __cur = __first;
try
typename _Tp2>
inline void
__uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
- const _Tp& __x,
- allocator<_Tp2>)
+ const _Tp& __x, allocator<_Tp2>&)
{ std::uninitialized_fill_n(__first, __n, __x); }
_InputIterator2 __first2,
_InputIterator2 __last2,
_ForwardIterator __result,
- _Allocator __alloc)
+ _Allocator& __alloc)
{
_ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
__result,
inline _ForwardIterator
__uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
const _Tp& __x, _InputIterator __first,
- _InputIterator __last,
- _Allocator __alloc)
+ _InputIterator __last, _Allocator& __alloc)
{
std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
try
__uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
_ForwardIterator __first2,
_ForwardIterator __last2, const _Tp& __x,
- _Allocator __alloc)
+ _Allocator& __alloc)
{
_ForwardIterator __mid2 = std::__uninitialized_copy_a(__first1, __last1,
__first2,
get_allocator() const
{ return *static_cast<const _Alloc*>(this); }
+ allocator_type&
+ _M_get_allocator()
+ { return *static_cast<_Alloc*>(this); }
+
+ const allocator_type&
+ _M_get_allocator() const
+ { return *static_cast<const _Alloc*>(this); }
+
_Rope_rep_base(size_t __size, const allocator_type&)
: _M_size(__size) { }
allocator_type;
using _Rope_rep_base<_CharT, _Alloc>::get_allocator;
+ using _Rope_rep_base<_CharT, _Alloc>::_M_get_allocator;
_Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_t __size,
- allocator_type __a)
+ const allocator_type& __a)
: _Rope_rep_base<_CharT, _Alloc>(__size, __a),
#ifndef __GC
_Refcount_Base(1),
#endif
static void
_S_free_string(__GC_CONST _CharT*, size_t __len,
- allocator_type __a);
+ allocator_type& __a);
#define __STL_FREE_STRING(__s, __l, __a) _S_free_string(__s, __l, __a);
// Deallocate data section of a leaf.
// This shouldn't be a member function.
allocator_type;
_Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size,
- allocator_type __a)
+ const allocator_type& __a)
: _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_leaf, 0, true,
__size, __a), _M_data(__d)
{
if (_M_data != this->_M_c_string)
this->_M_free_c_string();
- __STL_FREE_STRING(_M_data, this->_M_size, this->get_allocator());
+ __STL_FREE_STRING(_M_data, this->_M_size, this->_M_get_allocator());
}
#endif
protected:
_Rope_RopeConcatenation(_Rope_RopeRep<_CharT, _Alloc>* __l,
_Rope_RopeRep<_CharT, _Alloc>* __r,
- allocator_type __a)
+ const allocator_type& __a)
: _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_concat,
std::max(__l->_M_depth,
__r->_M_depth) + 1,
allocator_type;
_Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size,
- bool __d, allocator_type __a)
+ bool __d, const allocator_type& __a)
: _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_function, 0, true, __size, __a)
, _M_fn(__f)
#ifndef __GC
allocator_type;
_Rope_RopeSubstring(_Rope_RopeRep<_CharT, _Alloc>* __b, size_t __s,
- size_t __l, allocator_type __a)
+ size_t __l, const allocator_type& __a)
: _Rope_RopeFunction<_CharT, _Alloc>(this, __l, false, __a),
char_producer<_CharT>(), _M_base(__b), _M_start(__s)
{
get_allocator() const
{ return *static_cast<const _Alloc*>(this); }
+ allocator_type&
+ _M_get_allocator()
+ { return *static_cast<_Alloc*>(this); }
+
+ const allocator_type&
+ _M_get_allocator() const
+ { return *static_cast<const _Alloc*>(this); }
+
typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
// The one in _Base may not be visible due to template rules.
typedef typename _Base::allocator_type allocator_type;
using _Base::_M_tree_ptr;
using _Base::get_allocator;
+ using _Base::_M_get_allocator;
typedef __GC_CONST _CharT* _Cstrptr;
static _CharT _S_empty_c_str[1];
// Takes ownership of s instead of copying.
static _RopeLeaf*
_S_new_RopeLeaf(__GC_CONST _CharT *__s,
- size_t __size, allocator_type __a)
+ size_t __size, allocator_type& __a)
{
_RopeLeaf* __space = typename _Base::_LAlloc(__a).allocate(1);
return new(__space) _RopeLeaf(__s, __size, __a);
static _RopeConcatenation*
_S_new_RopeConcatenation(_RopeRep* __left, _RopeRep* __right,
- allocator_type __a)
+ allocator_type& __a)
{
_RopeConcatenation* __space = typename _Base::_CAlloc(__a).allocate(1);
return new(__space) _RopeConcatenation(__left, __right, __a);
static _RopeFunction*
_S_new_RopeFunction(char_producer<_CharT>* __f,
- size_t __size, bool __d, allocator_type __a)
+ size_t __size, bool __d, allocator_type& __a)
{
_RopeFunction* __space = typename _Base::_FAlloc(__a).allocate(1);
return new(__space) _RopeFunction(__f, __size, __d, __a);
static _RopeSubstring*
_S_new_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
- size_t __l, allocator_type __a)
+ size_t __l, allocator_type& __a)
{
_RopeSubstring* __space = typename _Base::_SAlloc(__a).allocate(1);
return new(__space) _RopeSubstring(__b, __s, __l, __a);
static _RopeLeaf*
_S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s,
- size_t __size, allocator_type __a)
+ size_t __size, allocator_type& __a)
#define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \
_S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a)
{
{ return _S_compare(this->_M_tree_ptr, __y._M_tree_ptr); }
rope(const _CharT* __s, const allocator_type& __a = allocator_type())
- : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, _S_char_ptr_len(__s),
- __a), __a)
- { }
+ : _Base(__a)
+ {
+ this->_M_tree_ptr =
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, _S_char_ptr_len(__s),
+ _M_get_allocator());
+ }
rope(const _CharT* __s, size_t __len,
const allocator_type& __a = allocator_type())
- : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __len, __a), __a)
- { }
+ : _Base(__a)
+ {
+ this->_M_tree_ptr =
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __len, _M_get_allocator());
+ }
// Should perhaps be templatized with respect to the iterator type
// and use Sequence_buffer. (It should perhaps use sequence_buffer
// even now.)
- rope(const _CharT *__s, const _CharT *__e,
+ rope(const _CharT* __s, const _CharT* __e,
const allocator_type& __a = allocator_type())
- : _Base(__STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __e - __s, __a), __a)
- { }
+ : _Base(__a)
+ {
+ this->_M_tree_ptr =
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __e - __s, _M_get_allocator());
+ }
rope(const const_iterator& __s, const const_iterator& __e,
const allocator_type& __a = allocator_type())
{
_CharT* __buf = this->_Data_allocate(_S_rounded_up_size(1));
- get_allocator().construct(__buf, __c);
+ _M_get_allocator().construct(__buf, __c);
try
- { this->_M_tree_ptr = _S_new_RopeLeaf(__buf, 1, __a); }
+ {
+ this->_M_tree_ptr = _S_new_RopeLeaf(__buf, 1,
+ _M_get_allocator());
+ }
catch(...)
{
- _RopeRep::__STL_FREE_STRING(__buf, 1, __a);
+ _RopeRep::__STL_FREE_STRING(__buf, 1, _M_get_allocator());
__throw_exception_again;
}
}
{
_RopeRep* __old = this->_M_tree_ptr;
_RopeRep* __left =
- __STL_ROPE_FROM_UNOWNED_CHAR_PTR(&__x, 1, this->get_allocator());
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(&__x, 1, _M_get_allocator());
try
{
this->_M_tree_ptr = _S_concat(__left, this->_M_tree_ptr);
void
copy(_CharT* __buffer) const
{
- _Destroy(__buffer, __buffer + size(), get_allocator());
+ _Destroy(__buffer, __buffer + size(), _M_get_allocator());
_S_flatten(this->_M_tree_ptr, __buffer);
}
size_t __size = size();
size_t __len = (__pos + __n > __size? __size - __pos : __n);
- _Destroy(__buffer, __buffer + __len, get_allocator());
+ _Destroy(__buffer, __buffer + __len, _M_get_allocator());
_S_flatten(this->_M_tree_ptr, __pos, __len, __buffer);
return __len;
}
// SGI's rope class implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
if (0 != __cstr)
{
size_t __size = this->_M_size + 1;
- _Destroy(__cstr, __cstr + __size, get_allocator());
+ _Destroy(__cstr, __cstr + __size, _M_get_allocator());
this->_Data_deallocate(__cstr, __size);
}
}
template <class _CharT, class _Alloc>
inline void
_Rope_RopeRep<_CharT, _Alloc>::
- _S_free_string(_CharT* __s, size_t __n, allocator_type __a)
+ _S_free_string(_CharT* __s, size_t __n, allocator_type& __a)
{
if (!_S_is_basic_char_type((_CharT*)0))
_Destroy(__s, __s + __n, __a);
try
{
__result = _S_new_RopeLeaf(__new_data, __old_len + __len,
- __r->get_allocator());
+ __r->_M_get_allocator());
}
catch(...)
{
_RopeRep::__STL_FREE_STRING(__new_data, __old_len + __len,
- __r->get_allocator());
+ __r->_M_get_allocator());
__throw_exception_again;
}
return __result;
{
_RopeConcatenation* __result = _S_new_RopeConcatenation(__left, __right,
__left->
- get_allocator());
+ _M_get_allocator());
size_t __depth = __result->_M_depth;
if (__depth > 20
}
if (0 == __r)
return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
- __r->get_allocator());
+ __r->_M_get_allocator());
if (__r->_M_tag == __detail::_S_leaf
&& __r->_M_size + __slen <= size_t(_S_copy_max))
{
}
}
_RopeRep* __nright =
- __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->_M_get_allocator());
try
{
__r->_M_ref_nonnil();
_RopeRep* __result;
if (0 == __r)
return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen,
- __r->get_allocator());
+ __r->_M_get_allocator());
size_t __count = __r->_M_ref_count;
size_t __orig_size = __r->_M_size;
if (__count > 1)
}
}
_RopeRep* __right =
- __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator());
+ __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->_M_get_allocator());
__r->_M_ref_nonnil();
try
{ __result = _S_tree_concat(__r, __right); }
#ifdef __GC
const _CharT* __section = __l->_M_data + __start;
__result = _S_new_RopeLeaf(__section, __result_len,
- __base->get_allocator());
+ __base->_M_get_allocator());
__result->_M_c_string = 0; // Not eos terminated.
#else
// We should sometimes create substring node instead.
__result = __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__l->_M_data + __start,
__result_len,
__base->
- get_allocator());
+ _M_get_allocator());
#endif
return __result;
}
_S_new_RopeSubstring(__old->_M_base,
__start + __old->_M_start,
__adj_endp1 - __start,
- __base->get_allocator());
+ __base->_M_get_allocator());
return __result;
} // *** else fall through: ***
catch(...)
{
_RopeRep::__STL_FREE_STRING(__section, __result_len,
- __base->get_allocator());
+ __base->_M_get_allocator());
__throw_exception_again;
}
_S_cond_store_eos(__section[__result_len]);
return _S_new_RopeLeaf(__section, __result_len,
- __base->get_allocator());
+ __base->_M_get_allocator());
}
}
lazy:
{
// Create substring node.
return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
- __base->get_allocator());
+ __base->_M_get_allocator());
}
}
{
__rest_buffer = this->_Data_allocate(_S_rounded_up_size(__rest));
__uninitialized_fill_n_a(__rest_buffer, __rest, __c,
- get_allocator());
+ _M_get_allocator());
_S_cond_store_eos(__rest_buffer[__rest]);
try
- { __remainder = _S_new_RopeLeaf(__rest_buffer, __rest, __a); }
+ { __remainder = _S_new_RopeLeaf(__rest_buffer, __rest,
+ _M_get_allocator()); }
catch(...)
{
- _RopeRep::__STL_FREE_STRING(__rest_buffer, __rest, __a);
+ _RopeRep::__STL_FREE_STRING(__rest_buffer, __rest,
+ _M_get_allocator());
__throw_exception_again;
}
}
_RopeLeaf* __base_leaf;
rope __base_rope;
__uninitialized_fill_n_a(__base_buffer, __exponentiate_threshold, __c,
- get_allocator());
+ _M_get_allocator());
_S_cond_store_eos(__base_buffer[__exponentiate_threshold]);
try
{
__base_leaf = _S_new_RopeLeaf(__base_buffer,
- __exponentiate_threshold, __a);
+ __exponentiate_threshold,
+ _M_get_allocator());
}
catch(...)
{
_RopeRep::__STL_FREE_STRING(__base_buffer,
- __exponentiate_threshold, __a);
+ __exponentiate_threshold,
+ _M_get_allocator());
__throw_exception_again;
}
__base_rope._M_tree_ptr = __base_leaf;
__result[__s] = _S_eos((_CharT*)0);
this->_M_tree_ptr->_M_unref_nonnil();
this->_M_tree_ptr = _S_new_RopeLeaf(__result, __s,
- this->get_allocator());
+ this->_M_get_allocator());
return(__result);
}
projects / gcc.git / commitdiff