From ff893307d082263698dc79b955cb72cca949dd64 Mon Sep 17 00:00:00 2001 From: Jason Merrill Date: Wed, 10 Sep 1997 02:49:45 +0000 Subject: [PATCH] algo.h, [...]: Update To September 8 SGI release. * algo.h, algobase.h, alloc.h, bvector.h, deque.h, hashtable.h, iterator.h, list.h, rope.h, ropeimpl.h, slist.h, stl_config.h, tree.h, vector.h: Update To September 8 SGI release. From-SVN: r15211 --- libstdc++/stl/ChangeLog | 6 + libstdc++/stl/algo.h | 326 ++++++++++++++++++++++++++++++------- libstdc++/stl/algobase.h | 75 --------- libstdc++/stl/alloc.h | 22 ++- libstdc++/stl/bvector.h | 37 +---- libstdc++/stl/deque.h | 105 ++++++------ libstdc++/stl/hashtable.h | 45 ++--- libstdc++/stl/iterator.h | 207 ++++++++++++++++++++++- libstdc++/stl/list.h | 42 +++-- libstdc++/stl/rope.h | 105 +++++++----- libstdc++/stl/ropeimpl.h | 157 +++++++++--------- libstdc++/stl/slist.h | 31 ++-- libstdc++/stl/stl_config.h | 18 +- libstdc++/stl/tree.h | 32 ++-- libstdc++/stl/vector.h | 33 +--- 15 files changed, 778 insertions(+), 463 deletions(-) diff --git a/libstdc++/stl/ChangeLog b/libstdc++/stl/ChangeLog index 4282867cbbf..2e12e0c8dab 100644 --- a/libstdc++/stl/ChangeLog +++ b/libstdc++/stl/ChangeLog @@ -1,3 +1,9 @@ +Tue Sep 9 19:47:28 1997 Jason Merrill + + * algo.h, algobase.h, alloc.h, bvector.h, deque.h, hashtable.h, + iterator.h, list.h, rope.h, ropeimpl.h, slist.h, stl_config.h, + tree.h, vector.h: Update To September 8 SGI release. + Tue Sep 9 17:38:47 1997 Mark Mitchell * stl_config.h (__STL_MEMBER_TEMPLATES): Enable. diff --git a/libstdc++/stl/algo.h b/libstdc++/stl/algo.h index 69f43c17a64..2f142898d8b 100644 --- a/libstdc++/stl/algo.h +++ b/libstdc++/stl/algo.h @@ -236,6 +236,63 @@ inline ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, distance_type(first1), distance_type(first2)); } +template +ForwardIterator search_n(ForwardIterator first, ForwardIterator last, + Integer count, const T& value) { + if (count <= 0) + return first; + else { + first = find(first, last, value); + while (first != last) { + Integer n = count - 1; + ForwardIterator i = first; + ++i; + while (i != last && n != 0 && *i == value) { + ++i; + --n; + } + if (n == 0) + return first; + else + first = find(i, last, value); + } + return last; + } +} + +template +ForwardIterator search_n(ForwardIterator first, ForwardIterator last, + Integer count, const T& value, + BinaryPredicate binary_pred) { + if (count <= 0) + return first; + else { + while (first != last) { + if (binary_pred(*first, value)) break; + ++first; + } + while (first != last) { + Integer n = count - 1; + ForwardIterator i = first; + ++i; + while (i != last && n != 0 && binary_pred(*i, value)) { + ++i; + --n; + } + if (n == 0) + return first; + else { + while (i != last) { + if (binary_pred(*i, value)) break; + ++i; + } + first = i; + } + } + return last; + } +} + template ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2) { @@ -1400,15 +1457,6 @@ ForwardIterator __lower_bound(ForwardIterator first, ForwardIterator last, return first; } -template -inline ForwardIterator __lower_bound(ForwardIterator first, - ForwardIterator last, - const T& value, Distance*, - bidirectional_iterator_tag) { - return __lower_bound(first, last, value, (Distance*)0, - forward_iterator_tag()); -} - template RandomAccessIterator __lower_bound(RandomAccessIterator first, RandomAccessIterator last, const T& value, @@ -1459,15 +1507,6 @@ ForwardIterator __lower_bound(ForwardIterator first, ForwardIterator last, return first; } -template -inline ForwardIterator __lower_bound(ForwardIterator first, - ForwardIterator last, - const T& value, Compare comp, Distance*, - bidirectional_iterator_tag) { - return __lower_bound(first, last, value, comp, (Distance*)0, - forward_iterator_tag()); -} - template RandomAccessIterator __lower_bound(RandomAccessIterator first, RandomAccessIterator last, @@ -1520,15 +1559,6 @@ ForwardIterator __upper_bound(ForwardIterator first, ForwardIterator last, return first; } -template -inline ForwardIterator __upper_bound(ForwardIterator first, - ForwardIterator last, - const T& value, Distance*, - bidirectional_iterator_tag) { - return __upper_bound(first, last, value, (Distance*)0, - forward_iterator_tag()); -} - template RandomAccessIterator __upper_bound(RandomAccessIterator first, RandomAccessIterator last, const T& value, @@ -1581,15 +1611,6 @@ ForwardIterator __upper_bound(ForwardIterator first, ForwardIterator last, return first; } -template -inline ForwardIterator __upper_bound(ForwardIterator first, - ForwardIterator last, - const T& value, Compare comp, Distance*, - bidirectional_iterator_tag) { - return __upper_bound(first, last, value, comp, (Distance*)0, - forward_iterator_tag()); -} - template RandomAccessIterator __upper_bound(RandomAccessIterator first, RandomAccessIterator last, @@ -1648,14 +1669,6 @@ __equal_range(ForwardIterator first, ForwardIterator last, const T& value, return pair(first, first); } -template -inline pair -__equal_range(ForwardIterator first, ForwardIterator last, const T& value, - Distance*, bidirectional_iterator_tag) { - return __equal_range(first, last, value, (Distance*)0, - forward_iterator_tag()); -} - template pair __equal_range(RandomAccessIterator first, RandomAccessIterator last, @@ -1718,14 +1731,6 @@ __equal_range(ForwardIterator first, ForwardIterator last, const T& value, return pair(first, first); } -template -inline pair -__equal_range(ForwardIterator first, ForwardIterator last, const T& value, - Compare comp, Distance*, bidirectional_iterator_tag) { - return __equal_range(first, last, value, comp, (Distance*)0, - forward_iterator_tag()); -} - template pair __equal_range(RandomAccessIterator first, RandomAccessIterator last, @@ -2543,6 +2548,213 @@ OutputIterator adjacent_difference(InputIterator first, InputIterator last, binary_op); } +template +InputIterator find_first_of(InputIterator first1, InputIterator last1, + ForwardIterator first2, ForwardIterator last2) +{ + for ( ; first1 != last1; ++first1) + for (ForwardIterator iter = first2; iter != last2; ++iter) + if (*first1 == *iter) + return first1; + return last1; +} + +template +InputIterator find_first_of(InputIterator first1, InputIterator last1, + ForwardIterator first2, ForwardIterator last2, + BinaryPredicate comp) +{ + for ( ; first1 != last1; ++first1) + for (ForwardIterator iter = first2; iter != last2; ++iter) + if (comp(*first1, *iter)) + return first1; + return last1; +} + + +// Search [first2, last2) as a subsequence in [first1, last1). + +// find_end for forward iterators. +template +ForwardIterator1 __find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + forward_iterator_tag, forward_iterator_tag) +{ + if (first2 == last2) + return last1; + else { + ForwardIterator1 result = last1; + while (1) { + ForwardIterator1 new_result = search(first1, last1, first2, last2); + if (new_result == last1) + return result; + else { + result = new_result; + first1 = new_result; + ++first1; + } + } + } +} + +template +ForwardIterator1 __find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + forward_iterator_tag, forward_iterator_tag, + BinaryPredicate comp) +{ + if (first2 == last2) + return last1; + else { + ForwardIterator1 result = last1; + while (1) { + ForwardIterator1 new_result = search(first1, last1, first2, last2, comp); + if (new_result == last1) + return result; + else { + result = new_result; + first1 = new_result; + ++first1; + } + } + } +} + +// find_end for bidirectional iterators. Requires partial specialization. +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + +template +BidirectionalIterator1 +__find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + BidirectionalIterator2 first2, BidirectionalIterator2 last2, + bidirectional_iterator_tag, bidirectional_iterator_tag) +{ + typedef reverse_iterator reviter1; + typedef reverse_iterator reviter2; + + reviter1 rlast1(first1); + reviter2 rlast2(first2); + reviter1 rresult = search(reviter1(last1), rlast1, reviter2(last2), rlast2); + + if (rresult == rlast1) + return last1; + else { + BidirectionalIterator1 result = rresult.base(); + advance(result, -distance(first2, last2)); + return result; + } +} + +template +BidirectionalIterator1 +__find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1, + BidirectionalIterator2 first2, BidirectionalIterator2 last2, + bidirectional_iterator_tag, bidirectional_iterator_tag, + BinaryPredicate comp) +{ + typedef reverse_iterator reviter1; + typedef reverse_iterator reviter2; + + reviter1 rlast1(first1); + reviter2 rlast2(first2); + reviter1 rresult = search(reviter1(last1), rlast1, reviter2(last2), rlast2, + comp); + + if (rresult == rlast1) + return last1; + else { + BidirectionalIterator1 result = rresult.base(); + advance(result, -distance(first2, last2)); + return result; + } +} +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + +// Dispatching functions. + +template +inline ForwardIterator +__find_end(ForwardIterator first1, ForwardIterator last1, + BidirectionalIterator first2, BidirectionalIterator last2, + forward_iterator_tag, bidirectional_iterator_tag) +{ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag()); +} + +template +inline BidirectionalIterator +__find_end(BidirectionalIterator first1, BidirectionalIterator last1, + ForwardIterator first2, ForwardIterator last2, + bidirectional_iterator_tag, forward_iterator_tag) +{ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag()); +} + +template +inline ForwardIterator +__find_end(ForwardIterator first1, ForwardIterator last1, + BidirectionalIterator first2, BidirectionalIterator last2, + forward_iterator_tag, bidirectional_iterator_tag, + BinaryPredicate comp) +{ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag(), + comp); + +} + +template +inline BidirectionalIterator +__find_end(BidirectionalIterator first1, BidirectionalIterator last1, + ForwardIterator first2, ForwardIterator last2, + bidirectional_iterator_tag, forward_iterator_tag, + BinaryPredicate comp) +{ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag(), + comp); +} + +template +inline ForwardIterator1 +find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2) +{ +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + return __find_end(first1, last1, first2, last2, + iterator_traits::iterator_category(), + iterator_traits::iterator_category()); +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag()); +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ +} + +template +inline ForwardIterator1 +find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate comp) +{ +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + return __find_end(first1, last1, first2, last2, + iterator_traits::iterator_category(), + iterator_traits::iterator_category(), + comp); +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + return __find_end(first1, last1, first2, last2, + forward_iterator_tag(), forward_iterator_tag(), + comp); +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ +} + // Returns x ** n, where n >= 0. Note that "multiplication" // is required to be associative, but not necessarily commutative. @@ -2551,18 +2763,18 @@ T power(T x, Integer n, MonoidOperation op) { if (n == 0) return identity_element(op); else { - while (n % 2 == 0) { - n /= 2; + while ((n & 1) == 0) { + n >>= 1; x = op(x, x); } T result = x; - n /= 2; + n >>= 1; while (n != 0) { x = op(x, x); - if (n % 2 != 0) + if ((n & 1) != 0) result = op(result, x); - n /= 2; + n >>= 1; } return result; } diff --git a/libstdc++/stl/algobase.h b/libstdc++/stl/algobase.h index 0a17f48b2e7..eccf465d52c 100644 --- a/libstdc++/stl/algobase.h +++ b/libstdc++/stl/algobase.h @@ -86,19 +86,6 @@ inline void __distance(InputIterator first, InputIterator last, Distance& n, while (first != last) { ++first; ++n; } } -template -inline void __distance(ForwardIterator first, ForwardIterator last, - Distance& n, - forward_iterator_tag) { - while (first != last) { ++first; ++n; } -} - -template -inline void __distance(BidirectionalIterator first, BidirectionalIterator last, - Distance& n, bidirectional_iterator_tag) { - while (first != last) { ++first; ++n; } -} - template inline void __distance(RandomAccessIterator first, RandomAccessIterator last, Distance& n, random_access_iterator_tag) { @@ -122,19 +109,6 @@ __distance(InputIterator first, InputIterator last, input_iterator_tag) { return n; } -template -inline iterator_traits::difference_type -__distance(ForwardIterator first, ForwardIterator last, forward_iterator_tag) { - return __distance(first, last, input_iterator_tag()); -} - -template -inline iterator_traits::difference_type -__distance(BidirectionalIterator first, BidirectionalIterator last, - bidirectional_iterator_tag) { - return __distance(first, last, input_iterator_tag()); -} - template inline iterator_traits::difference_type __distance(RandomAccessIterator first, RandomAccessIterator last, @@ -156,11 +130,6 @@ inline void __advance(InputIterator& i, Distance n, input_iterator_tag) { while (n--) ++i; } -template -inline void __advance(ForwardIterator& i, Distance n, forward_iterator_tag) { - while (n--) ++i; -} - #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) #pragma set woff 1183 #endif @@ -198,20 +167,6 @@ inline OutputIterator __copy(InputIterator first, InputIterator last, return result; } -template -inline OutputIterator __copy(InputIterator first, InputIterator last, - OutputIterator result, forward_iterator_tag) -{ - return __copy(first, last, result, input_iterator_tag()); -} - -template -inline OutputIterator __copy(InputIterator first, InputIterator last, - OutputIterator result, bidirectional_iterator_tag) -{ - return __copy(first, last, result, input_iterator_tag()); -} - template inline OutputIterator __copy_d(RandomAccessIterator first, RandomAccessIterator last, @@ -365,20 +320,6 @@ OutputIterator __copy_n(InputIterator first, Size count, return result; } -template -inline OutputIterator __copy_n(ForwardIterator first, Size count, - OutputIterator result, - forward_iterator_tag) { - return __copy_n(first, count, result, input_iterator_tag()); -} - -template -inline OutputIterator __copy_n(BidirectionalIterator first, Size count, - OutputIterator result, - bidirectional_iterator_tag) { - return __copy_n(first, count, result, input_iterator_tag()); -} - template inline OutputIterator __copy_n(RandomAccessIterator first, Size count, OutputIterator result, @@ -657,22 +598,6 @@ ForwardIterator __uninitialized_copy_n(InputIterator first, Size count, # endif /* __STL_USE_EXCEPTIONS */ } -template -inline ForwardIterator -__uninitialized_copy_n(ForwardIterator1 first, Size count, - ForwardIterator result, - forward_iterator_tag) { - return __uninitialized_copy_n(first, count, result, input_iterator_tag()); -} - -template -inline ForwardIterator -__uninitialized_copy_n(BidirectionalIterator first, Size count, - ForwardIterator result, - bidirectional_iterator_tag) { - return __uninitialized_copy_n(first, count, result, input_iterator_tag()); -} - template inline ForwardIterator __uninitialized_copy_n(RandomAccessIterator first, Size count, diff --git a/libstdc++/stl/alloc.h b/libstdc++/stl/alloc.h index 917ce8fdb80..8831976c614 100644 --- a/libstdc++/stl/alloc.h +++ b/libstdc++/stl/alloc.h @@ -49,7 +49,6 @@ #endif #ifdef __STL_WIN32THREADS # include -// This must precede stl_config.h #endif #include @@ -91,7 +90,11 @@ // This should work without threads, with sproc threads, or with // pthreads. It is suboptimal in all cases. // It is unlikely to even compile on nonSGI machines. -# include + + extern int __us_rsthread_malloc; + // The above is copied from malloc.h. Including + // would be cleaner but fails with certain levels of standard + // conformance. # define __NODE_ALLOCATOR_LOCK if (threads && __us_rsthread_malloc) \ { __lock(&__node_allocator_lock); } # define __NODE_ALLOCATOR_UNLOCK if (threads && __us_rsthread_malloc) \ @@ -383,15 +386,17 @@ public: obj * __VOLATILE * my_free_list; obj * __RESTRICT result; - if (n > __MAX_BYTES) { + if (n > (size_t) __MAX_BYTES) { return(malloc_alloc::allocate(n)); } my_free_list = free_list + FREELIST_INDEX(n); // Acquire the lock here with a constructor call. // This ensures that it is released in exit or during stack // unwinding. +# ifndef _NOTHREADS /*REFERENCED*/ lock lock_instance; +# endif result = *my_free_list; if (result == 0) { void *r = refill(ROUND_UP(n)); @@ -407,14 +412,16 @@ public: obj *q = (obj *)p; obj * __VOLATILE * my_free_list; - if (n > __MAX_BYTES) { + if (n > (size_t) __MAX_BYTES) { malloc_alloc::deallocate(p, n); return; } my_free_list = free_list + FREELIST_INDEX(n); // acquire lock +# ifndef _NOTHREADS /*REFERENCED*/ lock lock_instance; +# endif /* _NOTHREADS */ q -> free_list_link = *my_free_list; *my_free_list = q; // lock is released here @@ -480,6 +487,7 @@ __default_alloc_template::chunk_alloc(size_t size, int& nobjs) // right free list. } } + end_free = 0; // In case of exception. start_free = (char *)malloc_alloc::allocate(bytes_to_get); // This should either throw an // exception or remedy the situation. Thus we assume it @@ -533,7 +541,7 @@ __default_alloc_template::reallocate(void *p, void * result; size_t copy_sz; - if (old_sz > __MAX_BYTES && new_sz > __MAX_BYTES) { + if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) { return(realloc(p, new_sz)); } if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p); @@ -671,4 +679,6 @@ __default_alloc_template ::free_list[ #pragma reset woff 1174 #endif -#endif /* __NODE_ALLOC_H */ +#undef __PRIVATE + +#endif /* __ALLOC_H */ diff --git a/libstdc++/stl/bvector.h b/libstdc++/stl/bvector.h index 27878799aea..71b49173c40 100644 --- a/libstdc++/stl/bvector.h +++ b/libstdc++/stl/bvector.h @@ -82,7 +82,8 @@ public: friend class bit_vector; friend class const_iterator; public: - typedef bit_reference reference; + typedef bit_reference reference; + typedef bit_reference* pointer; protected: unsigned int* p; unsigned int offset; @@ -163,6 +164,7 @@ public: friend class bit_vector; public: typedef bit_const_reference reference; + typedef const bool* pointer; protected: unsigned int* p; unsigned int offset; @@ -243,10 +245,15 @@ public: } }; +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; + typedef reverse_iterator reverse_iterator; +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_iterator const_reverse_iterator; typedef reverse_iterator reverse_iterator; +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ protected: typedef simple_alloc data_allocator; @@ -303,20 +310,6 @@ protected: copy(first, last, start); } - template - void initialize_range(BidirectionalIterator first, - BidirectionalIterator last, - bidirectional_iterator_tag) { - initialize_range(first, last, forward_iterator_tag()); - } - - template - void initialize_range(RandomAccessIterator first, - RandomAccessIterator last, - random_access_iterator_tag) { - initialize_range(first, last, forward_iterator_tag()); - } - template void insert_range(iterator pos, InputIterator first, InputIterator last, @@ -352,20 +345,6 @@ protected: } } - template - void insert_range(iterator pos, - BidirectionalIterator first, BidirectionalIterator last, - bidirectional_iterator_tag) { - insert_range(pos, first, last, forward_iterator_tag()); - } - - template - void insert_range(iterator pos, - RandomAccessIterator first, RandomAccessIterator last, - random_access_iterator_tag) { - insert_range(pos, first, last, forward_iterator_tag()); - } - #endif /* __STL_MEMBER_TEMPLATES */ typedef bit_vector self; diff --git a/libstdc++/stl/deque.h b/libstdc++/stl/deque.h index 6685abffe7c..e202a117398 100644 --- a/libstdc++/stl/deque.h +++ b/libstdc++/stl/deque.h @@ -87,42 +87,44 @@ inline size_t __deque_buf_size(size_t n, size_t sz) } #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG -template +template struct __deque_iterator { - typedef __deque_iterator iterator; - typedef __deque_iterator const_iterator; + typedef __deque_iterator iterator; + typedef __deque_iterator const_iterator; static size_t buffer_size() {return __deque_buf_size(BufSiz, sizeof(T)); } #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */ -template +template struct __deque_iterator { - typedef __deque_iterator iterator; - typedef __deque_iterator const_iterator; + typedef __deque_iterator iterator; + typedef __deque_iterator const_iterator; static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); } #endif typedef random_access_iterator_tag iterator_category; typedef T value_type; - typedef value_type* pointer; - typedef value_type& reference; - typedef const value_type& const_reference; + typedef Ptr pointer; + typedef Ref reference; typedef size_t size_type; typedef ptrdiff_t difference_type; - typedef pointer* map_pointer; + typedef T** map_pointer; typedef __deque_iterator self; - pointer cur; - pointer first; - pointer last; + T* cur; + T* first; + T* last; map_pointer node; - __deque_iterator(pointer x, map_pointer y) + __deque_iterator(T* x, map_pointer y) : cur(x), first(*y), last(*y + buffer_size()), node(y) {} __deque_iterator() : cur(0), first(0), last(0), node(0) {} __deque_iterator(const iterator& x) : cur(x.cur), first(x.first), last(x.last), node(x.node) {} - Ref operator*() const { return *cur; } + reference operator*() const { return *cur; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ difference_type operator-(const self& x) const { return buffer_size() * (node - x.node - 1) + @@ -183,7 +185,7 @@ struct __deque_iterator { return tmp -= n; } - Ref operator[](difference_type n) const { return *(*this + n); } + reference operator[](difference_type n) const { return *(*this + n); } bool operator==(const self& x) const { return cur == x.cur; } bool operator!=(const self& x) const { return !(*this == x); } @@ -198,40 +200,45 @@ struct __deque_iterator { } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG -template +template inline random_access_iterator_tag -iterator_category(const __deque_iterator&) { +iterator_category(const __deque_iterator&) { return random_access_iterator_tag(); } -template -inline T* value_type(const __deque_iterator&) { return 0; } +template +inline T* value_type(const __deque_iterator&) { + return 0; +} -template -inline ptrdiff_t* distance_type(const __deque_iterator&) { +template +inline ptrdiff_t* distance_type(const __deque_iterator&) { return 0; } #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */ -template +template inline random_access_iterator_tag -iterator_category(const __deque_iterator&) { +iterator_category(const __deque_iterator&) { return random_access_iterator_tag(); } -template -inline T* value_type(const __deque_iterator&) { return 0; } +template +inline T* value_type(const __deque_iterator&) { return 0; } -template -inline ptrdiff_t* distance_type(const __deque_iterator&) { +template +inline ptrdiff_t* distance_type(const __deque_iterator&) { return 0; } #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */ +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ // See __deque_buf_size(). The only reason that the default value is 0 // is as a workaround for bugs in the way that some compilers handle @@ -248,17 +255,23 @@ public: // Basic types public: // Iterators #ifndef __STL_NON_TYPE_TMPL_PARAM_BUG - typedef __deque_iterator iterator; - typedef __deque_iterator const_iterator; + typedef __deque_iterator iterator; + typedef __deque_iterator const_iterator; #else /* __STL_NON_TYPE_TMPL_PARAM_BUG */ - typedef __deque_iterator iterator; - typedef __deque_iterator const_iterator; + typedef __deque_iterator iterator; + typedef __deque_iterator const_iterator; #endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */ + +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; + typedef reverse_iterator reverse_iterator; +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_iterator const_reverse_iterator; typedef reverse_iterator reverse_iterator; +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ protected: // Internal typedefs typedef pointer* map_pointer; @@ -553,19 +566,6 @@ protected: // Internal construction/destruction void range_initialize(ForwardIterator first, ForwardIterator last, forward_iterator_tag); - template - void range_initialize(BidirectionalIterator first, - BidirectionalIterator last, - bidirectional_iterator_tag) { - range_initialize(first, last, forward_iterator_tag()); - } - - template - void range_initialize(RandomAccessIterator first, RandomAccessIterator last, - random_access_iterator_tag) { - range_initialize(first, last, forward_iterator_tag()); - } - #endif /* __STL_MEMBER_TEMPLATES */ protected: // Internal push_* and pop_* @@ -587,19 +587,6 @@ protected: // Internal insert functions void insert(iterator pos, ForwardIterator first, ForwardIterator last, forward_iterator_tag); - template - void insert(iterator pos, - BidirectionalIterator first, BidirectionalIterator last, - bidirectional_iterator_tag) { - insert(pos, first, last, forward_iterator_tag()); - } - - template - void insert(iterator pos, - RandomAccessIterator first, RandomAccessIterator last, - random_access_iterator_tag) { - insert(pos, first, last, forward_iterator_tag()); - } #endif /* __STL_MEMBER_TEMPLATES */ iterator insert_aux(iterator pos, const value_type& x); @@ -881,7 +868,7 @@ void deque::fill_initialize(size_type n, } catch(...) { for (map_pointer n = start.node; n < cur; ++n) - destroy(*cur, *cur + buffer_size()); + destroy(*n, *n + buffer_size()); destroy_map_and_nodes(); throw; } diff --git a/libstdc++/stl/hashtable.h b/libstdc++/stl/hashtable.h index 420d7a8545a..fb4abc2b344 100644 --- a/libstdc++/stl/hashtable.h +++ b/libstdc++/stl/hashtable.h @@ -123,7 +123,6 @@ struct __hashtable_iterator { typedef ptrdiff_t difference_type; typedef size_t size_type; typedef Value& reference; - typedef const Value& const_reference; typedef Value* pointer; node* cur; @@ -132,6 +131,9 @@ struct __hashtable_iterator { __hashtable_iterator(node* n, hashtable* tab) : cur(n), ht(tab) {} __hashtable_iterator() {} reference operator*() const { return cur->val; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ iterator& operator++(); iterator operator++(int); bool operator==(const iterator& it) const { return cur == it.cur; } @@ -156,9 +158,8 @@ struct __hashtable_const_iterator { typedef Value value_type; typedef ptrdiff_t difference_type; typedef size_t size_type; - typedef Value& reference; - typedef const Value& const_reference; - typedef Value* pointer; + typedef const Value& reference; + typedef const Value* pointer; const node* cur; const hashtable* ht; @@ -167,7 +168,10 @@ struct __hashtable_const_iterator { : cur(n), ht(tab) {} __hashtable_const_iterator() {} __hashtable_const_iterator(const iterator& it) : cur(it.cur), ht(it.ht) {} - const_reference operator*() const { return cur->val; } + reference operator*() const { return cur->val; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ const_iterator& operator++(); const_iterator operator++(int); bool operator==(const const_iterator& it) const { return cur == it.cur; } @@ -399,34 +403,6 @@ public: insert_equal_noresize(*f); } - template - void insert_unique(BidirectionalIterator f, BidirectionalIterator l, - bidirectional_iterator_tag) - { - insert_unique(f, l, forward_iterator_tag()); - } - - template - void insert_equal(BidirectionalIterator f, BidirectionalIterator l, - bidirectional_iterator_tag) - { - insert_equal(f, l, forward_iterator_tag()); - } - - template - void insert_unique(RandomAccessIterator f, RandomAccessIterator l, - random_access_iterator_tag) - { - insert_unique(f, l, forward_iterator_tag()); - } - - template - void insert_equal(RandomAccessIterator f, RandomAccessIterator l, - random_access_iterator_tag) - { - insert_equal(f, l, forward_iterator_tag()); - } - #else /* __STL_MEMBER_TEMPLATES */ void insert_unique(const value_type* f, const value_type* l) { @@ -619,6 +595,7 @@ __hashtable_const_iterator::operator++(int) return tmp; } +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION template inline forward_iterator_tag @@ -661,6 +638,8 @@ distance_type(const __hashtable_const_iterator&) return (hashtable::difference_type*) 0; } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template bool operator==(const hashtable& ht1, const hashtable& ht2) diff --git a/libstdc++/stl/iterator.h b/libstdc++/stl/iterator.h index bdd2260596a..f8a19d0aa34 100644 --- a/libstdc++/stl/iterator.h +++ b/libstdc++/stl/iterator.h @@ -33,9 +33,9 @@ struct input_iterator_tag {}; struct output_iterator_tag {}; -struct forward_iterator_tag {}; -struct bidirectional_iterator_tag {}; -struct random_access_iterator_tag {}; +struct forward_iterator_tag : public input_iterator_tag {}; +struct bidirectional_iterator_tag : public forward_iterator_tag {}; +struct random_access_iterator_tag : public bidirectional_iterator_tag {}; template struct input_iterator { typedef input_iterator_tag iterator_category; @@ -47,6 +47,10 @@ template struct input_iterator { struct output_iterator { typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; }; template struct forward_iterator { @@ -106,7 +110,34 @@ struct iterator_traits { typedef T& reference; }; -#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ +template +struct iterator_traits { + typedef random_access_iterator_tag iterator_category; + typedef T value_type; + typedef ptrdiff_t difference_type; + typedef const T* pointer; + typedef const T& reference; +}; + +template +inline iterator_traits::iterator_category +iterator_category(const Iterator&) { + return iterator_traits::iterator_category(); +} + +template +inline iterator_traits::difference_type* +distance_type(const Iterator&) { + return static_cast::difference_type*>(0); +} + +template +inline iterator_traits::value_type* +value_type(const Iterator&) { + return static_cast::value_type*>(0); +} + +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ template inline input_iterator_tag @@ -189,12 +220,18 @@ distance_type(const random_access_iterator&) { template inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template class back_insert_iterator { protected: Container* container; public: typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; explicit back_insert_iterator(Container& x) : container(&x) {} back_insert_iterator& @@ -207,6 +244,8 @@ public: back_insert_iterator& operator++(int) { return *this; } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline output_iterator_tag iterator_category(const back_insert_iterator&) @@ -214,6 +253,8 @@ iterator_category(const back_insert_iterator&) return output_iterator_tag(); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template inline back_insert_iterator back_inserter(Container& x) { return back_insert_iterator(x); @@ -225,6 +266,10 @@ protected: Container* container; public: typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; explicit front_insert_iterator(Container& x) : container(&x) {} front_insert_iterator& @@ -237,6 +282,8 @@ public: front_insert_iterator& operator++(int) { return *this; } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline output_iterator_tag iterator_category(const front_insert_iterator&) @@ -244,6 +291,8 @@ iterator_category(const front_insert_iterator&) return output_iterator_tag(); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template inline front_insert_iterator front_inserter(Container& x) { return front_insert_iterator(x); @@ -256,6 +305,10 @@ protected: typename Container::iterator iter; public: typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; insert_iterator(Container& x, typename Container::iterator i) : container(&x), iter(i) {} @@ -270,6 +323,8 @@ public: insert_iterator& operator++(int) { return *this; } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline output_iterator_tag iterator_category(const insert_iterator&) @@ -277,6 +332,8 @@ iterator_category(const insert_iterator&) return output_iterator_tag(); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template inline insert_iterator inserter(Container& x, Iterator i) { typedef typename Container::iterator iter; @@ -311,6 +368,9 @@ public: BidirectionalIterator tmp = current; return *--tmp; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ self& operator++() { --current; return *this; @@ -331,6 +391,7 @@ public: } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION template @@ -357,6 +418,8 @@ distance_type(const reverse_bidirectional_iterator inline bool operator==( @@ -367,6 +430,109 @@ inline bool operator==( return x.current == y.current; } +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + +// This is the new version of reverse_iterator, as defined in the +// draft C++ standard. It relies on the iterator_traits template, +// which in turn relies on partial specialization. The class +// reverse_bidirectional_iterator is no longer part of the draft +// standard, but it is retained for backward compatibility. + +template +class reverse_iterator : public iterator_traits +{ +protected: + Iterator current; +public: + typedef Iterator iterator_type; + typedef reverse_iterator self; + +public: + reverse_iterator() {} + explicit reverse_iterator(iterator_type x) : current(x) {} + + reverse_iterator(const self& x) : current(x.current) {} +#ifdef __STL_MEMBER_TEMPLATES + template + reverse_iterator(const reverse_iterator& x) : current(x.current) {} +#endif /* __STL_MEMBER_TEMPLATES */ + + iterator_type base() const { return current; } + reference operator*() const { + Iterator tmp = current; + return *--tmp; + } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ + + self& operator++() { + --current; + return *this; + } + self operator++(int) { + self tmp = *this; + --current; + return tmp; + } + self& operator--() { + ++current; + return *this; + } + self operator--(int) { + self tmp = *this; + ++current; + return tmp; + } + + self operator+(difference_type n) const { + return self(current - n); + } + self& operator+=(difference_type n) { + current -= n; + return *this; + } + self operator-(difference_type n) const { + return self(current + n); + } + self& operator-=(difference_type n) { + current += n; + return *this; + } + reference operator[](difference_type n) { return *(*this + n); } +}; + +template +inline bool operator==(const reverse_iterator& x, + const reverse_iterator& y) { + return x.base() == y.base(); +} + +template +inline bool operator<(const reverse_iterator& x, + const reverse_iterator& y) { + return y.base() < x.base(); +} + +template +inline reverse_iterator::difference_type +operator-(const reverse_iterator& x, + const reverse_iterator& y) { + return y.base() - x.base(); +} + +template +inline reverse_iterator +operator+(reverse_iterator::difference_type n, + const reverse_iterator& x) { + return reverse_iterator(x.base() - n); +} + +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + +// This is the old version of reverse_iterator, as found in the original +// HP STL. It does not use partial specialization. + #ifndef __STL_LIMITED_DEFAULT_TEMPLATES template @@ -394,6 +560,9 @@ public: explicit reverse_iterator(RandomAccessIterator x) : current(x) {} RandomAccessIterator base() { return current; } Reference operator*() const { return *(current - 1); } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ self& operator++() { --current; return *this; @@ -482,6 +651,7 @@ operator+(Distance n, (x.current - n); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ template class raw_storage_iterator { @@ -489,6 +659,10 @@ protected: ForwardIterator iter; public: typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; explicit raw_storage_iterator(ForwardIterator x) : iter(x) {} raw_storage_iterator& operator*() { return *this; } @@ -507,6 +681,8 @@ public: } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline output_iterator_tag iterator_category(const raw_storage_iterator&) @@ -514,6 +690,8 @@ iterator_category(const raw_storage_iterator&) return output_iterator_tag(); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template class istream_iterator { friend bool operator==(const istream_iterator& x, @@ -531,12 +709,15 @@ public: typedef input_iterator_tag iterator_category; typedef T value_type; typedef Distance difference_type; - typedef T* pointer; - typedef T& reference; + typedef const T* pointer; + typedef const T& reference; istream_iterator() : stream(&cin), end_marker(false) {} istream_iterator(istream& s) : stream(&s) { read(); } - const T& operator*() const { return value; } + reference operator*() const { return value; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ istream_iterator& operator++() { read(); return *this; @@ -548,6 +729,8 @@ public: } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline input_iterator_tag iterator_category(const istream_iterator&) { @@ -562,6 +745,8 @@ inline Distance* distance_type(const istream_iterator&) { return (Distance*) 0; } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + template bool operator==(const istream_iterator& x, const istream_iterator& y) { @@ -576,6 +761,10 @@ protected: const char* string; public: typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; ostream_iterator(ostream& s) : stream(&s), string(0) {} ostream_iterator(ostream& s, const char* c) : stream(&s), string(c) {} @@ -589,10 +778,14 @@ public: ostream_iterator& operator++(int) { return *this; } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + template inline output_iterator_tag iterator_category(const ostream_iterator&) { return output_iterator_tag(); } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + #endif /* __SGI_STL_ITERATOR_H */ diff --git a/libstdc++/stl/list.h b/libstdc++/stl/list.h index b26692b5c82..6d9492865e8 100644 --- a/libstdc++/stl/list.h +++ b/libstdc++/stl/list.h @@ -40,17 +40,16 @@ struct __list_node { T data; }; -template +template struct __list_iterator { - typedef __list_iterator iterator; - typedef __list_iterator const_iterator; - typedef __list_iterator self; + typedef __list_iterator iterator; + typedef __list_iterator const_iterator; + typedef __list_iterator self; typedef bidirectional_iterator_tag iterator_category; typedef T value_type; - typedef value_type* pointer; - typedef value_type& reference; - typedef const value_type& const_reference; + typedef Ptr pointer; + typedef Ref reference; typedef __list_node* link_type; typedef size_t size_type; typedef ptrdiff_t difference_type; @@ -63,7 +62,11 @@ struct __list_iterator { bool operator==(const self& x) const { return node == x.node; } bool operator!=(const self& x) const { return node != x.node; } - Ref operator*() const { return (*node).data; } + reference operator*() const { return (*node).data; } + +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ self& operator++() { node = (link_type)((*node).next); @@ -85,25 +88,27 @@ struct __list_iterator { } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION -template +template inline bidirectional_iterator_tag -iterator_category(const __list_iterator&) { +iterator_category(const __list_iterator&) { return bidirectional_iterator_tag(); } -template +template inline T* -value_type(const __list_iterator&) { +value_type(const __list_iterator&) { return 0; } -template +template inline ptrdiff_t* -distance_type(const __list_iterator&) { +distance_type(const __list_iterator&) { return 0; } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ template class list { @@ -121,15 +126,20 @@ public: typedef ptrdiff_t difference_type; public: - typedef __list_iterator iterator; - typedef __list_iterator const_iterator; + typedef __list_iterator iterator; + typedef __list_iterator const_iterator; +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; + typedef reverse_iterator reverse_iterator; +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_bidirectional_iterator const_reverse_iterator; typedef reverse_bidirectional_iterator reverse_iterator; +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ protected: link_type get_node() { return list_node_allocator::allocate(); } diff --git a/libstdc++/stl/rope.h b/libstdc++/stl/rope.h index 105eb05d0cc..399352f477e 100644 --- a/libstdc++/stl/rope.h +++ b/libstdc++/stl/rope.h @@ -38,18 +38,18 @@ inline charT __eos(charT*) { return charT(); } // Test for basic character types. // For basic character types leaves having a trailing eos. template -inline bool __is_basic_char_type(charT* c) { return false; } +inline bool __is_basic_char_type(charT *) { return false; } template -inline bool __is_one_byte_char_type(charT* c) { return false; } +inline bool __is_one_byte_char_type(charT *) { return false; } -inline bool __is_basic_char_type(char* c) { return true; } -inline bool __is_one_byte_char_type(char* c) { return true; } -inline bool __is_basic_char_type(wchar_t* c) { return true; } +inline bool __is_basic_char_type(char *) { return true; } +inline bool __is_one_byte_char_type(char *) { return true; } +inline bool __is_basic_char_type(wchar_t *) { return true; } // Store an eos iff charT is a basic character type. // Do not reference __eos if it isn't. template -inline void __cond_store_eos(charT& c) {} +inline void __cond_store_eos(charT&) {} inline void __cond_store_eos(char& c) { c = 0; } inline void __cond_store_eos(wchar_t& c) { c = 0; } @@ -235,6 +235,7 @@ template class __rope_charT_ptr_proxy; template struct __rope_RopeBase { typedef rope my_rope; + typedef simple_alloc DataAlloc; typedef simple_alloc<__rope_RopeConcatenation, Alloc> CAlloc; typedef simple_alloc<__rope_RopeLeaf, Alloc> LAlloc; typedef simple_alloc<__rope_RopeFunction, Alloc> FAlloc; @@ -368,12 +369,17 @@ struct __rope_RopeBase { { if (0 != t) t -> incr_refcount(); } + static void free_if_unref(__rope_RopeBase* t) + { + if (0 != t && 0 == t -> refcount) t -> free_tree(); + } # else /* __GC */ void unref_nonnil() {} void ref_nonnil() {} static void unref(__rope_RopeBase* t) {} static void ref(__rope_RopeBase* t) {} static void fn_finalization_proc(void * tree, void *); + static void free_if_unref(__rope_RopeBase* t) {} # endif // The data fields of leaves are allocated with some @@ -384,9 +390,9 @@ struct __rope_RopeBase { size_t size_with_eos; if (__is_basic_char_type((charT *)0)) { - size_with_eos = (n + 1) * sizeof(charT); + size_with_eos = n + 1; } else { - size_with_eos = n * sizeof(charT); + size_with_eos = n; } # ifdef __GC return size_with_eos; @@ -684,6 +690,11 @@ class __rope_const_iterator : public __rope_iterator_base { const_cast(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 + // to be included in refcount. + typedef const charT* pointer; public: __rope_const_iterator() {}; @@ -702,7 +713,7 @@ class __rope_const_iterator : public __rope_iterator_base { } return(*this); } - const charT& operator*() { + reference operator*() { if (0 == buf_ptr) setcache(*this); return *buf_ptr; } @@ -758,7 +769,7 @@ class __rope_const_iterator : public __rope_iterator_base { friend __rope_const_iterator operator+ (ptrdiff_t n, const __rope_const_iterator & x); - charT operator[](size_t n) { + reference operator[](size_t n) { return rope::fetch(root, current_pos + n); } friend bool operator== @@ -790,6 +801,10 @@ class __rope_iterator : public __rope_iterator_base { RopeBase::ref(root); } void check(); + public: + typedef __rope_charT_ref_proxy reference; + typedef __rope_charT_ref_proxy* pointer; + public: rope& container() { return *root_rope; } __rope_iterator() { @@ -819,7 +834,7 @@ class __rope_iterator : public __rope_iterator_base { RopeBase::unref(old); return(*this); } - __rope_charT_ref_proxy operator*() { + reference operator*() { check(); if (0 == buf_ptr) { return __rope_charT_ref_proxy(root_rope, current_pos); @@ -862,7 +877,7 @@ class __rope_iterator : public __rope_iterator_base { decr(1); return __rope_iterator(root_rope, old_pos); } - __rope_charT_ref_proxy operator[](ptrdiff_t n) { + reference operator[](ptrdiff_t n) { return __rope_charT_ref_proxy(root_rope, current_pos + n); } friend bool operator== @@ -892,7 +907,7 @@ class rope { typedef charT value_type; typedef ptrdiff_t difference_type; typedef size_t size_type; - typedef const charT& const_reference; + typedef charT const_reference; typedef const charT* const_pointer; typedef __rope_iterator iterator; typedef __rope_const_iterator const_iterator; @@ -945,6 +960,7 @@ class rope { static charT empty_c_str[1]; + typedef simple_alloc DataAlloc; typedef simple_alloc<__rope_RopeConcatenation, Alloc> CAlloc; typedef simple_alloc<__rope_RopeLeaf, Alloc> LAlloc; typedef simple_alloc<__rope_RopeFunction, Alloc> FAlloc; @@ -1054,8 +1070,7 @@ class rope { // Adds a trailing NULL for basic char types. static charT * alloc_copy(const charT *s, size_t size) { - charT * result = (charT *) - Alloc::allocate(rounded_up_size(size)); + charT * result = DataAlloc::allocate(rounded_up_size(size)); uninitialized_copy_n(s, size, result); __cond_store_eos(result[size]); @@ -1073,6 +1088,15 @@ class rope { // In the nonGC case, it was allocated from Alloc with // rounded_up_size(size). + static RopeLeaf * RopeLeaf_from_unowned_char_ptr(const charT *s, + size_t size) { + charT * buf = alloc_copy(s, size); + __STL_TRY + return RopeLeaf_from_char_ptr(buf, size); + __STL_UNWIND(RopeBase::free_string(buf, size)) + } + + // Concatenation of nonempty strings. // Always builds a concatenation node. // Rebalances if the result is too deep. @@ -1107,24 +1131,14 @@ class rope { friend struct rope::concat_fn; struct concat_fn - : binary_function { - RopeBase * operator() (RopeBase * x, RopeBase *y) { - RopeBase * result; - x -> ref_nonnil(); - y -> ref_nonnil(); - __STL_TRY - result = tree_concat(x, y); -# ifndef __GC - result -> refcount = 0; -# endif - __STL_UNWIND(unref(x); unref(y)); - return result; - // In the nonGC case, x and y must remain accessible through - // the result. Use of concat could result on a memory leak. + : binary_function, rope, + rope > { + rope operator() (const rope& x, const rope& y) { + return x + y; } }; - friend RopeBase* identity_element(concat_fn) { return 0; } + friend rope identity_element(concat_fn) { return rope(); } static size_t char_ptr_len(const charT * s); // slightly generalized strlen @@ -1202,7 +1216,7 @@ class rope { if (0 == len) { tree_ptr = 0; } else { - tree_ptr = RopeLeaf_from_char_ptr(alloc_copy(s, len), len); + tree_ptr = RopeLeaf_from_unowned_char_ptr(s, len); # ifndef __GC __stl_assert(1 == tree_ptr -> refcount); # endif @@ -1214,7 +1228,7 @@ class rope { if (0 == len) { tree_ptr = 0; } else { - tree_ptr = RopeLeaf_from_char_ptr(alloc_copy(s, len), len); + tree_ptr = RopeLeaf_from_unowned_char_ptr(s, len); } } @@ -1225,7 +1239,7 @@ class rope { if (0 == len) { tree_ptr = 0; } else { - tree_ptr = RopeLeaf_from_char_ptr(alloc_copy(s, len), len); + tree_ptr = RopeLeaf_from_unowned_char_ptr(s, len); } } @@ -1241,10 +1255,12 @@ class rope { rope(charT c) { - charT * buf = (charT *)Alloc::allocate(rounded_up_size(1)); + charT * buf = DataAlloc::allocate(rounded_up_size(1)); construct(buf, c); - tree_ptr = RopeLeaf_from_char_ptr(buf, 1); + __STL_TRY + tree_ptr = RopeLeaf_from_char_ptr(buf, 1); + __STL_UNWIND(RopeBase::free_string(buf, 1)) } rope(size_t n, charT c); @@ -1258,7 +1274,7 @@ class rope { tree_ptr = 0; } else { size_t len = j - i; - tree_ptr = RopeLeaf_from_char_ptr(alloc_copy(i, len), len); + tree_ptr = RopeLeaf_from_unowned_char_ptr(i, len); } } @@ -1312,15 +1328,12 @@ class rope { return fetch(tree_ptr, tree_ptr -> size - 1); } - void push_front(const charT& x) + void push_front(charT x) { RopeBase *old = tree_ptr; - charT *buf = alloc_copy(&x, 1); RopeBase *left; - __STL_TRY - left = RopeLeaf_from_char_ptr(buf, 1); - __STL_UNWIND(RopeBase::free_string(buf, 1)) + left = RopeLeaf_from_unowned_char_ptr(&x, 1); __STL_TRY tree_ptr = concat(left, tree_ptr); unref(old); @@ -1436,9 +1449,13 @@ class rope { // but it's harder to make guarantees. } +# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; +# else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_iterator const_reverse_iterator; - +# endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } @@ -1794,8 +1811,12 @@ class rope { return(iterator(this, size())); } +# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator reverse_iterator; +# else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_iterator reverse_iterator; +# endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ reverse_iterator mutable_rbegin() { return reverse_iterator(mutable_end()); diff --git a/libstdc++/stl/ropeimpl.h b/libstdc++/stl/ropeimpl.h index b90bc08928b..d1c1ed4e689 100644 --- a/libstdc++/stl/ropeimpl.h +++ b/libstdc++/stl/ropeimpl.h @@ -11,11 +11,8 @@ * purpose. It is provided "as is" without express or implied warranty. */ -#if defined(_MSC_VER) -# include -#else -# include -#endif +# include +# include // Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf // if necessary. Assumes path_end[leaf_index] and leaf_pos are correct. @@ -330,7 +327,7 @@ inline void __rope_RopeBase::free_c_string() if (0 != cstr) { size_t sz = size + 1; destroy(cstr, cstr + sz); - Alloc::deallocate(cstr, sz); + DataAlloc::deallocate(cstr, sz); } } @@ -340,7 +337,7 @@ inline void __rope_RopeBase::free_string(charT* s, size_t n) if (!__is_basic_char_type((charT *)0)) { destroy(s, s + n); } - Alloc::deallocate(s, rounded_up_size(n)); + DataAlloc::deallocate(s, rounded_up_size(n)); } template @@ -413,7 +410,7 @@ rope::leaf_concat_char_iter { size_t old_len = r -> size; charT * new_data = (charT *) - Alloc::allocate(rounded_up_size(old_len + len)); + DataAlloc::allocate(rounded_up_size(old_len + len)); RopeLeaf * result; uninitialized_copy_n(r -> data, old_len, new_data); @@ -459,6 +456,7 @@ rope::destr_leaf_concat_char_iter #endif // Assumes left and right are not 0. +// Does not increment (nor decrement on exception) child reference counts. // Result has ref count 1. template rope::RopeBase * @@ -473,7 +471,7 @@ rope::tree_concat (RopeBase * left, RopeBase * right) result -> is_balanced = false; result -> size = rsize = left -> size + right -> size; if (right -> depth > child_depth) child_depth = right -> depth; - unsigned char depth = child_depth + 1; + unsigned char depth = (unsigned char)(child_depth + 1); result -> depth = depth; result -> left = left; result -> right = right; @@ -492,7 +490,12 @@ rope::tree_concat (RopeBase * left, RopeBase * right) && 1 == balanced -> refcount); } # endif - __STL_ALWAYS(result -> unref_nonnil()); + result -> unref_nonnil(); + __STL_UNWIND(CAlloc::deallocate(result)); + // In case of exception, we need to deallocate + // otherwise dangling result node. But caller + // still owns its children. Thus unref is + // inappropriate. return balanced; } else { return result; @@ -508,7 +511,7 @@ rope::RopeBase * rope::concat_char_iter ref(r); return r; } - if (0 == r) return RopeLeaf_from_char_ptr(alloc_copy(s, slen), slen); + if (0 == r) return RopeLeaf_from_unowned_char_ptr(s, slen); if (RopeBase::leaf == r -> tag && r -> size + slen <= copy_max) { result = leaf_concat_char_iter((RopeLeaf *)r, s, slen); # ifndef __GC @@ -521,23 +524,22 @@ rope::RopeBase * rope::concat_char_iter RopeLeaf *right = (RopeLeaf *)(((RopeConcatenation *)r) -> right); if (right -> size + slen <= copy_max) { RopeBase * left = ((RopeConcatenation *)r) -> left; + RopeBase * nright = leaf_concat_char_iter((RopeLeaf *)right, s, slen); left -> ref_nonnil(); __STL_TRY - result = tree_concat(left, - leaf_concat_char_iter((RopeLeaf *)right, - s, slen)); - __STL_UNWIND(unref(left)); + result = tree_concat(left, nright); + __STL_UNWIND(unref(left); unref(nright)); # ifndef __GC __stl_assert(1 == result -> refcount); # endif return result; } } + RopeBase * nright = RopeLeaf_from_unowned_char_ptr(s, slen); __STL_TRY r -> ref_nonnil(); - result = tree_concat(r, RopeLeaf_from_char_ptr(alloc_copy(s, slen), - slen)); - __STL_UNWIND(unref(r)); + result = tree_concat(r, nright); + __STL_UNWIND(unref(r); unref(nright)); # ifndef __GC __stl_assert(1 == result -> refcount); # endif @@ -551,7 +553,7 @@ rope::RopeBase * rope (RopeBase * r, const charT *s, size_t slen) { RopeBase *result; - if (0 == r) return RopeLeaf_from_char_ptr(alloc_copy(s, slen), slen); + if (0 == r) return RopeLeaf_from_unowned_char_ptr(s, slen); size_t count = r -> refcount; size_t orig_size = r -> size; __stl_assert(count >= 1); @@ -587,11 +589,11 @@ rope::RopeBase * rope return r; } } - charT * cpy = alloc_copy(s, slen); + RopeBase *right = RopeLeaf_from_unowned_char_ptr(s, slen); r -> ref_nonnil(); __STL_TRY - result = tree_concat(r, RopeLeaf_from_char_ptr(cpy, slen)); - __STL_UNWIND(unref(r); RopeBase::free_string(cpy,slen)) + result = tree_concat(r, right); + __STL_UNWIND(unref(r); unref(right)) __stl_assert(1 == result -> refcount); return result; } @@ -629,13 +631,15 @@ rope::concat(RopeBase * left, RopeBase * right) leftleft -> ref_nonnil(); __STL_TRY return(tree_concat(leftleft, rest)); - __STL_UNWIND(unref(left); unref(rest)) + __STL_UNWIND(unref(leftleft); unref(rest)) } } } left -> ref_nonnil(); right -> ref_nonnil(); - return(tree_concat(left, right)); + __STL_TRY + return(tree_concat(left, right)); + __STL_UNWIND(unref(left); unref(right)); } template @@ -686,21 +690,18 @@ rope::substring(RopeBase * base, size_t start, size_t endp1) { RopeLeaf * l = (RopeLeaf *)base; RopeLeaf * result; - __GC_CONST charT *section; size_t result_len; if (start >= adj_endp1) return 0; result_len = adj_endp1 - start; if (result_len > lazy_threshold) goto lazy; # ifdef __GC - section = l -> data + start; + const charT *section = l -> data + start; result = RopeLeaf_from_char_ptr(section, result_len); result -> c_string = 0; // Not eos terminated. # else - section = alloc_copy(l -> data + start, result_len); // We should sometimes create substring node instead. - __STL_TRY - result = RopeLeaf_from_char_ptr(section, result_len); - __STL_UNWIND(RopeBase::free_string(section, result_len)) + result = RopeLeaf_from_unowned_char_ptr( + l -> data + start, result_len); # endif return result; } @@ -730,7 +731,7 @@ rope::substring(RopeBase * base, size_t start, size_t endp1) if (result_len > lazy_threshold) goto lazy; section = (charT *) - Alloc::allocate(rounded_up_size(result_len)); + DataAlloc::allocate(rounded_up_size(result_len)); __STL_TRY (*(f -> fn))(start, result_len, section); __STL_UNWIND(RopeBase::free_string(section, result_len)); @@ -870,12 +871,11 @@ bool rope::apply_to_pieces( RopeFunction * f = (RopeFunction *)r; size_t len = end - begin; bool result; - charT * buffer = (charT *) - Alloc::allocate(len * sizeof(charT)); + charT * buffer = DataAlloc::allocate(len); __STL_TRY (*(f -> fn))(begin, end, buffer); result = c(buffer, len); - __STL_ALWAYS(Alloc::deallocate(buffer, len * sizeof(charT))) + __STL_ALWAYS(DataAlloc::deallocate(buffer, len)) return result; } default: @@ -887,23 +887,23 @@ bool rope::apply_to_pieces( inline void __rope_fill(ostream& o, size_t n) { - char f = cout.fill(); + char f = o.fill(); size_t i; for (i = 0; i < n; i++) o.put(f); } -template inline bool __rope_is_simple(charT *c) { return false; } -inline bool __rope_is_simple(char * c) { return true; } -inline bool __rope_is_simple(wchar_t * c) { return true; } +template inline bool __rope_is_simple(charT *) { return false; } +inline bool __rope_is_simple(char *) { return true; } +inline bool __rope_is_simple(wchar_t *) { return true; } template ostream& operator<< (ostream& o, const rope& r) { size_t w = o.width(); - bool left = o.flags() & ios::left; + bool left = bool(o.flags() & ios::left); size_t pad_len; size_t rope_len = r.size(); __rope_insert_char_consumer c(o); @@ -1084,6 +1084,9 @@ rope::balance(RopeBase *r) # endif result = concat(forest[i], result); forest[i] -> unref_nonnil(); +# if !defined(__GC) && defined(__STL_USE_EXCEPTIONS) + forest[i] = 0; +# endif } __STL_UNWIND(for(i = 0; i <= RopeBase::max_rope_depth; i++) unref(forest[i])) @@ -1114,12 +1117,11 @@ template void rope::add_leaf_to_forest(RopeBase *r, RopeBase **forest) { - self_destruct_ptr insertee(r); // included in refcount - self_destruct_ptr too_tiny(0); // included in refcount + RopeBase * insertee; // included in refcount + RopeBase * too_tiny = 0; // included in refcount int i; // forest[0..i-1] is empty - size_t s = insertee -> size; + size_t s = r -> size; - ref(r); for (i = 0; s >= min_len[i+1]/* not this bucket */; ++i) { if (0 != forest[i]) { # ifndef __GC @@ -1132,12 +1134,12 @@ rope::add_leaf_to_forest(RopeBase *r, RopeBase **forest) } { # ifndef __GC - self_destruct_ptr old(insertee); + self_destruct_ptr old(too_tiny); # endif - insertee = concat_and_set_balanced(too_tiny, insertee); + insertee = concat_and_set_balanced(too_tiny, r); } - unref(too_tiny); // too_tiny is dead. - too_tiny = 0; // Needed for exception safety. + // Too_tiny dead, and no longer included in refcount. + // Insertee is live and included. __stl_assert(is_almost_balanced(insertee)); __stl_assert(insertee -> depth <= r -> depth + 1); for (;; ++i) { @@ -1155,7 +1157,6 @@ rope::add_leaf_to_forest(RopeBase *r, RopeBase **forest) if (i == RopeBase::max_rope_depth || insertee -> size < min_len[i+1]) { forest[i] = insertee; - insertee = 0; // refcount is OK since insertee is now dead. return; } @@ -1348,12 +1349,13 @@ __rope_charT_ref_proxy::operator& () const { template rope::rope(size_t n, charT c) { - RopeBase * result; + rope result; const size_t exponentiate_threshold = 32; size_t exponent; size_t rest; charT *rest_buffer; RopeBase * remainder; + rope remainder_rope; if (0 == n) { tree_ptr = 0; return; } exponent = n / exponentiate_threshold; @@ -1361,53 +1363,42 @@ rope::rope(size_t n, charT c) if (0 == rest) { remainder = 0; } else { - rest_buffer = (charT *)Alloc::allocate(rounded_up_size(rest)); + rest_buffer = DataAlloc::allocate(rounded_up_size(rest)); uninitialized_fill_n(rest_buffer, rest, c); __cond_store_eos(rest_buffer[rest]); __STL_TRY remainder = RopeLeaf_from_char_ptr(rest_buffer, rest); __STL_UNWIND(RopeBase::free_string(rest_buffer, rest)) } - __STL_TRY - if (exponent != 0) { + remainder_rope.tree_ptr = remainder; + if (exponent != 0) { charT * base_buffer = - (charT *)Alloc::allocate( - rounded_up_size(exponentiate_threshold)); - self_destruct_ptr base_leaf; + DataAlloc::allocate(rounded_up_size(exponentiate_threshold)); + RopeLeaf * base_leaf; + rope base_rope; uninitialized_fill_n(base_buffer, exponentiate_threshold, c); __cond_store_eos(base_buffer[exponentiate_threshold]); __STL_TRY - base_leaf = RopeLeaf_from_char_ptr(base_buffer, - exponentiate_threshold); + base_leaf = RopeLeaf_from_char_ptr(base_buffer, + exponentiate_threshold); __STL_UNWIND(RopeBase::free_string(base_buffer, exponentiate_threshold)) + base_rope.tree_ptr = base_leaf; if (1 == exponent) { - result = base_leaf; -# ifndef __GC - __stl_assert(1 == result -> refcount); - result -> refcount = 2; // will be decremented when base_leaf disappears -# endif + result = base_rope; +# ifndef __GC + __stl_assert(1 == result -> tree_ptr -> refcount); +# endif } else { - result = power((RopeBase *)base_leaf, exponent, concat_fn()); -# ifndef __GC - __stl_assert(0 == result -> refcount); - result -> refcount = 1; -# endif + result = power(base_rope, exponent, concat_fn()); } if (0 != remainder) { -# ifndef __GC - __stl_assert(1 == remainder -> refcount); -# endif - result = tree_concat(result, remainder); + result += remainder_rope; } - // All partial results computed by power must be used. - } else { - result = remainder; - } - __STL_UNWIND(unref(remainder)); -# ifndef __GC - __stl_assert(0 == result || 1 == result -> refcount); -# endif - tree_ptr = result; + } else { + result = remainder_rope; + } + tree_ptr = result.tree_ptr; + tree_ptr -> ref_nonnil(); } template charT rope::empty_c_str[1]; @@ -1427,7 +1418,7 @@ const charT * rope::c_str() const { __GC_CONST charT * old_c_string = tree_ptr -> c_string; if (0 != old_c_string) return(old_c_string); size_t s = size(); - charT * result = (charT *)Alloc::allocate((s + 1)*sizeof(charT)); + charT * result = DataAlloc::allocate(s + 1); flatten(tree_ptr, result); result[s] = __eos((charT *)0); # ifdef __GC @@ -1438,7 +1429,7 @@ const charT * rope::c_str() const { // separately allocated. Deallocate the old copy, since we just // replaced it. destroy(old_c_string, old_c_string + s + 1); - Alloc::deallocate(old_c_string, s + 1); + DataAlloc::deallocate(old_c_string, s + 1); } # endif return(result); @@ -1455,7 +1446,7 @@ const charT * rope::replace_with_c_str() { return(old_c_string); } size_t s = size(); - charT * result = (charT *)Alloc::allocate(rounded_up_size(s)); + charT * result = DataAlloc::allocate(rounded_up_size(s)); flatten(tree_ptr, result); result[s] = __eos((charT *)0); tree_ptr -> unref_nonnil(); diff --git a/libstdc++/stl/slist.h b/libstdc++/stl/slist.h index bb99920185f..9ae6e117f0d 100644 --- a/libstdc++/stl/slist.h +++ b/libstdc++/stl/slist.h @@ -99,24 +99,27 @@ struct __slist_iterator_base } }; -template +template struct __slist_iterator : public __slist_iterator_base { - typedef __slist_iterator iterator; - typedef __slist_iterator const_iterator; - typedef __slist_iterator self; + typedef __slist_iterator iterator; + typedef __slist_iterator const_iterator; + typedef __slist_iterator self; typedef T value_type; - typedef value_type* pointer; - typedef value_type& reference; - typedef const value_type& const_reference; + typedef Ptr pointer; + typedef Ref reference; typedef __slist_node list_node; __slist_iterator(list_node* x) : __slist_iterator_base(x) {} __slist_iterator() : __slist_iterator_base(0) {} __slist_iterator(const iterator& x) : __slist_iterator_base(x.node) {} - Ref operator*() const { return ((list_node*) node)->data; } + reference operator*() const { return ((list_node*) node)->data; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ + self& operator++() { incr(); @@ -130,6 +133,8 @@ struct __slist_iterator : public __slist_iterator_base } }; +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + inline ptrdiff_t* distance_type(const __slist_iterator_base&) { @@ -142,12 +147,14 @@ iterator_category(const __slist_iterator_base&) return forward_iterator_tag(); } -template +template inline T* -value_type(const __slist_iterator&) { +value_type(const __slist_iterator&) { return 0; } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + inline size_t __slist_size(__slist_node_base* node) { size_t result = 0; @@ -167,8 +174,8 @@ public: typedef size_t size_type; typedef ptrdiff_t difference_type; - typedef __slist_iterator iterator; - typedef __slist_iterator const_iterator; + typedef __slist_iterator iterator; + typedef __slist_iterator const_iterator; private: typedef __slist_node list_node; diff --git a/libstdc++/stl/stl_config.h b/libstdc++/stl/stl_config.h index 905d84c7465..31e96cf7cd3 100644 --- a/libstdc++/stl/stl_config.h +++ b/libstdc++/stl/stl_config.h @@ -47,14 +47,16 @@ // (9) Defines __STL_NON_TYPE_TMPL_PARAM_BUG if the compiler has // trouble performing function template argument deduction for // non-type template parameters. -// (10) Defines __STL_USE_EXCEPTIONS if the compiler (in the current -// compilation mode) supports exceptions. -// (11) Defines __STL_SGI_THREADS if this is being compiled on an SGI -// compiler, and if the user hasn't selected pthreads or no threads -// instead. -// (12) Defines __STL_WIN32THREADS if this is being compiled on a +// (10) Defines __SGI_STL_NO_ARROW_OPERATOR if the compiler is unable +// to support the -> operator for iterators. +// (11) Defines __STL_USE_EXCEPTIONS if the compiler (in the current +// compilation mode) supports exceptions. +// (12) Defines __STL_SGI_THREADS if this is being compiled on an SGI +// compiler, and if the user hasn't selected pthreads or no threads +// instead. +// (13) Defines __STL_WIN32THREADS if this is being compiled on a // WIN32 compiler in multithreaded mode. -// (13) Defines __stl_assert either as a test or as a null macro, +// (14) Defines __stl_assert either as a test or as a null macro, // depending on whether or not __STL_ASSERTIONS is defined. # if defined(__sgi) && !defined(__GNUC__) @@ -120,6 +122,7 @@ # define __STL_NEED_EXPLICIT # endif # define __STL_NON_TYPE_TMPL_PARAM_BUG +# define __SGI_STL_NO_ARROW_OPERATOR # ifdef _CPPUNWIND # define __STL_USE_EXCEPTIONS # endif @@ -132,6 +135,7 @@ # define __STL_NO_DRAND48 # define __STL_NEED_TYPENAME # define __STL_LIMITED_DEFAULT_TEMPLATES +# define __SGI_STL_NO_ARROW_OPERATOR # define __STL_NON_TYPE_TMPL_PARAM_BUG # ifdef _CPPUNWIND # define __STL_USE_EXCEPTIONS diff --git a/libstdc++/stl/tree.h b/libstdc++/stl/tree.h index 0429c1a421d..b55f0c51f0f 100644 --- a/libstdc++/stl/tree.h +++ b/libstdc++/stl/tree.h @@ -137,23 +137,25 @@ struct __rb_tree_base_iterator } }; -template +template struct __rb_tree_iterator : public __rb_tree_base_iterator { typedef Value value_type; typedef Value& reference; - typedef const Value& const_reference; typedef Value* pointer; - typedef __rb_tree_iterator iterator; - typedef __rb_tree_iterator const_iterator; - typedef __rb_tree_iterator self; + typedef __rb_tree_iterator iterator; + typedef __rb_tree_iterator const_iterator; + typedef __rb_tree_iterator self; typedef __rb_tree_node* link_type; __rb_tree_iterator() {} __rb_tree_iterator(link_type x) { node = x; } __rb_tree_iterator(const iterator& it) { node = it.node; } - Ref operator*() const { return link_type(node)->value_field; } + reference operator*() const { return link_type(node)->value_field; } +#ifndef __SGI_STL_NO_ARROW_OPERATOR + pointer operator->() const { return &(operator*()); } +#endif /* __SGI_STL_NO_ARROW_OPERATOR */ self& operator++() { increment(); return *this; } self operator++(int) { @@ -180,6 +182,8 @@ inline bool operator!=(const __rb_tree_base_iterator& x, return x.node != y.node; } +#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION + inline bidirectional_iterator_tag iterator_category(const __rb_tree_base_iterator&) { return bidirectional_iterator_tag(); @@ -190,11 +194,13 @@ distance_type(const __rb_tree_base_iterator&) { return (__rb_tree_base_iterator::difference_type*) 0; } -template -inline Value* value_type(const __rb_tree_iterator&) { +template +inline Value* value_type(const __rb_tree_iterator&) { return (Value*) 0; } +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ + inline void __rb_tree_rotate_left(__rb_tree_node_base* x, __rb_tree_node_base*& root) { @@ -487,15 +493,21 @@ protected: } public: - typedef __rb_tree_iterator iterator; - typedef __rb_tree_iterator const_iterator; + typedef __rb_tree_iterator iterator; + typedef __rb_tree_iterator + const_iterator; +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; + typedef reverse_iterator reverse_iterator; +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_bidirectional_iterator reverse_iterator; typedef reverse_bidirectional_iterator const_reverse_iterator; +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ private: iterator __insert(base_ptr x, base_ptr y, const value_type& v); link_type __copy(link_type x, link_type p); diff --git a/libstdc++/stl/vector.h b/libstdc++/stl/vector.h index bb6a404766b..e0b88a1cd49 100644 --- a/libstdc++/stl/vector.h +++ b/libstdc++/stl/vector.h @@ -42,10 +42,16 @@ public: typedef const value_type& const_reference; typedef size_t size_type; typedef ptrdiff_t difference_type; + +#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION + typedef reverse_iterator const_reverse_iterator; + typedef reverse_iterator reverse_iterator; +#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */ typedef reverse_iterator const_reverse_iterator; typedef reverse_iterator reverse_iterator; +#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */ protected: typedef simple_alloc data_allocator; iterator start; @@ -256,20 +262,6 @@ protected: end_of_storage = finish; } - template - void range_initialize(BidirectionalIterator first, - BidirectionalIterator last, - bidirectional_iterator_tag) { - range_initialize(first, last, forward_iterator_tag()); - } - - template - void range_initialize(RandomAccessIterator first, - RandomAccessIterator last, - random_access_iterator_tag) { - range_initialize(first, last, forward_iterator_tag()); - } - template void range_insert(iterator pos, InputIterator first, InputIterator last, @@ -280,19 +272,6 @@ protected: ForwardIterator first, ForwardIterator last, forward_iterator_tag); - template - void range_insert(iterator pos, - BidirectionalIterator first, BidirectionalIterator last, - bidirectional_iterator_tag) { - range_insert(pos, first, last, forward_iterator_tag()); - } - - template - void range_insert(iterator pos, - RandomAccessIterator first, RandomAccessIterator last, - random_access_iterator_tag) { - range_insert(pos, first, last, forward_iterator_tag()); - } #endif /* __STL_MEMBER_TEMPLATES */ };