OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

algo.h, [...]: Update To September 8 SGI release.

Browse Source 
* 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
This commit is contained in:
Jason Merrill 1997-09-10 02:49:45 +00:00 committed by Jason Merrill
parent c6b50f1082
commit ff893307d0
15 changed files with 778 additions and 463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libstdc++/stl/ChangeLog
View File

@ -1,3 +1,9 @@
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.

326
libstdc++/stl/algo.h
View File

@ -236,6 +236,63 @@ inline ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
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) {
@ -1400,15 +1457,6 @@ ForwardIterator __lower_bound(ForwardIterator first, ForwardIterator last,
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,
@ -1459,15 +1507,6 @@ ForwardIterator __lower_bound(ForwardIterator first, ForwardIterator last,
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,
@ -1520,15 +1559,6 @@ ForwardIterator __upper_bound(ForwardIterator first, ForwardIterator 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,
@ -1581,15 +1611,6 @@ ForwardIterator __upper_bound(ForwardIterator first, ForwardIterator last,
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,
@ -1648,14 +1669,6 @@ __equal_range(ForwardIterator first, ForwardIterator last, const T& value,
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,
@ -1718,14 +1731,6 @@ __equal_range(ForwardIterator first, ForwardIterator last, const T& value,
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,
@ -2543,6 +2548,213 @@ OutputIterator adjacent_difference(InputIterator first, InputIterator 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.
@ -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;
}

75
libstdc++/stl/algobase.h
View File

@ -86,19 +86,6 @@ inline void __distance(InputIterator first, InputIterator last, Distance& n,
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) {
@ -122,19 +109,6 @@ __distance(InputIterator first, InputIterator last, input_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,
@ -156,11 +130,6 @@ inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
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
@ -198,20 +167,6 @@ inline OutputIterator __copy(InputIterator first, InputIterator last,
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,
@ -365,20 +320,6 @@ OutputIterator __copy_n(InputIterator first, Size count,
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,
@ -657,22 +598,6 @@ ForwardIterator __uninitialized_copy_n(InputIterator first, Size count,
# 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,

22
libstdc++/stl/alloc.h
View File

@ -49,7 +49,6 @@
#endif
#ifdef __STL_WIN32THREADS
# include <windows.h>
// This must precede stl_config.h
#endif
#include <stddef.h>
@ -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 <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) \
@ -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<threads, inst>::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<threads, inst>::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<threads, inst> ::free_list[
#pragma reset woff 1174
#endif
#endif /* __NODE_ALLOC_H */
#undef __PRIVATE
#endif /* __ALLOC_H */

35
libstdc++/stl/bvector.h
View File

@ -83,6 +83,7 @@ public:
friend class const_iterator;
public:
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_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;
@ -303,20 +310,6 @@ protected:
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,
@ -352,20 +345,6 @@ protected:
}
}
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;

105
libstdc++/stl/deque.h
View File

@ -87,42 +87,44 @@ inline size_t __deque_buf_size(size_t n, size_t sz)
}
#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) +
@ -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 <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
@ -248,17 +255,23 @@ public: // Basic types
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;
@ -553,19 +566,6 @@ protected: // Internal construction/destruction
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_*
@ -587,19 +587,6 @@ protected: // Internal insert functions
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);
@ -881,7 +868,7 @@ void deque<T, Alloc, BufSize>::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;
}

45
libstdc++/stl/hashtable.h
View File

@ -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 <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)
{
@ -619,6 +595,7 @@ __hashtable_const_iterator<V, K, HF, ExK, EqK, A>::operator++(int)
return tmp;
}
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class V, class K, class HF, class ExK, class EqK, class All>
inline forward_iterator_tag
@ -661,6 +638,8 @@ distance_type(const __hashtable_const_iterator<V, K, HF, ExK, EqK, All>&)
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)

207
libstdc++/stl/iterator.h
View File

@ -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 <class T, class Distance> struct input_iterator {
typedef input_iterator_tag iterator_category;
@ -47,6 +47,10 @@ template <class T, class Distance> 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 <class T, class Distance> struct forward_iterator {
@ -106,7 +110,34 @@ struct iterator_traits<T*> {
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
@ -189,12 +220,18 @@ distance_type(const random_access_iterator<T, Distance>&) {
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>&
@ -207,6 +244,8 @@ public:
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>&)
@ -214,6 +253,8 @@ 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);
@ -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<Container>&
@ -237,6 +282,8 @@ public:
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>&)
@ -244,6 +291,8 @@ 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);
@ -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<Container>& operator++(int) { return *this; }
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class Container>
inline output_iterator_tag
iterator_category(const insert_iterator<Container>&)
@ -277,6 +332,8 @@ 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;
@ -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 <class BidirectionalIterator, class T, class Reference,
class Distance>
@ -357,6 +418,8 @@ distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
return (Distance*) 0;
}
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
template <class BidirectionalIterator, class T, class Reference,
class Distance>
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 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>
@ -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 ForwardIterator, class T>
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<ForwardIterator, T>& operator*() { return *this; }
@ -507,6 +681,8 @@ public:
}
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class ForwardIterator, class T>
inline output_iterator_tag
iterator_category(const raw_storage_iterator<ForwardIterator, T>&)
@ -514,6 +690,8 @@ 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,
@ -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<T, Distance>& operator++() {
read();
return *this;
@ -548,6 +729,8 @@ public:
}
};
#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
template <class T, class Distance>
inline input_iterator_tag
iterator_category(const istream_iterator<T, Distance>&) {
@ -562,6 +745,8 @@ inline Distance* distance_type(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) {
@ -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<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 */

42
libstdc++/stl/list.h
View File

@ -40,17 +40,16 @@ struct __list_node {
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;
@ -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 <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 {
@ -121,15 +126,20 @@ public:
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(); }

101
libstdc++/stl/rope.h
View File

@ -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 <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; }
@ -235,6 +235,7 @@ template<class CharT, class Alloc> class __rope_charT_ptr_proxy;
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;
@ -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<charT,Alloc> {
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() {};
@ -702,7 +713,7 @@ class __rope_const_iterator : public __rope_iterator_base<charT,Alloc> {
}
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<charT,Alloc> {
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==
@ -790,6 +801,10 @@ class __rope_iterator : public __rope_iterator_base<charT,Alloc> {
RopeBase::ref(root);
}
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() {
@ -819,7 +834,7 @@ class __rope_iterator : public __rope_iterator_base<charT,Alloc> {
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);
@ -862,7 +877,7 @@ class __rope_iterator : public __rope_iterator_base<charT,Alloc> {
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==
@ -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<charT,Alloc> iterator;
typedef __rope_const_iterator<charT,Alloc> const_iterator;
@ -945,6 +960,7 @@ class rope {
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;
@ -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<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
@ -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);
__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,8 +1449,12 @@ class rope {
// 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());
@ -1794,8 +1811,12 @@ class rope {
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());

139
libstdc++/stl/ropeimpl.h
View File

@ -11,11 +11,8 @@
* purpose. It is provided "as is" without express or implied warranty.
*/
#if defined(_MSC_VER)
# include <ostream>
#else
# include <stdio.h>
# include <iostream.h>
#endif
// 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<charT,Alloc>::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<charT,Alloc>::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 <class charT, class Alloc>
@ -413,7 +410,7 @@ rope<charT,Alloc>::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<charT,Alloc>::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 <class charT, class Alloc>
rope<charT,Alloc>::RopeBase *
@ -473,7 +471,7 @@ rope<charT,Alloc>::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<charT,Alloc>::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<charT,Alloc>::RopeBase * rope<charT,Alloc>::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<charT,Alloc>::RopeBase * rope<charT,Alloc>::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<charT,Alloc>::RopeBase * rope<charT,Alloc>
(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<charT,Alloc>::RopeBase * rope<charT,Alloc>
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<charT,Alloc>::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();
__STL_TRY
return(tree_concat(left, right));
__STL_UNWIND(unref(left); unref(right));
}
template <class charT, class Alloc>
@ -686,21 +690,18 @@ rope<charT,Alloc>::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<charT,Alloc>::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<charT, Alloc>::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<charT, Alloc>::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 <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);
@ -1084,6 +1084,9 @@ rope<charT,Alloc>::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 <class charT, class Alloc>
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
@ -1132,12 +1134,12 @@ rope<charT,Alloc>::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<charT,Alloc>::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<charT, Alloc>::operator& () const {
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;
@ -1361,53 +1363,42 @@ rope<charT, Alloc>::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
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);
__STL_UNWIND(RopeBase::free_string(base_buffer, exponentiate_threshold))
base_rope.tree_ptr = base_leaf;
if (1 == exponent) {
result = base_leaf;
result = base_rope;
# ifndef __GC
__stl_assert(1 == result -> refcount);
result -> refcount = 2; // will be decremented when base_leaf disappears
__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;
result = remainder_rope;
}
__STL_UNWIND(unref(remainder));
# ifndef __GC
__stl_assert(0 == result || 1 == result -> refcount);
# endif
tree_ptr = result;
tree_ptr = result.tree_ptr;
tree_ptr -> ref_nonnil();
}
template<class charT, class Alloc> charT rope<charT,Alloc>::empty_c_str[1];
@ -1427,7 +1418,7 @@ const charT * rope<charT,Alloc>::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<charT,Alloc>::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<charT,Alloc>::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();

31
libstdc++/stl/slist.h
View File

@ -99,24 +99,27 @@ struct __slist_iterator_base
}
};
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();
@ -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 <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;
@ -167,8 +174,8 @@ public:
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;

12
libstdc++/stl/stl_config.h
View File

@ -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
// (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.
// (11) Defines __STL_SGI_THREADS if this is being compiled on an SGI
// (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.
// (12) Defines __STL_WIN32THREADS if this is being compiled on a
// (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

32
libstdc++/stl/tree.h
View File

@ -137,23 +137,25 @@ struct __rb_tree_base_iterator
}
};
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) {
@ -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 <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)
{
@ -487,15 +493,21 @@ protected:
}
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);

33
libstdc++/stl/vector.h
View File

@ -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_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;
@ -256,20 +262,6 @@ protected:
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,
@ -280,19 +272,6 @@ protected:
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 */
};