From 659096c96926ba7726401bc7180b9997638b11c2 Mon Sep 17 00:00:00 2001 From: Andrea Ornstein Date: Tue, 20 Nov 2007 17:00:46 +0000 Subject: ................ Merged revisions 116474-127002 via svnmerge from svn+ssh://gcc.gnu.org/svn/gcc/trunk remove obsolete lang hook merge changes in langhooks adapt to new structure of CALL_EXPR handle POINTER_PLUS_EXPR handle GIMPLE_MODIFY_STMT in the same way we do for MODIFY_EXPR generate new POINTER_PLUS_EXPR instead of PLUS_EXPR generate GIMPLE_MODIFY_STMT instead of MODIFY_EXPR use new function get_calee_fndecl, use build_call_list insteadof build3 (CALL_EXPR,... ................ update contact info ................ mv target dependent file bb-layout.c to cil32 dir ................ avoid use of 'struct with no fields', is not standard C ................ do not run mudflap_2 for cli ................ Fix generation of calls to functions without prototype ................ move to a new file code related to removal of stloc ldloc ................ add missing Makefile rules in libcilsupport and libgcc4net ................ added handling of cil_strattr attribute and JitCompilationHints (frequencies and probabilities) ................ Early switch simplification pass added ................ add missing call to Environment.Exit in body of StartupHelper::Shutdown in libgcc4net ................ git-svn-id: https://gcc.gnu.org/svn/gcc/branches/st/cli@130317 138bc75d-0d04-0410-961f-82ee72b054a4 --- libstdc++-v3/include/ext/rope | 250 +++++++++++++++++++++++------------------- 1 file changed, 138 insertions(+), 112 deletions(-) (limited to 'libstdc++-v3/include/ext/rope') diff --git a/libstdc++-v3/include/ext/rope b/libstdc++-v3/include/ext/rope index 059342f22a5..e0f0aa39036 100644 --- a/libstdc++-v3/include/ext/rope +++ b/libstdc++-v3/include/ext/rope @@ -1,6 +1,6 @@ // SGI's rope class -*- 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 @@ -57,29 +57,28 @@ #include #include #include +#include +#include # ifdef __GC # define __GC_CONST const # else -# include # define __GC_CONST // constant except for deallocation # endif #include // For uninitialized_copy_n -namespace -{ - enum { _S_max_rope_depth = 45 }; - enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function}; -} - _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; - using std::iterator; - using std::reverse_iterator; using std::_Destroy; // The _S_eos function is used for those functions that @@ -138,7 +137,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) class char_producer { public: - virtual ~char_producer() {}; + virtual ~char_producer() { }; virtual void operator()(size_t __start_pos, size_t __len, @@ -165,7 +164,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) template class sequence_buffer - : public iterator + : public std::iterator { public: typedef typename _Sequence::value_type value_type; @@ -302,7 +301,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) // 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; @@ -534,8 +533,16 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) get_allocator() const { return *static_cast(this); } + allocator_type& + _M_get_allocator() + { return *static_cast<_Alloc*>(this); } + + const allocator_type& + _M_get_allocator() const + { return *static_cast(this); } + _Rope_rep_base(size_t __size, const allocator_type&) - : _M_size(__size) {} + : _M_size(__size) { } size_t _M_size; @@ -558,7 +565,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) # 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; @@ -573,9 +580,10 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) allocator_type; using _Rope_rep_base<_CharT, _Alloc>::get_allocator; + using _Rope_rep_base<_CharT, _Alloc>::_M_get_allocator; - _Rope_RopeRep(_Tag __t, int __d, bool __b, size_t __size, - allocator_type __a) + _Rope_RopeRep(__detail::_Tag __t, int __d, bool __b, size_t __size, + const allocator_type& __a) : _Rope_rep_base<_CharT, _Alloc>(__size, __a), #ifndef __GC _Refcount_Base(1), @@ -592,11 +600,11 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) #endif #ifdef __GC void - _M_incr () {} + _M_incr () { } #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. @@ -640,11 +648,11 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) __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& @@ -690,8 +698,8 @@ protected: allocator_type; _Rope_RopeLeaf(__GC_CONST _CharT* __d, size_t __size, - allocator_type __a) - : _Rope_RopeRep<_CharT, _Alloc>(_S_leaf, 0, true, + const allocator_type& __a) + : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_leaf, 0, true, __size, __a), _M_data(__d) { if (_S_is_basic_char_type((_CharT *)0)) @@ -709,7 +717,7 @@ protected: 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: @@ -732,8 +740,8 @@ protected: _Rope_RopeConcatenation(_Rope_RopeRep<_CharT, _Alloc>* __l, _Rope_RopeRep<_CharT, _Alloc>* __r, - allocator_type __a) - : _Rope_RopeRep<_CharT, _Alloc>(::_S_concat, + const allocator_type& __a) + : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_concat, std::max(__l->_M_depth, __r->_M_depth) + 1, false, @@ -780,8 +788,8 @@ protected: allocator_type; _Rope_RopeFunction(char_producer<_CharT>* __f, size_t __size, - bool __d, allocator_type __a) - : _Rope_RopeRep<_CharT, _Alloc>(::_S_function, 0, true, __size, __a) + bool __d, const allocator_type& __a) + : _Rope_RopeRep<_CharT, _Alloc>(__detail::_S_function, 0, true, __size, __a) , _M_fn(__f) #ifndef __GC , _M_delete_when_done(__d) @@ -832,15 +840,15 @@ protected: { 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; @@ -857,14 +865,14 @@ protected: 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) { #ifndef __GC _M_base->_M_ref_nonnil(); #endif - this->_M_tag = ::_S_substringfn; + this->_M_tag = __detail::_S_substringfn; } virtual ~_Rope_RopeSubstring() throw() { @@ -893,12 +901,12 @@ protected: ~_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*() @@ -941,18 +949,18 @@ protected: _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; @@ -985,12 +993,12 @@ protected: 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) { } @@ -1023,7 +1031,7 @@ protected: template class _Rope_iterator_base - : public iterator + : public std::iterator { friend class rope<_CharT, _Alloc>; public: @@ -1074,10 +1082,10 @@ protected: 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); @@ -1114,7 +1122,7 @@ protected: : _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 @@ -1122,7 +1130,7 @@ protected: 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) { } @@ -1267,13 +1275,13 @@ protected: 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) @@ -1287,7 +1295,6 @@ protected: 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; } @@ -1446,13 +1453,21 @@ protected: get_allocator() const { return *static_cast(this); } + allocator_type& + _M_get_allocator() + { return *static_cast<_Alloc*>(this); } + + const allocator_type& + _M_get_allocator() const + { return *static_cast(this); } + typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep; // 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; @@ -1506,6 +1521,7 @@ protected: 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]; @@ -1554,8 +1570,8 @@ protected: { _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 @@ -1616,7 +1632,7 @@ protected: // 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); @@ -1624,7 +1640,7 @@ protected: 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); @@ -1632,7 +1648,7 @@ protected: 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); @@ -1640,7 +1656,7 @@ protected: 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); @@ -1648,7 +1664,7 @@ protected: 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) { @@ -1711,7 +1727,7 @@ protected: _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) @@ -1770,22 +1786,31 @@ protected: { 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()) @@ -1804,12 +1829,15 @@ protected: { _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; } } @@ -1818,9 +1846,9 @@ protected: 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) @@ -1866,9 +1894,8 @@ protected: 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); } @@ -1881,7 +1908,7 @@ protected: { _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); @@ -1919,7 +1946,7 @@ protected: 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); } @@ -1934,7 +1961,7 @@ protected: 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; } @@ -1961,7 +1988,7 @@ protected: { 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) { @@ -2013,13 +2040,13 @@ protected: 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. } - typedef reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; const_reverse_iterator rbegin() const @@ -2049,12 +2076,13 @@ protected: template 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) { @@ -2550,7 +2578,7 @@ protected: mutable_end() { return(iterator(this, size())); } - typedef reverse_iterator reverse_iterator; + typedef std::reverse_iterator reverse_iterator; reverse_iterator mutable_rbegin() @@ -2576,9 +2604,9 @@ protected: 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 @@ -2747,21 +2775,21 @@ protected: __x._M_current_pos + __n); } template - 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 - 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 @@ -2778,9 +2806,9 @@ protected: 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)); } @@ -2797,8 +2825,8 @@ protected: 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)); } @@ -2887,7 +2915,6 @@ protected: operator()(const crope& __str) const { size_t __size = __str.size(); - if (0 == __size) return 0; return 13 * __str[0] + 5 * __str[__size - 1] + __size; @@ -2902,7 +2929,6 @@ protected: operator()(const wrope& __str) const { size_t __size = __str.size(); - if (0 == __size) return 0; return 13 * __str[0] + 5 * __str[__size - 1] + __size; -- cgit v1.2.3