struct Aux_require_same

struct Aux_require_same< Type, Type >

struct SameTypeConcept

struct IntegerConcept

struct IntegerConcept< short >

struct IntegerConcept< unsigned short >

struct IntegerConcept< int >

struct IntegerConcept< unsigned int >

struct IntegerConcept< long >

struct IntegerConcept< unsigned long >

struct IntegerConcept< long long >

struct IntegerConcept< unsigned long long >

struct SignedIntegerConcept

struct SignedIntegerConcept< short >

struct SignedIntegerConcept< int >

struct SignedIntegerConcept< long >

struct SignedIntegerConcept< long long >

struct UnsignedIntegerConcept

struct UnsignedIntegerConcept< unsigned short >

struct UnsignedIntegerConcept< unsigned int >

struct UnsignedIntegerConcept< unsigned long >

struct UnsignedIntegerConcept< unsigned long long >

struct DefaultConstructibleConcept

struct AssignableConcept

struct CopyConstructibleConcept

struct SGIAssignableConcept

struct ConvertibleConcept

struct EqualityComparableConcept

struct LessThanComparableConcept

struct ComparableConcept

struct GeneratorConcept

struct GeneratorConcept< Func, void >

struct UnaryFunctionConcept

struct UnaryFunctionConcept< Func, void, Arg >

struct BinaryFunctionConcept

struct BinaryFunctionConcept< Func, void, First, Second >

struct UnaryPredicateConcept

struct BinaryPredicateConcept

struct ConstBinaryPredicateConcept

struct TrivialIteratorConcept

struct MutableTrivialIteratorConcept

struct InputIteratorConcept

struct OutputIteratorConcept

struct ForwardIteratorConcept

struct MutableForwardIteratorConcept

struct BidirectionalIteratorConcept

struct MutableBidirectionalIteratorConcept

struct RandomAccessIteratorConcept

struct MutableRandomAccessIteratorConcept

struct ContainerConcept

struct MutableContainerConcept

struct ForwardContainerConcept

struct MutableForwardContainerConcept

struct ReversibleContainerConcept

struct MutableReversibleContainerConcept

struct RandomAccessContainerConcept

struct MutableRandomAccessContainerConcept

struct SequenceConcept

struct FrontInsertionSequenceConcept

struct BackInsertionSequenceConcept

struct AssociativeContainerConcept

struct UniqueAssociativeContainerConcept

struct MultipleAssociativeContainerConcept

struct SimpleAssociativeContainerConcept

struct PairAssociativeContainerConcept

struct SortedAssociativeContainerConcept

class normal_iterator

struct enc_char_traits

class enc_filebuf

class unary_compose

An SGI extension . class binary_compose

An SGI extension . struct identity

struct select1st

An SGI extension . struct select2nd

An SGI extension . struct Project1st

struct Project2nd

struct project1st

An SGI extension . struct project2nd

An SGI extension . struct Constant_void_fun

struct Constant_unary_fun

struct Constant_binary_fun

struct constant_void_fun

An SGI extension . struct constant_unary_fun

An SGI extension . struct constant_binary_fun

An SGI extension . class subtractive_rng

class hash_map

class hash_multimap

class hash_set

class hash_multiset

struct temporary_buffer

struct rb_tree

class Rope_flatten_char_consumer

class Rope_find_char_char_consumer

class Rope_insert_char_consumer

struct Slist_node_base

struct Slist_node

struct Slist_iterator_base

struct Slist_iterator

class Slist_alloc_base

class Slist_alloc_base< Type, Allocator, true >

struct Slist_base

class slist

class stdio_filebuf

Provides a layer of compatibility for C/POSIX. struct hash

struct hash< char * >

struct hash< const char * >

struct hash< char >

struct hash< unsigned char >

struct hash< signed char >

struct hash< short >

struct hash< unsigned short >

struct hash< int >

struct hash< unsigned int >

struct hash< long >

struct hash< unsigned long >

struct Hashtable_node

struct Hashtable_iterator

struct Hashtable_const_iterator

class hashtable

class char_producer

class sequence_buffer

class Rope_char_consumer

struct RopeConcat_fn

class Rope_rep_alloc_base

class Rope_rep_alloc_base< CharT, Allocator, true >

struct Rope_rep_base

struct RopeRopeRep

struct RopeRopeLeaf

struct RopeRopeConcatenation

struct RopeRopeFunction

struct RopeRopeSubstring

struct Rope_self_destruct_ptr

class Rope_char_ref_proxy

class Rope_char_ptr_proxy

class Rope_iterator_base

class Rope_const_iterator

class Rope_iterator

class Rope_alloc_base

class Rope_alloc_base< CharT, Allocator, true >

struct Rope_base

class rope

struct hash< crope >

struct hash< wrope >

namespace c99_binding

typedef char fake_facet_name[sizeof(char *) attribute__ )((aligned(alignof__(char *))))

typedef rope< char > crope

typedef rope< wchar_t > wrope

enum

void __verbose_terminate_handler ()

template<class Concept> void __function_requires ()

template<class Type> void aux_require_boolean_expr (const Type &__t)

template<typename IteratorL, typename IteratorR, typename Container> bool operator== (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator== (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> bool operator!= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator!= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> bool operator< (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator< (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> bool operator> (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator> (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> bool operator<= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator<= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> bool operator>= (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> bool operator>= (const normal_iterator< Iterator, Container > &__lhs, const normal_iterator< Iterator, Container > &__rhs)

template<typename IteratorL, typename IteratorR, typename Container> normal_iterator< IteratorL, Container >::difference_type operator- (const normal_iterator< IteratorL, Container > &__lhs, const normal_iterator< IteratorR, Container > &__rhs)

template<typename Iterator, typename Container> normal_iterator< Iterator, Container > operator+ (typename normal_iterator< Iterator, Container >::difference_type n, const normal_iterator< Iterator, Container > &__i)

template<typename InputIter, typename Size, typename OutputIter> pair< InputIter, OutputIter > copy_n (InputIter first, Size count, OutputIter __result, input_iterator_tag)

template<typename RAIter, typename Size, typename OutputIter> pair< RAIter, OutputIter > copy_n (RAIter first, Size count, OutputIter __result, random_access_iterator_tag)

template<typename InputIter, typename Size, typename OutputIter> pair< InputIter, OutputIter > copy_n (InputIter first, Size count, OutputIter __result)

Copies the range [first,first+count) into [result,result+count). template<typename InputIter1, typename InputIter2> int __lexicographical_compare_3way (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)

int __lexicographical_compare_3way (const unsigned char *first1, const unsigned char *last1, const unsigned char *first2, const unsigned char *last2)

int __lexicographical_compare_3way (const char *first1, const char *last1, const char *first2, const char *last2)

template<typename InputIter1, typename InputIter2> int lexicographical_compare_3way (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)

memcmp on steroids. template<typename InputIter, typename Type, typename Size> void count (InputIter first, InputIter last, const Type &value, Size &n)

template<typename InputIter, typename Predicate, typename Size> void count_if (InputIter first, InputIter last, Predicate pred, Size &n)

template<typename ForwardIter, typename OutputIter, typename Distance> OutputIter random_sample_n (ForwardIter first, ForwardIter last, OutputIter out, const Distance n)

template<typename ForwardIter, typename OutputIter, typename Distance, typename RandomNumberGenerator> OutputIter random_sample_n (ForwardIter first, ForwardIter last, OutputIter out, const Distance n, RandomNumberGenerator &__rand)

template<typename InputIter, typename RandomAccessIter, typename Distance> RandomAccessIter __random_sample (InputIter first, InputIter last, RandomAccessIter out, const Distance n)

template<typename InputIter, typename RandomAccessIter, typename RandomNumberGenerator, typename Distance> RandomAccessIter __random_sample (InputIter first, InputIter last, RandomAccessIter out, RandomNumberGenerator &__rand, const Distance n)

template<typename InputIter, typename RandomAccessIter> RandomAccessIter random_sample (InputIter first, InputIter last, RandomAccessIter out_first, RandomAccessIter out_last)

template<typename InputIter, typename RandomAccessIter, typename RandomNumberGenerator> RandomAccessIter random_sample (InputIter first, InputIter last, RandomAccessIter out_first, RandomAccessIter out_last, RandomNumberGenerator &__rand)

template<typename RandomAccessIter, typename Distance> bool __is_heap (RandomAccessIter first, Distance n)

template<typename RandomAccessIter, typename Distance, typename StrictWeakOrdering> bool __is_heap (RandomAccessIter first, StrictWeakOrdering comp, Distance n)

template<typename RandomAccessIter> bool is_heap (RandomAccessIter first, RandomAccessIter last)

template<typename RandomAccessIter, typename StrictWeakOrdering> bool is_heap (RandomAccessIter first, RandomAccessIter last, StrictWeakOrdering comp)

template<typename ForwardIter> bool is_sorted (ForwardIter first, ForwardIter last)

template<typename ForwardIter, typename StrictWeakOrdering> bool is_sorted (ForwardIter first, ForwardIter last, StrictWeakOrdering comp)

template<class Type> Type identity_element (std::plus< Type >)

An SGI extension . template<class Type> Type identity_element (std::multiplies< Type >)

An SGI extension . template<class Operation1, class Operation2> unary_compose< Operation1, Operation2 > compose1 (const Operation1 &__fn1, const Operation2 &__fn2)

An SGI extension . template<class Operation1, class Operation2, class Operation3> binary_compose< Operation1, Operation2, Operation3 > compose2 (const Operation1 &__fn1, const Operation2 &__fn2, const Operation3 &__fn3)

An SGI extension . template<class Result> constant_void_fun< Result > constant0 (const Result &__val)

An SGI extension . template<class Result> constant_unary_fun< Result, Result > constant1 (const Result &__val)

An SGI extension . template<class Result> constant_binary_fun< Result, Result, Result > constant2 (const Result &__val)

An SGI extension . template<class Ret, class Type, class Arg> mem_fun1_t< Ret, Type, Arg > mem_fun1 (Ret(Type::*__f)(Arg))

template<class Ret, class Type, class Arg> mem_fun1_ref_t< Ret, Type, Arg > mem_fun1_ref (Ret(Type::*__f)(Arg))

template<class Key, class Type, class HashFcn, class EqlKey, class Alloc> bool operator== (const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)

template<class Key, class Type, class HashFcn, class EqlKey, class Alloc> bool operator!= (const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, const hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)

template<class Key, class Type, class HashFcn, class EqlKey, class Alloc> void swap (hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, hash_map< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)

template<class Key, class Type, class HF, class EqKey, class Alloc> bool operator== (const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm1, const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm2)

template<class Key, class Type, class HF, class EqKey, class Alloc> bool operator!= (const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm1, const hash_multimap< Key, Type, HF, EqKey, Alloc > &__hm2)

template<class Key, class Type, class HashFcn, class EqlKey, class Alloc> void swap (hash_multimap< Key, Type, HashFcn, EqlKey, Alloc > &__hm1, hash_multimap< Key, Type, HashFcn, EqlKey, Alloc > &__hm2)

template<class Value, class HashFcn, class EqualKey, class Alloc> bool operator== (const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs1, const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs2)

template<class Value, class HashFcn, class EqualKey, class Alloc> bool operator!= (const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs1, const hash_set< Value, HashFcn, EqualKey, Alloc > &__hs2)

template<class Val, class HashFcn, class EqualKey, class Alloc> void swap (hash_set< Val, HashFcn, EqualKey, Alloc > &__hs1, hash_set< Val, HashFcn, EqualKey, Alloc > &__hs2)

template<class Val, class HashFcn, class EqualKey, class Alloc> bool operator== (const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)

template<class Val, class HashFcn, class EqualKey, class Alloc> bool operator!= (const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, const hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)

template<class Val, class HashFcn, class EqualKey, class Alloc> void swap (hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs1, hash_multiset< Val, HashFcn, EqualKey, Alloc > &__hs2)

template<typename InputIterator, typename Distance> void __distance (InputIterator first, InputIterator last, Distance &n, std::input_iterator_tag)

template<typename RandomAccessIterator, typename Distance> void __distance (RandomAccessIterator first, RandomAccessIterator last, Distance &n, std::random_access_iterator_tag)

template<typename InputIterator, typename Distance> void distance (InputIterator first, InputIterator last, Distance &n)

template<typename InputIter, typename Size, typename ForwardIter> pair< InputIter, ForwardIter > __uninitialized_copy_n (InputIter first, Size count, ForwardIter __result, std::input_iterator_tag)

template<typename RandomAccessIter, typename Size, typename ForwardIter> pair< RandomAccessIter, ForwardIter > __uninitialized_copy_n (RandomAccessIter first, Size count, ForwardIter __result, std::random_access_iterator_tag)

template<typename InputIter, typename Size, typename ForwardIter> pair< InputIter, ForwardIter > __uninitialized_copy_n (InputIter first, Size count, ForwardIter __result)

template<typename InputIter, typename Size, typename ForwardIter> pair< InputIter, ForwardIter > uninitialized_copy_n (InputIter first, Size count, ForwardIter __result)

Copies the range [first,last) into result. template<typename Type, typename Integer, typename MonoidOperation> Type __power (Type x, Integer n, MonoidOperation __monoid_op)

template<typename Type, typename Integer> Type __power (Type x, Integer n)

template<typename Type, typename Integer, typename MonoidOperation> Type power (Type x, Integer n, MonoidOperation __monoid_op)

template<typename Type, typename Integer> Type power (Type x, Integer n)

template<typename ForwardIter, typename Type> void iota (ForwardIter first, ForwardIter last, Type value)

template<class CharT, class Traits> void Rope_fill (basic_ostream< CharT, Traits > &__o, size_t n)

template<class CharT> bool Rope_is_simple (CharT *)

bool Rope_is_simple (char *)

bool Rope_is_simple (wchar_t *)

template<class CharT, class Traits, class Alloc> basic_ostream< CharT, Traits > & operator<< (basic_ostream< CharT, Traits > &__o, const rope< CharT, Alloc > &__r)

template<class Rope_iterator> void Rope_rotate (Rope_iterator first, Rope_iterator __middle, Rope_iterator last)

void rotate (Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> first, Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> __middle, Rope_iterator< char, _STLDEFAULTALLOCATOR(char)> last)

Slist_node_base * slist_make_link (Slist_node_base *__prev_node, Slist_node_base *new_node)

Slist_node_base * slist_previous (Slist_node_base *__head, const Slist_node_base *node)

const Slist_node_base * slist_previous (const Slist_node_base *__head, const Slist_node_base *node)

void slist_splice_after (Slist_node_base *position, Slist_node_base *__before_first, Slist_node_base *__before_last)

void slist_splice_after (Slist_node_base *position, Slist_node_base *__head)

Slist_node_base * slist_reverse (Slist_node_base *node)

size_t slist_size (Slist_node_base *node)

template<class Type, class Alloc> bool operator== (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> bool operator< (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> bool operator!= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> bool operator> (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> bool operator<= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> bool operator>= (const slist< Type, Alloc > &SL1, const slist< Type, Alloc > &SL2)

template<class Type, class Alloc> void swap (slist< Type, Alloc > &x, slist< Type, Alloc > &y)

size_t stl_hash_string (const char *s)

unsigned long stl_next_prime (unsigned long n)

template<class Val, class Key, class HF, class Ex, class Eq, class All> bool operator== (const hashtable< Val, Key, HF, Ex, Eq, All > &__ht1, const hashtable< Val, Key, HF, Ex, Eq, All > &__ht2)

template<class Val, class Key, class HF, class Ex, class Eq, class All> bool operator!= (const hashtable< Val, Key, HF, Ex, Eq, All > &__ht1, const hashtable< Val, Key, HF, Ex, Eq, All > &__ht2)

template<class Val, class Key, class HF, class Extract, class EqKey, class All> void swap (hashtable< Val, Key, HF, Extract, EqKey, All > &__ht1, hashtable< Val, Key, HF, Extract, EqKey, All > &__ht2)

template<class CharT> CharT S_eos (CharT *)

template<class CharT> bool S_is_basic_char_type (CharT *)

template<class CharT> bool S_is_one_byte_char_type (CharT *)

bool S_is_basic_char_type (char *)

bool S_is_one_byte_char_type (char *)

bool S_is_basic_char_type (wchar_t *)

template<class CharT> void S_cond_store_eos (CharT &)

void S_cond_store_eos (char &c)

void S_cond_store_eos (wchar_t &c)

template<class CharT, class Alloc> bool operator== (const Rope_char_ptr_proxy< CharT, Alloc > &x, const Rope_char_ptr_proxy< CharT, Alloc > &y)

template<class CharT, class Alloc> Rope_const_iterator< CharT, Alloc > operator- (const Rope_const_iterator< CharT, Alloc > &x, ptrdiff_t n)

template<class CharT, class Alloc> Rope_const_iterator< CharT, Alloc > operator+ (const Rope_const_iterator< CharT, Alloc > &x, ptrdiff_t n)

template<class CharT, class Alloc> Rope_const_iterator< CharT, Alloc > operator+ (ptrdiff_t n, const Rope_const_iterator< CharT, Alloc > &x)

template<class CharT, class Alloc> bool operator== (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator< (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> ptrdiff_t operator- (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> Rope_iterator< CharT, Alloc > operator- (const Rope_iterator< CharT, Alloc > &x, ptrdiff_t n)

template<class CharT, class Alloc> Rope_iterator< CharT, Alloc > operator+ (const Rope_iterator< CharT, Alloc > &x, ptrdiff_t n)

template<class CharT, class Alloc> Rope_iterator< CharT, Alloc > operator+ (ptrdiff_t n, const Rope_iterator< CharT, Alloc > &x)

template<class CharT, class Alloc> bool operator== (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator< (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> ptrdiff_t operator- (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)

template<class CharT, class Alloc> rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, const CharT *__right)

template<class CharT, class Alloc> rope< CharT, Alloc > operator+ (const rope< CharT, Alloc > &__left, CharT __right)

template<class CharT, class _Alloc> void swap (Rope_char_ref_proxy< CharT, _Alloc > a, Rope_char_ref_proxy< CharT, _Alloc > __b)

template<class CharT, class Alloc> bool operator!= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator> (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator<= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator>= (const Rope_const_iterator< CharT, Alloc > &x, const Rope_const_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator!= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator> (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator<= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator>= (const Rope_iterator< CharT, Alloc > &x, const Rope_iterator< CharT, Alloc > &y)

template<class CharT, class Alloc> rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)

template<class CharT, class Alloc> rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, const CharT *__right)

template<class CharT, class Alloc> rope< CharT, Alloc > & operator+= (rope< CharT, Alloc > &__left, CharT __right)

template<class CharT, class Alloc> bool operator< (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)

template<class CharT, class Alloc> bool operator== (const rope< CharT, Alloc > &__left, const rope< CharT, Alloc > &__right)

template<class CharT, class Alloc> bool operator!= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator> (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator<= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator>= (const rope< CharT, Alloc > &x, const rope< CharT, Alloc > &y)

template<class CharT, class Alloc> bool operator!= (const Rope_char_ptr_proxy< CharT, Alloc > &x, const Rope_char_ptr_proxy< CharT, Alloc > &y)

crope::reference __mutable_reference_at (crope &c, size_t __i)

wrope::reference __mutable_reference_at (wrope &c, size_t __i)

template<class CharT, class Alloc> void swap (rope< CharT, Alloc > &x, rope< CharT, Alloc > &y)

fake_facet_name facet_name [6+GLIBCPPNUMCATEGORIES]

fake_localeImpl c_locale_impl

fake_locale c_locale

const int o

fake_localeImpl_compat c_locale_impl_compat

fake_facet_vec facet_vec [GLIBCPPNUMFACETS]

fake_facet_cache_vec facet_cache_vec [2 *GLIBCPPNUMFACETS]

fake_ctype_c ctype_c

fake_collate_c collate_c

fake_numpunct_c numpunct_c

fake_num_get_c num_get_c

fake_num_put_c num_put_c

fake_codecvt_c codecvt_c

fake_moneypunct_c moneypunct_tc

fake_moneypunct_c moneypunct_fc

ZSt13moneypunct_fc

fake_money_get_c money_get_c

fake_money_put_c money_put_c

fake_timepunct_c timepunct_c

fake_time_get_c time_get_c

fake_time_put_c time_put_c

fake_messages_c messages_c

fake_locale_cache_np_c locale_cache_np_c

fake_filebuf buf_cout

fake_filebuf buf_cin

fake_filebuf buf_cerr

GLIBCPPDEFINEBINARYOPERATORCONSTRAINT * TimesOpConcept

static const unsigned long stl_prime_list [stl_num_primes]

rope< CharT, Alloc > identity_element (RopeConcat_fn< CharT, Alloc >)

A replacement for the standard terminate_handler which prints more information about the terminating exception (if any) on stderr. Call

        std::set_terminate (__gnu_cxx::__verbose_terminate_handler)

to use. For more info, see http://gcc.gnu.org/onlinedocs/libstdc++/19_diagnostics/howto.html#4

Definition at line 44 of file vterminate.cc.

References std::type_info::name, and std::exception::what().