From fa30fe72d1d6e281786d296333b18ceff3d8c089 Mon Sep 17 00:00:00 2001 From: Bernardo Innocenti Date: Tue, 9 Dec 2003 05:31:53 +0100 Subject: algorithm, [...]: Remove trailing whitespace. * include/ext/algorithm, include/ext/debug_allocator.h, include/ext/enc_filebuf.h, include/ext/functional, include/ext/hash_fun.h, include/ext/hash_map, include/ext/hash_set, include/ext/hashtable.h, include/ext/iterator, include/ext/malloc_allocator.h, include/ext/memory, include/ext/mt_allocator.h, include/ext/numeric, include/ext/pod_char_traits.h, include/ext/pool_allocator.h, include/ext/rb_tree, include/ext/rope, include/ext/ropeimpl.h, include/ext/slist, include/ext/stdio_filebuf.h, include/ext/stdio_sync_filebuf.h: Remove trailing whitespace. From-SVN: r74464 --- libstdc++-v3/ChangeLog | 13 +++ libstdc++-v3/include/ext/algorithm | 20 ++-- libstdc++-v3/include/ext/debug_allocator.h | 4 +- libstdc++-v3/include/ext/enc_filebuf.h | 12 +-- libstdc++-v3/include/ext/functional | 28 ++--- libstdc++-v3/include/ext/hash_fun.h | 32 +++--- libstdc++-v3/include/ext/hash_map | 40 +++---- libstdc++-v3/include/ext/hash_set | 44 ++++---- libstdc++-v3/include/ext/hashtable.h | 86 +++++++-------- libstdc++-v3/include/ext/iterator | 6 +- libstdc++-v3/include/ext/malloc_allocator.h | 4 +- libstdc++-v3/include/ext/memory | 18 ++-- libstdc++-v3/include/ext/mt_allocator.h | 90 ++++++++-------- libstdc++-v3/include/ext/numeric | 4 +- libstdc++-v3/include/ext/pod_char_traits.h | 78 +++++++------- libstdc++-v3/include/ext/pool_allocator.h | 26 ++--- libstdc++-v3/include/ext/rb_tree | 8 +- libstdc++-v3/include/ext/rope | 146 +++++++++++++------------- libstdc++-v3/include/ext/ropeimpl.h | 122 ++++++++++----------- libstdc++-v3/include/ext/slist | 104 +++++++++--------- libstdc++-v3/include/ext/stdio_filebuf.h | 22 ++-- libstdc++-v3/include/ext/stdio_sync_filebuf.h | 30 +++--- 22 files changed, 475 insertions(+), 462 deletions(-) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index d6aaf44..ba57e35 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,18 @@ 2003-12-09 Bernardo Innocenti + * include/ext/algorithm, include/ext/debug_allocator.h, + include/ext/enc_filebuf.h, include/ext/functional, + include/ext/hash_fun.h, include/ext/hash_map, include/ext/hash_set, + include/ext/hashtable.h, include/ext/iterator, + include/ext/malloc_allocator.h, include/ext/memory, + include/ext/mt_allocator.h, include/ext/numeric, + include/ext/pod_char_traits.h, include/ext/pool_allocator.h, + include/ext/rb_tree, include/ext/rope, include/ext/ropeimpl.h, + include/ext/slist, include/ext/stdio_filebuf.h, + include/ext/stdio_sync_filebuf.h: Remove trailing whitespace. + +2003-12-09 Bernardo Innocenti + * include/debug/bitset, include/debug/debug.h, include/debug/deque, include/debug/formatter.h, include/debug/hash_map.h, include/debug/hash_multimap.h, include/debug/hash_multiset.h, diff --git a/libstdc++-v3/include/ext/algorithm b/libstdc++-v3/include/ext/algorithm index fa6996c..07ac4cb 100644 --- a/libstdc++-v3/include/ext/algorithm +++ b/libstdc++-v3/include/ext/algorithm @@ -160,11 +160,11 @@ namespace __gnu_cxx const ptrdiff_t __len1 = __last1 - __first1; const ptrdiff_t __len2 = __last2 - __first2; const int __result = std::memcmp(__first1, __first2, min(__len1, __len2)); - return __result != 0 ? __result + return __result != 0 ? __result : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1)); } - inline int + inline int __lexicographical_compare_3way(const char* __first1, const char* __last1, const char* __first2, const char* __last2) { @@ -295,7 +295,7 @@ namespace __gnu_cxx typename _RandomNumberGenerator> _OutputIterator random_sample_n(_ForwardIterator __first, _ForwardIterator __last, - _OutputIterator __out, const _Distance __n, + _OutputIterator __out, const _Distance __n, _RandomNumberGenerator& __rand) { // concept requirements @@ -330,7 +330,7 @@ namespace __gnu_cxx { _Distance __m = 0; _Distance __t = __n; - for ( ; __first != __last && __m < __n; ++__m, ++__first) + for ( ; __first != __last && __m < __n; ++__m, ++__first) __out[__m] = *__first; while (__first != __last) { @@ -380,7 +380,7 @@ namespace __gnu_cxx template inline _RandomAccessIterator random_sample(_InputIterator __first, _InputIterator __last, - _RandomAccessIterator __out_first, _RandomAccessIterator __out_last) + _RandomAccessIterator __out_first, _RandomAccessIterator __out_last) { // concept requirements __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) @@ -398,12 +398,12 @@ namespace __gnu_cxx * @ingroup SGIextensions * @doctodo */ - template inline _RandomAccessIterator random_sample(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __out_first, _RandomAccessIterator __out_last, - _RandomNumberGenerator& __rand) + _RandomNumberGenerator& __rand) { // concept requirements __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) @@ -416,7 +416,7 @@ namespace __gnu_cxx __out_first, __rand, __out_last - __out_first); } - + /** * This is an SGI extension. * @ingroup SGIextensions @@ -448,7 +448,7 @@ namespace __gnu_cxx // concept requirements __glibcxx_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>) __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, - typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type, typename iterator_traits<_RandomAccessIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); @@ -498,7 +498,7 @@ namespace __gnu_cxx // concept requirements __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, - typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type, typename iterator_traits<_ForwardIterator>::value_type>) __glibcxx_requires_valid_range(__first, __last); diff --git a/libstdc++-v3/include/ext/debug_allocator.h b/libstdc++-v3/include/ext/debug_allocator.h index 0f7eb0c..7bab02e 100644 --- a/libstdc++-v3/include/ext/debug_allocator.h +++ b/libstdc++-v3/include/ext/debug_allocator.h @@ -41,7 +41,7 @@ */ /** @file ext/debug_allocator.h - * This file is a GNU extension to the Standard C++ Library. + * This file is a GNU extension to the Standard C++ Library. * You should only include this header if you are using GCC 3 or later. */ @@ -125,7 +125,7 @@ namespace std /// Versions for the __allocator adaptor used with the predefined /// "SGI" style allocators. template - struct _Alloc_traits<_Tp, __allocator<_Tp1, + struct _Alloc_traits<_Tp, __allocator<_Tp1, __gnu_cxx::__debug_alloc<_Alloc> > > { static const bool _S_instanceless = true; diff --git a/libstdc++-v3/include/ext/enc_filebuf.h b/libstdc++-v3/include/ext/enc_filebuf.h index 81dad12..80c3b5a 100644 --- a/libstdc++-v3/include/ext/enc_filebuf.h +++ b/libstdc++-v3/include/ext/enc_filebuf.h @@ -39,7 +39,7 @@ namespace __gnu_cxx struct enc_char_traits: public std::char_traits<_CharT> { typedef std::__enc_traits state_type; - typedef typename std::fpos pos_type; + typedef typename std::fpos pos_type; }; template @@ -47,13 +47,13 @@ namespace __gnu_cxx : public std::basic_filebuf<_CharT, enc_char_traits<_CharT> > { public: - typedef enc_char_traits<_CharT> traits_type; - typedef typename traits_type::state_type state_type; - typedef typename traits_type::pos_type pos_type; - + typedef enc_char_traits<_CharT> traits_type; + typedef typename traits_type::state_type state_type; + typedef typename traits_type::pos_type pos_type; + enc_filebuf(state_type& __state) : std::basic_filebuf<_CharT, enc_char_traits<_CharT> >() - { + { // Set state type to something useful. // Something more than copyconstructible is needed here, so // require default and copy constructible + assignment operator. diff --git a/libstdc++-v3/include/ext/functional b/libstdc++-v3/include/ext/functional index c8b4b61..1a37817 100644 --- a/libstdc++-v3/include/ext/functional +++ b/libstdc++-v3/include/ext/functional @@ -100,7 +100,7 @@ template inline _Tp identity_element(std::multiplies<_Tp>) { * Calling @c operator() with a single argument @c x returns @c f(g(x)). * The function @c compose1 takes the two functions and constructs a * @c unary_compose variable for you. - * + * * @c binary_compose is constructed from three functors, @c f, @c g1, * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function * @compose2 takes f, g1, and g2, and constructs the @c binary_compose @@ -124,13 +124,13 @@ template inline _Tp identity_element(std::multiplies<_Tp>) { template class unary_compose : public unary_function + typename _Operation1::result_type> { protected: _Operation1 _M_fn1; _Operation2 _M_fn2; public: - unary_compose(const _Operation1& __x, const _Operation2& __y) + unary_compose(const _Operation1& __x, const _Operation2& __y) : _M_fn1(__x), _M_fn2(__y) {} typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { @@ -140,7 +140,7 @@ public: /// An \link SGIextensions SGI extension \endlink. template -inline unary_compose<_Operation1,_Operation2> +inline unary_compose<_Operation1,_Operation2> compose1(const _Operation1& __fn1, const _Operation2& __fn2) { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); @@ -156,8 +156,8 @@ protected: _Operation2 _M_fn2; _Operation3 _M_fn3; public: - binary_compose(const _Operation1& __x, const _Operation2& __y, - const _Operation3& __z) + binary_compose(const _Operation1& __x, const _Operation2& __y, + const _Operation3& __z) : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { @@ -167,8 +167,8 @@ public: /// An \link SGIextensions SGI extension \endlink. template -inline binary_compose<_Operation1, _Operation2, _Operation3> -compose2(const _Operation1& __fn1, const _Operation2& __fn2, +inline binary_compose<_Operation1, _Operation2, _Operation3> +compose2(const _Operation1& __fn1, const _Operation2& __fn2, const _Operation3& __fn3) { return binary_compose<_Operation1,_Operation2,_Operation3> @@ -220,7 +220,7 @@ struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> { */ /// An \link SGIextensions SGI extension \endlink. -template +template struct project1st : public _Project1st<_Arg1, _Arg2> {}; /// An \link SGIextensions SGI extension \endlink. @@ -236,7 +236,7 @@ struct _Constant_void_fun { _Constant_void_fun(const result_type& __v) : _M_val(__v) {} const result_type& operator()() const { return _M_val; } -}; +}; template struct _Constant_unary_fun { @@ -279,7 +279,7 @@ struct _Constant_binary_fun { template struct constant_void_fun : public _Constant_void_fun<_Result> { constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} -}; +}; /// An \link SGIextensions SGI extension \endlink. template constant1(const _Result& __val) /// An \link SGIextensions SGI extension \endlink. template -inline constant_binary_fun<_Result,_Result,_Result> +inline constant_binary_fun<_Result,_Result,_Result> constant2(const _Result& __val) { return constant_binary_fun<_Result,_Result,_Result>(__val); @@ -369,7 +369,7 @@ public: subtractive_rng() { _M_initialize(161803398u); } }; -// Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, +// Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, // provided for backward compatibility, they are no longer part of // the C++ standard. @@ -391,5 +391,5 @@ mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } } // namespace __gnu_cxx -#endif +#endif diff --git a/libstdc++-v3/include/ext/hash_fun.h b/libstdc++-v3/include/ext/hash_fun.h index 1542526..27453a6 100644 --- a/libstdc++-v3/include/ext/hash_fun.h +++ b/libstdc++-v3/include/ext/hash_fun.h @@ -70,53 +70,53 @@ namespace __gnu_cxx template struct hash { }; - inline size_t + inline size_t __stl_hash_string(const char* __s) { - unsigned long __h = 0; + unsigned long __h = 0; for ( ; *__s; ++__s) - __h = 5*__h + *__s; + __h = 5*__h + *__s; return size_t(__h); } template<> struct hash { - size_t operator()(const char* __s) const + size_t operator()(const char* __s) const { return __stl_hash_string(__s); } }; - + template<> struct hash { - size_t operator()(const char* __s) const + size_t operator()(const char* __s) const { return __stl_hash_string(__s); } }; - template<> struct hash + template<> struct hash { size_t operator()(char __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(unsigned char __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(unsigned char __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(short __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(unsigned short __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(int __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(unsigned int __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(long __x) const { return __x; } }; - template<> struct hash + template<> struct hash { size_t operator()(unsigned long __x) const { return __x; } }; } // namespace __gnu_cxx -#endif +#endif diff --git a/libstdc++-v3/include/ext/hash_map b/libstdc++-v3/include/ext/hash_map index 363b27d..5032c7b 100644 --- a/libstdc++-v3/include/ext/hash_map +++ b/libstdc++-v3/include/ext/hash_map @@ -59,7 +59,7 @@ * include this header if you are using GCC 3 or later. */ -#ifndef _HASH_MAP +#ifndef _HASH_MAP #define _HASH_MAP 1 #include @@ -102,7 +102,7 @@ public: typedef typename _Ht::value_type value_type; typedef typename _Ht::hasher hasher; typedef typename _Ht::key_equal key_equal; - + typedef typename _Ht::size_type size_type; typedef typename _Ht::difference_type difference_type; typedef typename _Ht::pointer pointer; @@ -171,10 +171,10 @@ public: void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_unique(__f,__l); } pair insert_noresize(const value_type& __obj) - { return _M_ht.insert_unique_noresize(__obj); } + { return _M_ht.insert_unique_noresize(__obj); } iterator find(const key_type& __key) { return _M_ht.find(__key); } - const_iterator find(const key_type& __key) const + const_iterator find(const key_type& __key) const { return _M_ht.find(__key); } _Tp& operator[](const key_type& __key) { @@ -182,7 +182,7 @@ public: } size_type count(const key_type& __key) const { return _M_ht.count(__key); } - + pair equal_range(const key_type& __key) { return _M_ht.equal_range(__key); } pair @@ -202,7 +202,7 @@ public: }; template -inline bool +inline bool operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) { @@ -210,14 +210,14 @@ operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, } template -inline bool +inline bool operator!=(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) { return !(__hm1 == __hm2); } template -inline void +inline void swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) { @@ -233,7 +233,7 @@ template -inline bool +inline bool operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2); @@ -253,7 +253,7 @@ class hash_multimap private: typedef hashtable, _Key, _HashFcn, - _Select1st >, _EqualKey, _Alloc> + _Select1st >, _EqualKey, _Alloc> _Ht; _Ht _M_ht; @@ -327,20 +327,20 @@ public: const_iterator end() const { return _M_ht.end(); } public: - iterator insert(const value_type& __obj) + iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); } template - void insert(_InputIterator __f, _InputIterator __l) + void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_equal(__f,__l); } iterator insert_noresize(const value_type& __obj) - { return _M_ht.insert_equal_noresize(__obj); } + { return _M_ht.insert_equal_noresize(__obj); } iterator find(const key_type& __key) { return _M_ht.find(__key); } - const_iterator find(const key_type& __key) const + const_iterator find(const key_type& __key) const { return _M_ht.find(__key); } size_type count(const key_type& __key) const { return _M_ht.count(__key); } - + pair equal_range(const key_type& __key) { return _M_ht.equal_range(__key); } pair @@ -361,7 +361,7 @@ public: }; template -inline bool +inline bool operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) { @@ -369,14 +369,14 @@ operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, } template -inline bool +inline bool operator!=(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) { return !(__hm1 == __hm2); } template -inline void +inline void swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) { @@ -407,7 +407,7 @@ public: insert_iterator(_Container& __x, typename _Container::iterator) : container(&__x) {} insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { + operator=(const typename _Container::value_type& __value) { container->insert(__value); return *this; } @@ -434,7 +434,7 @@ public: insert_iterator(_Container& __x, typename _Container::iterator) : container(&__x) {} insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { + operator=(const typename _Container::value_type& __value) { container->insert(__value); return *this; } diff --git a/libstdc++-v3/include/ext/hash_set b/libstdc++-v3/include/ext/hash_set index 0a0b738..3151ee6 100644 --- a/libstdc++-v3/include/ext/hash_set +++ b/libstdc++-v3/include/ext/hash_set @@ -75,12 +75,12 @@ namespace __gnu_cxx // Forward declaration of equality operator; needed for friend // declaration. template , - class _EqualKey = equal_to<_Value>, + class _EqualKey = equal_to<_Value>, class _Alloc = allocator<_Value> > class hash_set; template - inline bool + inline bool operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2); @@ -98,7 +98,7 @@ class hash_set __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) private: - typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, _EqualKey, _Alloc> _Ht; _Ht _M_ht; @@ -161,7 +161,7 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); } - template + template friend bool operator== (const hash_set<_Val, _HF, _EqK, _Al>&, const hash_set<_Val, _HF, _EqK, _Al>&); @@ -175,11 +175,11 @@ public: return pair(__p.first, __p.second); } template - void insert(_InputIterator __f, _InputIterator __l) + void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_unique(__f,__l); } pair insert_noresize(const value_type& __obj) { - pair __p = + pair __p = _M_ht.insert_unique_noresize(__obj); return pair(__p.first, __p.second); } @@ -187,7 +187,7 @@ public: iterator find(const key_type& __key) const { return _M_ht.find(__key); } size_type count(const key_type& __key) const { return _M_ht.count(__key); } - + pair equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } @@ -205,7 +205,7 @@ public: }; template -inline bool +inline bool operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2) { @@ -213,14 +213,14 @@ operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1, } template -inline bool +inline bool operator!=(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2) { return !(__hs1 == __hs2); } template -inline void +inline void swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) { @@ -235,7 +235,7 @@ template -inline bool +inline bool operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2); @@ -254,7 +254,7 @@ class hash_multiset __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) private: - typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, _EqualKey, _Alloc> _Ht; _Ht _M_ht; @@ -317,7 +317,7 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); } - template + template friend bool operator== (const hash_multiset<_Val, _HF, _EqK, _Al>&, const hash_multiset<_Val, _HF, _EqK, _Al>&); @@ -328,15 +328,15 @@ public: iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); } template - void insert(_InputIterator __f, _InputIterator __l) + void insert(_InputIterator __f, _InputIterator __l) { _M_ht.insert_equal(__f,__l); } iterator insert_noresize(const value_type& __obj) - { return _M_ht.insert_equal_noresize(__obj); } + { return _M_ht.insert_equal_noresize(__obj); } iterator find(const key_type& __key) const { return _M_ht.find(__key); } size_type count(const key_type& __key) const { return _M_ht.count(__key); } - + pair equal_range(const key_type& __key) const { return _M_ht.equal_range(__key); } @@ -354,7 +354,7 @@ public: }; template -inline bool +inline bool operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) { @@ -362,14 +362,14 @@ operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, } template -inline bool +inline bool operator!=(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) { return !(__hs1 == __hs2); } template -inline void +inline void swap(hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1, hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) { __hs1.swap(__hs2); @@ -399,7 +399,7 @@ public: insert_iterator(_Container& __x, typename _Container::iterator) : container(&__x) {} insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { + operator=(const typename _Container::value_type& __value) { container->insert(__value); return *this; } @@ -426,7 +426,7 @@ public: insert_iterator(_Container& __x, typename _Container::iterator) : container(&__x) {} insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { + operator=(const typename _Container::value_type& __value) { container->insert(__value); return *this; } @@ -436,4 +436,4 @@ public: }; } // namespace std -#endif +#endif diff --git a/libstdc++-v3/include/ext/hashtable.h b/libstdc++-v3/include/ext/hashtable.h index 435221c..4e5ea09 100644 --- a/libstdc++-v3/include/ext/hashtable.h +++ b/libstdc++-v3/include/ext/hashtable.h @@ -90,7 +90,7 @@ struct _Hashtable_node { _Hashtable_node* _M_next; _Val _M_val; -}; +}; template @@ -109,10 +109,10 @@ template _Hashtable; - typedef _Hashtable_iterator<_Val, _Key, _HashFcn, + typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> iterator; - typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> const_iterator; typedef _Hashtable_node<_Val> _Node; @@ -127,7 +127,7 @@ struct _Hashtable_iterator { _Node* _M_cur; _Hashtable* _M_ht; - _Hashtable_iterator(_Node* __n, _Hashtable* __tab) + _Hashtable_iterator(_Node* __n, _Hashtable* __tab) : _M_cur(__n), _M_ht(__tab) {} _Hashtable_iterator() {} reference operator*() const { return _M_cur->_M_val; } @@ -146,10 +146,10 @@ template _Hashtable; - typedef _Hashtable_iterator<_Val,_Key,_HashFcn, + typedef _Hashtable_iterator<_Val,_Key,_HashFcn, _ExtractKey,_EqualKey,_Alloc> iterator; - typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> const_iterator; typedef _Hashtable_node<_Val> _Node; @@ -167,15 +167,15 @@ struct _Hashtable_const_iterator { _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab) : _M_cur(__n), _M_ht(__tab) {} _Hashtable_const_iterator() {} - _Hashtable_const_iterator(const iterator& __it) + _Hashtable_const_iterator(const iterator& __it) : _M_cur(__it._M_cur), _M_ht(__it._M_ht) {} reference operator*() const { return _M_cur->_M_val; } pointer operator->() const { return &(operator*()); } const_iterator& operator++(); const_iterator operator++(int); - bool operator==(const const_iterator& __it) const + bool operator==(const const_iterator& __it) const { return _M_cur == __it._M_cur; } - bool operator!=(const const_iterator& __it) const + bool operator!=(const const_iterator& __it) const { return _M_cur != __it._M_cur; } }; @@ -188,7 +188,7 @@ static const unsigned long __stl_prime_list[_S_num_primes] = 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, - 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, + 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul }; @@ -337,7 +337,7 @@ public: } iterator begin() - { + { for (size_type __n = 0; __n < _M_buckets.size(); ++__n) if (_M_buckets[__n]) return iterator(_M_buckets[__n], this); @@ -364,7 +364,7 @@ public: size_type bucket_count() const { return _M_buckets.size(); } size_type max_bucket_count() const - { return __stl_prime_list[(int)_S_num_primes - 1]; } + { return __stl_prime_list[(int)_S_num_primes - 1]; } size_type elems_in_bucket(size_type __bucket) const { @@ -388,7 +388,7 @@ public: pair insert_unique_noresize(const value_type& __obj); iterator insert_equal_noresize(const value_type& __obj); - + template void insert_unique(_InputIterator __f, _InputIterator __l) { @@ -439,7 +439,7 @@ public: reference find_or_insert(const value_type& __obj); - iterator find(const key_type& __key) + iterator find(const key_type& __key) { size_type __n = _M_bkt_num_key(__key); _Node* __first; @@ -448,7 +448,7 @@ public: __first = __first->_M_next) {} return iterator(__first, this); - } + } const_iterator find(const key_type& __key) const { @@ -459,7 +459,7 @@ public: __first = __first->_M_next) {} return const_iterator(__first, this); - } + } size_type count(const key_type& __key) const { @@ -472,10 +472,10 @@ public: return __result; } - pair + pair equal_range(const key_type& __key); - pair + pair equal_range(const key_type& __key) const; size_type erase(const key_type& __key); @@ -534,7 +534,7 @@ private: __throw_exception_again; } } - + void _M_delete_node(_Node* __n) { _Destroy(&__n->_M_val); @@ -548,7 +548,7 @@ private: }; -template _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>& _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++() @@ -563,7 +563,7 @@ _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++() return *this; } -template inline _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All> _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int) @@ -573,7 +573,7 @@ _Hashtable_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int) return __tmp; } -template _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>& _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++() @@ -588,7 +588,7 @@ _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++() return *this; } -template inline _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All> _Hashtable_const_iterator<_Val,_Key,_HF,_ExK,_EqK,_All>::operator++(int) @@ -632,7 +632,7 @@ bool operator==(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1, } } return true; -} +} template inline bool operator!=(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1, @@ -640,7 +640,7 @@ inline bool operator!=(const hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>& __ht1, return !(__ht1 == __ht2); } -template inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1, hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2) { @@ -649,14 +649,14 @@ inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1, template -pair::iterator, bool> +pair::iterator, bool> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::insert_unique_noresize(const value_type& __obj) { const size_type __n = _M_bkt_num(__obj); _Node* __first = _M_buckets[__n]; - for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) return pair(iterator(__cur, this), false); @@ -668,14 +668,14 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> } template -typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator +typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::insert_equal_noresize(const value_type& __obj) { const size_type __n = _M_bkt_num(__obj); _Node* __first = _M_buckets[__n]; - for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) { _Node* __tmp = _M_new_node(__obj); __tmp->_M_next = __cur->_M_next; @@ -692,7 +692,7 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> } template -typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::reference +typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::reference hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj) { resize(_M_num_elements + 1); @@ -713,7 +713,7 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj) template pair::iterator, - typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator> + typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key) { typedef pair _Pii; @@ -734,8 +734,8 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key) } template -pair::const_iterator, - typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator> +pair::const_iterator, + typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator> hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::equal_range(const key_type& __key) const { @@ -743,7 +743,7 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> const size_type __n = _M_bkt_num_key(__key); for (const _Node* __first = _M_buckets[__n] ; - __first; + __first; __first = __first->_M_next) { if (_M_equals(_M_get_key(__first->_M_val), __key)) { for (const _Node* __cur = __first->_M_next; @@ -763,7 +763,7 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> } template -typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::size_type +typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::size_type hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::erase(const key_type& __key) { const size_type __n = _M_bkt_num_key(__key); @@ -831,9 +831,9 @@ template void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::erase(iterator __first, iterator __last) { - size_type __f_bucket = __first._M_cur ? + size_type __f_bucket = __first._M_cur ? _M_bkt_num(__first._M_cur->_M_val) : _M_buckets.size(); - size_type __l_bucket = __last._M_cur ? + size_type __l_bucket = __last._M_cur ? _M_bkt_num(__last._M_cur->_M_val) : _M_buckets.size(); if (__first._M_cur == __last._M_cur) @@ -886,7 +886,7 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> _M_buckets[__bucket] = __first->_M_next; __first->_M_next = __tmp[__new_bucket]; __tmp[__new_bucket] = __first; - __first = _M_buckets[__bucket]; + __first = _M_buckets[__bucket]; } } _M_buckets.swap(__tmp); @@ -914,8 +914,8 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> _M_erase_bucket(__n, __last); else { _Node* __next; - for (__next = __cur->_M_next; - __next != __first; + for (__next = __cur->_M_next; + __next != __first; __cur = __next, __next = __cur->_M_next) ; while (__next != __last) { @@ -956,7 +956,7 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::clear() _M_num_elements = 0; } - + template void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> ::_M_copy_from(const hashtable& __ht) @@ -971,8 +971,8 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All> _Node* __local_copy = _M_new_node(__cur->_M_val); _M_buckets[__i] = __local_copy; - for (_Node* __next = __cur->_M_next; - __next; + for (_Node* __next = __cur->_M_next; + __next; __cur = __next, __next = __cur->_M_next) { __local_copy->_M_next = _M_new_node(__next->_M_val); __local_copy = __local_copy->_M_next; diff --git a/libstdc++-v3/include/ext/iterator b/libstdc++-v3/include/ext/iterator index e492e68..094313c 100644 --- a/libstdc++-v3/include/ext/iterator +++ b/libstdc++-v3/include/ext/iterator @@ -72,7 +72,7 @@ namespace __gnu_cxx // There are two signatures for distance. In addition to the one // taking two iterators and returning a result, there is another // taking two iterators and a reference-to-result variable, and - // returning nothing. The latter seems to be an SGI extension. + // returning nothing. The latter seems to be an SGI extension. // -- pedwards template inline void @@ -86,7 +86,7 @@ namespace __gnu_cxx template inline void - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, _Distance& __n, std::random_access_iterator_tag) { // concept requirements @@ -109,5 +109,5 @@ namespace __gnu_cxx } } // namespace __gnu_cxx -#endif +#endif diff --git a/libstdc++-v3/include/ext/malloc_allocator.h b/libstdc++-v3/include/ext/malloc_allocator.h index 410b296..b0a837b 100644 --- a/libstdc++-v3/include/ext/malloc_allocator.h +++ b/libstdc++-v3/include/ext/malloc_allocator.h @@ -41,7 +41,7 @@ */ /** @file ext/debug_allocator.h - * This file is a GNU extension to the Standard C++ Library. + * This file is a GNU extension to the Standard C++ Library. * You should only include this header if you are using GCC 3 or later. */ @@ -149,7 +149,7 @@ namespace std /// Versions for the __allocator adaptor used with the predefined /// "SGI" style allocators. template - struct _Alloc_traits<_Tp, __allocator<_Tp1, + struct _Alloc_traits<_Tp, __allocator<_Tp1, __gnu_cxx::__malloc_alloc<__inst> > > { static const bool _S_instanceless = true; diff --git a/libstdc++-v3/include/ext/memory b/libstdc++-v3/include/ext/memory index 8a3a335..1d93f90 100644 --- a/libstdc++-v3/include/ext/memory +++ b/libstdc++-v3/include/ext/memory @@ -73,30 +73,30 @@ namespace __gnu_cxx using std::pair; using std::__iterator_category; using std::_Temporary_buffer; - + template pair<_InputIter, _ForwardIter> __uninitialized_copy_n(_InputIter __first, _Size __count, _ForwardIter __result, std::input_iterator_tag) { _ForwardIter __cur = __result; - try + try { - for ( ; __count > 0 ; --__count, ++__first, ++__cur) + for ( ; __count > 0 ; --__count, ++__first, ++__cur) std::_Construct(&*__cur, *__first); return pair<_InputIter, _ForwardIter>(__first, __cur); } catch(...) { std::_Destroy(__result, __cur); - __throw_exception_again; + __throw_exception_again; } } - + template inline pair<_RandomAccessIter, _ForwardIter> __uninitialized_copy_n(_RandomAccessIter __first, _Size __count, - _ForwardIter __result, + _ForwardIter __result, std::random_access_iterator_tag) { _RandomAccessIter __last = __first + __count; @@ -108,7 +108,7 @@ namespace __gnu_cxx template inline pair<_InputIter, _ForwardIter> __uninitialized_copy_n(_InputIter __first, _Size __count, - _ForwardIter __result) + _ForwardIter __result) { return __uninitialized_copy_n(__first, __count, __result, __iterator_category(__first)); @@ -127,7 +127,7 @@ namespace __gnu_cxx template inline pair<_InputIter, _ForwardIter> uninitialized_copy_n(_InputIter __first, _Size __count, - _ForwardIter __result) + _ForwardIter __result) { return __uninitialized_copy_n(__first, __count, __result, __iterator_category(__first)); @@ -154,7 +154,7 @@ namespace __gnu_cxx * * @ingroup SGIextensions */ - template ::value_type > struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp> { diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h index b1a88ec..42c804f 100644 --- a/libstdc++-v3/include/ext/mt_allocator.h +++ b/libstdc++-v3/include/ext/mt_allocator.h @@ -28,7 +28,7 @@ // the GNU General Public License. /** @file ext/mt_allocator.h - * This file is a GNU extension to the Standard C++ Library. + * This file is a GNU extension to the Standard C++ Library. * You should only include this header if you are using GCC 3 or later. */ @@ -36,7 +36,7 @@ #define _MT_ALLOCATOR_H 1 #include -#include +#include #include #include #include @@ -64,8 +64,8 @@ namespace __gnu_cxx private: /* * We need to create the initial lists and set up some variables - * before we can answer to the first request for memory. - * The initialization of these variables is done at file scope + * before we can answer to the first request for memory. + * The initialization of these variables is done at file scope * below class declaration. */ #ifdef __GTHREADS @@ -93,7 +93,7 @@ namespace __gnu_cxx static size_t _S_freelist_headroom; /* - * Each requesting thread is assigned an id ranging from 1 to + * Each requesting thread is assigned an id ranging from 1 to * _S_max_threads. Thread id 0 is used as a global memory pool. * In order to get constant performance on the thread assignment * routine, we keep a list of free ids. When a thread first requests @@ -141,8 +141,8 @@ namespace __gnu_cxx struct bin_record { /* - * An "array" of pointers to the first/last free block for each - * thread id. Memory to these "arrays" is allocated in _S_init() + * An "array" of pointers to the first/last free block for each + * thread id. Memory to these "arrays" is allocated in _S_init() * for _S_max_threads + global pool 0. */ block_record** first; @@ -151,24 +151,24 @@ namespace __gnu_cxx /* * An "array" of counters used to keep track of the amount of blocks * that are on the freelist/used for each thread id. - * Memory to these "arrays" is allocated in _S_init() + * Memory to these "arrays" is allocated in _S_init() * for _S_max_threads + global pool 0. */ size_t* free; size_t* used; /* - * Each bin has its own mutex which is used to ensure data integrity + * Each bin has its own mutex which is used to ensure data integrity * while changing "ownership" on a block. * The mutex is initialized in _S_init(). */ #ifdef __GTHREADS - __gthread_mutex_t* mutex; + __gthread_mutex_t* mutex; #endif }; /* - * An "array" of bin_records each of which represents a specific + * An "array" of bin_records each of which represents a specific * power of 2 size. Memory to this "array" is allocated in _S_init(). */ static bin_record* _S_bin; @@ -185,7 +185,7 @@ namespace __gnu_cxx if (__n > _S_max_bytes) { void* __ret = malloc(__n); - if (!__ret) + if (!__ret) __throw_bad_alloc(); return __ret; @@ -233,12 +233,12 @@ namespace __gnu_cxx { /* * Are we using threads? - * - Yes, lock and check if there are free blocks on the global - * list (and if not add new ones), get the first one + * - Yes, lock and check if there are free blocks on the global + * list (and if not add new ones), get the first one * and change owner. - * - No, all operations are made directly to global pool 0 - * no need to lock or change ownership but check for free - * blocks on global list (and if not add new ones) and + * - No, all operations are made directly to global pool 0 + * no need to lock or change ownership but check for free + * blocks on global list (and if not add new ones) and * get the first one. */ #ifdef __GTHREADS @@ -248,7 +248,7 @@ namespace __gnu_cxx if (_S_bin[bin].first[0] == NULL) { - _S_bin[bin].first[0] = + _S_bin[bin].first[0] = (block_record*)malloc(_S_chunk_size); if (!_S_bin[bin].first[0]) @@ -258,7 +258,7 @@ namespace __gnu_cxx } size_t bin_t = 1 << bin; - size_t block_count = + size_t block_count = _S_chunk_size /(bin_t + sizeof(block_record)); _S_bin[bin].free[0] = block_count; @@ -268,7 +268,7 @@ namespace __gnu_cxx while (block_count > 0) { - block->next = (block_record*)((char*)block + + block->next = (block_record*)((char*)block + (bin_t + sizeof(block_record))); block = block->next; block_count--; @@ -302,11 +302,11 @@ namespace __gnu_cxx { _S_bin[bin].first[0] = (block_record*)malloc(_S_chunk_size); - if (!_S_bin[bin].first[0]) + if (!_S_bin[bin].first[0]) __throw_bad_alloc(); size_t bin_t = 1 << bin; - size_t block_count = + size_t block_count = _S_chunk_size / (bin_t + sizeof(block_record)); _S_bin[bin].free[0] = block_count; @@ -316,7 +316,7 @@ namespace __gnu_cxx while (block_count > 0) { - block->next = (block_record*)((char*)block + + block->next = (block_record*)((char*)block + (bin_t + sizeof(block_record))); block = block->next; block_count--; @@ -335,7 +335,7 @@ namespace __gnu_cxx _S_bin[bin].free[0]--; _S_bin[bin].used[0]++; } - } + } else { /* @@ -376,7 +376,7 @@ namespace __gnu_cxx size_t thread_id = 0; #endif - block_record* block = (block_record*)((char*)__p + block_record* block = (block_record*)((char*)__p - sizeof(block_record)); /* @@ -391,7 +391,7 @@ namespace __gnu_cxx /* * Calculate the number of records to remove from our freelist */ - int remove = _S_bin[bin].free[thread_id] - + int remove = _S_bin[bin].free[thread_id] - (_S_bin[bin].used[thread_id] / _S_freelist_headroom); /* @@ -400,8 +400,8 @@ namespace __gnu_cxx * too much contention when locking and therefore we * wait until the number of records is "high enough". */ - if (remove > (int)(100 * (_S_no_of_bins - bin)) && - remove > (int)(_S_bin[bin].free[thread_id] / + if (remove > (int)(100 * (_S_no_of_bins - bin)) && + remove > (int)(_S_bin[bin].free[thread_id] / _S_freelist_headroom)) { __gthread_mutex_lock(_S_bin[bin].mutex); @@ -415,7 +415,7 @@ namespace __gnu_cxx _S_bin[bin].last[0] = _S_bin[bin].first[thread_id]; - _S_bin[bin].first[thread_id] = + _S_bin[bin].first[thread_id] = _S_bin[bin].first[thread_id]->next; _S_bin[bin].free[0]++; @@ -506,7 +506,7 @@ namespace __gnu_cxx _S_binmap = (binmap_type*) malloc ((_S_max_bytes + 1) * sizeof(binmap_type)); - if (!_S_binmap) + if (!_S_binmap) __throw_bad_alloc(); binmap_type* bp_t = _S_binmap; @@ -530,20 +530,20 @@ namespace __gnu_cxx #ifdef __GTHREADS if (__gthread_active_p()) { - _S_thread_freelist_first = + _S_thread_freelist_first = (thread_record*)malloc(sizeof(thread_record) * _S_max_threads); - if (!_S_thread_freelist_first) + if (!_S_thread_freelist_first) __throw_bad_alloc(); /* - * NOTE! The first assignable thread id is 1 since the global + * NOTE! The first assignable thread id is 1 since the global * pool uses id 0 */ size_t i; for (i = 1; i < _S_max_threads; i++) { - _S_thread_freelist_first[i - 1].next = + _S_thread_freelist_first[i - 1].next = &_S_thread_freelist_first[i]; _S_thread_freelist_first[i - 1].id = i; @@ -575,7 +575,7 @@ namespace __gnu_cxx */ _S_bin = (bin_record*)malloc(sizeof(bin_record) * _S_no_of_bins); - if (!_S_bin) + if (!_S_bin) __throw_bad_alloc(); for (size_t bin = 0; bin < _S_no_of_bins; bin++) @@ -583,25 +583,25 @@ namespace __gnu_cxx _S_bin[bin].first = (block_record**) malloc(sizeof(block_record*) * (_S_max_threads + 1)); - if (!_S_bin[bin].first) + if (!_S_bin[bin].first) __throw_bad_alloc(); _S_bin[bin].last = (block_record**) malloc(sizeof(block_record*) * (_S_max_threads + 1)); - if (!_S_bin[bin].last) + if (!_S_bin[bin].last) __throw_bad_alloc(); _S_bin[bin].free = (size_t*) malloc(sizeof(size_t) * (_S_max_threads + 1)); - if (!_S_bin[bin].free) + if (!_S_bin[bin].free) __throw_bad_alloc(); _S_bin[bin].used = (size_t*) malloc(sizeof(size_t) * (_S_max_threads + 1)); - if (!_S_bin[bin].used) + if (!_S_bin[bin].used) __throw_bad_alloc(); /* @@ -609,10 +609,10 @@ namespace __gnu_cxx * a parser problem - see PR c++/9779 for more info. */ #ifdef __GTHREADS - size_t s = sizeof(__gthread_mutex_t); + size_t s = sizeof(__gthread_mutex_t); _S_bin[bin].mutex = (__gthread_mutex_t*)malloc(s); - if (!_S_bin[bin].mutex) + if (!_S_bin[bin].mutex) __throw_bad_alloc(); #ifdef __GTHREAD_MUTEX_INIT @@ -656,7 +656,7 @@ namespace __gnu_cxx */ for (size_t bin = 0; bin < _S_no_of_bins; bin++) { - block_record* block = + block_record* block = _S_bin[bin].first[((thread_record*)freelist_pos)->id]; if (block != NULL) @@ -711,7 +711,7 @@ namespace __gnu_cxx { thread_record* freelist_pos; - if ((freelist_pos = + if ((freelist_pos = (thread_record*)__gthread_getspecific(_S_thread_key)) == NULL) { __gthread_mutex_lock(&_S_thread_freelist_mutex); @@ -742,7 +742,7 @@ namespace __gnu_cxx _S_bin[bin].last[freelist_pos->id] = NULL; _S_bin[bin].free[freelist_pos->id] = 0; } - } + } return freelist_pos->id; } @@ -851,7 +851,7 @@ namespace std }; template - struct _Alloc_traits<_Tp, + struct _Alloc_traits<_Tp, __allocator<_Tp1, __gnu_cxx::__mt_alloc<__inst> > > { static const bool _S_instanceless = true; diff --git a/libstdc++-v3/include/ext/numeric b/libstdc++-v3/include/ext/numeric index a596d99..40edf07 100644 --- a/libstdc++-v3/include/ext/numeric +++ b/libstdc++-v3/include/ext/numeric @@ -72,7 +72,7 @@ namespace __gnu_cxx { // Returns __x ** __n, where __n >= 0. _Note that "multiplication" - // is required to be associative, but not necessarily commutative. + // is required to be associative, but not necessarily commutative. template _Tp __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) @@ -131,7 +131,7 @@ namespace __gnu_cxx */ // iota is not part of the C++ standard. It is an extension. template - void + void iota(_ForwardIter __first, _ForwardIter __last, _Tp __value) { // concept requirements diff --git a/libstdc++-v3/include/ext/pod_char_traits.h b/libstdc++-v3/include/ext/pod_char_traits.h index 0519029..c69025e 100644 --- a/libstdc++-v3/include/ext/pod_char_traits.h +++ b/libstdc++-v3/include/ext/pod_char_traits.h @@ -32,7 +32,7 @@ #ifndef _POD_CHAR_TRAITS_H #define _POD_CHAR_TRAITS_H 1 - + #include namespace __gnu_cxx @@ -40,19 +40,19 @@ namespace __gnu_cxx template struct character { - typedef V value_type; - typedef I int_type; - typedef S state_type; - value_type value; + typedef V value_type; + typedef I int_type; + typedef S state_type; + value_type value; }; - + template - inline bool + inline bool operator==(const character& lhs, const character& rhs) { return lhs.value == rhs.value; } - + template - inline bool + inline bool operator<(const character& lhs, const character& rhs) { return lhs.value < rhs.value; } } // namespace __gnu_cxx @@ -63,93 +63,93 @@ namespace std template struct char_traits<__gnu_cxx::character > { - typedef __gnu_cxx::character char_type; + typedef __gnu_cxx::character char_type; // NB: This type should be bigger than char_type, so as to // properly hold EOF values in addition to the full range of // char_type values. - // Also, assumes + // Also, assumes // int_type(value_type) is valid. // int_type(-1) is possible. typedef typename char_type::int_type int_type; typedef typename char_type::state_type state_type; typedef fpos pos_type; - typedef streamoff off_type; - - static void + typedef streamoff off_type; + + static void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } - static bool + static bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } - static bool + static bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } - static int + static int compare(const char_type* __s1, const char_type* __s2, size_t __n) - { + { for (size_t __i = 0; __i < __n; ++__i) if (!eq(__s1[__i], __s2[__i])) return lt(__s1[__i], __s2[__i]) ? -1 : 1; - return 0; + return 0; } static size_t length(const char_type* __s) - { - const char_type* __p = __s; - while (__p->value) - ++__p; - return (__p - __s); + { + const char_type* __p = __s; + while (__p->value) + ++__p; + return (__p - __s); } - static const char_type* + static const char_type* find(const char_type* __s, size_t __n, const char_type& __a) - { + { for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p) - if (*__p == __a) + if (*__p == __a) return __p; return 0; } - static char_type* + static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); } - static char_type* + static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); } - static char_type* + static char_type* assign(char_type* __s, size_t __n, char_type __a) - { - for (char_type* __p = __s; __p < __s + __n; ++__p) + { + for (char_type* __p = __s; __p < __s + __n; ++__p) assign(*__p, __a); - return __s; + return __s; } - static char_type + static char_type to_char_type(const int_type& __c) { char_type __r = { __c }; return __r; } - static int_type - to_int_type(const char_type& __c) + static int_type + to_int_type(const char_type& __c) { return int_type(__c.value); } - static bool + static bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } - static int_type + static int_type eof() { return static_cast(-1); } - static int_type + static int_type not_eof(const int_type& __c) { return eq_int_type(__c, eof()) ? int_type(0) : __c; } }; diff --git a/libstdc++-v3/include/ext/pool_allocator.h b/libstdc++-v3/include/ext/pool_allocator.h index cec7920..15e1eb4 100644 --- a/libstdc++-v3/include/ext/pool_allocator.h +++ b/libstdc++-v3/include/ext/pool_allocator.h @@ -41,14 +41,14 @@ */ /** @file ext/debug_allocator.h - * This file is a GNU extension to the Standard C++ Library. + * This file is a GNU extension to the Standard C++ Library. * You should only include this header if you are using GCC 3 or later. */ #ifndef _POOL_ALLOCATOR_H #define _POOL_ALLOCATOR_H 1 -#include +#include #include #include #include @@ -111,7 +111,7 @@ namespace __gnu_cxx static size_t _S_heap_size; static _STL_mutex_lock _S_lock; - static _Atomic_word _S_force_new; + static _Atomic_word _S_force_new; static size_t _S_round_up(size_t __bytes) @@ -152,7 +152,7 @@ namespace __gnu_cxx template inline bool - operator==(const __pool_alloc<__threads,__inst>&, + operator==(const __pool_alloc<__threads,__inst>&, const __pool_alloc<__threads,__inst>&) { return true; } @@ -289,7 +289,7 @@ namespace __gnu_cxx else __atomic_add(&_S_force_new, -1); } - + if ((__n > (size_t) _S_max_bytes) || (_S_force_new > 0)) __ret = __new_alloc::allocate(__n); else @@ -306,13 +306,13 @@ namespace __gnu_cxx { *__free_list = __result -> _M_free_list_link; __ret = __result; - } + } if (__builtin_expect(__ret == 0, 0)) __throw_bad_alloc(); } return __ret; } - + template void __pool_alloc<__threads, __inst>::deallocate(void* __p, size_t __n) @@ -323,7 +323,7 @@ namespace __gnu_cxx { _Obj* volatile* __free_list = _S_free_list + _S_freelist_index(__n); _Obj* __q = (_Obj*)__p; - + // Acquire the lock here with a constructor call. This // ensures that it is released in exit or during stack // unwinding. @@ -368,9 +368,9 @@ namespace std template struct _Alloc_traits<_Tp, __gnu_cxx::__pool_alloc<__thr, __inst> > { - static const bool _S_instanceless = true; - typedef __gnu_cxx::__pool_alloc<__thr, __inst> base_alloc_type; - typedef __simple_alloc<_Tp, base_alloc_type> _Alloc_type; + static const bool _S_instanceless = true; + typedef __gnu_cxx::__pool_alloc<__thr, __inst> base_alloc_type; + typedef __simple_alloc<_Tp, base_alloc_type> _Alloc_type; typedef __allocator<_Tp, base_alloc_type> allocator_type; }; //@} @@ -379,11 +379,11 @@ namespace std /// Versions for the __allocator adaptor used with the predefined /// "SGI" style allocators. template - struct _Alloc_traits<_Tp, __allocator<_Tp1, + struct _Alloc_traits<_Tp, __allocator<_Tp1, __gnu_cxx::__pool_alloc<__thr, __inst> > > { static const bool _S_instanceless = true; - typedef __gnu_cxx::__pool_alloc<__thr, __inst> base_alloc_type; + typedef __gnu_cxx::__pool_alloc<__thr, __inst> base_alloc_type; typedef __simple_alloc<_Tp, base_alloc_type> _Alloc_type; typedef __allocator<_Tp, base_alloc_type> allocator_type; }; diff --git a/libstdc++-v3/include/ext/rb_tree b/libstdc++-v3/include/ext/rb_tree index f0aed47..2c38b39 100644 --- a/libstdc++-v3/include/ext/rb_tree +++ b/libstdc++-v3/include/ext/rb_tree @@ -70,7 +70,7 @@ namespace __gnu_cxx { using std::_Rb_tree; using std::allocator; - + // Class rb_tree is not part of the C++ standard. It is provided for // compatibility with the HP STL. @@ -85,13 +85,13 @@ namespace __gnu_cxx { typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base; typedef typename _Base::allocator_type allocator_type; - + rb_tree(const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _Base(__comp, __a) { } - + ~rb_tree() { } }; } // namespace __gnu_cxx -#endif +#endif diff --git a/libstdc++-v3/include/ext/rope b/libstdc++-v3/include/ext/rope index c12eaa8..4323e19 100644 --- a/libstdc++-v3/include/ext/rope +++ b/libstdc++-v3/include/ext/rope @@ -112,7 +112,7 @@ template class char_producer { public: virtual ~char_producer() {}; - virtual void operator()(size_t __start_pos, size_t __len, + virtual void operator()(size_t __start_pos, size_t __len, _CharT* __buffer) = 0; // Buffer should really be an arbitrary output iterator. // That way we could flatten directly into an ostream, etc. @@ -265,17 +265,17 @@ _Rope_const_iterator<_CharT,_Alloc> operator+ const _Rope_const_iterator<_CharT,_Alloc>& __x); template -bool operator== +bool operator== (const _Rope_const_iterator<_CharT,_Alloc>& __x, const _Rope_const_iterator<_CharT,_Alloc>& __y); template -bool operator< +bool operator< (const _Rope_const_iterator<_CharT,_Alloc>& __x, const _Rope_const_iterator<_CharT,_Alloc>& __y); template -ptrdiff_t operator- +ptrdiff_t operator- (const _Rope_const_iterator<_CharT,_Alloc>& __x, const _Rope_const_iterator<_CharT,_Alloc>& __y); @@ -295,32 +295,32 @@ _Rope_iterator<_CharT,_Alloc> operator+ const _Rope_iterator<_CharT,_Alloc>& __x); template -bool operator== +bool operator== (const _Rope_iterator<_CharT,_Alloc>& __x, const _Rope_iterator<_CharT,_Alloc>& __y); template -bool operator< +bool operator< (const _Rope_iterator<_CharT,_Alloc>& __x, const _Rope_iterator<_CharT,_Alloc>& __y); template -ptrdiff_t operator- +ptrdiff_t operator- (const _Rope_iterator<_CharT,_Alloc>& __x, const _Rope_iterator<_CharT,_Alloc>& __y); template rope<_CharT,_Alloc> operator+ (const rope<_CharT,_Alloc>& __left, const rope<_CharT,_Alloc>& __right); - + template rope<_CharT,_Alloc> operator+ (const rope<_CharT,_Alloc>& __left, const _CharT* __right); - + template rope<_CharT,_Alloc> operator+ (const rope<_CharT,_Alloc>& __left, _CharT __right); - + // Some helpers, so we can use power on ropes. // See below for why this isn't local to the implementation. @@ -347,16 +347,16 @@ identity_element(_Rope_Concat_fn<_CharT, _Alloc>) // Class _Refcount_Base provides a type, _RC_t, a data member, // _M_ref_count, and member functions _M_incr and _M_decr, which perform - // atomic preincrement/predecrement. The constructor initializes + // atomic preincrement/predecrement. The constructor initializes // _M_ref_count. struct _Refcount_Base { // The type _RC_t typedef size_t _RC_t; - + // The data member _M_ref_count volatile _RC_t _M_ref_count; - + // Constructor __gthread_mutex_t _M_ref_count_lock; @@ -372,16 +372,16 @@ identity_element(_Rope_Concat_fn<_CharT, _Alloc>) #endif } - void - _M_incr() + void + _M_incr() { __gthread_mutex_lock(&_M_ref_count_lock); ++_M_ref_count; __gthread_mutex_unlock(&_M_ref_count_lock); } - _RC_t - _M_decr() + _RC_t + _M_decr() { __gthread_mutex_lock(&_M_ref_count_lock); volatile _RC_t __tmp = --_M_ref_count; @@ -420,7 +420,7 @@ identity_element(_Rope_Concat_fn<_CharT, _Alloc>) // we are using standard conforming allocators, and whether the allocator // instances have real state. Thus this macro is invoked repeatedly // with different definitions of __ROPE_DEFINE_ALLOC. -// __ROPE_DEFINE_ALLOC(type,name) defines +// __ROPE_DEFINE_ALLOC(type,name) defines // type * name_allocate(size_t) and // void name_deallocate(tipe *, size_t) // Both functions may or may not be static. @@ -460,7 +460,7 @@ public: size_t _M_size; // This is here only to avoid wasting space // for an otherwise empty base class. - + protected: allocator_type _M_data_allocator; @@ -476,7 +476,7 @@ protected: }; // Specialization for allocators that have the property that we don't -// actually have to store an allocator object. +// actually have to store an allocator object. template class _Rope_rep_alloc_base<_CharT,_Allocator,true> { public: @@ -486,7 +486,7 @@ public: _Rope_rep_alloc_base(size_t __size, const allocator_type&) : _M_size(__size) {} size_t _M_size; - + protected: # define __ROPE_DEFINE_ALLOC(_Tp, __name) \ @@ -513,7 +513,7 @@ struct _Rope_rep_base typedef typename _Base::allocator_type allocator_type; _Rope_rep_base(size_t __size, const allocator_type& __a) : _Base(__size, __a) {} -}; +}; template @@ -612,7 +612,7 @@ struct _Rope_RopeLeaf : public _Rope_RopeRep<_CharT,_Alloc> { enum { _S_alloc_granularity = 8 }; static size_t _S_rounded_up_size(size_t __n) { size_t __size_with_eos; - + if (_S_is_basic_char_type((_CharT*)0)) { __size_with_eos = __n + 1; } else { @@ -780,7 +780,7 @@ struct _Rope_RopeSubstring : public _Rope_RopeFunction<_CharT,_Alloc>, this->_M_tag = _Rope_RopeFunction<_CharT,_Alloc>::_S_substringfn; } virtual ~_Rope_RopeSubstring() - { + { # ifndef __GC _M_base->_M_unref_nonnil(); // _M_free_c_string(); -- done by parent class @@ -802,7 +802,7 @@ struct _Rope_RopeSubstring : public _Rope_RopeFunction<_CharT,_Alloc>, template struct _Rope_self_destruct_ptr { _Rope_RopeRep<_CharT,_Alloc>* _M_ptr; - ~_Rope_self_destruct_ptr() + ~_Rope_self_destruct_ptr() { _Rope_RopeRep<_CharT,_Alloc>::_S_unref(_M_ptr); } #ifdef __EXCEPTIONS _Rope_self_destruct_ptr() : _M_ptr(0) {}; @@ -854,7 +854,7 @@ class _Rope_char_ref_proxy { _Rope_char_ref_proxy& operator= (_CharT __c); _Rope_char_ptr_proxy<_CharT,_Alloc> operator& () const; _Rope_char_ref_proxy& operator= (const _Rope_char_ref_proxy& __c) { - return operator=((_CharT)__c); + return operator=((_CharT)__c); } }; @@ -873,14 +873,14 @@ class _Rope_char_ptr_proxy { size_t _M_pos; rope<_CharT,_Alloc>* _M_root; // The whole rope. public: - _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x) + _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x) : _M_pos(__x._M_pos), _M_root(__x._M_root) {} _Rope_char_ptr_proxy(const _Rope_char_ptr_proxy& __x) : _M_pos(__x._M_pos), _M_root(__x._M_root) {} _Rope_char_ptr_proxy() {} _Rope_char_ptr_proxy(_CharT* __x) : _M_root(0), _M_pos(0) { } - _Rope_char_ptr_proxy& + _Rope_char_ptr_proxy& operator= (const _Rope_char_ptr_proxy& __x) { _M_pos = __x._M_pos; _M_root = __x._M_root; @@ -942,7 +942,7 @@ class _Rope_iterator_base // __right. Assumes path_cache_len <= 9. _CharT _M_tmp_buf[_S_iterator_buf_len]; // Short buffer for surrounding chars. - // This is useful primarily for + // This is useful primarily for // RopeFunctions. We put the buffer // here to avoid locking in the // multithreaded case. @@ -1081,7 +1081,7 @@ class _Rope_const_iterator : public _Rope_iterator_base<_CharT,_Alloc> { (const _Rope_const_iterator<_CharT2,_Alloc2>& __x, const _Rope_const_iterator<_CharT2,_Alloc2>& __y); template - friend bool operator< + friend bool operator< (const _Rope_const_iterator<_CharT2,_Alloc2>& __x, const _Rope_const_iterator<_CharT2,_Alloc2>& __y); template @@ -1105,7 +1105,7 @@ class _Rope_iterator : public _Rope_iterator_base<_CharT,_Alloc> { // nonGC case. _Rope_iterator(rope<_CharT,_Alloc>* __r, size_t __pos) : _Rope_iterator_base<_CharT,_Alloc>(__r->_M_tree_ptr, __pos), - _M_root_rope(__r) + _M_root_rope(__r) { _RopeRep::_S_ref(this->_M_root); if (!(__r -> empty()))_S_setcache(*this); } @@ -1235,7 +1235,7 @@ public: : _M_tree_ptr(__t), _M_data_allocator(__a) {} _Rope_alloc_base(const allocator_type& __a) : _M_data_allocator(__a) {} - + protected: // The only data members of a rope: allocator_type _M_data_allocator; @@ -1253,7 +1253,7 @@ protected: }; // Specialization for allocators that have the property that we don't -// actually have to store an allocator object. +// actually have to store an allocator object. template class _Rope_alloc_base<_CharT,_Allocator,true> { public: @@ -1264,7 +1264,7 @@ public: _Rope_alloc_base(_RopeRep *__t, const allocator_type&) : _M_tree_ptr(__t) {} _Rope_alloc_base(const allocator_type&) {} - + protected: // The only data member of a rope: _RopeRep *_M_tree_ptr; @@ -1283,7 +1283,7 @@ protected: }; template -struct _Rope_base +struct _Rope_base : public _Rope_alloc_base<_CharT,_Alloc, _Alloc_traits<_CharT,_Alloc>::_S_instanceless> { @@ -1295,7 +1295,7 @@ struct _Rope_base // The one in _Base may not be visible due to template rules. _Rope_base(_RopeRep* __t, const allocator_type& __a) : _Base(__t, __a) {} _Rope_base(const allocator_type& __a) : _Base(__a) {} -}; +}; /** @@ -1429,7 +1429,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { return _S_rounded_up_size(__n); } } - + // Allocate and construct a RopeLeaf using the supplied allocator // Takes ownership of s instead of copying. static _RopeLeaf* _S_new_RopeLeaf(__GC_CONST _CharT *__s, @@ -1466,7 +1466,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { _RopeLeaf* _S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s, size_t __size, allocator_type __a) # define __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __size, __a) \ - _S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a) + _S_RopeLeaf_from_unowned_char_ptr(__s, __size, __a) { if (0 == __size) return 0; _CharT* __buf = __a.allocate(_S_rounded_up_size(__size)); @@ -1482,7 +1482,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { __throw_exception_again; } } - + // Concatenation of nonempty strings. // Always builds a concatenation node. @@ -1526,7 +1526,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { size_t __start, size_t __len, _CharT* __buffer); - static const unsigned long + static const unsigned long _S_min_len[_RopeRep::_S_max_rope_depth + 1]; static bool _S_is_balanced(_RopeRep* __r) @@ -1559,7 +1559,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { // Add all unbalanced subtrees to the forest of balanceed trees. // Used only by balance. static void _S_add_to_forest(_RopeRep*__r, _RopeRep** __forest); - + // Add __r to forest, assuming __r is already balanced. static void _S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest); @@ -1677,7 +1677,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { void pop_back() { _RopeRep* __old = this->_M_tree_ptr; - this->_M_tree_ptr = + this->_M_tree_ptr = _S_substring(this->_M_tree_ptr, 0, this->_M_tree_ptr->_M_size - 1); @@ -1736,7 +1736,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { // rest of the interface. // Note that this guaranteed not to compile if the draft standard // order is assumed. - size_type copy(size_type __pos, size_type __n, _CharT* __buffer) const + size_type copy(size_type __pos, size_type __n, _CharT* __buffer) const { size_t __size = size(); size_t __len = (__pos + __n > __size? __size - __pos : __n); @@ -1765,8 +1765,8 @@ class rope : public _Rope_base<_CharT,_Alloc> { // is safe for multiple threads. void delete_c_str () { if (0 == this->_M_tree_ptr) return; - if (_RopeRep::_S_leaf == this->_M_tree_ptr->_M_tag && - ((_RopeLeaf*)this->_M_tree_ptr)->_M_data == + if (_RopeRep::_S_leaf == this->_M_tree_ptr->_M_tag && + ((_RopeLeaf*)this->_M_tree_ptr)->_M_data == this->_M_tree_ptr->_M_c_string) { // Representation shared return; @@ -1803,7 +1803,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { return(const_iterator(this->_M_tree_ptr, size())); } - size_type size() const { + size_type size() const { return(0 == this->_M_tree_ptr? 0 : this->_M_tree_ptr->_M_size); } @@ -1840,12 +1840,12 @@ class rope : public _Rope_base<_CharT,_Alloc> { friend rope<_CharT2,_Alloc2> operator+ (const rope<_CharT2,_Alloc2>& __left, const rope<_CharT2,_Alloc2>& __right); - + template friend rope<_CharT2,_Alloc2> operator+ (const rope<_CharT2,_Alloc2>& __left, const _CharT2* __right); - + template friend rope<_CharT2,_Alloc2> operator+ (const rope<_CharT2,_Alloc2>& __left, _CharT2 __right); @@ -1856,7 +1856,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { // The first argument should be an input iterator or // forward iterator with value_type _CharT. rope& append(const _CharT* __iter, size_t __n) { - _RopeRep* __result = + _RopeRep* __result = _S_destr_concat_char_iter(this->_M_tree_ptr, __iter, __n); _S_unref(this->_M_tree_ptr); this->_M_tree_ptr = __result; @@ -1880,7 +1880,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { rope& append(const_iterator __s, const_iterator __e) { _Self_destruct_ptr __appendee(_S_substring( __s._M_root, __s._M_current_pos, __e._M_current_pos)); - _RopeRep* __result = + _RopeRep* __result = _S_concat(this->_M_tree_ptr, (_RopeRep*)__appendee); _S_unref(this->_M_tree_ptr); this->_M_tree_ptr = __result; @@ -1888,7 +1888,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { } rope& append(_CharT __c) { - _RopeRep* __result = + _RopeRep* __result = _S_destr_concat_char_iter(this->_M_tree_ptr, &__c, 1); _S_unref(this->_M_tree_ptr); this->_M_tree_ptr = __result; @@ -1938,7 +1938,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { public: void insert(size_t __p, const rope& __r) { - _RopeRep* __result = + _RopeRep* __result = replace(this->_M_tree_ptr, __p, __p, __r._M_tree_ptr); _S_unref(this->_M_tree_ptr); this->_M_tree_ptr = __result; @@ -1996,13 +1996,13 @@ class rope : public _Rope_base<_CharT,_Alloc> { // (position, length) versions of replace operations: void replace(size_t __p, size_t __n, const rope& __r) { - _RopeRep* __result = + _RopeRep* __result = replace(this->_M_tree_ptr, __p, __p + __n, __r._M_tree_ptr); _S_unref(this->_M_tree_ptr); this->_M_tree_ptr = __result; } - void replace(size_t __p, size_t __n, + void replace(size_t __p, size_t __n, const _CharT* __i, size_t __i_len) { rope __r(__i, __i_len); replace(__p, __n, __r); @@ -2018,7 +2018,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { replace(__p, __n, __r); } - void replace(size_t __p, size_t __n, + void replace(size_t __p, size_t __n, const _CharT* __i, const _CharT* __j) { rope __r(__i, __j); replace(__p, __n, __r); @@ -2080,20 +2080,20 @@ class rope : public _Rope_base<_CharT,_Alloc> { erase(__p, __p + 1); } - // Insert, iterator variants. + // Insert, iterator variants. iterator insert(const iterator& __p, const rope& __r) { insert(__p.index(), __r); return __p; } iterator insert(const iterator& __p, size_t __n, _CharT __c) { insert(__p.index(), __n, __c); return __p; } - iterator insert(const iterator& __p, _CharT __c) + iterator insert(const iterator& __p, _CharT __c) { insert(__p.index(), __c); return __p; } - iterator insert(const iterator& __p ) + iterator insert(const iterator& __p ) { insert(__p.index()); return __p; } - iterator insert(const iterator& __p, const _CharT* c_string) + iterator insert(const iterator& __p, const _CharT* c_string) { insert(__p.index(), c_string); return __p; } iterator insert(const iterator& __p, const _CharT* __i, size_t __n) { insert(__p.index(), __i, __n); return __p; } - iterator insert(const iterator& __p, const _CharT* __i, + iterator insert(const iterator& __p, const _CharT* __i, const _CharT* __j) { insert(__p.index(), __i, __j); return __p; } iterator insert(const iterator& __p, @@ -2136,7 +2136,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { { replace(__p.index(), __i, __n); } void replace(const iterator& __p, const _CharT* __i, const _CharT* __j) { replace(__p.index(), __i, __j); } - void replace(const iterator& __p, const_iterator __i, + void replace(const iterator& __p, const_iterator __i, const_iterator __j) { replace(__p.index(), __i, __j); } void replace(const iterator& __p, iterator __i, iterator __j) @@ -2167,13 +2167,13 @@ class rope : public _Rope_base<_CharT,_Alloc> { __start.index(), __end.index())); } - + rope substr(iterator __start) const { size_t __pos = __start.index(); return rope<_CharT,_Alloc>( _S_substring(this->_M_tree_ptr, __pos, __pos + 1)); } - + rope substr(const_iterator __start, const_iterator __end) const { // This might eventually take advantage of the cache in the // iterator. @@ -2244,7 +2244,7 @@ class rope : public _Rope_base<_CharT,_Alloc> { // Stuff below this line is dangerous because it's error prone. // I would really like to get rid of it. // copy function with funny arg ordering. - size_type copy(_CharT* __buffer, size_type __n, + size_type copy(_CharT* __buffer, size_type __n, size_type __pos = 0) const { return copy(__pos, __n, __buffer); } @@ -2264,11 +2264,11 @@ class rope : public _Rope_base<_CharT,_Alloc> { const_iterator begin() { return const_begin(); } const_reverse_iterator rend() { return const_rend(); } - + const_reverse_iterator rbegin() { return const_rbegin(); } # endif - + }; template @@ -2278,7 +2278,7 @@ const typename rope<_CharT, _Alloc>::size_type rope<_CharT, _Alloc>::npos = template inline bool operator== (const _Rope_const_iterator<_CharT,_Alloc>& __x, const _Rope_const_iterator<_CharT,_Alloc>& __y) { - return (__x._M_current_pos == __y._M_current_pos && + return (__x._M_current_pos == __y._M_current_pos && __x._M_root == __y._M_root); } @@ -2342,7 +2342,7 @@ operator+(ptrdiff_t __n, const _Rope_const_iterator<_CharT,_Alloc>& __x) { template inline bool operator== (const _Rope_iterator<_CharT,_Alloc>& __x, const _Rope_iterator<_CharT,_Alloc>& __y) { - return (__x._M_current_pos == __y._M_current_pos && + return (__x._M_current_pos == __y._M_current_pos && __x._M_root_rope == __y._M_root_rope); } @@ -2420,7 +2420,7 @@ operator+ (const rope<_CharT,_Alloc>& __left, template inline rope<_CharT,_Alloc>& -operator+= (rope<_CharT,_Alloc>& __left, +operator+= (rope<_CharT,_Alloc>& __left, const rope<_CharT,_Alloc>& __right) { __left.append(__right); @@ -2435,7 +2435,7 @@ operator+ (const rope<_CharT,_Alloc>& __left, size_t __rlen = rope<_CharT,_Alloc>::_S_char_ptr_len(__right); return rope<_CharT,_Alloc>( rope<_CharT,_Alloc>::_S_concat_char_iter( - __left._M_tree_ptr, __right, __rlen)); + __left._M_tree_ptr, __right, __rlen)); } template @@ -2466,14 +2466,14 @@ operator+= (rope<_CharT,_Alloc>& __left, _CharT __right) { template bool -operator< (const rope<_CharT,_Alloc>& __left, +operator< (const rope<_CharT,_Alloc>& __left, const rope<_CharT,_Alloc>& __right) { return __left.compare(__right) < 0; } - + template bool -operator== (const rope<_CharT,_Alloc>& __left, +operator== (const rope<_CharT,_Alloc>& __left, const rope<_CharT,_Alloc>& __right) { return __left.compare(__right) == 0; } diff --git a/libstdc++-v3/include/ext/ropeimpl.h b/libstdc++-v3/include/ext/ropeimpl.h index 6129084..b8357ee 100644 --- a/libstdc++-v3/include/ext/ropeimpl.h +++ b/libstdc++-v3/include/ext/ropeimpl.h @@ -45,7 +45,7 @@ * You should not attempt to use it directly. */ -#include +#include #include #include @@ -57,7 +57,7 @@ namespace __gnu_cxx { using std::size_t; using std::printf; - using std::basic_ostream; + using std::basic_ostream; using std::__throw_length_error; using std::__alloc; using std::_Destroy; @@ -68,7 +68,7 @@ namespace __gnu_cxx // Results in a valid buf_ptr if the iterator can be legitimately // dereferenced. template -void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf( +void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf( _Rope_iterator_base<_CharT,_Alloc>& __x) { const _RopeRep* __leaf = __x._M_path_end[__x._M_leaf_index]; @@ -77,7 +77,7 @@ void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf( switch(__leaf->_M_tag) { case _RopeRep::_S_leaf: - __x._M_buf_start = + __x._M_buf_start = ((_Rope_RopeLeaf<_CharT,_Alloc>*)__leaf)->_M_data; __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos); __x._M_buf_end = __x._M_buf_start + __leaf->_M_size; @@ -111,7 +111,7 @@ void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf( } } -// Set path and buffer inside a rope iterator. We assume that +// Set path and buffer inside a rope iterator. We assume that // pos and root are already set. template void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache @@ -154,7 +154,7 @@ void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache (_Rope_RopeConcatenation<_CharT,_Alloc>*)__curr_rope; _RopeRep* __left = __c->_M_left; size_t __left_len = __left->_M_size; - + __dirns <<= 1; if (__pos >= __curr_start_pos + __left_len) { __dirns |= 1; @@ -203,7 +203,7 @@ void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache_for_incr } // node_start_pos is starting position of last_node. while (--__current_index >= 0) { - if (!(__dirns & 1) /* Path turned left */) + if (!(__dirns & 1) /* Path turned left */) break; __current_node = __x._M_path_end[__current_index]; __c = (_Rope_RopeConcatenation<_CharT,_Alloc>*)__current_node; @@ -288,23 +288,23 @@ void _Rope_iterator<_CharT,_Alloc>::_M_check() { } template -inline +inline _Rope_const_iterator<_CharT, _Alloc>::_Rope_const_iterator( const _Rope_iterator<_CharT,_Alloc>& __x) -: _Rope_iterator_base<_CharT,_Alloc>(__x) +: _Rope_iterator_base<_CharT,_Alloc>(__x) { } template inline _Rope_iterator<_CharT,_Alloc>::_Rope_iterator( rope<_CharT,_Alloc>& __r, size_t __pos) -: _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos), +: _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr, __pos), _M_root_rope(&__r) { _RopeRep::_S_ref(this->_M_root); } template -inline size_t +inline size_t rope<_CharT,_Alloc>::_S_char_ptr_len(const _CharT* __s) { const _CharT* __p = __s; @@ -409,7 +409,7 @@ rope<_CharT,_Alloc>::_S_leaf_concat_char_iter _CharT* __new_data = (_CharT*) _Data_allocate(_S_rounded_up_size(__old_len + __len)); _RopeLeaf* __result; - + uninitialized_copy_n(__r->_M_data, __old_len, __new_data); uninitialized_copy_n(__iter, __len, __new_data + __old_len); _S_cond_store_eos(__new_data[__old_len + __len]); @@ -463,22 +463,22 @@ template typename rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right) { - _RopeConcatenation* __result = _S_new_RopeConcatenation(__left, __right, + _RopeConcatenation* __result = _S_new_RopeConcatenation(__left, __right, __left->get_allocator()); size_t __depth = __result->_M_depth; - + if (__depth > 20 && (__result->_M_size < 1000 || - __depth > _RopeRep::_S_max_rope_depth)) + __depth > _RopeRep::_S_max_rope_depth)) { _RopeRep* __balanced; - - try + + try { __balanced = _S_balance(__result); __result->_M_unref_nonnil(); } catch(...) - { + { _C_deallocate(__result,1); __throw_exception_again; } @@ -487,8 +487,8 @@ rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right) // still owns its children. Thus unref is // inappropriate. return __balanced; - } - else + } + else return __result; } @@ -505,18 +505,18 @@ rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter if (0 == __r) return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator()); - if (_RopeRep::_S_leaf == __r->_M_tag && + if (_RopeRep::_S_leaf == __r->_M_tag && __r->_M_size + __slen <= _S_copy_max) { __result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen); return __result; } if (_RopeRep::_S_concat == __r->_M_tag && _RopeRep::_S_leaf == ((_RopeConcatenation*)__r)->_M_right->_M_tag) { - _RopeLeaf* __right = + _RopeLeaf* __right = (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right); if (__right->_M_size + __slen <= _S_copy_max) { _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left; - _RopeRep* __nright = + _RopeRep* __nright = _S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen); __left->_M_ref_nonnil(); try { @@ -524,7 +524,7 @@ rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter } catch(...) { - _S_unref(__left); + _S_unref(__left); _S_unref(__nright); __throw_exception_again; } @@ -539,7 +539,7 @@ rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter } catch(...) { - _S_unref(__r); + _S_unref(__r); _S_unref(__nright); __throw_exception_again; } @@ -548,7 +548,7 @@ rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_concat_char_iter #ifndef __GC template -typename rope<_CharT,_Alloc>::_RopeRep* +typename rope<_CharT,_Alloc>::_RopeRep* rope<_CharT,_Alloc>::_S_destr_concat_char_iter( _RopeRep* __r, const _CharT* __s, size_t __slen) { @@ -563,7 +563,7 @@ rope<_CharT,_Alloc>::_S_destr_concat_char_iter( __r->_M_ref_count = 2; // One more than before return __r; } - if (__orig_size + __slen <= _S_copy_max && + if (__orig_size + __slen <= _S_copy_max && _RopeRep::_S_leaf == __r->_M_tag) { __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen); return __result; @@ -572,11 +572,11 @@ rope<_CharT,_Alloc>::_S_destr_concat_char_iter( _RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*)__r)->_M_right); if (_RopeRep::_S_leaf == __right->_M_tag && __right->_M_size + __slen <= _S_copy_max) { - _RopeRep* __new_right = + _RopeRep* __new_right = _S_destr_leaf_concat_char_iter(__right, __s, __slen); - if (__right == __new_right) + if (__right == __new_right) __new_right->_M_ref_count = 1; - else + else __right->_M_unref_nonnil(); __r->_M_ref_count = 2; // One more than before. ((_RopeConcatenation*)__r)->_M_right = __new_right; @@ -596,7 +596,7 @@ rope<_CharT,_Alloc>::_S_destr_concat_char_iter( } catch(...) { - _S_unref(__r); + _S_unref(__r); _S_unref(__right); __throw_exception_again; } @@ -627,7 +627,7 @@ rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right) && _RopeRep::_S_leaf == ((_RopeConcatenation*)__left)->_M_right->_M_tag) { _RopeLeaf* __leftright = - (_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right); + (_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right); if (__leftright->_M_size + __right->_M_size <= _S_copy_max) { _RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left; _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright, @@ -639,7 +639,7 @@ rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right) } catch(...) { - _S_unref(__leftleft); + _S_unref(__leftleft); _S_unref(__rest); __throw_exception_again; } @@ -653,7 +653,7 @@ rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right) } catch(...) { - _S_unref(__left); + _S_unref(__left); _S_unref(__right); __throw_exception_again; } @@ -661,14 +661,14 @@ rope<_CharT,_Alloc>::_S_concat(_RopeRep* __left, _RopeRep* __right) template typename rope<_CharT,_Alloc>::_RopeRep* -rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base, +rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base, size_t __start, size_t __endp1) { if (0 == __base) return 0; size_t __len = __base->_M_size; size_t __adj_endp1; const size_t __lazy_threshold = 128; - + if (__endp1 >= __len) { if (0 == __start) { __base->_M_ref_nonnil(); @@ -788,14 +788,14 @@ class _Rope_flatten_char_consumer : public _Rope_char_consumer<_CharT> { return true; } }; - + template class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> { private: _CharT _M_pattern; public: size_t _M_count; // Number of nonmatching characters - _Rope_find_char_char_consumer(_CharT __p) + _Rope_find_char_char_consumer(_CharT __p) : _M_pattern(__p), _M_count(0) {} ~_Rope_find_char_char_consumer() {} bool operator() (const _CharT* __leaf, size_t __n) { @@ -808,7 +808,7 @@ class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> { _M_count += __n; return true; } }; - + template // Here _CharT is both the stream and rope character type. class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> { @@ -816,14 +816,14 @@ class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> { typedef basic_ostream<_CharT,_Traits> _Insert_ostream; _Insert_ostream& _M_o; public: - _Rope_insert_char_consumer(_Insert_ostream& __writer) + _Rope_insert_char_consumer(_Insert_ostream& __writer) : _M_o(__writer) {}; ~_Rope_insert_char_consumer() { }; // Caller is presumed to own the ostream bool operator() (const _CharT* __leaf, size_t __n); // Returns true to continue traversal. }; - + template bool _Rope_insert_char_consumer<_CharT, _Traits>::operator() (const _CharT* __leaf, size_t __n) @@ -901,7 +901,7 @@ bool rope<_CharT, _Alloc>::_S_apply_to_pieces( for (__i = 0; __i < __n; __i++) __o.put(__f); } - + template inline bool _Rope_is_simple(_CharT*) { return false; } inline bool _Rope_is_simple(char*) { return true; } @@ -917,7 +917,7 @@ basic_ostream<_CharT, _Traits>& operator<< (basic_ostream<_CharT, _Traits>& __o, size_t __rope_len = __r.size(); _Rope_insert_char_consumer<_CharT, _Traits> __c(__o); bool __is_simple = _Rope_is_simple((_CharT*)0); - + if (__rope_len < __w) { __pad_len = __w - __rope_len; } else { @@ -937,7 +937,7 @@ basic_ostream<_CharT, _Traits>& operator<< (basic_ostream<_CharT, _Traits>& __o, } catch(...) { - if (!__is_simple) + if (!__is_simple) __o.width(__w); __throw_exception_again; } @@ -1058,8 +1058,8 @@ rope<_CharT,_Alloc>::_S_dump(_RopeRep* __r, int __indent) bool __too_big = __r->_M_size > __prefix->_M_size; _S_flatten(__prefix, __buffer); - __buffer[__prefix->_M_size] = _S_eos((_CharT*)0); - printf("%s%s\n", + __buffer[__prefix->_M_size] = _S_eos((_CharT*)0); + printf("%s%s\n", (char*)__buffer, __too_big? "...\n" : "\n"); } else { printf("\n"); @@ -1097,11 +1097,11 @@ rope<_CharT,_Alloc>::_S_balance(_RopeRep* __r) // __forest[__i]._M_depth = __i // References from forest are included in refcount. - for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) + for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) __forest[__i] = 0; try { _S_add_to_forest(__r, __forest); - for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) + for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i) if (0 != __forest[__i]) { # ifndef __GC _Self_destruct_ptr __old(__result); @@ -1148,9 +1148,9 @@ template void rope<_CharT,_Alloc>::_S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest) { - _RopeRep* __insertee; // included in refcount - _RopeRep* __too_tiny = 0; // included in refcount - int __i; // forest[0..__i-1] is empty + _RopeRep* __insertee; // included in refcount + _RopeRep* __too_tiny = 0; // included in refcount + int __i; // forest[0..__i-1] is empty size_t __s = __r->_M_size; for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i) { @@ -1180,7 +1180,7 @@ rope<_CharT,_Alloc>::_S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest) __forest[__i]->_M_unref_nonnil(); __forest[__i] = 0; } - if (__i == _RopeRep::_S_max_rope_depth || + if (__i == _RopeRep::_S_max_rope_depth || __insertee->_M_size < _S_min_len[__i+1]) { __forest[__i] = __insertee; // refcount is OK since __insertee is now dead. @@ -1195,7 +1195,7 @@ rope<_CharT,_Alloc>::_S_fetch(_RopeRep* __r, size_type __i) { __GC_CONST _CharT* __cstr = __r->_M_c_string; - if (0 != __cstr) return __cstr[__i]; + if (0 != __cstr) return __cstr[__i]; for(;;) { switch(__r->_M_tag) { case _RopeRep::_S_concat: @@ -1285,7 +1285,7 @@ rope<_CharT,_Alloc>::_S_fetch_ptr(_RopeRep* __r, size_type __i) // flat strings. template int -rope<_CharT,_Alloc>::_S_compare (const _RopeRep* __left, +rope<_CharT,_Alloc>::_S_compare (const _RopeRep* __left, const _RopeRep* __right) { size_t __left_len; @@ -1387,7 +1387,7 @@ rope<_CharT, _Alloc>::rope(size_t __n, _CharT __c, if (0 == __n) return; - + __exponent = __n / __exponentiate_threshold; __rest = __n % __exponentiate_threshold; if (0 == __rest) { @@ -1419,12 +1419,12 @@ rope<_CharT, _Alloc>::rope(size_t __n, _CharT __c, } catch(...) { - _RopeRep::__STL_FREE_STRING(__base_buffer, + _RopeRep::__STL_FREE_STRING(__base_buffer, __exponentiate_threshold, __a); __throw_exception_again; } __base_rope._M_tree_ptr = __base_leaf; - if (1 == __exponent) { + if (1 == __exponent) { __result = __base_rope; } else { __result = power(__base_rope, __exponent, @@ -1494,14 +1494,14 @@ _Rope_rotate(_Rope_iterator __first, { typedef typename _Rope_iterator::value_type _CharT; typedef typename _Rope_iterator::_allocator_type _Alloc; - + rope<_CharT,_Alloc>& __r(__first.container()); rope<_CharT,_Alloc> __prefix = __r.substr(0, __first.index()); - rope<_CharT,_Alloc> __suffix = + rope<_CharT,_Alloc> __suffix = __r.substr(__last.index(), __r.size() - __last.index()); - rope<_CharT,_Alloc> __part1 = + rope<_CharT,_Alloc> __part1 = __r.substr(__middle.index(), __last.index() - __middle.index()); - rope<_CharT,_Alloc> __part2 = + rope<_CharT,_Alloc> __part2 = __r.substr(__first.index(), __middle.index() - __first.index()); __r = __prefix; __r += __part1; diff --git a/libstdc++-v3/include/ext/slist b/libstdc++-v3/include/ext/slist index 9bcfb71..5a6e250 100644 --- a/libstdc++-v3/include/ext/slist +++ b/libstdc++-v3/include/ext/slist @@ -57,7 +57,7 @@ #include namespace __gnu_cxx -{ +{ using std::size_t; using std::ptrdiff_t; using std::_Alloc_traits; @@ -79,7 +79,7 @@ __slist_make_link(_Slist_node_base* __prev_node, return __new_node; } -inline _Slist_node_base* +inline _Slist_node_base* __slist_previous(_Slist_node_base* __head, const _Slist_node_base* __node) { @@ -88,7 +88,7 @@ __slist_previous(_Slist_node_base* __head, return __head; } -inline const _Slist_node_base* +inline const _Slist_node_base* __slist_previous(const _Slist_node_base* __head, const _Slist_node_base* __node) { @@ -206,7 +206,7 @@ struct _Slist_iterator : public _Slist_iterator_base // an ordinary standard-conforming allocator, a standard-conforming // allocator with no non-static data, and an SGI-style allocator. // This complexity is necessary only because we're worrying about backward -// compatibility and because we want to avoid wasting storage on an +// compatibility and because we want to avoid wasting storage on an // allocator instance if it isn't necessary. // Base for general standard-conforming allocators. @@ -220,9 +220,9 @@ public: _Slist_alloc_base(const allocator_type& __a) : _M_node_allocator(__a) {} protected: - _Slist_node<_Tp>* _M_get_node() + _Slist_node<_Tp>* _M_get_node() { return _M_node_allocator.allocate(1); } - void _M_put_node(_Slist_node<_Tp>* __p) + void _M_put_node(_Slist_node<_Tp>* __p) { _M_node_allocator.deallocate(__p, 1); } protected: @@ -280,7 +280,7 @@ protected: _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*); }; -template +template _Slist_node_base* _Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first, _Slist_node_base* __last_node) { @@ -341,7 +341,7 @@ private: } return __node; } - + _Node* _M_create_node() { _Node* __node = this->_M_get_node(); try { @@ -408,7 +408,7 @@ public: public: iterator begin() { return iterator((_Node*)this->_M_head._M_next); } - const_iterator begin() const + const_iterator begin() const { return const_iterator((_Node*)this->_M_head._M_next);} iterator end() { return iterator(0); } @@ -417,8 +417,8 @@ public: // Experimental new feature: before_begin() returns a // non-dereferenceable iterator that, when incremented, yields // begin(). This iterator may be used as the argument to - // insert_after, erase_after, etc. Note that even for an empty - // slist, before_begin() is not the same iterator as end(). It + // insert_after, erase_after, etc. Note that even for an empty + // slist, before_begin() is not the same iterator as end(). It // is always necessary to increment before_begin() at least once to // obtain end(). iterator before_begin() { return iterator((_Node*) &this->_M_head); } @@ -426,7 +426,7 @@ public: { return const_iterator((_Node*) &this->_M_head); } size_type size() const { return __slist_size(this->_M_head._M_next); } - + size_type max_size() const { return size_type(-1); } bool empty() const { return this->_M_head._M_next == 0; } @@ -437,7 +437,7 @@ public: public: reference front() { return ((_Node*) this->_M_head._M_next)->_M_data; } - const_reference front() const + const_reference front() const { return ((_Node*) this->_M_head._M_next)->_M_data; } void push_front(const value_type& __x) { __slist_make_link(&this->_M_head, _M_create_node(__x)); @@ -475,7 +475,7 @@ private: // Check whether it's an integral type. If so, it's not an iterator. template - void _M_insert_after_range(_Node_base* __pos, + void _M_insert_after_range(_Node_base* __pos, _InIterator __first, _InIterator __last) { typedef typename _Is_integer<_InIterator>::_Integral _Integral; _M_insert_after_range(__pos, __first, __last, _Integral()); @@ -533,13 +533,13 @@ public: void insert(iterator __pos, size_type __n, const value_type& __x) { _M_insert_after_fill(__slist_previous(&this->_M_head, __pos._M_node), __n, __x); - } - + } + // We don't need any dispatching tricks here, because _M_insert_after_range // already does them. template void insert(iterator __pos, _InIterator __first, _InIterator __last) { - _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node), + _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node), __first, __last); } @@ -548,12 +548,12 @@ public: return iterator((_Node*) this->_M_erase_after(__pos._M_node)); } iterator erase_after(iterator __before_first, iterator __last) { - return iterator((_Node*) this->_M_erase_after(__before_first._M_node, + return iterator((_Node*) this->_M_erase_after(__before_first._M_node, __last._M_node)); - } + } iterator erase(iterator __pos) { - return (_Node*) this->_M_erase_after(__slist_previous(&this->_M_head, + return (_Node*) this->_M_erase_after(__slist_previous(&this->_M_head, __pos._M_node)); } iterator erase(iterator __first, iterator __last) { @@ -568,11 +568,11 @@ public: public: // Moves the range [__before_first + 1, __before_last + 1) to *this, // inserting it immediately after __pos. This is constant time. - void splice_after(iterator __pos, + void splice_after(iterator __pos, iterator __before_first, iterator __before_last) { - if (__before_first != __before_last) - __slist_splice_after(__pos._M_node, __before_first._M_node, + if (__before_first != __before_last) + __slist_splice_after(__pos._M_node, __before_first._M_node, __before_last._M_node); } @@ -618,27 +618,27 @@ public: } public: - void reverse() { + void reverse() { if (this->_M_head._M_next) this->_M_head._M_next = __slist_reverse(this->_M_head._M_next); } - void remove(const _Tp& __val); - void unique(); + void remove(const _Tp& __val); + void unique(); void merge(slist& __x); - void sort(); + void sort(); - template + template void remove_if(_Predicate __pred); - template - void unique(_BinaryPredicate __pred); + template + void unique(_BinaryPredicate __pred); - template + template void merge(slist&, _StrictWeakOrdering); - template - void sort(_StrictWeakOrdering __comp); + template + void sort(_StrictWeakOrdering __comp); }; template @@ -657,7 +657,7 @@ slist<_Tp,_Alloc>& slist<_Tp,_Alloc>::operator=(const slist<_Tp,_Alloc>& __x) if (__n2 == 0) this->_M_erase_after(__p1, 0); else - _M_insert_after_range(__p1, const_iterator((_Node*)__n2), + _M_insert_after_range(__p1, const_iterator((_Node*)__n2), const_iterator(0)); } return *this; @@ -698,7 +698,7 @@ slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first, _InputIterator __ } template -inline bool +inline bool operator==(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator; @@ -719,30 +719,30 @@ template inline bool operator<(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { - return std::lexicographical_compare(_SL1.begin(), _SL1.end(), + return std::lexicographical_compare(_SL1.begin(), _SL1.end(), _SL2.begin(), _SL2.end()); } template -inline bool +inline bool operator!=(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { return !(_SL1 == _SL2); } template -inline bool +inline bool operator>(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { return _SL2 < _SL1; } template -inline bool +inline bool operator<=(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { return !(_SL2 < _SL1); } template -inline bool +inline bool operator>=(const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) { return !(_SL1 < _SL2); } @@ -761,7 +761,7 @@ void slist<_Tp,_Alloc>::resize(size_type __len, const _Tp& __x) --__len; __cur = __cur->_M_next; } - if (__cur->_M_next) + if (__cur->_M_next) this->_M_erase_after(__cur, 0); else _M_insert_after_fill(__cur, __len, __x); @@ -779,13 +779,13 @@ void slist<_Tp,_Alloc>::remove(const _Tp& __val) } } -template +template void slist<_Tp,_Alloc>::unique() { _Node_base* __cur = this->_M_head._M_next; if (__cur) { while (__cur->_M_next) { - if (((_Node*)__cur)->_M_data == + if (((_Node*)__cur)->_M_data == ((_Node*)(__cur->_M_next))->_M_data) this->_M_erase_after(__cur); else @@ -799,8 +799,8 @@ void slist<_Tp,_Alloc>::merge(slist<_Tp,_Alloc>& __x) { _Node_base* __n1 = &this->_M_head; while (__n1->_M_next && __x._M_head._M_next) { - if (((_Node*) __x._M_head._M_next)->_M_data < - ((_Node*) __n1->_M_next)->_M_data) + if (((_Node*) __x._M_head._M_next)->_M_data < + ((_Node*) __n1->_M_next)->_M_data) __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next); __n1 = __n1->_M_next; } @@ -837,7 +837,7 @@ void slist<_Tp,_Alloc>::sort() } } -template +template template void slist<_Tp,_Alloc>::remove_if(_Predicate __pred) { @@ -850,13 +850,13 @@ void slist<_Tp,_Alloc>::remove_if(_Predicate __pred) } } -template template +template template void slist<_Tp,_Alloc>::unique(_BinaryPredicate __pred) { _Node* __cur = (_Node*) this->_M_head._M_next; if (__cur) { while (__cur->_M_next) { - if (__pred(((_Node*)__cur)->_M_data, + if (__pred(((_Node*)__cur)->_M_data, ((_Node*)(__cur->_M_next))->_M_data)) this->_M_erase_after(__cur); else @@ -882,7 +882,7 @@ void slist<_Tp,_Alloc>::merge(slist<_Tp,_Alloc>& __x, } } -template template +template template void slist<_Tp,_Alloc>::sort(_StrictWeakOrdering __comp) { if (this->_M_head._M_next && this->_M_head._M_next->_M_next) { @@ -930,7 +930,7 @@ public: typedef void pointer; typedef void reference; - insert_iterator(_Container& __x, typename _Container::iterator __i) + insert_iterator(_Container& __x, typename _Container::iterator __i) : container(&__x) { if (__i == __x.begin()) iter = __x.before_begin(); @@ -939,7 +939,7 @@ public: } insert_iterator<_Container>& - operator=(const typename _Container::value_type& __value) { + operator=(const typename _Container::value_type& __value) { iter = container->insert_after(iter, __value); return *this; } @@ -950,4 +950,4 @@ public: } // namespace std -#endif +#endif diff --git a/libstdc++-v3/include/ext/stdio_filebuf.h b/libstdc++-v3/include/ext/stdio_filebuf.h index 142af37..19649296 100644 --- a/libstdc++-v3/include/ext/stdio_filebuf.h +++ b/libstdc++-v3/include/ext/stdio_filebuf.h @@ -54,13 +54,13 @@ namespace __gnu_cxx { public: // Types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; typedef std::size_t size_t; - + public: /** * @param fd An open file descriptor. @@ -70,20 +70,20 @@ namespace __gnu_cxx * This constructor associates a file stream buffer with an open * POSIX file descriptor. */ - stdio_filebuf(int __fd, std::ios_base::openmode __mode, + stdio_filebuf(int __fd, std::ios_base::openmode __mode, size_t __size = static_cast(BUFSIZ)); /** * @param f An open @c FILE*. * @param mode Same meaning as in a standard filebuf. * @param size Optimal or preferred size of internal buffer, in chars. - * Defaults to system's @c BUFSIZ. + * Defaults to system's @c BUFSIZ. * * This constructor associates a file stream buffer with an open * C @c FILE*. The @c FILE* will not be automatically closed when the * stdio_filebuf is closed/destroyed. */ - stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, + stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, size_t __size = static_cast(BUFSIZ)); /** @@ -128,7 +128,7 @@ namespace __gnu_cxx template stdio_filebuf<_CharT, _Traits>:: - stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, + stdio_filebuf(std::__c_file* __f, std::ios_base::openmode __mode, size_t __size) { this->_M_file.sys_open(__f, __mode); @@ -144,4 +144,4 @@ namespace __gnu_cxx } } // namespace __gnu_cxx -#endif +#endif diff --git a/libstdc++-v3/include/ext/stdio_sync_filebuf.h b/libstdc++-v3/include/ext/stdio_sync_filebuf.h index e610912..2076ca5 100644 --- a/libstdc++-v3/include/ext/stdio_sync_filebuf.h +++ b/libstdc++-v3/include/ext/stdio_sync_filebuf.h @@ -61,22 +61,22 @@ namespace __gnu_cxx { public: // Types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; private: // Underlying stdio FILE std::__c_file* const _M_file; - + // Last character gotten. This is used when pbackfail is // called from basic_streambuf::sungetc() int_type _M_unget_buf; public: - explicit + explicit stdio_sync_filebuf(std::__c_file* __f) : _M_file(__f), _M_unget_buf(traits_type::eof()) { } @@ -131,10 +131,10 @@ namespace __gnu_cxx virtual std::streamsize xsgetn(char_type* __s, std::streamsize __n); - + virtual std::streamsize showmanyc() - { + { #if defined(_GLIBCXX_HAVE_S_ISREG) || defined(_GLIBCXX_HAVE_S_IFREG) // Regular files. struct stat __buffer; @@ -142,7 +142,7 @@ namespace __gnu_cxx if (!__ret && _GLIBCXX_ISREG(__buffer.st_mode)) return __buffer.st_size - ftell(_M_file); #endif - return 0; + return 0; } virtual int_type @@ -183,7 +183,7 @@ namespace __gnu_cxx #ifdef _GLIBCXX_USE_LFS if (!fseeko64(_M_file, __off, __whence)) __ret = std::streampos(ftello64(_M_file)); -#else +#else if (!fseek(_M_file, __off, __whence)) __ret = std::streampos(std::ftell(_M_file)); #endif @@ -248,7 +248,7 @@ namespace __gnu_cxx template<> inline std::streamsize stdio_sync_filebuf::xsgetn(wchar_t* __s, std::streamsize __n) - { + { std::streamsize __ret = 0; const int_type __eof = traits_type::eof(); while (__n--) @@ -266,10 +266,10 @@ namespace __gnu_cxx _M_unget_buf = traits_type::eof(); return __ret; } - + template<> inline std::streamsize - stdio_sync_filebuf::xsputn(const wchar_t* __s, + stdio_sync_filebuf::xsputn(const wchar_t* __s, std::streamsize __n) { std::streamsize __ret = 0; @@ -292,4 +292,4 @@ namespace __gnu_cxx #endif } // namespace __gnu_cxx -#endif +#endif -- cgit v1.1