+Tue Sep 9 19:47:28 1997 Jason Merrill <jason@yorick.cygnus.com>
+
+ * 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 <mmitchell@usa.net>
* stl_config.h (__STL_MEMBER_TEMPLATES): Enable.
distance_type(first1), distance_type(first2));
}
+template <class ForwardIterator, class Integer, class T>
+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 <class ForwardIterator, class Integer, class T, class BinaryPredicate>
+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 <class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2) {
return first;
}
-template <class ForwardIterator, class T, class Distance>
-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 <class RandomAccessIterator, class T, class Distance>
RandomAccessIterator __lower_bound(RandomAccessIterator first,
RandomAccessIterator last, const T& value,
return first;
}
-template <class ForwardIterator, class T, class Compare, class Distance>
-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 <class RandomAccessIterator, class T, class Compare, class Distance>
RandomAccessIterator __lower_bound(RandomAccessIterator first,
RandomAccessIterator last,
return first;
}
-template <class ForwardIterator, class T, class Distance>
-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 <class RandomAccessIterator, class T, class Distance>
RandomAccessIterator __upper_bound(RandomAccessIterator first,
RandomAccessIterator last, const T& value,
return first;
}
-template <class ForwardIterator, class T, class Compare, class Distance>
-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 <class RandomAccessIterator, class T, class Compare, class Distance>
RandomAccessIterator __upper_bound(RandomAccessIterator first,
RandomAccessIterator last,
return pair<ForwardIterator, ForwardIterator>(first, first);
}
-template <class ForwardIterator, class T, class Distance>
-inline pair<ForwardIterator, ForwardIterator>
-__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 <class RandomAccessIterator, class T, class Distance>
pair<RandomAccessIterator, RandomAccessIterator>
__equal_range(RandomAccessIterator first, RandomAccessIterator last,
return pair<ForwardIterator, ForwardIterator>(first, first);
}
-template <class ForwardIterator, class T, class Compare, class Distance>
-inline pair<ForwardIterator, ForwardIterator>
-__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 <class RandomAccessIterator, class T, class Compare, class Distance>
pair<RandomAccessIterator, RandomAccessIterator>
__equal_range(RandomAccessIterator first, RandomAccessIterator last,
binary_op);
}
+template <class InputIterator, class ForwardIterator>
+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 <class InputIterator, class ForwardIterator, class BinaryPredicate>
+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 <class ForwardIterator1, class ForwardIterator2>
+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 <class ForwardIterator1, class ForwardIterator2,
+ class BinaryPredicate>
+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 <class BidirectionalIterator1, class BidirectionalIterator2>
+BidirectionalIterator1
+__find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+ BidirectionalIterator2 first2, BidirectionalIterator2 last2,
+ bidirectional_iterator_tag, bidirectional_iterator_tag)
+{
+ typedef reverse_iterator<BidirectionalIterator1> reviter1;
+ typedef reverse_iterator<BidirectionalIterator2> 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 <class BidirectionalIterator1, class BidirectionalIterator2,
+ class BinaryPredicate>
+BidirectionalIterator1
+__find_end(BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+ BidirectionalIterator2 first2, BidirectionalIterator2 last2,
+ bidirectional_iterator_tag, bidirectional_iterator_tag,
+ BinaryPredicate comp)
+{
+ typedef reverse_iterator<BidirectionalIterator1> reviter1;
+ typedef reverse_iterator<BidirectionalIterator2> 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 <class ForwardIterator, class BidirectionalIterator>
+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 <class BidirectionalIterator, class ForwardIterator>
+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 <class ForwardIterator, class BidirectionalIterator,
+ class BinaryPredicate>
+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 <class BidirectionalIterator, class ForwardIterator,
+ class BinaryPredicate>
+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 <class ForwardIterator1, class ForwardIterator2>
+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<ForwardIterator1>::iterator_category(),
+ iterator_traits<ForwardIterator2>::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 <class ForwardIterator1, class ForwardIterator2,
+ class BinaryPredicate>
+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<ForwardIterator1>::iterator_category(),
+ iterator_traits<ForwardIterator2>::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.
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;
}
while (first != last) { ++first; ++n; }
}
-template <class ForwardIterator, class Distance>
-inline void __distance(ForwardIterator first, ForwardIterator last,
- Distance& n,
- forward_iterator_tag) {
- while (first != last) { ++first; ++n; }
-}
-
-template <class BidirectionalIterator, class Distance>
-inline void __distance(BidirectionalIterator first, BidirectionalIterator last,
- Distance& n, bidirectional_iterator_tag) {
- while (first != last) { ++first; ++n; }
-}
-
template <class RandomAccessIterator, class Distance>
inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
Distance& n, random_access_iterator_tag) {
return n;
}
-template <class ForwardIterator>
-inline iterator_traits<ForwardIterator>::difference_type
-__distance(ForwardIterator first, ForwardIterator last, forward_iterator_tag) {
- return __distance(first, last, input_iterator_tag());
-}
-
-template <class BidirectionalIterator>
-inline iterator_traits<BidirectionalIterator>::difference_type
-__distance(BidirectionalIterator first, BidirectionalIterator last,
- bidirectional_iterator_tag) {
- return __distance(first, last, input_iterator_tag());
-}
-
template <class RandomAccessIterator>
inline iterator_traits<RandomAccessIterator>::difference_type
__distance(RandomAccessIterator first, RandomAccessIterator last,
while (n--) ++i;
}
-template <class ForwardIterator, class Distance>
-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
return result;
}
-template <class InputIterator, class OutputIterator>
-inline OutputIterator __copy(InputIterator first, InputIterator last,
- OutputIterator result, forward_iterator_tag)
-{
- return __copy(first, last, result, input_iterator_tag());
-}
-
-template <class InputIterator, class OutputIterator>
-inline OutputIterator __copy(InputIterator first, InputIterator last,
- OutputIterator result, bidirectional_iterator_tag)
-{
- return __copy(first, last, result, input_iterator_tag());
-}
-
template <class RandomAccessIterator, class OutputIterator, class Distance>
inline OutputIterator
__copy_d(RandomAccessIterator first, RandomAccessIterator last,
return result;
}
-template <class ForwardIterator, class Size, class OutputIterator>
-inline OutputIterator __copy_n(ForwardIterator first, Size count,
- OutputIterator result,
- forward_iterator_tag) {
- return __copy_n(first, count, result, input_iterator_tag());
-}
-
-template <class BidirectionalIterator, class Size, class OutputIterator>
-inline OutputIterator __copy_n(BidirectionalIterator first, Size count,
- OutputIterator result,
- bidirectional_iterator_tag) {
- return __copy_n(first, count, result, input_iterator_tag());
-}
-
template <class RandomAccessIterator, class Size, class OutputIterator>
inline OutputIterator __copy_n(RandomAccessIterator first, Size count,
OutputIterator result,
# endif /* __STL_USE_EXCEPTIONS */
}
-template <class ForwardIterator1, class Size, class ForwardIterator>
-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 <class BidirectionalIterator, class Size, class ForwardIterator>
-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 <class RandomAccessIterator, class Size, class ForwardIterator>
inline ForwardIterator
__uninitialized_copy_n(RandomAccessIterator first, Size count,
#endif
#ifdef __STL_WIN32THREADS
# include <windows.h>
-// This must precede stl_config.h
#endif
#include <stddef.h>
// 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 <malloc.h>
+
+ extern int __us_rsthread_malloc;
+ // The above is copied from malloc.h. Including <malloc.h>
+ // 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) \
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));
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
// 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
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);
#pragma reset woff 1174
#endif
-#endif /* __NODE_ALLOC_H */
+#undef __PRIVATE
+
+#endif /* __ALLOC_H */
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;
friend class bit_vector;
public:
typedef bit_const_reference reference;
+ typedef const bool* pointer;
protected:
unsigned int* p;
unsigned int offset;
}
};
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected:
typedef simple_alloc<unsigned int, alloc> data_allocator;
copy(first, last, start);
}
- template <class BidirectionalIterator>
- void initialize_range(BidirectionalIterator first,
- BidirectionalIterator last,
- bidirectional_iterator_tag) {
- initialize_range(first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- void initialize_range(RandomAccessIterator first,
- RandomAccessIterator last,
- random_access_iterator_tag) {
- initialize_range(first, last, forward_iterator_tag());
- }
-
template <class InputIterator>
void insert_range(iterator pos,
InputIterator first, InputIterator last,
}
}
- template <class BidirectionalIterator>
- void insert_range(iterator pos,
- BidirectionalIterator first, BidirectionalIterator last,
- bidirectional_iterator_tag) {
- insert_range(pos, first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- 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;
}
#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
-template <class T, class Ref, size_t BufSiz>
+template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator {
- typedef __deque_iterator<T, T&, BufSiz> iterator;
- typedef __deque_iterator<T, const T&, BufSiz> const_iterator;
+ typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
+ typedef __deque_iterator<T, const T&, const T*, BufSiz> const_iterator;
static size_t buffer_size() {return __deque_buf_size(BufSiz, sizeof(T)); }
#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
struct __deque_iterator {
- typedef __deque_iterator<T, T&> iterator;
- typedef __deque_iterator<T, const T&> const_iterator;
+ typedef __deque_iterator<T, T&, T*> iterator;
+ typedef __deque_iterator<T, const T&, const T*> 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) +
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); }
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
-template <class T, class Ref, size_t BufSiz>
+template <class T, class Ref, class Ptr, size_t BufSiz>
inline random_access_iterator_tag
-iterator_category(const __deque_iterator<T, Ref, BufSiz>&) {
+iterator_category(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
return random_access_iterator_tag();
}
-template <class T, class Ref, size_t BufSiz>
-inline T* value_type(const __deque_iterator<T, Ref, BufSiz>&) { return 0; }
+template <class T, class Ref, class Ptr, size_t BufSiz>
+inline T* value_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
+ return 0;
+}
-template <class T, class Ref, size_t BufSiz>
-inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, BufSiz>&) {
+template <class T, class Ref, class Ptr, size_t BufSiz>
+inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, Ptr, BufSiz>&) {
return 0;
}
#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
inline random_access_iterator_tag
-iterator_category(const __deque_iterator<T, Ref>&) {
+iterator_category(const __deque_iterator<T, Ref, Ptr>&) {
return random_access_iterator_tag();
}
-template <class T, class Ref>
-inline T* value_type(const __deque_iterator<T, Ref>&) { return 0; }
+template <class T, class Ref, class Ptr>
+inline T* value_type(const __deque_iterator<T, Ref, Ptr>&) { return 0; }
-template <class T, class Ref>
-inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref>&) {
+template <class T, class Ref, class Ptr>
+inline ptrdiff_t* distance_type(const __deque_iterator<T, Ref, Ptr>&) {
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
public: // Iterators
#ifndef __STL_NON_TYPE_TMPL_PARAM_BUG
- typedef __deque_iterator<value_type, reference, BufSiz> iterator;
- typedef __deque_iterator<value_type, const_reference, BufSiz> const_iterator;
+ typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
+ typedef __deque_iterator<T, const T&, const T&, BufSiz> const_iterator;
#else /* __STL_NON_TYPE_TMPL_PARAM_BUG */
- typedef __deque_iterator<value_type, reference> iterator;
- typedef __deque_iterator<value_type, const_reference> const_iterator;
+ typedef __deque_iterator<T, T&, T*> iterator;
+ typedef __deque_iterator<T, const T&, const T*> const_iterator;
#endif /* __STL_NON_TYPE_TMPL_PARAM_BUG */
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type>
const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected: // Internal typedefs
typedef pointer* map_pointer;
void range_initialize(ForwardIterator first, ForwardIterator last,
forward_iterator_tag);
- template <class BidirectionalIterator>
- void range_initialize(BidirectionalIterator first,
- BidirectionalIterator last,
- bidirectional_iterator_tag) {
- range_initialize(first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- 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_*
void insert(iterator pos, ForwardIterator first, ForwardIterator last,
forward_iterator_tag);
- template <class BidirectionalIterator>
- void insert(iterator pos,
- BidirectionalIterator first, BidirectionalIterator last,
- bidirectional_iterator_tag) {
- insert(pos, first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- 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);
}
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;
}
typedef ptrdiff_t difference_type;
typedef size_t size_type;
typedef Value& reference;
- typedef const Value& const_reference;
typedef Value* pointer;
node* cur;
__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; }
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;
: 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; }
insert_equal_noresize(*f);
}
- template <class BidirectionalIterator>
- void insert_unique(BidirectionalIterator f, BidirectionalIterator l,
- bidirectional_iterator_tag)
- {
- insert_unique(f, l, forward_iterator_tag());
- }
-
- template <class BidirectionalIterator>
- void insert_equal(BidirectionalIterator f, BidirectionalIterator l,
- bidirectional_iterator_tag)
- {
- insert_equal(f, l, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- void insert_unique(RandomAccessIterator f, RandomAccessIterator l,
- random_access_iterator_tag)
- {
- insert_unique(f, l, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- 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)
{
return tmp;
}
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class V, class K, class HF, class ExK, class EqK, class All>
inline forward_iterator_tag
return (hashtable<V, K, HF, ExK, EqK, All>::difference_type*) 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class V, class K, class HF, class Ex, class Eq, class A>
bool operator==(const hashtable<V, K, HF, Ex, Eq, A>& ht1,
const hashtable<V, K, HF, Ex, Eq, A>& ht2)
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 <class T, class Distance> struct input_iterator {
typedef input_iterator_tag iterator_category;
struct output_iterator {
typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
};
template <class T, class Distance> struct forward_iterator {
typedef T& reference;
};
-#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+template <class T>
+struct iterator_traits<const T*> {
+ 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 <class Iterator>
+inline iterator_traits<Iterator>::iterator_category
+iterator_category(const Iterator&) {
+ return iterator_traits<Iterator>::iterator_category();
+}
+
+template <class Iterator>
+inline iterator_traits<Iterator>::difference_type*
+distance_type(const Iterator&) {
+ return static_cast<iterator_traits<Iterator>::difference_type*>(0);
+}
+
+template <class Iterator>
+inline iterator_traits<Iterator>::value_type*
+value_type(const Iterator&) {
+ return static_cast<iterator_traits<Iterator>::value_type*>(0);
+}
+
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
template <class T, class Distance>
inline input_iterator_tag
template <class T>
inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class Container>
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<Container>&
back_insert_iterator<Container>& operator++(int) { return *this; }
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class Container>
inline output_iterator_tag
iterator_category(const back_insert_iterator<Container>&)
return output_iterator_tag();
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class Container>
inline back_insert_iterator<Container> back_inserter(Container& x) {
return back_insert_iterator<Container>(x);
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<Container>&
front_insert_iterator<Container>& operator++(int) { return *this; }
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class Container>
inline output_iterator_tag
iterator_category(const front_insert_iterator<Container>&)
return output_iterator_tag();
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class Container>
inline front_insert_iterator<Container> front_inserter(Container& x) {
return front_insert_iterator<Container>(x);
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) {}
insert_iterator<Container>& operator++(int) { return *this; }
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class Container>
inline output_iterator_tag
iterator_category(const insert_iterator<Container>&)
return output_iterator_tag();
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class Container, class Iterator>
inline insert_iterator<Container> inserter(Container& x, Iterator i) {
typedef typename Container::iterator iter;
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;
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class BidirectionalIterator, class T, class Reference,
class Distance>
return (Distance*) 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class BidirectionalIterator, class T, class Reference,
class Distance>
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 Iterator>
+class reverse_iterator : public iterator_traits<Iterator>
+{
+protected:
+ Iterator current;
+public:
+ typedef Iterator iterator_type;
+ typedef reverse_iterator<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 <class Iter>
+ reverse_iterator(const reverse_iterator<Iter>& 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 <class Iterator>
+inline bool operator==(const reverse_iterator<Iterator>& x,
+ const reverse_iterator<Iterator>& y) {
+ return x.base() == y.base();
+}
+
+template <class Iterator>
+inline bool operator<(const reverse_iterator<Iterator>& x,
+ const reverse_iterator<Iterator>& y) {
+ return y.base() < x.base();
+}
+
+template <class Iterator>
+inline reverse_iterator<Iterator>::difference_type
+operator-(const reverse_iterator<Iterator>& x,
+ const reverse_iterator<Iterator>& y) {
+ return y.base() - x.base();
+}
+
+template <class Iterator>
+inline reverse_iterator<Iterator>
+operator+(reverse_iterator<Iterator>::difference_type n,
+ const reverse_iterator<Iterator>& x) {
+ return reverse_iterator<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 <class RandomAccessIterator, class T, class Reference = T&,
class Distance = ptrdiff_t>
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;
(x.current - n);
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
template <class ForwardIterator, class T>
class raw_storage_iterator {
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<ForwardIterator, T>& operator*() { return *this; }
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class ForwardIterator, class T>
inline output_iterator_tag
iterator_category(const raw_storage_iterator<ForwardIterator, T>&)
return output_iterator_tag();
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class T, class Distance = ptrdiff_t>
class istream_iterator {
friend bool operator==(const istream_iterator<T, Distance>& x,
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<T, Distance>& operator++() {
read();
return *this;
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const istream_iterator<T, Distance>&) {
return (Distance*) 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
template <class T, class Distance>
bool operator==(const istream_iterator<T, Distance>& x,
const istream_iterator<T, Distance>& y) {
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) {}
ostream_iterator<T>& operator++(int) { return *this; }
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
template <class T>
inline output_iterator_tag
iterator_category(const ostream_iterator<T>&) {
return output_iterator_tag();
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
#endif /* __SGI_STL_ITERATOR_H */
T data;
};
-template<class T, class Ref>
+template<class T, class Ref, class Ptr>
struct __list_iterator {
- typedef __list_iterator<T, T&> iterator;
- typedef __list_iterator<T, const T&> const_iterator;
- typedef __list_iterator<T, Ref> self;
+ typedef __list_iterator<T, T&, T*> iterator;
+ typedef __list_iterator<T, const T&, const T*> const_iterator;
+ typedef __list_iterator<T, Ref, Ptr> 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<T>* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
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);
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
inline bidirectional_iterator_tag
-iterator_category(const __list_iterator<T, Ref>&) {
+iterator_category(const __list_iterator<T, Ref, Ptr>&) {
return bidirectional_iterator_tag();
}
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
inline T*
-value_type(const __list_iterator<T, Ref>&) {
+value_type(const __list_iterator<T, Ref, Ptr>&) {
return 0;
}
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
inline ptrdiff_t*
-distance_type(const __list_iterator<T, Ref>&) {
+distance_type(const __list_iterator<T, Ref, Ptr>&) {
return 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
template <class T, class Alloc = alloc>
class list {
typedef ptrdiff_t difference_type;
public:
- typedef __list_iterator<T, T&> iterator;
- typedef __list_iterator<T, const T&> const_iterator;
+ typedef __list_iterator<T, T&, T*> iterator;
+ typedef __list_iterator<T, const T&, const T*> const_iterator;
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_bidirectional_iterator<const_iterator, value_type,
const_reference, difference_type>
const_reverse_iterator;
typedef reverse_bidirectional_iterator<iterator, value_type, reference,
difference_type>
reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected:
link_type get_node() { return list_node_allocator::allocate(); }
// Test for basic character types.
// For basic character types leaves having a trailing eos.
template <class charT>
-inline bool __is_basic_char_type(charT* c) { return false; }
+inline bool __is_basic_char_type(charT *) { return false; }
template <class charT>
-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 <class charT>
-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; }
template<class charT, class Alloc>
struct __rope_RopeBase {
typedef rope<charT,Alloc> my_rope;
+ typedef simple_alloc<charT, Alloc> DataAlloc;
typedef simple_alloc<__rope_RopeConcatenation<charT,Alloc>, Alloc> CAlloc;
typedef simple_alloc<__rope_RopeLeaf<charT,Alloc>, Alloc> LAlloc;
typedef simple_alloc<__rope_RopeFunction<charT,Alloc>, Alloc> FAlloc;
{
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
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;
const_cast<RopeBase *>(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() {};
}
return(*this);
}
- const charT& operator*() {
+ reference operator*() {
if (0 == buf_ptr) setcache(*this);
return *buf_ptr;
}
friend __rope_const_iterator<charT,Alloc> operator+
(ptrdiff_t n,
const __rope_const_iterator<charT,Alloc> & x);
- charT operator[](size_t n) {
+ reference operator[](size_t n) {
return rope<charT,Alloc>::fetch(root, current_pos + n);
}
friend bool operator==
}
void check();
public:
+ typedef __rope_charT_ref_proxy<charT,Alloc> reference;
+ typedef __rope_charT_ref_proxy<charT,Alloc>* pointer;
+
+ public:
rope<charT,Alloc>& container() { return *root_rope; }
__rope_iterator() {
root = 0; // Needed for reference counting.
RopeBase::unref(old);
return(*this);
}
- __rope_charT_ref_proxy<charT,Alloc> operator*() {
+ reference operator*() {
check();
if (0 == buf_ptr) {
return __rope_charT_ref_proxy<charT,Alloc>(root_rope, current_pos);
decr(1);
return __rope_iterator<charT,Alloc>(root_rope, old_pos);
}
- __rope_charT_ref_proxy<charT,Alloc> operator[](ptrdiff_t n) {
+ reference operator[](ptrdiff_t n) {
return __rope_charT_ref_proxy<charT,Alloc>(root_rope, current_pos + n);
}
friend bool operator==
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<charT,Alloc> iterator;
typedef __rope_const_iterator<charT,Alloc> const_iterator;
static charT empty_c_str[1];
+ typedef simple_alloc<charT, Alloc> DataAlloc;
typedef simple_alloc<__rope_RopeConcatenation<charT,Alloc>, Alloc> CAlloc;
typedef simple_alloc<__rope_RopeLeaf<charT,Alloc>, Alloc> LAlloc;
typedef simple_alloc<__rope_RopeFunction<charT,Alloc>, Alloc> FAlloc;
// 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]);
// 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.
friend struct rope<charT,Alloc>::concat_fn;
struct concat_fn
- : binary_function<RopeBase *, RopeBase *, RopeBase *> {
- 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<charT,Alloc>, rope<charT,Alloc>,
+ rope<charT,Alloc> > {
+ 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<charT,Alloc>(); }
static size_t char_ptr_len(const charT * s);
// slightly generalized strlen
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
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);
}
}
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);
}
}
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);
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);
}
}
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);
// but it's harder to make guarantees.
}
+# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+# else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
-
+# endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
return(iterator(this, size()));
}
+# ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<iterator> reverse_iterator;
+# else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<iterator, value_type, reference,
difference_type> reverse_iterator;
+# endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
reverse_iterator mutable_rbegin() {
return reverse_iterator(mutable_end());
* purpose. It is provided "as is" without express or implied warranty.
*/
-#if defined(_MSC_VER)
-# include <ostream>
-#else
-# include <iostream.h>
-#endif
+# include <stdio.h>
+# include <iostream.h>
// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
// if necessary. Assumes path_end[leaf_index] and leaf_pos are correct.
if (0 != cstr) {
size_t sz = size + 1;
destroy(cstr, cstr + sz);
- Alloc::deallocate(cstr, sz);
+ DataAlloc::deallocate(cstr, sz);
}
}
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 <class charT, class Alloc>
{
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);
#endif
// Assumes left and right are not 0.
+// Does not increment (nor decrement on exception) child reference counts.
// Result has ref count 1.
template <class charT, class Alloc>
rope<charT,Alloc>::RopeBase *
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;
&& 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;
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
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
(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);
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;
}
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 <class charT, class Alloc>
{
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;
}
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));
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:
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 <class charT> 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 <class charT> 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<class charT, class Alloc>
ostream& operator<< (ostream& o, const rope<charT, Alloc>& 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<charT> c(o);
# 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]))
void
rope<charT,Alloc>::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
}
{
# 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) {
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;
}
template <class charT, class Alloc>
rope<charT, Alloc>::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;
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<class charT, class Alloc> charT rope<charT,Alloc>::empty_c_str[1];
__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
// 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);
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();
}
};
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
struct __slist_iterator : public __slist_iterator_base
{
- typedef __slist_iterator<T, T&> iterator;
- typedef __slist_iterator<T, const T&> const_iterator;
- typedef __slist_iterator<T, Ref> self;
+ typedef __slist_iterator<T, T&, T*> iterator;
+ typedef __slist_iterator<T, const T&, const T*> const_iterator;
+ typedef __slist_iterator<T, Ref, Ptr> 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<T> 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();
}
};
+#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
+
inline ptrdiff_t*
distance_type(const __slist_iterator_base&)
{
return forward_iterator_tag();
}
-template <class T, class Ref>
+template <class T, class Ref, class Ptr>
inline T*
-value_type(const __slist_iterator<T, Ref>&) {
+value_type(const __slist_iterator<T, Ref, Ptr>&) {
return 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
inline size_t __slist_size(__slist_node_base* node)
{
size_t result = 0;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
- typedef __slist_iterator<T, reference> iterator;
- typedef __slist_iterator<T, const_reference> const_iterator;
+ typedef __slist_iterator<T, T&, T*> iterator;
+ typedef __slist_iterator<T, const T&, const T*> const_iterator;
private:
typedef __slist_node<T> list_node;
// (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__)
# 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
# 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
}
};
-template <class Value, class Ref>
+template <class Value, class Ref, class Ptr>
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<Value, reference> iterator;
- typedef __rb_tree_iterator<Value, const_reference> const_iterator;
- typedef __rb_tree_iterator<Value, Ref> self;
+ typedef __rb_tree_iterator<Value, Value&, Value*> iterator;
+ typedef __rb_tree_iterator<Value, const Value&, const Value*> const_iterator;
+ typedef __rb_tree_iterator<Value, Ref, Ptr> self;
typedef __rb_tree_node<Value>* 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) {
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();
return (__rb_tree_base_iterator::difference_type*) 0;
}
-template <class Value, class Ref>
-inline Value* value_type(const __rb_tree_iterator<Value, Ref>&) {
+template <class Value, class Ref, class Ptr>
+inline Value* value_type(const __rb_tree_iterator<Value, Ref, Ptr>&) {
return (Value*) 0;
}
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
+
inline void
__rb_tree_rotate_left(__rb_tree_node_base* x, __rb_tree_node_base*& root)
{
}
public:
- typedef __rb_tree_iterator<value_type, reference> iterator;
- typedef __rb_tree_iterator<value_type, const_reference> const_iterator;
-
+ typedef __rb_tree_iterator<value_type, reference, pointer> iterator;
+ typedef __rb_tree_iterator<value_type, const_reference, const_pointer>
+ const_iterator;
+
+#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
+ typedef reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_bidirectional_iterator<iterator, value_type, reference,
difference_type>
reverse_iterator;
typedef reverse_bidirectional_iterator<const_iterator, value_type,
const_reference, difference_type>
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);
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_iterator> const_reverse_iterator;
+ typedef reverse_iterator<iterator> reverse_iterator;
+#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference,
difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
+#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected:
typedef simple_alloc<value_type, Alloc> data_allocator;
iterator start;
end_of_storage = finish;
}
- template <class BidirectionalIterator>
- void range_initialize(BidirectionalIterator first,
- BidirectionalIterator last,
- bidirectional_iterator_tag) {
- range_initialize(first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- void range_initialize(RandomAccessIterator first,
- RandomAccessIterator last,
- random_access_iterator_tag) {
- range_initialize(first, last, forward_iterator_tag());
- }
-
template <class InputIterator>
void range_insert(iterator pos,
InputIterator first, InputIterator last,
ForwardIterator first, ForwardIterator last,
forward_iterator_tag);
- template <class BidirectionalIterator>
- void range_insert(iterator pos,
- BidirectionalIterator first, BidirectionalIterator last,
- bidirectional_iterator_tag) {
- range_insert(pos, first, last, forward_iterator_tag());
- }
-
- template <class RandomAccessIterator>
- 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 */
};
OSDN Git Service
