diff options
Diffstat (limited to 'libstdc++-v3/include')
242 files changed, 9360 insertions, 3284 deletions
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 1ced7813c1c..6c0230ad292 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -121,6 +121,15 @@ bits_headers = \ ${bits_srcdir}/postypes.h \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ + ${bits_srcdir}/regex.h \ + ${bits_srcdir}/regex_compiler.h \ + ${bits_srcdir}/regex_constants.h \ + ${bits_srcdir}/regex_cursor.h \ + ${bits_srcdir}/regex_error.h \ + ${bits_srcdir}/regex_grep_matcher.h \ + ${bits_srcdir}/regex_grep_matcher.tcc \ + ${bits_srcdir}/regex_nfa.h \ + ${bits_srcdir}/regex_nfa.tcc \ ${bits_srcdir}/stream_iterator.h \ ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/shared_ptr.h \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index fd45a43e9da..631561c585e 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -361,6 +361,15 @@ bits_headers = \ ${bits_srcdir}/postypes.h \ ${bits_srcdir}/random.h \ ${bits_srcdir}/random.tcc \ + ${bits_srcdir}/regex.h \ + ${bits_srcdir}/regex_compiler.h \ + ${bits_srcdir}/regex_constants.h \ + ${bits_srcdir}/regex_cursor.h \ + ${bits_srcdir}/regex_error.h \ + ${bits_srcdir}/regex_grep_matcher.h \ + ${bits_srcdir}/regex_grep_matcher.tcc \ + ${bits_srcdir}/regex_nfa.h \ + ${bits_srcdir}/regex_nfa.tcc \ ${bits_srcdir}/stream_iterator.h \ ${bits_srcdir}/streambuf_iterator.h \ ${bits_srcdir}/shared_ptr.h \ diff --git a/libstdc++-v3/include/backward/hash_fun.h b/libstdc++-v3/include/backward/hash_fun.h index b7b14a1e418..66e31d844cd 100644 --- a/libstdc++-v3/include/backward/hash_fun.h +++ b/libstdc++-v3/include/backward/hash_fun.h @@ -57,7 +57,7 @@ #ifndef _BACKWARD_HASH_FUN_H #define _BACKWARD_HASH_FUN_H 1 -#include <cstddef> +#include <bits/c++config.h> _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc index d450a4717de..ab71ad67e17 100644 --- a/libstdc++-v3/include/bits/basic_string.tcc +++ b/libstdc++-v3/include/bits/basic_string.tcc @@ -1,7 +1,7 @@ // Components for manipulating sequences of characters -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2008, 2009 +// 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -130,7 +130,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) #endif // NB: Not required, but considered best practice. if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) - __throw_logic_error(__N("basic_string::_S_construct NULL not valid")); + __throw_logic_error(__N("basic_string::_S_construct null not valid")); const size_type __dnew = static_cast<size_type>(std::distance(__beg, __end)); diff --git a/libstdc++-v3/include/bits/boost_concept_check.h b/libstdc++-v3/include/bits/boost_concept_check.h index 054fcf27e5e..cffd7fb2d05 100644 --- a/libstdc++-v3/include/bits/boost_concept_check.h +++ b/libstdc++-v3/include/bits/boost_concept_check.h @@ -1,6 +1,7 @@ // -*- C++ -*- -// Copyright (C) 2004, 2005, 2006, 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -41,7 +42,7 @@ #pragma GCC system_header -#include <cstddef> // for ptrdiff_t, used next +#include <bits/c++config.h> #include <bits/stl_iterator_base_types.h> // for traits and tags _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index 3746696458a..9dc9ac24cd8 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -1,7 +1,7 @@ // Predefined symbols and macros -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -376,4 +376,19 @@ _GLIBCXX_END_NAMESPACE # endif #endif +#ifdef __cplusplus + +_GLIBCXX_BEGIN_NAMESPACE(std) + + typedef __SIZE_TYPE__ size_t; + typedef __PTRDIFF_TYPE__ ptrdiff_t; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + typedef decltype(nullptr) nullptr_t; +#endif + +_GLIBCXX_END_NAMESPACE + +#endif // __cplusplus + // End of prewritten config; the discovered settings follow. diff --git a/libstdc++-v3/include/bits/deque.tcc b/libstdc++-v3/include/bits/deque.tcc index cde067cf382..d8c27870647 100644 --- a/libstdc++-v3/include/bits/deque.tcc +++ b/libstdc++-v3/include/bits/deque.tcc @@ -1,6 +1,7 @@ // Deque implementation (out of line) -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, +// 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -59,6 +60,33 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template <typename _Tp, typename _Alloc> + void + deque<_Tp, _Alloc>:: + _M_default_initialize() + { + _Map_pointer __cur; + __try + { + for (__cur = this->_M_impl._M_start._M_node; + __cur < this->_M_impl._M_finish._M_node; + ++__cur) + std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(), + _M_get_Tp_allocator()); + std::__uninitialized_default_a(this->_M_impl._M_finish._M_first, + this->_M_impl._M_finish._M_cur, + _M_get_Tp_allocator()); + } + __catch(...) + { + std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), + _M_get_Tp_allocator()); + __throw_exception_again; + } + } +#endif + template <typename _Tp, typename _Alloc> deque<_Tp, _Alloc>& deque<_Tp, _Alloc>:: @@ -271,6 +299,32 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) _M_insert_aux(__pos, __n, __x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template <typename _Tp, typename _Alloc> + void + deque<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + __try + { + std::__uninitialized_default_a(this->_M_impl._M_finish, + __new_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + } +#endif + template <typename _Tp, typename _Alloc> void deque<_Tp, _Alloc>:: diff --git a/libstdc++-v3/include/bits/forward_list.h b/libstdc++-v3/include/bits/forward_list.h index c0c135cd1b3..3708a62c37d 100644 --- a/libstdc++-v3/include/bits/forward_list.h +++ b/libstdc++-v3/include/bits/forward_list.h @@ -463,7 +463,9 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * constructed elements. */ explicit - forward_list(size_type __n); + forward_list(size_type __n) + : _Base() + { _M_default_initialize(__n); } /** * @brief Creates a %forward_list with copies of an exemplar element. @@ -1209,6 +1211,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Called by splice_after and insert_after. iterator _M_splice_after(const_iterator __pos, forward_list&& __list); + + // Called by forward_list(n). + void + _M_default_initialize(size_type __n); + + // Called by resize(sz). + void + _M_default_insert_after(const_iterator __pos, size_type __n); }; /** diff --git a/libstdc++-v3/include/bits/forward_list.tcc b/libstdc++-v3/include/bits/forward_list.tcc index 7468a90d1af..a3719a8698d 100644 --- a/libstdc++-v3/include/bits/forward_list.tcc +++ b/libstdc++-v3/include/bits/forward_list.tcc @@ -114,7 +114,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _M_fill_initialize(size_type __n, const value_type& __value) { _Node_base* __to = &this->_M_impl._M_head; - for (; __n > 0; --__n) + for (; __n; --__n) { __to->_M_next = this->_M_create_node(__value); __to = __to->_M_next; @@ -122,12 +122,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } template<typename _Tp, typename _Alloc> + void forward_list<_Tp, _Alloc>:: - forward_list(size_type __n) - : _Base() + _M_default_initialize(size_type __n) { _Node_base* __to = &this->_M_impl._M_head; - for (; __n > 0; --__n) + for (; __n; --__n) { __to->_M_next = this->_M_create_node(); __to = __to->_M_next; @@ -164,6 +164,24 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template<typename _Tp, typename _Alloc> void forward_list<_Tp, _Alloc>:: + _M_default_insert_after(const_iterator __pos, size_type __n) + { + const_iterator __saved_pos = __pos; + __try + { + for (; __n; --__n) + __pos = emplace_after(__pos); + } + __catch(...) + { + erase_after(__saved_pos, ++__pos); + __throw_exception_again; + } + } + + template<typename _Tp, typename _Alloc> + void + forward_list<_Tp, _Alloc>:: resize(size_type __sz) { iterator __k = before_begin(); @@ -177,10 +195,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) if (__len == __sz) erase_after(__k, end()); else - { - forward_list __tmp(__sz - __len); - splice_after(__k, std::move(__tmp)); - } + _M_default_insert_after(__k, __sz - __len); } template<typename _Tp, typename _Alloc> diff --git a/libstdc++-v3/include/bits/fstream.tcc b/libstdc++-v3/include/bits/fstream.tcc index c5f7f8c52af..c498f48caee 100644 --- a/libstdc++-v3/include/bits/fstream.tcc +++ b/libstdc++-v3/include/bits/fstream.tcc @@ -64,21 +64,21 @@ _GLIBCXX_BEGIN_NAMESPACE(std) if (_M_buf_allocated) { delete [] _M_buf; - _M_buf = NULL; + _M_buf = 0; _M_buf_allocated = false; } delete [] _M_ext_buf; - _M_ext_buf = NULL; + _M_ext_buf = 0; _M_ext_buf_size = 0; - _M_ext_next = NULL; - _M_ext_end = NULL; + _M_ext_next = 0; + _M_ext_end = 0; } template<typename _CharT, typename _Traits> basic_filebuf<_CharT, _Traits>:: basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), - _M_state_last(), _M_buf(NULL), _M_buf_size(BUFSIZ), + _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ), _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), @@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) basic_filebuf<_CharT, _Traits>:: open(const char* __s, ios_base::openmode __mode) { - __filebuf_type *__ret = NULL; + __filebuf_type *__ret = 0; if (!this->is_open()) { _M_file.open(__s, __mode); @@ -128,7 +128,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) close() { if (!this->is_open()) - return NULL; + return 0; bool __testfail = false; { @@ -167,7 +167,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __testfail = true; if (__testfail) - return NULL; + return 0; else return this; } diff --git a/libstdc++-v3/include/bits/functional_hash.h b/libstdc++-v3/include/bits/functional_hash.h index aaa05aad689..a207ffa6bd0 100644 --- a/libstdc++-v3/include/bits/functional_hash.h +++ b/libstdc++-v3/include/bits/functional_hash.h @@ -32,7 +32,7 @@ #pragma GCC system_header -#include <cstddef> +#include <bits/c++config.h> #include <bits/stl_function.h> namespace std diff --git a/libstdc++-v3/include/bits/list.tcc b/libstdc++-v3/include/bits/list.tcc index f1c4a10dd66..3446c42a85b 100644 --- a/libstdc++-v3/include/bits/list.tcc +++ b/libstdc++-v3/include/bits/list.tcc @@ -112,6 +112,56 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) return __ret; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp, typename _Alloc> + void + list<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + size_type __i = 0; + __try + { + for (; __i < __n; ++__i) + emplace_back(); + } + __catch(...) + { + for (; __i; --__i) + pop_back(); + __throw_exception_again; + } + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp, _Alloc>:: + resize(size_type __new_size) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + _M_default_append(__new_size - __len); + } + + template<typename _Tp, typename _Alloc> + void + list<_Tp, _Alloc>:: + resize(size_type __new_size, const value_type& __x) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + insert(end(), __new_size - __len, __x); + } +#else template<typename _Tp, typename _Alloc> void list<_Tp, _Alloc>:: @@ -126,6 +176,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) else // __i == end() insert(end(), __new_size - __len, __x); } +#endif template<typename _Tp, typename _Alloc> list<_Tp, _Alloc>& diff --git a/libstdc++-v3/include/bits/locale_facets.h b/libstdc++-v3/include/bits/locale_facets.h index 2e18f7da8ed..79bfd03026d 100644 --- a/libstdc++-v3/include/bits/locale_facets.h +++ b/libstdc++-v3/include/bits/locale_facets.h @@ -1587,12 +1587,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std) bool _M_allocated; - __numpunct_cache(size_t __refs = 0) : facet(__refs), - _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false), - _M_truename(NULL), _M_truename_size(0), _M_falsename(NULL), - _M_falsename_size(0), _M_decimal_point(_CharT()), - _M_thousands_sep(_CharT()), _M_allocated(false) - { } + __numpunct_cache(size_t __refs = 0) + : facet(__refs), _M_grouping(0), _M_grouping_size(0), + _M_use_grouping(false), + _M_truename(0), _M_truename_size(0), _M_falsename(0), + _M_falsename_size(0), _M_decimal_point(_CharT()), + _M_thousands_sep(_CharT()), _M_allocated(false) + { } ~__numpunct_cache(); @@ -1657,7 +1658,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * @param refs Refcount to pass to the base class. */ explicit - numpunct(size_t __refs = 0) : facet(__refs), _M_data(NULL) + numpunct(size_t __refs = 0) + : facet(__refs), _M_data(0) { _M_initialize_numpunct(); } /** @@ -1685,7 +1687,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) */ explicit numpunct(__c_locale __cloc, size_t __refs = 0) - : facet(__refs), _M_data(NULL) + : facet(__refs), _M_data(0) { _M_initialize_numpunct(__cloc); } /** @@ -1841,7 +1843,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // For use at construction time only. void - _M_initialize_numpunct(__c_locale __cloc = NULL); + _M_initialize_numpunct(__c_locale __cloc = 0); }; template<typename _CharT> diff --git a/libstdc++-v3/include/bits/locale_facets.tcc b/libstdc++-v3/include/bits/locale_facets.tcc index 1608e2c42da..52bafd36dfe 100644 --- a/libstdc++-v3/include/bits/locale_facets.tcc +++ b/libstdc++-v3/include/bits/locale_facets.tcc @@ -1,7 +1,7 @@ // Locale support -*- C++ -*- // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2008, 2009 +// 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const locale::facet** __caches = __loc._M_impl->_M_caches; if (!__caches[__i]) { - __numpunct_cache<_CharT>* __tmp = NULL; + __numpunct_cache<_CharT>* __tmp = 0; __try { __tmp = new __numpunct_cache<_CharT>; diff --git a/libstdc++-v3/include/bits/locale_facets_nonio.h b/libstdc++-v3/include/bits/locale_facets_nonio.h index a25e0acd2c0..fdc810d12be 100644 --- a/libstdc++-v3/include/bits/locale_facets_nonio.h +++ b/libstdc++-v3/include/bits/locale_facets_nonio.h @@ -118,20 +118,20 @@ _GLIBCXX_BEGIN_NAMESPACE(std) bool _M_allocated; __timepunct_cache(size_t __refs = 0) : facet(__refs), - _M_date_format(NULL), _M_date_era_format(NULL), _M_time_format(NULL), - _M_time_era_format(NULL), _M_date_time_format(NULL), - _M_date_time_era_format(NULL), _M_am(NULL), _M_pm(NULL), - _M_am_pm_format(NULL), _M_day1(NULL), _M_day2(NULL), _M_day3(NULL), - _M_day4(NULL), _M_day5(NULL), _M_day6(NULL), _M_day7(NULL), - _M_aday1(NULL), _M_aday2(NULL), _M_aday3(NULL), _M_aday4(NULL), - _M_aday5(NULL), _M_aday6(NULL), _M_aday7(NULL), _M_month01(NULL), - _M_month02(NULL), _M_month03(NULL), _M_month04(NULL), _M_month05(NULL), - _M_month06(NULL), _M_month07(NULL), _M_month08(NULL), _M_month09(NULL), - _M_month10(NULL), _M_month11(NULL), _M_month12(NULL), _M_amonth01(NULL), - _M_amonth02(NULL), _M_amonth03(NULL), _M_amonth04(NULL), - _M_amonth05(NULL), _M_amonth06(NULL), _M_amonth07(NULL), - _M_amonth08(NULL), _M_amonth09(NULL), _M_amonth10(NULL), - _M_amonth11(NULL), _M_amonth12(NULL), _M_allocated(false) + _M_date_format(0), _M_date_era_format(0), _M_time_format(0), + _M_time_era_format(0), _M_date_time_format(0), + _M_date_time_era_format(0), _M_am(0), _M_pm(0), + _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0), + _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0), + _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0), + _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0), + _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0), + _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0), + _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0), + _M_amonth02(0), _M_amonth03(0), _M_amonth04(0), + _M_amonth05(0), _M_amonth06(0), _M_amonth07(0), + _M_amonth08(0), _M_amonth09(0), _M_amonth10(0), + _M_amonth11(0), _M_amonth12(0), _M_allocated(false) { } ~__timepunct_cache(); @@ -313,7 +313,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // For use at construction time only. void - _M_initialize_timepunct(__c_locale __cloc = NULL); + _M_initialize_timepunct(__c_locale __cloc = 0); }; template<typename _CharT> @@ -883,11 +883,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) bool _M_allocated; __moneypunct_cache(size_t __refs = 0) : facet(__refs), - _M_grouping(NULL), _M_grouping_size(0), _M_use_grouping(false), + _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false), _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), - _M_curr_symbol(NULL), _M_curr_symbol_size(0), - _M_positive_sign(NULL), _M_positive_sign_size(0), - _M_negative_sign(NULL), _M_negative_sign_size(0), + _M_curr_symbol(0), _M_curr_symbol_size(0), + _M_positive_sign(0), _M_positive_sign_size(0), + _M_negative_sign(0), _M_negative_sign_size(0), _M_frac_digits(0), _M_pos_format(money_base::pattern()), _M_neg_format(money_base::pattern()), _M_allocated(false) @@ -955,7 +955,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * @param refs Passed to the base facet class. */ explicit - moneypunct(size_t __refs = 0) : facet(__refs), _M_data(NULL) + moneypunct(size_t __refs = 0) + : facet(__refs), _M_data(0) { _M_initialize_moneypunct(); } /** @@ -983,7 +984,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) */ explicit moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0) - : facet(__refs), _M_data(NULL) + : facet(__refs), _M_data(0) { _M_initialize_moneypunct(__cloc, __s); } /** @@ -1271,8 +1272,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // For use at construction time only. void - _M_initialize_moneypunct(__c_locale __cloc = NULL, - const char* __name = NULL); + _M_initialize_moneypunct(__c_locale __cloc = 0, + const char* __name = 0); }; template<typename _CharT, bool _Intl> diff --git a/libstdc++-v3/include/bits/locale_facets_nonio.tcc b/libstdc++-v3/include/bits/locale_facets_nonio.tcc index 48a913901e7..b5c77b9d7c0 100644 --- a/libstdc++-v3/include/bits/locale_facets_nonio.tcc +++ b/libstdc++-v3/include/bits/locale_facets_nonio.tcc @@ -44,7 +44,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const locale::facet** __caches = __loc._M_impl->_M_caches; if (!__caches[__i]) { - __moneypunct_cache<_CharT, _Intl>* __tmp = NULL; + __moneypunct_cache<_CharT, _Intl>* __tmp = 0; __try { __tmp = new __moneypunct_cache<_CharT, _Intl>; diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h index a137f982bed..98755dc7e57 100644 --- a/libstdc++-v3/include/bits/move.h +++ b/libstdc++-v3/include/bits/move.h @@ -31,7 +31,6 @@ #define _MOVE_H 1 #include <bits/c++config.h> -#include <cstddef> #include <bits/concept_check.h> _GLIBCXX_BEGIN_NAMESPACE(std) diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc index 5a66bd6b2e2..690af186f96 100644 --- a/libstdc++-v3/include/bits/random.tcc +++ b/libstdc++-v3/include/bits/random.tcc @@ -828,27 +828,61 @@ namespace std operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { - // XXX Must be fixed to work well for *arbitrary* __urng.max(), - // __urng.min(), __param.b(), __param.a(). Currently works fine only - // in the most common case __urng.max() - __urng.min() >= - // __param.b() - __param.a(), with __urng.max() > __urng.min() >= 0. typedef typename std::make_unsigned<typename - _UniformRandomNumberGenerator::result_type>::type __urntype; + _UniformRandomNumberGenerator::result_type>::type __urngtype; typedef typename std::make_unsigned<result_type>::type __utype; - typedef typename std::conditional<(sizeof(__urntype) > sizeof(__utype)), - __urntype, __utype>::type __uctype; + typedef typename std::conditional<(sizeof(__urngtype) + > sizeof(__utype)), + __urngtype, __utype>::type __uctype; - result_type __ret; + const __uctype __urngmin = __urng.min(); + const __uctype __urngmax = __urng.max(); + const __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); - const __urntype __urnmin = __urng.min(); - const __urntype __urnmax = __urng.max(); - const __urntype __urnrange = __urnmax - __urnmin; - const __uctype __urange = __param.b() - __param.a(); - const __uctype __udenom = (__urnrange <= __urange - ? 1 : __urnrange / (__urange + 1)); - do - __ret = (__urntype(__urng()) - __urnmin) / __udenom; - while (__ret > __param.b() - __param.a()); + __uctype __ret; + + if (__urngrange > __urange) + { + // downscaling + const __uctype __uerange = __urange + 1; // __urange can be zero + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + __ret /= __scaling; + } + else if (__urngrange < __urange) + { + // upscaling + /* + Note that every value in [0, urange] + can be written uniquely as + + (urngrange + 1) * high + low + + where + + high in [0, urange / (urngrange + 1)] + + and + + low in [0, urngrange]. + */ + __uctype __tmp; // wraparound control + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + } + else + __ret = __uctype(__urng()) - __urngmin; return __ret + __param.a(); } diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h new file mode 100644 index 00000000000..f035fd4ade4 --- /dev/null +++ b/libstdc++-v3/include/bits/regex.h @@ -0,0 +1,2428 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ + +/** + * @defgroup regex Regular Expressions + * A facility for performing regular expression pattern matching. + */ + //@{ + + // [7.7] Class regex_traits + /** + * @brief Describes aspects of a regular expression. + * + * A regular expression traits class that satisfies the requirements of + * section [28.7]. + * + * The class %regex is parameterized around a set of related types and + * functions used to complete the definition of its semantics. This class + * satisfies the requirements of such a traits class. + */ + template<typename _Ch_type> + struct regex_traits + { + public: + typedef _Ch_type char_type; + typedef std::basic_string<char_type> string_type; + typedef std::locale locale_type; + typedef std::ctype_base::mask char_class_type; + + public: + /** + * @brief Constructs a default traits object. + */ + regex_traits() + { } + + /** + * @brief Gives the length of a C-style string starting at @p __p. + * + * @param __p a pointer to the start of a character sequence. + * + * @returns the number of characters between @p *__p and the first + * default-initialized value of type @p char_type. In other words, uses + * the C-string algorithm for determining the length of a sequence of + * characters. + */ + static std::size_t + length(const char_type* __p) + { return string_type::traits_type::length(__p); } + + /** + * @brief Performs the identity translation. + * + * @param c A character to the locale-specific character set. + * + * @returns c. + */ + char_type + translate(char_type __c) const + { return __c; } + + /** + * @brief Translates a character into a case-insensitive equivalent. + * + * @param c A character to the locale-specific character set. + * + * @returns the locale-specific lower-case equivalent of c. + * @throws std::bad_cast if the imbued locale does not support the ctype + * facet. + */ + char_type + translate_nocase(char_type __c) const + { + using std::ctype; + using std::use_facet; + return use_facet<ctype<char_type> >(_M_locale).tolower(__c); + } + + /** + * @brief Gets a sort key for a character sequence. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * + * Returns a sort key for the character sequence designated by the + * iterator range [F1, F2) such that if the character sequence [G1, G2) + * sorts before the character sequence [H1, H2) then + * v.transform(G1, G2) < v.transform(H1, H2). + * + * What this really does is provide a more efficient way to compare a + * string to multiple other strings in locales with fancy collation + * rules and equivalence classes. + * + * @returns a locale-specific sort key equivalent to the input range. + * + * @throws std::bad_cast if the current locale does not have a collate + * facet. + */ + template<typename _Fwd_iter> + string_type + transform(_Fwd_iter __first, _Fwd_iter __last) const + { + using std::collate; + using std::use_facet; + const collate<_Ch_type>& __c(use_facet< + collate<_Ch_type> >(_M_locale)); + string_type __s(__first, __last); + return __c.transform(__s.data(), __s.data() + __s.size()); + } + + /** + * @brief Gets a sort key for a character sequence, independant of case. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * + * Effects: if typeid(use_facet<collate<_Ch_type> >) == + * typeid(collate_byname<_Ch_type>) and the form of the sort key + * returned by collate_byname<_Ch_type>::transform(first, last) is known + * and can be converted into a primary sort key then returns that key, + * otherwise returns an empty string. + * + * @todo Implement this function. + */ + template<typename _Fwd_iter> + string_type + transform_primary(_Fwd_iter __first, _Fwd_iter __last) const + { return string_type(); } + + /** + * @brief Gets a collation element by name. + * + * @param first beginning of the collation element name. + * @param last one-past-the-end of the collation element name. + * + * @returns a sequence of one or more characters that represents the + * collating element consisting of the character sequence designated by + * the iterator range [first, last). Returns an empty string if the + * character sequence is not a valid collating element. + * + * @todo Implement this function. + */ + template<typename _Fwd_iter> + string_type + lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const + { return string_type(); } + + /** + * @brief Maps one or more characters to a named character + * classification. + * + * @param first beginning of the character sequence. + * @param last one-past-the-end of the character sequence. + * @param icase ignores the case of the classification name. + * + * @returns an unspecified value that represents the character + * classification named by the character sequence designated by the + * iterator range [first, last). If @p icase is true, the returned mask + * identifies the classification regardless of the case of the characters + * to be matched (for example, [[:lower:]] is the same as [[:alpha:]]), + * otherwise a case-dependant classification is returned. The value + * returned shall be independent of the case of the characters in the + * character sequence. If the name is not recognized then returns a value + * that compares equal to 0. + * + * At least the following names (or their wide-character equivalent) are + * supported. + * - d + * - w + * - s + * - alnum + * - alpha + * - blank + * - cntrl + * - digit + * - graph + * - lower + * - print + * - punct + * - space + * - upper + * - xdigit + * + * @todo Implement this function. + */ + template<typename _Fwd_iter> + char_class_type + lookup_classname(_Fwd_iter __first, _Fwd_iter __last, + bool __icase = false) const + { return 0; } + + /** + * @brief Determines if @p c is a member of an identified class. + * + * @param c a character. + * @param f a class type (as returned from lookup_classname). + * + * @returns true if the character @p c is a member of the classification + * represented by @p f, false otherwise. + * + * @throws std::bad_cast if the current locale does not have a ctype + * facet. + */ + bool + isctype(_Ch_type __c, char_class_type __f) const; + + /** + * @brief Converts a digit to an int. + * + * @param ch a character representing a digit. + * @param radix the radix if the numeric conversion (limited to 8, 10, + * or 16). + * + * @returns the value represented by the digit ch in base radix if the + * character ch is a valid digit in base radix; otherwise returns -1. + */ + int + value(_Ch_type __ch, int __radix) const; + + /** + * @brief Imbues the regex_traits object with a copy of a new locale. + * + * @param loc A locale. + * + * @returns a copy of the previous locale in use by the regex_traits + * object. + * + * @note Calling imbue with a different locale than the one currently in + * use invalidates all cached data held by *this. + */ + locale_type + imbue(locale_type __loc) + { + std::swap(_M_locale, __loc); + return __loc; + } + + /** + * @brief Gets a copy of the current locale in use by the regex_traits + * object. + */ + locale_type + getloc() const + { return _M_locale; } + + protected: + locale_type _M_locale; + }; + + template<typename _Ch_type> + bool + regex_traits<_Ch_type>:: + isctype(_Ch_type __c, char_class_type __f) const + { + using std::ctype; + using std::use_facet; + const ctype<_Ch_type>& __ctype(use_facet< + ctype<_Ch_type> >(_M_locale)); + + if (__ctype.is(__c, __f)) + return true; + + // special case of underscore in [[:w:]] + if (__c == __ctype.widen('_')) + { + const char __wb[] = "w"; + char_class_type __wt = this->lookup_classname(__wb, + __wb + sizeof(__wb)); + if (__f | __wt) + return true; + } + + // special case of [[:space:]] in [[:blank:]] + if (__ctype.is(std::ctype_base::space, __c)) + { + const char __bb[] = "blank"; + char_class_type __bt = this->lookup_classname(__bb, + __bb + sizeof(__bb)); + if (__f | __bt) + return true; + } + + return false; + } + + template<typename _Ch_type> + int + regex_traits<_Ch_type>:: + value(_Ch_type __ch, int __radix) const + { + std::basic_istringstream<_Ch_type> __is(string_type(1, __ch)); + int __v; + if (__radix == 8) + __is >> std::oct; + else if (__radix == 16) + __is >> std::hex; + __is >> __v; + return __is.fail() ? -1 : __v; + } + + // [7.8] Class basic_regex + /** + * Objects of specializations of this class represent regular expressions + * constructed from sequences of character type @p _Ch_type. + * + * Storage for the regular expression is allocated and deallocated as + * necessary by the member functions of this class. + */ + template<typename _Ch_type, typename _Rx_traits = regex_traits<_Ch_type> > + class basic_regex + { + public: + // types: + typedef _Ch_type value_type; + typedef regex_constants::syntax_option_type flag_type; + typedef typename _Rx_traits::locale_type locale_type; + typedef typename _Rx_traits::string_type string_type; + + /** + * @name Constants + * std [28.8.1](1) + * @todo These should be constexpr. + */ + //@{ + static const regex_constants::syntax_option_type icase + = regex_constants::icase; + static const regex_constants::syntax_option_type nosubs + = regex_constants::nosubs; + static const regex_constants::syntax_option_type optimize + = regex_constants::optimize; + static const regex_constants::syntax_option_type collate + = regex_constants::collate; + static const regex_constants::syntax_option_type ECMAScript + = regex_constants::ECMAScript; + static const regex_constants::syntax_option_type basic + = regex_constants::basic; + static const regex_constants::syntax_option_type extended + = regex_constants::extended; + static const regex_constants::syntax_option_type awk + = regex_constants::awk; + static const regex_constants::syntax_option_type grep + = regex_constants::grep; + static const regex_constants::syntax_option_type egrep + = regex_constants::egrep; + //@} + + // [7.8.2] construct/copy/destroy + /** + * Constructs a basic regular expression that does not match any + * character sequence. + */ + basic_regex() + : _M_flags(regex_constants::ECMAScript), + _M_automaton(__regex::__compile<const _Ch_type*, _Rx_traits>(0, 0, + _M_traits, _M_flags)) + { } + + /** + * @brief Constructs a basic regular expression from the sequence + * [p, p + char_traits<_Ch_type>::length(p)) interpreted according to the + * flags in @p f. + * + * @param p A pointer to the start of a C-style null-terminated string + * containing a regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + explicit + basic_regex(const _Ch_type* __p, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), + _M_automaton(__regex::__compile(__p, __p + _Rx_traits::length(__p), + _M_traits, _M_flags)) + { } + + /** + * @brief Constructs a basic regular expression from the sequence + * [p, p + len) interpreted according to the flags in @p f. + * + * @param p A pointer to the start of a string containing a regular + * expression. + * @param len The length of the string containing the regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p p is not a valid regular expression. + */ + basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f) + : _M_flags(__f), + _M_automaton(__regex::__compile(__p, __p + __len, _M_traits, _M_flags)) + { } + + /** + * @brief Copy-constructs a basic regular expression. + * + * @param rhs A @p regex object. + */ + basic_regex(const basic_regex& __rhs) + : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits), + _M_automaton(__rhs._M_automaton) + { } + + /** + * @brief Move-constructs a basic regular expression. + * + * @param rhs A @p regex object. + */ + basic_regex(const basic_regex&& __rhs) + : _M_flags(__rhs._M_flags), _M_traits(__rhs._M_traits), + _M_automaton(std::move(__rhs._M_automaton)) + { } + + /** + * @brief Constructs a basic regular expression from the string + * @p s interpreted according to the flags in @p f. + * + * @param s A string containing a regular expression. + * @param f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p s is not a valid regular expression. + */ + template<typename _Ch_traits, typename _Ch_alloc> + explicit + basic_regex(const std::basic_string<_Ch_type, _Ch_traits, + _Ch_alloc>& __s, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), + _M_automaton(__regex::__compile(__s.begin(), __s.end(), + _M_traits, _M_flags)) + { } + + /** + * @brief Constructs a basic regular expression from the range + * [first, last) interpreted according to the flags in @p f. + * + * @param first The start of a range containing a valid regular + * expression. + * @param last The end of a range containing a valid regular + * expression. + * @param f The format flags of the regular expression. + * + * @throws regex_error if @p [first, last) is not a valid regular + * expression. + */ + template<typename _InputIterator> + basic_regex(_InputIterator __first, _InputIterator __last, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), + _M_automaton(__regex::__compile(__first, __last, _M_traits, _M_flags)) + { } + + /** + * @brief Constructs a basic regular expression from an initializer list. + * + * @param l The initializer list. + * @param f The format flags of the regular expression. + * + * @throws regex_error if @p l is not a valid regular expression. + */ + basic_regex(initializer_list<_Ch_type> __l, + flag_type __f = regex_constants::ECMAScript) + : _M_flags(__f), + _M_automaton(__regex::__compile(__l.begin(), __l.end(), + _M_traits, _M_flags)) + { } + + /** + * @brief Destroys a basic regular expression. + */ + ~basic_regex() + { } + + /** + * @brief Assigns one regular expression to another. + */ + basic_regex& + operator=(const basic_regex& __rhs) + { return this->assign(__rhs); } + + /** + * @brief Move-assigns one regular expression to another. + */ + basic_regex& + operator=(basic_regex&& __rhs) + { return this->assign(std::move(__rhs)); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a C-style null-terminated string. + * + * @param A pointer to the start of a null-terminated C-style string + * containing a regular expression. + */ + basic_regex& + operator=(const _Ch_type* __p) + { return this->assign(__p, flags()); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a string. + * + * @param A pointer to a string containing a regular expression. + */ + template<typename _Ch_typeraits, typename _Allocator> + basic_regex& + operator=(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s) + { return this->assign(__s, flags()); } + + // [7.8.3] assign + /** + * @brief the real assignment operator. + * + * @param rhs Another regular expression object. + */ + basic_regex& + assign(const basic_regex& __rhs) + { + basic_regex __tmp(__rhs); + this->swap(__tmp); + return *this; + } + + /** + * @brief The move-assignment operator. + * + * @param rhs Another regular expression object. + */ + basic_regex& + assign(basic_regex&& __rhs) + { + basic_regex __tmp(std::move(__rhs)); + this->swap(__tmp); + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style null-terminated string containing a regular expression + * pattern. + * + * @param p A pointer to a C-style null-terminated string containing + * a regular expression pattern. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, + flag_type __flags = regex_constants::ECMAScript) + { return this->assign(string_type(__p), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style string containing a regular expression pattern. + * + * @param p A pointer to a C-style string containing a + * regular expression pattern. + * @param len The length of the regular expression pattern string. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, std::size_t __len, flag_type __flags) + { return this->assign(string_type(__p, __len), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * string containing a regular expression pattern. + * + * @param s A string containing a regular expression pattern. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * *this remains unchanged. + */ + template<typename _Ch_typeraits, typename _Allocator> + basic_regex& + assign(const basic_string<_Ch_type, _Ch_typeraits, _Allocator>& __s, + flag_type __f = regex_constants::ECMAScript) + { + basic_regex __tmp(__s, __f); + this->swap(__tmp); + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object. + * + * @param first The start of a range containing a valid regular + * expression. + * @param last The end of a range containing a valid regular + * expression. + * @param flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular expression + * pattern interpreted according to @p flags. If regex_error is thrown, + * the object remains unchanged. + */ + template<typename _InputIterator> + basic_regex& + assign(_InputIterator __first, _InputIterator __last, + flag_type __flags = regex_constants::ECMAScript) + { return this->assign(string_type(__first, __last), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object. + * + * @param l An initializer list representing a regular expression. + * @param flags Syntax option flags. + * + * @throws regex_error if @p l does not contain a valid regular + * expression pattern interpreted according to @p flags. If regex_error + * is thrown, the object remains unchanged. + */ + basic_regex& + assign(initializer_list<_Ch_type> __l, + flag_type __f = regex_constants::ECMAScript) + { return this->assign(__l.begin(), __l.end(), __f); } + + // [7.8.4] const operations + /** + * @brief Gets the number of marked subexpressions within the regular + * expression. + */ + unsigned int + mark_count() const + { return _M_automaton->_M_sub_count() - 1; } + + /** + * @brief Gets the flags used to construct the regular expression + * or in the last call to assign(). + */ + flag_type + flags() const + { return _M_flags; } + + // [7.8.5] locale + /** + * @brief Imbues the regular expression object with the given locale. + * + * @param loc A locale. + */ + locale_type + imbue(locale_type __loc) + { return _M_traits.imbue(__loc); } + + /** + * @brief Gets the locale currently imbued in the regular expression + * object. + */ + locale_type + getloc() const + { return _M_traits.getloc(); } + + // [7.8.6] swap + /** + * @brief Swaps the contents of two regular expression objects. + * + * @param rhs Another regular expression object. + */ + void + swap(basic_regex& __rhs) + { + std::swap(_M_flags, __rhs._M_flags); + std::swap(_M_traits, __rhs._M_traits); + std::swap(_M_automaton, __rhs._M_automaton); + } + +#ifdef _GLIBCXX_DEBUG + void + _M_dot(std::ostream& __ostr) + { _M_automaton->_M_dot(__ostr); } +#endif + + const __regex::_AutomatonPtr& + _M_get_automaton() const + { return _M_automaton; } + + protected: + flag_type _M_flags; + _Rx_traits _M_traits; + __regex::_AutomatonPtr _M_automaton; + }; + + /** @brief Standard regular expressions. */ + typedef basic_regex<char> regex; +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Standard wide-character regular expressions. */ + typedef basic_regex<wchar_t> wregex; +#endif + + + // [7.8.6] basic_regex swap + /** + * @brief Swaps the contents of two regular expression objects. + * @param lhs First regular expression. + * @param rhs Second regular expression. + */ + template<typename _Ch_type, typename _Rx_traits> + inline void + swap(basic_regex<_Ch_type, _Rx_traits>& __lhs, + basic_regex<_Ch_type, _Rx_traits>& __rhs) + { __lhs.swap(__rhs); } + + + // [7.9] Class template sub_match + /** + * A sequence of characters matched by a particular marked sub-expression. + * + * An object of this class is essentially a pair of iterators marking a + * matched subexpression within a regular expression pattern match. Such + * objects can be converted to and compared with std::basic_string objects + * of a similar base character type as the pattern matched by the regular + * expression. + * + * The iterators that make up the pair are the usual half-open interval + * referencing the actual original pattern matched. + */ + template<typename _BiIter> + class sub_match : public std::pair<_BiIter, _BiIter> + { + public: + typedef typename iterator_traits<_BiIter>::value_type value_type; + typedef typename iterator_traits<_BiIter>::difference_type + difference_type; + typedef _BiIter iterator; + typedef std::basic_string<value_type> string_type; + + public: + bool matched; + + /** + * Gets the length of the matching sequence. + */ + difference_type + length() const + { return this->matched ? std::distance(this->first, this->second) : 0; } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + * + * This is the implicit conversion operator. It is identical to the + * str() member function except that it will want to pop up in + * unexpected places and cause a great deal of confusion and cursing + * from the unwary. + */ + operator string_type() const + { + return this->matched + ? string_type(this->first, this->second) + : string_type(); + } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + */ + string_type + str() const + { + return this->matched + ? string_type(this->first, this->second) + : string_type(); + } + + /** + * @brief Compares this and another matched sequence. + * + * @param s Another matched sequence to compare to this one. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const sub_match& __s) const + { return this->str().compare(__s.str()); } + + /** + * @brief Compares this sub_match to a string. + * + * @param s A string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const string_type& __s) const + { return this->str().compare(__s); } + + /** + * @brief Compares this sub_match to a C-style string. + * + * @param s A C-style string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p s. + * @retval =0 this matched sequence is equivalent to @p s. + * @retval <0 this matched sequence will collate after @p s. + */ + int + compare(const value_type* __s) const + { return this->str().compare(__s); } + }; + + + /** @brief Standard regex submatch over a C-style null-terminated string. */ + typedef sub_match<const char*> csub_match; + /** @brief Standard regex submatch over a standard string. */ + typedef sub_match<string::const_iterator> ssub_match; +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Regex submatch over a C-style null-terminated wide string. */ + typedef sub_match<const wchar_t*> wcsub_match; + /** @brief Regex submatch over a standard wide string. */ + typedef sub_match<wstring::const_iterator> wssub_match; +#endif + + // [7.9.2] sub_match non-member operators + + /** + * @brief Tests the equivalence of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator==(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) == 0; } + + /** + * @brief Tests the inequivalence of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator!=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) != 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator<(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator<=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) <= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator>=(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) >= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param lhs First regular expression submatch. + * @param rhs Second regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _BiIter> + inline bool + operator>(const sub_match<_BiIter>& __lhs, + const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) > 0; } + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator==(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator!=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator<(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator>(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator>=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator<=(const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __lhs, const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter, typename _Ch_traits, typename _Ch_alloc> + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc> + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc> + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc> + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter, class _Ch_traits, class _Ch_alloc> + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + const basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Tests the equivalence of a C string and a regular expression + * submatch. + * @param lhs A C string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of an iterator value and a regular + * expression submatch. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A pointer to a string? + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A pointer to a string. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A string. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs == __rhs.str(); } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs != __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs < __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs > __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs >= __rhs.str(); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param lhs A string. + * @param rhs A regular expression submatch. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __lhs <= __rhs.str(); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs is equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() == __rhs; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs is not equivalent to @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() != __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs precedes @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() < __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs succeeds @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() > __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs does not precede @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() >= __rhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param lhs A regular expression submatch. + * @param rhs A const string reference. + * @returns true if @a lhs does not succeed @a rhs, false otherwise. + */ + template<typename _Bi_iter> + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __lhs.str() <= __rhs; } + + /** + * @brief Inserts a matched string into an output stream. + * + * @param os The output stream. + * @param m A submatch string. + * + * @returns the output stream with the submatch string inserted. + */ + template<typename _Ch_type, typename _Ch_traits, typename _Bi_iter> + inline + basic_ostream<_Ch_type, _Ch_traits>& + operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os, + const sub_match<_Bi_iter>& __m) + { return __os << __m.str(); } + + // [7.10] Class template match_results + + /* + * Special sub_match object representing an unmatched sub-expression. + */ + template<typename _Bi_iter> + inline const sub_match<_Bi_iter>& + __unmatched_sub() + { + static const sub_match<_Bi_iter> __unmatched = sub_match<_Bi_iter>(); + return __unmatched; + } + + /** + * @brief The results of a match or search operation. + * + * A collection of character sequences representing the result of a regular + * expression match. Storage for the collection is allocated and freed as + * necessary by the member functions of class template match_results. + * + * This class satisfies the Sequence requirements, with the exception that + * only the operations defined for a const-qualified Sequence are supported. + * + * The sub_match object stored at index 0 represents sub-expression 0, i.e. + * the whole match. In this case the %sub_match member matched is always true. + * The sub_match object stored at index n denotes what matched the marked + * sub-expression n within the matched expression. If the sub-expression n + * participated in a regular expression match then the %sub_match member + * matched evaluates to true, and members first and second denote the range + * of characters [first, second) which formed that match. Otherwise matched + * is false, and members first and second point to the end of the sequence + * that was searched. + * + * @nosubgrouping + */ + template<typename _Bi_iter, + typename _Allocator = allocator<sub_match<_Bi_iter> > > + class match_results + : private std::vector<std::sub_match<_Bi_iter>, _Allocator> + { + private: + /* + * The vector base is empty if this does not represent a successful match. + * Otherwise it contains n+3 elements where n is the number of marked + * sub-expressions: + * [0] entire match + * [1] 1st marked subexpression + * ... + * [n] nth marked subexpression + * [n+1] prefix + * [n+2] suffix + */ + typedef std::vector<std::sub_match<_Bi_iter>, _Allocator> + _Base_type; + + public: + /** + * @name 10.? Public Types + */ + //@{ + typedef sub_match<_Bi_iter> value_type; + typedef const value_type& const_reference; + typedef const_reference reference; + typedef typename _Base_type::const_iterator const_iterator; + typedef const_iterator iterator; + typedef typename std::iterator_traits<_Bi_iter>::difference_type + difference_type; + /* TODO: needs allocator_traits */ + typedef typename _Allocator::size_type size_type; + typedef _Allocator allocator_type; + typedef typename std::iterator_traits<_Bi_iter>::value_type + char_type; + typedef std::basic_string<char_type> string_type; + //@} + + public: + /** + * @name 10.1 Construction, Copying, and Destruction + */ + //@{ + + /** + * @brief Constructs a default %match_results container. + * @post size() returns 0 and str() returns an empty string. + */ + explicit + match_results(const _Allocator& __a = _Allocator()) + : _Base_type(__a) + { } + + /** + * @brief Copy constructs a %match_results. + */ + match_results(const match_results& __rhs) + : _Base_type(__rhs) + { } + + /** + * @brief Assigns rhs to *this. + */ + match_results& + operator=(const match_results __rhs) + { + match_results(__rhs).swap(*this); + return *this; + } + + /** + * @brief Destroys a %match_results object. + */ + ~match_results() + { } + + //@} + + /** + * @name 10.2 Size + */ + //@{ + + /** + * @brief Gets the number of matches and submatches. + * + * The number of matches for a given regular expression will be either 0 + * if there was no match or mark_count() + 1 if a match was successful. + * Some matches may be empty. + * + * @returns the number of matches found. + */ + size_type + size() const + { + size_type __size = _Base_type::size(); + return (__size && _Base_type::operator[](0).matched) ? __size - 2 : 0; + } + + size_type + max_size() const + { return _Base_type::max_size(); } + + /** + * @brief Indicates if the %match_results contains no results. + * @retval true The %match_results object is empty. + * @retval false The %match_results object is not empty. + */ + bool + empty() const + { return _Base_type::empty(); } + + //@} + + /** + * @name 10.3 Element Access + */ + //@{ + + /** + * @brief Gets the length of the indicated submatch. + * @param sub indicates the submatch. + * + * This function returns the length of the indicated submatch, or the + * length of the entire match if @p sub is zero (the default). + */ + difference_type + length(size_type __sub = 0) const + { return this[__sub].length(); } + + /** + * @brief Gets the offset of the beginning of the indicated submatch. + * @param sub indicates the submatch. + * + * This function returns the offset from the beginning of the target + * sequence to the beginning of the submatch, unless the value of @p sub + * is zero (the default), in which case this function returns the offset + * from the beginning of the target sequence to the beginning of the + * match. + * + * Returns -1 if @p sub is out of range. + */ + difference_type + position(size_type __sub = 0) const + { + return __sub < size() ? std::distance(this->prefix().first, + (*this)[__sub].first) : -1; + } + + /** + * @brief Gets the match or submatch converted to a string type. + * @param sub indicates the submatch. + * + * This function gets the submatch (or match, if @p sub is zero) extracted + * from the target range and converted to the associated string type. + */ + string_type + str(size_type __sub = 0) const + { return (*this)[__sub].str(); } + + /** + * @brief Gets a %sub_match reference for the match or submatch. + * @param sub indicates the submatch. + * + * This function gets a reference to the indicated submatch, or the entire + * match if @p sub is zero. + * + * If @p sub >= size() then this function returns a %sub_match with a + * special value indicating no submatch. + */ + const_reference + operator[](size_type __sub) const + { + return __sub < size() + ? _Base_type::operator[](__sub) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets a %sub_match representing the match prefix. + * + * This function gets a reference to a %sub_match object representing the + * part of the target range between the start of the target range and the + * start of the match. + */ + const_reference + prefix() const + { + return !empty() + ? _Base_type::operator[](_Base_type::size() - 2) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets a %sub_match representing the match suffix. + * + * This function gets a reference to a %sub_match object representing the + * part of the target range between the end of the match and the end of + * the target range. + */ + const_reference + suffix() const + { + return !empty() + ? _Base_type::operator[](_Base_type::size() - 1) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets an iterator to the start of the %sub_match collection. + */ + const_iterator + begin() const + { return _Base_type::begin(); } + + /** + * @brief Gets an iterator to the start of the %sub_match collection. + */ + const_iterator + cbegin() const + { return _Base_type::cbegin(); } + + /** + * @brief Gets an iterator to one-past-the-end of the collection. + */ + const_iterator + end() const + { + return !empty() + ? _Base_type::end() - 2 + : _Base_type::end(); + } + + /** + * @brief Gets an iterator to one-past-the-end of the collection. + */ + const_iterator + cend() const + { + return !empty() + ? _Base_type::cend() - 2 + : _Base_type::cend(); + } + + //@} + + /** + * @name 10.4 Formatting + * + * These functions perform formatted substitution of the matched character + * sequences into their target. The format specifiers and escape sequences + * accepted by these functions are determined by their @p flags parameter + * as documented above. + */ + //@{ + + /** + * @todo Implement this function. + */ + template<typename _Out_iter> + _Out_iter + format(_Out_iter __out, const string_type& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::format_default) const + { return __out; } + + /** + * @todo Implement this function. + */ + string_type + format(const string_type& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::format_default) const; + + //@} + + /** + * @name 10.5 Allocator + */ + //@{ + + /** + * @brief Gets a copy of the allocator. + */ + allocator_type + get_allocator() const + { return _Base_type::get_allocator(); } + + //@} + + /** + * @name 10.6 Swap + */ + //@{ + + /** + * @brief Swaps the contents of two match_results. + */ + void + swap(match_results& __that) + { _Base_type::swap(__that); } + //@} + + private: + friend class __regex::_SpecializedResults<_Bi_iter, _Allocator>; + }; + + typedef match_results<const char*> cmatch; + typedef match_results<string::const_iterator> smatch; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef match_results<const wchar_t*> wcmatch; + typedef match_results<wstring::const_iterator> wsmatch; +#endif + + // match_results comparisons + /** + * @brief Compares two match_results for equality. + * @returns true if the two objects refer to the same match, + * false otherwise. + * @todo Implement this function. + */ + template<typename _Bi_iter, typename _Allocator> + inline bool + operator==(const match_results<_Bi_iter, _Allocator>& __m1, + const match_results<_Bi_iter, _Allocator>& __m2); + + /** + * @brief Compares two match_results for inequality. + * @returns true if the two objects do not refer to the same match, + * false otherwise. + */ + template<typename _Bi_iter, class _Allocator> + inline bool + operator!=(const match_results<_Bi_iter, _Allocator>& __m1, + const match_results<_Bi_iter, _Allocator>& __m2) + { return !(__m1 == __m2); } + + // [7.10.6] match_results swap + /** + * @brief Swaps two match results. + * @param lhs A match result. + * @param rhs A match result. + * + * The contents of the two match_results objects are swapped. + */ + template<typename _Bi_iter, typename _Allocator> + inline void + swap(match_results<_Bi_iter, _Allocator>& __lhs, + match_results<_Bi_iter, _Allocator>& __rhs) + { __lhs.swap(__rhs); } + + // [7.11.2] Function template regex_match + /** + * @name Matching, Searching, and Replacing + */ + //@{ + + /** + * @brief Determines if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param s Start of the character sequence to match. + * @param e One-past-the-end of the character sequence to match. + * @param m The match results. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + * + * @todo Implement this function. + */ + template<typename _Bi_iter, typename _Allocator, + typename _Ch_type, typename _Rx_traits> + bool + regex_match(_Bi_iter __s, + _Bi_iter __e, + match_results<_Bi_iter, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + __regex::_AutomatonPtr __a = __re._M_get_automaton(); + __regex::_Automaton::_SizeT __sz = __a->_M_sub_count(); + __regex::_SpecializedCursor<_Bi_iter> __cs(__s, __e); + __regex::_SpecializedResults<_Bi_iter, _Allocator> __r(__sz, __cs, __m); + __regex::_Grep_matcher __matcher(__cs, __r, __a, __flags); + return __m[0].matched; + } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param first Beginning of the character sequence to match. + * @param last One-past-the-end of the character sequence to match. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits> + bool + regex_match(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_match(__first, __last, __what, __re, __flags); + } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param s The C-style null-terminated string to match. + * @param m The match results. + * @param re The regular expression. + * @param f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_type, typename _Allocator, typename _Rx_traits> + inline bool + regex_match(const _Ch_type* __s, + match_results<const _Ch_type*, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a string. + * + * @param s The string to match. + * @param m The match results. + * @param re The regular expression. + * @param flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_traits, typename _Ch_alloc, + typename _Allocator, typename _Ch_type, typename _Rx_traits> + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results<typename basic_string<_Ch_type, + _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param s The C-style null-terminated string to match. + * @param re The regular expression. + * @param f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_type, class _Rx_traits> + inline bool + regex_match(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a string. + * + * @param s [IN] The string to match. + * @param re [IN] The regular expression. + * @param flags [IN] Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_traits, typename _Str_allocator, + typename _Ch_type, typename _Rx_traits> + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __re, __flags); } + + // [7.11.3] Function template regex_search + /** + * Searches for a regular expression within a range. + * @param first [IN] The start of the string to search. + * @param last [IN] One-past-the-end of the string to search. + * @param m [OUT] The match results. + * @param re [IN] The regular expression to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * + * @throws an exception of type regex_error. + * + * @todo Implement this function. + */ + template<typename _Bi_iter, typename _Allocator, + typename _Ch_type, typename _Rx_traits> + inline bool + regex_search(_Bi_iter __first, _Bi_iter __last, + match_results<_Bi_iter, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return false; } + + /** + * Searches for a regular expression within a range. + * @param first [IN] The start of the string to search. + * @param last [IN] One-past-the-end of the string to search. + * @param re [IN] The regular expression to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @doctodo + * + * @throws an exception of type regex_error. + */ + template<typename _Bi_iter, typename _Ch_type, typename _Rx_traits> + inline bool + regex_search(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_search(__first, __last, __what, __re, __flags); + } + + /** + * @brief Searches for a regular expression within a C-string. + * @param s [IN] A C-string to search for the regex. + * @param m [OUT] The set of regex matches. + * @param e [IN] The regex to search for in @p s. + * @param f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * @doctodo + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_type, class _Allocator, class _Rx_traits> + inline bool + regex_search(const _Ch_type* __s, + match_results<const _Ch_type*, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); } + + /** + * @brief Searches for a regular expression within a C-string. + * @param s [IN] The C-string to search. + * @param e [IN] The regular expression to search for. + * @param f [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @doctodo + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_type, typename _Rx_traits> + inline bool + regex_search(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); } + + /** + * @brief Searches for a regular expression within a string. + * @param s [IN] The string to search. + * @param e [IN] The regular expression to search for. + * @param flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * @doctodo + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_traits, typename _String_allocator, + typename _Ch_type, typename _Rx_traits> + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, + _String_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __e, __flags); } + + /** + * @brief Searches for a regular expression within a string. + * @param s [IN] A C++ string to search for the regex. + * @param m [OUT] The set of regex matches. + * @param e [IN] The regex to search for in @p s. + * @param f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * + * @throws an exception of type regex_error. + */ + template<typename _Ch_traits, typename _Ch_alloc, + typename _Allocator, typename _Ch_type, + typename _Rx_traits> + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results<typename basic_string<_Ch_type, + _Ch_traits, _Ch_alloc>::const_iterator, _Allocator>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __m, __e, __f); } + + // std [28.11.4] Function template regex_replace + /** + * @doctodo + * @param out + * @param first + * @param last + * @param e + * @param fmt + * @param flags + * + * @returns out + * @throws an exception of type regex_error. + * + * @todo Implement this function. + */ + template<typename _Out_iter, typename _Bi_iter, + typename _Rx_traits, typename _Ch_type> + inline _Out_iter + regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return __out; } + + /** + * @doctodo + * @param s + * @param e + * @param fmt + * @param flags + * + * @returns a copy of string @p s with replacements. + * + * @throws an exception of type regex_error. + */ + template<typename _Rx_traits, typename _Ch_type> + inline basic_string<_Ch_type> + regex_replace(const basic_string<_Ch_type>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + std::string __result; + regex_replace(std::back_inserter(__result), + __s.begin(), __s.end(), __e, __fmt, __flags); + return __result; + } + + //@} + + // std [28.12] Class template regex_iterator + /** + * An iterator adaptor that will provide repeated calls of regex_search over + * a range until no more matches remain. + */ + template<typename _Bi_iter, + typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef match_results<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + public: + /** + * @brief Provides a singular iterator, useful for indicating + * one-past-the-end of a range. + * @todo Implement this function. + * @doctodo + */ + regex_iterator(); + + /** + * Constructs a %regex_iterator... + * @param a [IN] The start of a text range to search. + * @param b [IN] One-past-the-end of the text range to search. + * @param re [IN] The regular expression to match. + * @param m [IN] Policy flags for match rules. + * @todo Implement this function. + * @doctodo + */ + regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Copy constructs a %regex_iterator. + * @todo Implement this function. + * @doctodo + */ + regex_iterator(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @doctodo + */ + regex_iterator& + operator=(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @doctodo + */ + bool + operator==(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @doctodo + */ + bool + operator!=(const regex_iterator& __rhs); + + /** + * @todo Implement this function. + * @doctodo + */ + const value_type& + operator*(); + + /** + * @todo Implement this function. + * @doctodo + */ + const value_type* + operator->(); + + /** + * @todo Implement this function. + * @doctodo + */ + regex_iterator& + operator++(); + + /** + * @todo Implement this function. + * @doctodo + */ + regex_iterator + operator++(int); + + private: + // these members are shown for exposition only: + _Bi_iter begin; + _Bi_iter end; + const regex_type* pregex; + regex_constants::match_flag_type flags; + match_results<_Bi_iter> match; + }; + + typedef regex_iterator<const char*> cregex_iterator; + typedef regex_iterator<string::const_iterator> sregex_iterator; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef regex_iterator<const wchar_t*> wcregex_iterator; + typedef regex_iterator<wstring::const_iterator> wsregex_iterator; +#endif + + // [7.12.2] Class template regex_token_iterator + /** + * Iterates over submatches in a range (or @a splits a text string). + * + * The purpose of this iterator is to enumerate all, or all specified, + * matches of a regular expression within a text range. The dereferenced + * value of an iterator of this class is a std::sub_match object. + */ + template<typename _Bi_iter, + typename _Ch_type = typename iterator_traits<_Bi_iter>::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_token_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef sub_match<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + public: + /** + * @brief Default constructs a %regex_token_iterator. + * @todo Implement this function. + * + * A default-constructed %regex_token_iterator is a singular iterator + * that will compare equal to the one-past-the-end value for any + * iterator of the same type. + */ + regex_token_iterator(); + + /** + * Constructs a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-end of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatch [IN] Which submatch to return. There are some + * special values for this parameter: + * - -1 each enumerated subexpression does NOT + * match the regular expression (aka field + * splitting) + * - 0 the entire string matching the + * subexpression is returned for each match + * within the text. + * - >0 enumerates only the indicated + * subexpression from a match within the text. + * @param m [IN] Policy flags for match rules. + * + * @todo Implement this function. + * @doctodo + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + int __submatch = 0, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Constructs a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-end of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param m [IN] Policy flags for match rules. + * + * @todo Implement this function. + * @doctodo + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const std::vector<int>& __submatches, + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * Constructs a %regex_token_iterator... + * @param a [IN] The start of the text to search. + * @param b [IN] One-past-the-end of the text to search. + * @param re [IN] The regular expression to search for. + * @param submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param m [IN] Policy flags for match rules. + + * @todo Implement this function. + * @doctodo + */ + template<std::size_t _Nm> + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const int (&__submatches)[_Nm], + regex_constants::match_flag_type __m + = regex_constants::match_default); + + /** + * @brief Copy constructs a %regex_token_iterator. + * @param rhs [IN] A %regex_token_iterator to copy. + * @todo Implement this function. + */ + regex_token_iterator(const regex_token_iterator& __rhs); + + /** + * @brief Assigns a %regex_token_iterator to another. + * @param rhs [IN] A %regex_token_iterator to copy. + * @todo Implement this function. + */ + regex_token_iterator& + operator=(const regex_token_iterator& __rhs); + + /** + * @brief Compares a %regex_token_iterator to another for equality. + * @todo Implement this function. + */ + bool + operator==(const regex_token_iterator& __rhs); + + /** + * @brief Compares a %regex_token_iterator to another for inequality. + * @todo Implement this function. + */ + bool + operator!=(const regex_token_iterator& __rhs); + + /** + * @brief Dereferences a %regex_token_iterator. + * @todo Implement this function. + */ + const value_type& + operator*(); + + /** + * @brief Selects a %regex_token_iterator member. + * @todo Implement this function. + */ + const value_type* + operator->(); + + /** + * @brief Increments a %regex_token_iterator. + * @todo Implement this function. + */ + regex_token_iterator& + operator++(); + + /** + * @brief Postincrements a %regex_token_iterator. + * @todo Implement this function. + */ + regex_token_iterator + operator++(int); + + private: // data members for exposition only: + typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> position_iterator; + + position_iterator __position; + const value_type* __result; + value_type __suffix; + std::size_t __n; + std::vector<int> __subs; + }; + + /** @brief Token iterator for C-style NULL-terminated strings. */ + typedef regex_token_iterator<const char*> cregex_token_iterator; + /** @brief Token iterator for standard strings. */ + typedef regex_token_iterator<string::const_iterator> sregex_token_iterator; +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Token iterator for C-style NULL-terminated wide strings. */ + typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator; + /** @brief Token iterator for standard wide-character strings. */ + typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator; +#endif + + //@} // group regex + +} + diff --git a/libstdc++-v3/include/bits/regex_compiler.h b/libstdc++-v3/include/bits/regex_compiler.h new file mode 100644 index 00000000000..0bc362dc77e --- /dev/null +++ b/libstdc++-v3/include/bits/regex_compiler.h @@ -0,0 +1,1115 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_parser.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ +namespace __regex +{ + struct _Scanner_base + { + // FIXME: replace these constanst with constexpr + typedef unsigned int _StateT; + + static const _StateT _S_state_at_start = 1 << 0; + static const _StateT _S_state_in_brace = 1 << 2; + static const _StateT _S_state_in_bracket = 1 << 3; + }; + + // + // @brief Scans an input range for regex tokens. + // + // The %_Scanner class interprets the regular expression pattern in the input + // range passed to its constructor as a sequence of parse tokens passed to + // the regular expression compiler. The sequence of tokens provided depends + // on the flag settings passed to the constructor: different regular + // expression gramars will interpret the same input pattern in syntactically + // different ways. + // + template<typename _InputIterator> + class _Scanner: public _Scanner_base + { + public: + typedef _InputIterator _IteratorT; + typedef typename std::iterator_traits<_IteratorT>::value_type _CharT; + typedef std::basic_string<_CharT> _StringT; + typedef regex_constants::syntax_option_type _FlagT; + typedef const std::ctype<_CharT> _CtypeT; + + // Token types returned from the scanner. + enum _TokenT + { + _S_token_anychar, + _S_token_backref, + _S_token_bracket_begin, + _S_token_bracket_end, + _S_token_inverse_class, + _S_token_char_class_name, + _S_token_closure0, + _S_token_closure1, + _S_token_collelem_multi, + _S_token_collelem_single, + _S_token_collsymbol, + _S_token_comma, + _S_token_dash, + _S_token_dup_count, + _S_token_eof, + _S_token_equiv_class_name, + _S_token_interval_begin, + _S_token_interval_end, + _S_token_line_begin, + _S_token_line_end, + _S_token_opt, + _S_token_or, + _S_token_ord_char, + _S_token_quoted_char, + _S_token_subexpr_begin, + _S_token_subexpr_end, + _S_token_word_begin, + _S_token_word_end, + _S_token_unknown + }; + + public: + _Scanner(_IteratorT __begin, _IteratorT __end, _FlagT __flags, + std::locale __loc) + : _M_current(__begin) , _M_end(__end) , _M_flags(__flags), + _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_state(_S_state_at_start) + { _M_advance(); } + + void + _M_advance(); + + _TokenT + _M_token() const + { return _M_curToken; } + + const _StringT& + _M_value() const + { return _M_curValue; } + +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_print(std::ostream&); +#endif + + private: + void + _M_eat_escape(); + + void + _M_scan_in_brace(); + + void + _M_scan_in_bracket(); + + void + _M_eat_charclass(); + + void + _M_eat_equivclass(); + + void + _M_eat_collsymbol(); + + private: + _IteratorT _M_current; + _IteratorT _M_end; + _FlagT _M_flags; + _CtypeT& _M_ctype; + _TokenT _M_curToken; + _StringT _M_curValue; + _StateT _M_state; + }; + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_advance() + { + if (_M_current == _M_end) + { + _M_curToken = _S_token_eof; + return; + } + + _CharT __c = *_M_current; + if (_M_state & _S_state_in_bracket) + { + _M_scan_in_bracket(); + return; + } + if (_M_state & _S_state_in_brace) + { + _M_scan_in_brace(); + return; + } + else if (_M_state & _S_state_at_start && __c == _M_ctype.widen('^')) + { + _M_curToken = _S_token_line_begin; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('$')) + { + _M_curToken = _S_token_line_end; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('.')) + { + _M_curToken = _S_token_anychar; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('*')) + { + _M_curToken = _S_token_closure0; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('+')) + { + _M_curToken = _S_token_closure1; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('|')) + { + _M_curToken = _S_token_or; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('[')) + { + _M_curToken = _S_token_bracket_begin; + _M_state |= (_S_state_in_bracket | _S_state_at_start); + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('\\')) + { + _M_eat_escape(); + return; + } + else if (!(_M_flags & (regex_constants::basic | regex_constants::grep))) + { + if (__c == _M_ctype.widen('(')) + { + _M_curToken = _S_token_subexpr_begin; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen(')')) + { + _M_curToken = _S_token_subexpr_end; + ++_M_current; + return; + } + else if (__c == _M_ctype.widen('{')) + { + _M_curToken = _S_token_interval_begin; + _M_state |= _S_state_in_brace; + ++_M_current; + return; + } + } + + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + ++_M_current; + } + + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_scan_in_brace() + { + if (_M_ctype.is(_CtypeT::digit, *_M_current)) + { + _M_curToken = _S_token_dup_count; + _M_curValue.assign(1, *_M_current); + ++_M_current; + while (_M_current != _M_end + && _M_ctype.is(_CtypeT::digit, *_M_current)) + { + _M_curValue += *_M_current; + ++_M_current; + } + return; + } + else if (*_M_current == _M_ctype.widen(',')) + { + _M_curToken = _S_token_comma; + ++_M_current; + return; + } + if (_M_flags & (regex_constants::basic | regex_constants::grep)) + { + if (*_M_current == _M_ctype.widen('\\')) + _M_eat_escape(); + } + else + { + if (*_M_current == _M_ctype.widen('}')) + { + _M_curToken = _S_token_interval_end; + _M_state &= ~_S_state_in_brace; + ++_M_current; + return; + } + } + } + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_scan_in_bracket() + { + if (_M_state & _S_state_at_start && *_M_current == _M_ctype.widen('^')) + { + _M_curToken = _S_token_inverse_class; + _M_state &= ~_S_state_at_start; + ++_M_current; + return; + } + else if (*_M_current == _M_ctype.widen('[')) + { + ++_M_current; + if (_M_current == _M_end) + { + _M_curToken = _S_token_eof; + return; + } + + if (*_M_current == _M_ctype.widen('.')) + { + _M_curToken = _S_token_collsymbol; + _M_eat_collsymbol(); + return; + } + else if (*_M_current == _M_ctype.widen(':')) + { + _M_curToken = _S_token_char_class_name; + _M_eat_charclass(); + return; + } + else if (*_M_current == _M_ctype.widen('=')) + { + _M_curToken = _S_token_equiv_class_name; + _M_eat_equivclass(); + return; + } + } + else if (*_M_current == _M_ctype.widen('-')) + { + _M_curToken = _S_token_dash; + ++_M_current; + return; + } + else if (*_M_current == _M_ctype.widen(']')) + { + if (!(_M_flags & regex_constants::ECMAScript) + || !(_M_state & _S_state_at_start)) + { + // special case: only if _not_ chr first after + // '[' or '[^' and if not ECMAscript + _M_curToken = _S_token_bracket_end; + ++_M_current; + return; + } + } + _M_curToken = _S_token_collelem_single; + _M_curValue.assign(1, *_M_current); + ++_M_current; + } + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_eat_escape() + { + ++_M_current; + if (_M_current == _M_end) + { + _M_curToken = _S_token_eof; + return; + } + _CharT __c = *_M_current; + ++_M_current; + + if (__c == _M_ctype.widen('(')) + { + if (!(_M_flags & (regex_constants::basic | regex_constants::grep))) + { + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + } + else + _M_curToken = _S_token_subexpr_begin; + } + else if (__c == _M_ctype.widen(')')) + { + if (!(_M_flags & (regex_constants::basic | regex_constants::grep))) + { + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + } + else + _M_curToken = _S_token_subexpr_end; + } + else if (__c == _M_ctype.widen('{')) + { + if (!(_M_flags & (regex_constants::basic | regex_constants::grep))) + { + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + } + else + { + _M_curToken = _S_token_interval_begin; + _M_state |= _S_state_in_brace; + } + } + else if (__c == _M_ctype.widen('}')) + { + if (!(_M_flags & (regex_constants::basic | regex_constants::grep))) + { + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + } + else + { + if (!(_M_state && _S_state_in_brace)) + __throw_regex_error(regex_constants::error_badbrace); + _M_state &= ~_S_state_in_brace; + _M_curToken = _S_token_interval_end; + } + } + else if (__c == _M_ctype.widen('x')) + { + ++_M_current; + if (_M_current == _M_end) + { + _M_curToken = _S_token_eof; + return; + } + if (_M_ctype.is(_CtypeT::digit, *_M_current)) + { + _M_curValue.assign(1, *_M_current); + ++_M_current; + if (_M_current == _M_end) + { + _M_curToken = _S_token_eof; + return; + } + if (_M_ctype.is(_CtypeT::digit, *_M_current)) + { + _M_curValue += *_M_current; + ++_M_current; + return; + } + } + } + else if (__c == _M_ctype.widen('^') + || __c == _M_ctype.widen('.') + || __c == _M_ctype.widen('*') + || __c == _M_ctype.widen('$') + || __c == _M_ctype.widen('\\')) + { + _M_curToken = _S_token_ord_char; + _M_curValue.assign(1, __c); + } + else if (_M_ctype.is(_CtypeT::digit, __c)) + { + _M_curToken = _S_token_backref; + _M_curValue.assign(1, __c); + } + else + __throw_regex_error(regex_constants::error_escape); + } + + + // Eats a character class or throwns an exception. + // current point to ':' delimiter on entry, char after ']' on return + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_eat_charclass() + { + ++_M_current; // skip ':' + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_ctype); + for (_M_curValue.clear(); + _M_current != _M_end && *_M_current != _M_ctype.widen(':'); + ++_M_current) + _M_curValue += *_M_current; + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_ctype); + ++_M_current; // skip ':' + if (*_M_current != _M_ctype.widen(']')) + __throw_regex_error(regex_constants::error_ctype); + ++_M_current; // skip ']' + } + + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_eat_equivclass() + { + ++_M_current; // skip '=' + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_collate); + for (_M_curValue.clear(); + _M_current != _M_end && *_M_current != _M_ctype.widen('='); + ++_M_current) + _M_curValue += *_M_current; + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_collate); + ++_M_current; // skip '=' + if (*_M_current != _M_ctype.widen(']')) + __throw_regex_error(regex_constants::error_collate); + ++_M_current; // skip ']' + } + + + template<typename _InputIterator> + void + _Scanner<_InputIterator>:: + _M_eat_collsymbol() + { + ++_M_current; // skip '.' + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_collate); + for (_M_curValue.clear(); + _M_current != _M_end && *_M_current != _M_ctype.widen('.'); + ++_M_current) + _M_curValue += *_M_current; + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_collate); + ++_M_current; // skip '.' + if (*_M_current != _M_ctype.widen(']')) + __throw_regex_error(regex_constants::error_collate); + ++_M_current; // skip ']' + } + +#ifdef _GLIBCXX_DEBUG + template<typename _InputIterator> + std::ostream& + _Scanner<_InputIterator>:: + _M_print(std::ostream& ostr) + { + switch (_M_curToken) + { + case _S_token_anychar: + ostr << "any-character\n"; + break; + case _S_token_backref: + ostr << "backref\n"; + break; + case _S_token_bracket_begin: + ostr << "bracket-begin\n"; + break; + case _S_token_bracket_end: + ostr << "bracket-end\n"; + break; + case _S_token_char_class_name: + ostr << "char-class-name \"" << _M_curValue << "\"\n"; + break; + case _S_token_closure0: + ostr << "closure0\n"; + break; + case _S_token_closure1: + ostr << "closure1\n"; + break; + case _S_token_collelem_multi: + ostr << "coll-elem-multi \"" << _M_curValue << "\"\n"; + break; + case _S_token_collelem_single: + ostr << "coll-elem-single \"" << _M_curValue << "\"\n"; + break; + case _S_token_collsymbol: + ostr << "collsymbol \"" << _M_curValue << "\"\n"; + break; + case _S_token_comma: + ostr << "comma\n"; + break; + case _S_token_dash: + ostr << "dash\n"; + break; + case _S_token_dup_count: + ostr << "dup count: " << _M_curValue << "\n"; + break; + case _S_token_eof: + ostr << "EOF\n"; + break; + case _S_token_equiv_class_name: + ostr << "equiv-class-name \"" << _M_curValue << "\"\n"; + break; + case _S_token_interval_begin: + ostr << "interval begin\n"; + break; + case _S_token_interval_end: + ostr << "interval end\n"; + break; + case _S_token_line_begin: + ostr << "line begin\n"; + break; + case _S_token_line_end: + ostr << "line end\n"; + break; + case _S_token_opt: + ostr << "opt\n"; + break; + case _S_token_or: + ostr << "or\n"; + break; + case _S_token_ord_char: + ostr << "ordinary character: \"" << _M_value() << "\"\n"; + break; + case _S_token_quoted_char: + ostr << "quoted char\n"; + break; + case _S_token_subexpr_begin: + ostr << "subexpr begin\n"; + break; + case _S_token_subexpr_end: + ostr << "subexpr end\n"; + break; + case _S_token_word_begin: + ostr << "word begin\n"; + break; + case _S_token_word_end: + ostr << "word end\n"; + break; + case _S_token_unknown: + ostr << "-- unknown token --\n"; + break; + } + return ostr; + } +#endif + + // Builds an NFA from an input iterator interval. + template<typename _InIter, typename _TraitsT> + class _Compiler + { + public: + typedef _InIter _IterT; + typedef typename std::iterator_traits<_InIter>::value_type _CharT; + typedef std::basic_string<_CharT> _StringT; + typedef regex_constants::syntax_option_type _FlagT; + + public: + _Compiler(const _InIter& __b, const _InIter& __e, + _TraitsT& __traits, _FlagT __flags); + + const _Nfa& + _M_nfa() const + { return _M_state_store; } + + private: + typedef _Scanner<_InIter> _ScannerT; + typedef typename _ScannerT::_TokenT _TokenT; + typedef std::stack<_StateSeq, std::vector<_StateSeq> > _StackT; + typedef _RangeMatcher<_InIter, _TraitsT> _RMatcherT; + + // accepts a specific token or returns false. + bool + _M_match_token(_TokenT __token); + + void + _M_disjunction(); + + bool + _M_alternative(); + + bool + _M_term(); + + bool + _M_assertion(); + + bool + _M_quantifier(); + + bool + _M_atom(); + + bool + _M_bracket_expression(); + + bool + _M_bracket_list(_RMatcherT& __matcher); + + bool + _M_follow_list(_RMatcherT& __matcher); + + bool + _M_follow_list2(_RMatcherT& __matcher); + + bool + _M_expression_term(_RMatcherT& __matcher); + + bool + _M_range_expression(_RMatcherT& __matcher); + + bool + _M_start_range(_RMatcherT& __matcher); + + bool + _M_collating_symbol(_RMatcherT& __matcher); + + bool + _M_equivalence_class(_RMatcherT& __matcher); + + bool + _M_character_class(_RMatcherT& __matcher); + + int + _M_cur_int_value(int __radix); + + private: + _TraitsT& _M_traits; + _ScannerT _M_scanner; + _StringT _M_cur_value; + _Nfa _M_state_store; + _StackT _M_stack; + }; + + template<typename _InIter, typename _TraitsT> + _Compiler<_InIter, _TraitsT>:: + _Compiler(const _InIter& __b, const _InIter& __e, _TraitsT& __traits, + _Compiler<_InIter, _TraitsT>::_FlagT __flags) + : _M_traits(__traits), _M_scanner(__b, __e, __flags, _M_traits.getloc()), + _M_state_store(__flags) + { + using std::bind; + using std::placeholders::_1; + using std::placeholders::_2; + typedef _StartTagger<_InIter, _TraitsT> _Start; + typedef _EndTagger<_InIter, _TraitsT> _End; + + _StateSeq __r(_M_state_store, + _M_state_store._M_insert_subexpr_begin( + bind(_Start(0), _1, _2))); + _M_disjunction(); + if (!_M_stack.empty()) + { + __r._M_append(_M_stack.top()); + _M_stack.pop(); + } + __r._M_append(_M_state_store. + _M_insert_subexpr_end(0, bind(_End(0), _1, _2))); + __r._M_append(_M_state_store._M_insert_accept()); + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_match_token(_Compiler<_InIter, _TraitsT>::_TokenT token) + { + if (token == _M_scanner._M_token()) + { + _M_cur_value = _M_scanner._M_value(); + _M_scanner._M_advance(); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + void + _Compiler<_InIter, _TraitsT>:: + _M_disjunction() + { + this->_M_alternative(); + if (_M_match_token(_ScannerT::_S_token_or)) + { + _StateSeq __alt1 = _M_stack.top(); _M_stack.pop(); + this->_M_disjunction(); + _StateSeq __alt2 = _M_stack.top(); _M_stack.pop(); + _M_stack.push(_StateSeq(__alt1, __alt2)); + } + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_alternative() + { + if (this->_M_term()) + { + _StateSeq __re = _M_stack.top(); _M_stack.pop(); + this->_M_alternative(); + if (!_M_stack.empty()) + { + __re._M_append(_M_stack.top()); + _M_stack.pop(); + } + _M_stack.push(__re); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_term() + { + if (this->_M_assertion()) + return true; + if (this->_M_atom()) + { + this->_M_quantifier(); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_assertion() + { + if (_M_match_token(_ScannerT::_S_token_line_begin)) + { + // __m.push(_Matcher::_S_opcode_line_begin); + return true; + } + if (_M_match_token(_ScannerT::_S_token_line_end)) + { + // __m.push(_Matcher::_S_opcode_line_end); + return true; + } + if (_M_match_token(_ScannerT::_S_token_word_begin)) + { + // __m.push(_Matcher::_S_opcode_word_begin); + return true; + } + if (_M_match_token(_ScannerT::_S_token_word_end)) + { + // __m.push(_Matcher::_S_opcode_word_end); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_quantifier() + { + if (_M_match_token(_ScannerT::_S_token_closure0)) + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + _StateSeq __r(_M_stack.top(), -1); + __r._M_append(__r._M_front()); + _M_stack.pop(); + _M_stack.push(__r); + return true; + } + if (_M_match_token(_ScannerT::_S_token_closure1)) + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + _StateSeq __r(_M_state_store, + _M_state_store. + _M_insert_alt(_S_invalid_state_id, + _M_stack.top()._M_front())); + _M_stack.top()._M_append(__r); + return true; + } + if (_M_match_token(_ScannerT::_S_token_opt)) + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + _StateSeq __r(_M_stack.top(), -1); + _M_stack.pop(); + _M_stack.push(__r); + return true; + } + if (_M_match_token(_ScannerT::_S_token_interval_begin)) + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + if (!_M_match_token(_ScannerT::_S_token_dup_count)) + __throw_regex_error(regex_constants::error_badbrace); + _StateSeq __r(_M_stack.top()); + int __min_rep = _M_cur_int_value(10); + for (int __i = 1; __i < __min_rep; ++__i) + _M_stack.top()._M_append(__r._M_clone()); + if (_M_match_token(_ScannerT::_S_token_comma)) + if (_M_match_token(_ScannerT::_S_token_dup_count)) + { + int __n = _M_cur_int_value(10) - __min_rep; + if (__n < 0) + __throw_regex_error(regex_constants::error_badbrace); + for (int __i = 0; __i < __n; ++__i) + { + _StateSeq __r(_M_state_store, + _M_state_store. + _M_insert_alt(_S_invalid_state_id, + _M_stack.top()._M_front())); + _M_stack.top()._M_append(__r); + } + } + else + { + _StateSeq __r(_M_stack.top(), -1); + __r._M_push_back(__r._M_front()); + _M_stack.pop(); + _M_stack.push(__r); + } + if (!_M_match_token(_ScannerT::_S_token_interval_end)) + __throw_regex_error(regex_constants::error_brace); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_atom() + { + using std::bind; + using std::placeholders::_1; + using std::placeholders::_2; + typedef _CharMatcher<_InIter, _TraitsT> _CMatcher; + typedef _StartTagger<_InIter, _TraitsT> _Start; + typedef _EndTagger<_InIter, _TraitsT> _End; + + if (_M_match_token(_ScannerT::_S_token_anychar)) + { + _M_stack.push(_StateSeq(_M_state_store, + _M_state_store. + _M_insert_matcher(bind(_AnyMatcher, _1)))); + return true; + } + if (_M_match_token(_ScannerT::_S_token_ord_char)) + { + _M_stack.push(_StateSeq + (_M_state_store, _M_state_store. + _M_insert_matcher + (bind(_CMatcher(_M_cur_value[0], _M_traits), _1)))); + return true; + } + if (_M_match_token(_ScannerT::_S_token_quoted_char)) + { + // note that in the ECMA grammar, this case covers backrefs. + _M_stack.push(_StateSeq(_M_state_store, + _M_state_store. + _M_insert_matcher + (bind(_CMatcher(_M_cur_value[0], _M_traits), + _1)))); + return true; + } + if (_M_match_token(_ScannerT::_S_token_backref)) + { + // __m.push(_Matcher::_S_opcode_ordchar, _M_cur_value); + return true; + } + if (_M_match_token(_ScannerT::_S_token_subexpr_begin)) + { + int __mark = _M_state_store._M_sub_count(); + _StateSeq __r(_M_state_store, + _M_state_store. + _M_insert_subexpr_begin(bind(_Start(__mark), _1, _2))); + this->_M_disjunction(); + if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) + __throw_regex_error(regex_constants::error_paren); + if (!_M_stack.empty()) + { + __r._M_append(_M_stack.top()); + _M_stack.pop(); + } + __r._M_append(_M_state_store._M_insert_subexpr_end + (__mark, bind(_End(__mark), _1, _2))); + _M_stack.push(__r); + return true; + } + return _M_bracket_expression(); + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_bracket_expression() + { + using std::bind; + using std::placeholders::_1; + if (_M_match_token(_ScannerT::_S_token_bracket_begin)) + { + _RMatcherT __matcher(_M_match_token(_ScannerT::_S_token_line_begin), + _M_traits); + if (!_M_bracket_list(__matcher) + || !_M_match_token(_ScannerT::_S_token_bracket_end)) + __throw_regex_error(regex_constants::error_brack); + _M_stack.push(_StateSeq(_M_state_store, + _M_state_store._M_insert_matcher + (bind(__matcher, _1)))); + return true; + } + return false; + } + + // If the dash is the last character in the bracket expression, it is not + // special. + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_bracket_list(_RMatcherT& __matcher) + { + if (_M_follow_list(__matcher)) + { + if (_M_match_token(_ScannerT::_S_token_dash)) + __matcher._M_add_char(_M_cur_value[0]); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_follow_list(_RMatcherT& __matcher) + { return _M_expression_term(__matcher) && _M_follow_list2(__matcher); } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_follow_list2(_RMatcherT& __matcher) + { + if (_M_expression_term(__matcher)) + return _M_follow_list2(__matcher); + return true; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_expression_term(_RMatcherT& __matcher) + { + return (_M_collating_symbol(__matcher) + || _M_character_class(__matcher) + || _M_equivalence_class(__matcher) + || (_M_start_range(__matcher) + && _M_range_expression(__matcher))); + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_range_expression(_RMatcherT& __matcher) + { + if (!_M_collating_symbol(__matcher)) + if (!_M_match_token(_ScannerT::_S_token_dash)) + __throw_regex_error(regex_constants::error_range); + __matcher._M_make_range(); + return true; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_start_range(_RMatcherT& __matcher) + { return _M_match_token(_ScannerT::_S_token_dash); } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_collating_symbol(_RMatcherT& __matcher) + { + if (_M_match_token(_ScannerT::_S_token_collelem_single)) + { + __matcher._M_add_char(_M_cur_value[0]); + return true; + } + if (_M_match_token(_ScannerT::_S_token_collsymbol)) + { + __matcher._M_add_collating_element(_M_cur_value); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_equivalence_class(_RMatcherT& __matcher) + { + if (_M_match_token(_ScannerT::_S_token_equiv_class_name)) + { + __matcher._M_add_equivalence_class(_M_cur_value); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + bool + _Compiler<_InIter, _TraitsT>:: + _M_character_class(_RMatcherT& __matcher) + { + if (_M_match_token(_ScannerT::_S_token_char_class_name)) + { + __matcher._M_add_character_class(_M_cur_value); + return true; + } + return false; + } + + template<typename _InIter, typename _TraitsT> + int + _Compiler<_InIter, _TraitsT>:: + _M_cur_int_value(int __radix) + { + int __v = 0; + for (typename _StringT::size_type __i = 0; + __i < _M_cur_value.length(); ++__i) + __v =__v * __radix + _M_traits.value(_M_cur_value[__i], __radix); + return __v; + } + + template<typename _InIter, typename _TraitsT> + _AutomatonPtr + __compile(const _InIter& __b, const _InIter& __e, _TraitsT& __t, + regex_constants::syntax_option_type __f) + { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t, + __f)._M_nfa())); } + +} // namespace __regex +} // namespace std + +/* vim: set ts=8 sw=2 sts=2: */ diff --git a/libstdc++-v3/include/bits/regex_constants.h b/libstdc++-v3/include/bits/regex_constants.h new file mode 100644 index 00000000000..787b88b8cd4 --- /dev/null +++ b/libstdc++-v3/include/bits/regex_constants.h @@ -0,0 +1,299 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_constants + * @brief Constant definitions for the std regex library. + * + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ + +/** + * @namespace std::regex_constants + * @brief ISO C++-0x entities sub namespace for regex. + */ +namespace regex_constants +{ + /** + * @name 5.1 Regular Expression Syntax Options + */ + //@{ + enum __syntax_option + { + _S_icase, + _S_nosubs, + _S_optimize, + _S_collate, + _S_ECMAScript, + _S_basic, + _S_extended, + _S_awk, + _S_grep, + _S_egrep, + _S_syntax_last + }; + + /** + * @brief This is a bitmask type indicating how to interpret the regex. + * + * The @c syntax_option_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + * + * A valid value of type syntax_option_type shall have exactly one of the + * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep + * %set. + */ + typedef unsigned int syntax_option_type; + + /** + * Specifies that the matching of regular expressions against a character + * sequence shall be performed without regard to case. + */ + static const syntax_option_type icase = 1 << _S_icase; + + /** + * Specifies that when a regular expression is matched against a character + * container sequence, no sub-expression matches are to be stored in the + * supplied match_results structure. + */ + static const syntax_option_type nosubs = 1 << _S_nosubs; + + /** + * Specifies that the regular expression engine should pay more attention to + * the speed with which regular expressions are matched, and less to the + * speed with which regular expression objects are constructed. Otherwise + * it has no detectable effect on the program output. + */ + static const syntax_option_type optimize = 1 << _S_optimize; + + /** + * Specifies that character ranges of the form [a-b] should be locale + * sensitive. + */ + static const syntax_option_type collate = 1 << _S_collate; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript + * Language Specification, Standard Ecma-262, third edition, 1999], as + * modified in section [28.13]. This grammar is similar to that defined + * in the PERL scripting language but extended with elements found in the + * POSIX regular expression grammar. + */ + static const syntax_option_type ECMAScript = 1 << _S_ECMAScript; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001, + * Portable Operating System Interface (POSIX), Base Definitions and + * Headers, Section 9, Regular Expressions [IEEE, Information Technology -- + * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + */ + static const syntax_option_type basic = 1 << _S_basic; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001, + * Portable Operating System Interface (POSIX), Base Definitions and Headers, + * Section 9, Regular Expressions. + */ + static const syntax_option_type extended = 1 << _S_extended; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is + * identical to syntax_option_type extended, except that C-style escape + * sequences are supported. These sequences are: + * \\\\, \\a, \\b, \\f, \\n, \\r, \\t , \\v, \\', ', + * and \\ddd (where ddd is one, two, or three octal digits). + */ + static const syntax_option_type awk = 1 << _S_awk; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is + * identical to syntax_option_type basic, except that newlines are treated + * as whitespace. + */ + static const syntax_option_type grep = 1 << _S_grep; + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility grep when given the -E option in + * IEEE Std 1003.1-2001. This option is identical to syntax_option_type + * extended, except that newlines are treated as whitespace. + */ + static const syntax_option_type egrep = 1 << _S_egrep; + + //@} + + /** + * @name 5.2 Matching Rules + * + * Matching a regular expression against a sequence of characters [first, + * last) proceeds according to the rules of the grammar specified for the + * regular expression object, modified according to the effects listed + * below for any bitmask elements set. + * + */ + //@{ + + enum __match_flag + { + _S_not_bol, + _S_not_eol, + _S_not_bow, + _S_not_eow, + _S_any, + _S_not_null, + _S_continuous, + _S_prev_avail, + _S_sed, + _S_no_copy, + _S_first_only, + _S_match_flag_last + }; + + /** + * @brief This is a bitmask type indicating regex matching rules. + * + * The @c match_flag_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + */ + typedef std::bitset<_S_match_flag_last> match_flag_type; + + /** + * The default matching rules. + */ + static const match_flag_type match_default = 0; + + /** + * The first character in the sequence [first, last) is treated as though it + * is not at the beginning of a line, so the character (^) in the regular + * expression shall not match [first, first). + */ + static const match_flag_type match_not_bol = 1 << _S_not_bol; + + /** + * The last character in the sequence [first, last) is treated as though it + * is not at the end of a line, so the character ($) in the regular + * expression shall not match [last, last). + */ + static const match_flag_type match_not_eol = 1 << _S_not_eol; + + /** + * The expression \\b is not matched against the sub-sequence + * [first,first). + */ + static const match_flag_type match_not_bow = 1 << _S_not_bow; + + /** + * The expression \\b should not be matched against the sub-sequence + * [last,last). + */ + static const match_flag_type match_not_eow = 1 << _S_not_eow; + + /** + * If more than one match is possible then any match is an acceptable + * result. + */ + static const match_flag_type match_any = 1 << _S_any; + + /** + * The expression does not match an empty sequence. + */ + static const match_flag_type match_not_null = 1 << _S_not_null; + + /** + * The expression only matches a sub-sequence that begins at first . + */ + static const match_flag_type match_continuous = 1 << _S_continuous; + + /** + * --first is a valid iterator position. When this flag is set then the + * flags match_not_bol and match_not_bow are ignored by the regular + * expression algorithms 7.11 and iterators 7.12. + */ + static const match_flag_type match_prev_avail = 1 << _S_prev_avail; + + /** + * When a regular expression match is to be replaced by a new string, the + * new string is constructed using the rules used by the ECMAScript replace + * function in ECMA- 262 [Ecma International, ECMAScript Language + * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11 + * String.prototype.replace. In addition, during search and replace + * operations all non-overlapping occurrences of the regular expression + * are located and replaced, and sections of the input that did not match + * the expression are copied unchanged to the output string. + * + * Format strings (from ECMA-262 [15.5.4.11]): + * @li $$ The dollar-sign itself ($) + * @li $& The matched substring. + * @li $` The portion of @a string that precedes the matched substring. + * This would be match_results::prefix(). + * @li $' The portion of @a string that follows the matched substring. + * This would be match_results::suffix(). + * @li $n The nth capture, where n is in [1,9] and $n is not followed by a + * decimal digit. If n <= match_results::size() and the nth capture + * is undefined, use the empty string instead. If n > + * match_results::size(), the result is implementation-defined. + * @li $nn The nnth capture, where nn is a two-digit decimal number on + * [01, 99]. If nn <= match_results::size() and the nth capture is + * undefined, use the empty string instead. If + * nn > match_results::size(), the result is implementation-defined. + */ + static const match_flag_type format_default = 0; + + /** + * When a regular expression match is to be replaced by a new string, the + * new string is constructed using the rules used by the POSIX sed utility + * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable + * Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + */ + static const match_flag_type format_sed = 1 << _S_sed; + + /** + * During a search and replace operation, sections of the character + * container sequence being searched that do not match the regular + * expression shall not be copied to the output string. + */ + static const match_flag_type format_no_copy = 1 << _S_no_copy; + + /** + * When specified during a search and replace operation, only the first + * occurrence of the regular expression shall be replaced. + */ + static const match_flag_type format_first_only = 1 << _S_first_only; + + //@} + +} // namespace regex_constants +} // namespace std + diff --git a/libstdc++-v3/include/bits/regex_cursor.h b/libstdc++-v3/include/bits/regex_cursor.h new file mode 100644 index 00000000000..e8330fb7885 --- /dev/null +++ b/libstdc++-v3/include/bits/regex_cursor.h @@ -0,0 +1,92 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_cursor.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ +namespace __regex +{ + // ABC for pattern matching + struct _PatternCursor + { + virtual ~_PatternCursor() { }; + virtual void _M_next() = 0; + virtual bool _M_at_end() const = 0; + }; + + // Provides a cursor into the specific target string. + template<typename _FwdIterT> + class _SpecializedCursor + : public _PatternCursor + { + public: + _SpecializedCursor(const _FwdIterT& __b, const _FwdIterT __e) + : _M_b(__b), _M_c(__b), _M_e(__e) + { } + + typename std::iterator_traits<_FwdIterT>::value_type + _M_current() const + { return *_M_c; } + + void + _M_next() + { ++_M_c; } + + _FwdIterT + _M_pos() const + { return _M_c; } + + const _FwdIterT& + _M_begin() const + { return _M_b; } + + const _FwdIterT& + _M_end() const + { return _M_e; } + + bool + _M_at_end() const + { return _M_c == _M_e; } + + private: + _FwdIterT _M_b; + _FwdIterT _M_c; + _FwdIterT _M_e; + }; + + // Helper funxtion to create a cursor specialized for an iterator class. + template<typename _FwdIterT> + inline _SpecializedCursor<_FwdIterT> + __cursor(const _FwdIterT& __b, const _FwdIterT __e) + { return _SpecializedCursor<_FwdIterT>(__b, __e); } + +} // namespace __regex +} // namespace std + +/* vim: set ts=8 sw=2 sts=2: */ diff --git a/libstdc++-v3/include/bits/regex_error.h b/libstdc++-v3/include/bits/regex_error.h new file mode 100644 index 00000000000..56bfae4cc66 --- /dev/null +++ b/libstdc++-v3/include/bits/regex_error.h @@ -0,0 +1,160 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_error + * @brief Error and exception objects for the std regex library. + * + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ + +namespace regex_constants +{ + /** + * @name 5.3 Error Types + */ + //@{ + + enum error_type + { + _S_error_collate, + _S_error_ctype, + _S_error_escape, + _S_error_backref, + _S_error_brack, + _S_error_paren, + _S_error_brace, + _S_error_badbrace, + _S_error_range, + _S_error_space, + _S_error_badrepeat, + _S_error_complexity, + _S_error_stack, + _S_error_last + }; + + /** The expression contained an invalid collating element name. */ + static const error_type error_collate(_S_error_collate); + + /** The expression contained an invalid character class name. */ + static const error_type error_ctype(_S_error_ctype); + + /** + * The expression contained an invalid escaped character, or a trailing + * escape. + */ + static const error_type error_escape(_S_error_escape); + + /** The expression contained an invalid back reference. */ + static const error_type error_backref(_S_error_backref); + + /** The expression contained mismatched [ and ]. */ + static const error_type error_brack(_S_error_brack); + + /** The expression contained mismatched ( and ). */ + static const error_type error_paren(_S_error_paren); + + /** The expression contained mismatched { and } */ + static const error_type error_brace(_S_error_brace); + + /** The expression contained an invalid range in a {} expression. */ + static const error_type error_badbrace(_S_error_badbrace); + + /** + * The expression contained an invalid character range, + * such as [b-a] in most encodings. + */ + static const error_type error_range(_S_error_range); + + /** + * There was insufficient memory to convert the expression into a + * finite state machine. + */ + static const error_type error_space(_S_error_space); + + /** + * One of <em>*?+{<em> was not preceded by a valid regular expression. + */ + static const error_type error_badrepeat(_S_error_badrepeat); + + /** + * The complexity of an attempted match against a regular expression + * exceeded a pre-set level. + */ + static const error_type error_complexity(_S_error_complexity); + + /** + * There was insufficient memory to determine whether the + * regular expression could match the specified character sequence. + */ + static const error_type error_stack(_S_error_stack); + + //@} +} + + // [7.8] Class regex_error + /** + * @brief A regular expression exception class. + * @ingroup exceptions + * + * The regular expression library throws objects of this class on error. + */ + class regex_error + : public std::runtime_error + { + public: + /** + * @brief Constructs a regex_error object. + * + * @param ecode the regex error code. + */ + explicit + regex_error(regex_constants::error_type __ecode) + : std::runtime_error("regex_error"), _M_code(__ecode) + { } + + /** + * @brief Gets the regex error code. + * + * @returns the regex error code. + */ + regex_constants::error_type + code() const + { return _M_code; } + + protected: + regex_constants::error_type _M_code; + }; + + + inline void + __throw_regex_error(regex_constants::error_type __ecode) + { throw regex_error(__ecode); } + +} // namespace std + diff --git a/libstdc++-v3/include/bits/regex_grep_matcher.h b/libstdc++-v3/include/bits/regex_grep_matcher.h new file mode 100644 index 00000000000..f243c92406b --- /dev/null +++ b/libstdc++-v3/include/bits/regex_grep_matcher.h @@ -0,0 +1,131 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_executor.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + + +namespace std +{ + template<typename _BiIter> + class sub_match; + + template<typename _Bi_iter, typename _Allocator> + class match_results; + +namespace __regex +{ + // A _Results facade specialized for wrapping a templated sub_match. + template<typename _FwdIterT, typename _Alloc> + class _SpecializedResults + : public _Results + { + public: + _SpecializedResults(const _Automaton::_SizeT __size, + const _SpecializedCursor<_FwdIterT>& __cursor, + match_results<_FwdIterT, _Alloc>& __m); + + void + _M_set_pos(int __i, int __j, const _PatternCursor& __pc); + + void + _M_set_matched(int __i, bool __is_matched) + { _M_results.at(__i).matched = __is_matched; } + + private: + match_results<_FwdIterT, _Alloc>& _M_results; + }; + + template<typename _FwdIterT, typename _Alloc> + _SpecializedResults<_FwdIterT, _Alloc>:: + _SpecializedResults(const _Automaton::_SizeT __size, + const _SpecializedCursor<_FwdIterT>& __cursor, + match_results<_FwdIterT, _Alloc>& __m) + : _M_results(__m) + { + typedef typename match_results<_FwdIterT, _Alloc>::size_type size_type; + _M_results.clear(); + std::sub_match<_FwdIterT> __sm; + __sm.matched = false; + size_type __result_count = __size + 2; + for (size_type __i = 0; __i < __result_count; ++__i) + _M_results.push_back(__sm); + _M_results.at(__size+0).first = __cursor._M_begin(); + _M_results.at(__size+0).second = __cursor._M_begin(); + _M_results.at(__size+1).first = __cursor._M_end(); + _M_results.at(__size+1).second = __cursor._M_end(); + } + + template<typename _FwdIterT, typename _Alloc> + void + _SpecializedResults<_FwdIterT, _Alloc>:: + _M_set_pos(int __i, int __j, const _PatternCursor& __pc) + { + typedef const _SpecializedCursor<_FwdIterT>& _CursorT; + _CursorT __c = static_cast<_CursorT>(__pc); + if (__j == 0) + _M_results.at(__i).first = __c._M_pos(); + else + _M_results.at(__i).second = __c._M_pos()+1; + } + + // A stack of states used in evaluating the NFA. + typedef std::stack<_StateIdT, std::vector<_StateIdT> > _StateStack; + + // Executes a regular expression NFA/DFA over a range using a variant of + // the parallel execution algorithm featured in the grep utility, modified + // to use Laurikari tags. + class _Grep_matcher + { + public: + _Grep_matcher(_PatternCursor& __p, + _Results& __r, + const _AutomatonPtr& __automaton, + regex_constants::match_flag_type __flags); + + private: + _StateSet + _M_e_closure(_StateIdT __i); + + _StateSet + _M_e_closure(const _StateSet& __s); + + _StateSet + _M_e_closure(_StateStack& __stack, const _StateSet& __s); + + private: + const std::shared_ptr<_Nfa> _M_nfa; + _PatternCursor& _M_pattern; + _Results& _M_results; + }; + +} // namespace __regex +} // namespace std + +#include <bits/regex_grep_matcher.tcc> + +/* vim: set ts=8 sw=2 sts=2: */ diff --git a/libstdc++-v3/include/bits/regex_grep_matcher.tcc b/libstdc++-v3/include/bits/regex_grep_matcher.tcc new file mode 100644 index 00000000000..17d1e6449dc --- /dev/null +++ b/libstdc++-v3/include/bits/regex_grep_matcher.tcc @@ -0,0 +1,177 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file regex_grep_matcher.cc + */ +#include <regex> + +namespace std +{ + +namespace +{ + + // A stack of states used in evaluating the NFA. + typedef std::stack<std::__regex::_StateIdT, + std::vector<std::__regex::_StateIdT> + > _StateStack; + + // Obtains the next state set given the current state set __s and the current + // input character. + inline std::__regex::_StateSet + __move(const std::__regex::_PatternCursor& __p, + const std::__regex::_Nfa& __nfa, + const std::__regex::_StateSet& __s) + { + std::__regex::_StateSet __m; + for (std::__regex::_StateSet::const_iterator __i = __s.begin(); + __i != __s.end(); ++__i) + { + if (*__i == std::__regex::_S_invalid_state_id) + continue; + + const std::__regex::_State& __state = __nfa[*__i]; + if (__state._M_opcode == std::__regex::_S_opcode_match + && __state._M_matches(__p)) + __m.insert(__state._M_next); + } + return __m; + } + + // returns true if (__s intersect __t) is not empty + inline bool + __includes_some(const std::__regex::_StateSet& __s, + const std::__regex::_StateSet& __t) + { + if (__s.size() > 0 && __t.size() > 0) + { + std::__regex::_StateSet::const_iterator __first = __s.begin(); + std::__regex::_StateSet::const_iterator __second = __t.begin(); + while (__first != __s.end() && __second != __t.end()) + { + if (*__first < *__second) + ++__first; + else if (*__second < *__first) + ++__second; + else + return true; + } + } + return false; + } + + // If an identified state __u is not already in the current state set __e, + // insert it and push it on the current state stack __s. + inline void + __add_visited_state(const std::__regex::_StateIdT __u, + _StateStack& __s, + std::__regex::_StateSet& __e) + { + if (__e.count(__u) == 0) + { + __e.insert(__u); + __s.push(__u); + } + } + +} // anonymous namespace + +namespace __regex +{ + inline _Grep_matcher:: + _Grep_matcher(_PatternCursor& __p, _Results& __r, + const _AutomatonPtr& __nfa, + regex_constants::match_flag_type __flags) + : _M_nfa(static_pointer_cast<_Nfa>(__nfa)), _M_pattern(__p), _M_results(__r) + { + __regex::_StateSet __t = this->_M_e_closure(_M_nfa->_M_start()); + for (; !_M_pattern._M_at_end(); _M_pattern._M_next()) + __t = this->_M_e_closure(__move(_M_pattern, *_M_nfa, __t)); + + _M_results._M_set_matched(0, + __includes_some(_M_nfa->_M_final_states(), __t)); + } + + // Creates the e-closure set for the initial state __i. + inline _StateSet _Grep_matcher:: + _M_e_closure(_StateIdT __i) + { + _StateSet __s; + __s.insert(__i); + _StateStack __stack; + __stack.push(__i); + return this->_M_e_closure(__stack, __s); + } + + // Creates the e-closure set for an arbitrary state set __s. + inline _StateSet _Grep_matcher:: + _M_e_closure(const _StateSet& __s) + { + _StateStack __stack; + for (_StateSet::const_iterator __i = __s.begin(); __i != __s.end(); ++__i) + __stack.push(*__i); + return this->_M_e_closure(__stack, __s); + } + + inline _StateSet _Grep_matcher:: + _M_e_closure(_StateStack& __stack, const _StateSet& __s) + { + _StateSet __e = __s; + while (!__stack.empty()) + { + _StateIdT __t = __stack.top(); __stack.pop(); + if (__t == _S_invalid_state_id) + continue; + // for each __u with edge from __t to __u labeled e do ... + const _State& __state = _M_nfa->operator[](__t); + switch (__state._M_opcode) + { + case _S_opcode_alternative: + __add_visited_state(__state._M_next, __stack, __e); + __add_visited_state(__state._M_alt, __stack, __e); + break; + case _S_opcode_subexpr_begin: + __add_visited_state(__state._M_next, __stack, __e); + __state._M_tagger(_M_pattern, _M_results); + break; + case _S_opcode_subexpr_end: + __add_visited_state(__state._M_next, __stack, __e); + __state._M_tagger(_M_pattern, _M_results); + _M_results._M_set_matched(__state._M_subexpr, true); + break; + case _S_opcode_accept: + __add_visited_state(__state._M_next, __stack, __e); + break; + default: + break; + } + } + return __e; + } + +} // namespace __regex +} // namespace std + +/* vim: set ts=8 sw=2 sts=2: */ diff --git a/libstdc++-v3/include/bits/regex_nfa.h b/libstdc++-v3/include/bits/regex_nfa.h new file mode 100644 index 00000000000..2a938915b97 --- /dev/null +++ b/libstdc++-v3/include/bits/regex_nfa.h @@ -0,0 +1,403 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file bits/regex_nfa.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +namespace std +{ +namespace __regex +{ + + // Base class for, um, automata. Could be an NFA or a DFA. Your choice. + class _Automaton + { + public: + typedef unsigned int _SizeT; + + public: + virtual + ~_Automaton() + { } + + virtual _SizeT + _M_sub_count() const = 0; + +#ifdef _GLIBCXX_DEBUG + virtual std::ostream& + _M_dot(std::ostream& __ostr) const = 0; +#endif + }; + + // Generic shred pointer to an automaton. + typedef std::shared_ptr<_Automaton> _AutomatonPtr; + + // Operation codes that define the type of transitions within the base NFA + // that represents the regular expression. + enum _Opcode + { + _S_opcode_unknown = 0, + _S_opcode_alternative = 1, + _S_opcode_subexpr_begin = 4, + _S_opcode_subexpr_end = 5, + _S_opcode_match = 100, + _S_opcode_accept = 255 + }; + + // Provides a generic facade for a templated match_results. + struct _Results + { + virtual void _M_set_pos(int __i, int __j, const _PatternCursor& __p) = 0; + virtual void _M_set_matched(int __i, bool __is_matched) = 0; + }; + + // Tags current state (for subexpr begin/end). + typedef std::function<void (const _PatternCursor&, _Results&)> _Tagger; + + template<typename _FwdIterT, typename _TraitsT> + struct _StartTagger + : public _Tagger + { + explicit + _StartTagger(int __i) + : _M_index(__i) + { } + + void + operator()(const _PatternCursor& __pc, _Results& __r) + { __r._M_set_pos(_M_index, 0, __pc); } + + int _M_index; + }; + + template<typename _FwdIterT, typename _TraitsT> + struct _EndTagger + : public _Tagger + { + explicit + _EndTagger(int __i) + : _M_index(__i) + { } + + void + operator()(const _PatternCursor& __pc, _Results& __r) + { __r._M_set_pos(_M_index, 1, __pc); } + + int _M_index; + _FwdIterT _M_pos; + }; + // Indicates if current state matches cursor current. + typedef std::function<bool (const _PatternCursor&)> _Matcher; + + // Matches any character + inline bool + _AnyMatcher(const _PatternCursor&) + { return true; } + + // Matches a single character + template<typename _InIterT, typename _TraitsT> + struct _CharMatcher + : public _Matcher + { + typedef typename _TraitsT::char_type char_type; + + explicit + _CharMatcher(char_type __c, const _TraitsT& __t = _TraitsT()) + : _M_traits(__t), _M_c(_M_traits.translate(__c)) + { } + + bool + operator()(const _PatternCursor& __pc) const + { + typedef const _SpecializedCursor<_InIterT>& _CursorT; + _CursorT __c = static_cast<_CursorT>(__pc); + return _M_traits.translate(__c._M_current()) == _M_c; + } + + const _TraitsT& _M_traits; + char_type _M_c; + }; + + // Matches a character range (bracket expression) + template<typename _InIterT, typename _TraitsT> + struct _RangeMatcher + : public _Matcher + { + typedef typename _TraitsT::char_type _CharT; + typedef std::basic_string<_CharT> _StringT; + + explicit + _RangeMatcher(bool __is_non_matching, const _TraitsT& __t = _TraitsT()) + : _M_traits(__t), _M_is_non_matching(__is_non_matching) + { } + + bool + operator()(const _PatternCursor& __pc) const + { + typedef const _SpecializedCursor<_InIterT>& _CursorT; + _CursorT __c = static_cast<_CursorT>(__pc); + return true; + } + + void + _M_add_char(_CharT __c) + { } + + void + _M_add_collating_element(const _StringT& __s) + { } + + void + _M_add_equivalence_class(const _StringT& __s) + { } + + void + _M_add_character_class(const _StringT& __s) + { } + + void + _M_make_range() + { } + + const _TraitsT& _M_traits; + bool _M_is_non_matching; + }; + + // Identifies a state in the NFA. + typedef int _StateIdT; + + // The special case in which a state identifier is not an index. + static const _StateIdT _S_invalid_state_id = -1; + + + // An individual state in an NFA + // + // In this case a "state" is an entry in the NFA definition coupled with its + // outgoing transition(s). All states have a single outgoing transition, + // except for accepting states (which have no outgoing transitions) and alt + // states, which have two outgoing transitions. + // + struct _State + { + typedef int _OpcodeT; + + _OpcodeT _M_opcode; // type of outgoing transition + _StateIdT _M_next; // outgoing tranition + _StateIdT _M_alt; // for _S_opcode_alternative + unsigned int _M_subexpr; // for _S_opcode_subexpr_* + _Tagger _M_tagger; // for _S_opcode_subexpr_* + _Matcher _M_matches; // for _S_opcode_match + + explicit _State(_OpcodeT __opcode) + : _M_opcode(__opcode), _M_next(_S_invalid_state_id) + { } + + _State(const _Matcher& __m) + : _M_opcode(_S_opcode_match), _M_next(_S_invalid_state_id), _M_matches(__m) + { } + + _State(_OpcodeT __opcode, unsigned int __s, const _Tagger& __t) + : _M_opcode(__opcode), _M_next(_S_invalid_state_id), _M_subexpr(__s), + _M_tagger(__t) + { } + + _State(_StateIdT __next, _StateIdT __alt) + : _M_opcode(_S_opcode_alternative), _M_next(__next), _M_alt(__alt) + { } + +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_print(std::ostream& ostr) const; + + // Prints graphviz dot commands for state. + std::ostream& + _M_dot(std::ostream& __ostr, _StateIdT __id) const; +#endif + }; + + + // The Grep Matcher works on sets of states. Here are sets of states. + typedef std::set<_StateIdT> _StateSet; + + // A collection of all states making up an NFA + // + // An NFA is a 4-tuple M = (K, S, s, F), where + // K is a finite set of states, + // S is the alphabet of the NFA, + // s is the initial state, + // F is a set of final (accepting) states. + // + // This NFA class is templated on S, a type that will hold values of the + // underlying alphabet (without regard to semantics of that alphabet). The + // other elements of the tuple are generated during construction of the NFA + // and are available through accessor member functions. + // + class _Nfa + : public _Automaton, public std::vector<_State> + { + public: + typedef _State _StateT; + typedef unsigned int _SizeT; + typedef regex_constants::syntax_option_type _FlagT; + + public: + _Nfa(_FlagT __f) + : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0) + { } + + ~_Nfa() + { } + + _FlagT + _M_options() const + { return _M_flags; } + + _StateIdT + _M_start() const + { return _M_start_state; } + + const _StateSet& + _M_final_states() const + { return _M_accepting_states; } + + _SizeT + _M_sub_count() const + { return _M_subexpr_count; } + + _StateIdT + _M_insert_accept() + { + this->push_back(_StateT(_S_opcode_accept)); + _M_accepting_states.insert(this->size()-1); + return this->size()-1; + } + + _StateIdT + _M_insert_alt(_StateIdT __next, _StateIdT __alt) + { + this->push_back(_StateT(__next, __alt)); + return this->size()-1; + } + + _StateIdT + _M_insert_matcher(_Matcher __m) + { + this->push_back(_StateT(__m)); + return this->size()-1; + } + + _StateIdT + _M_insert_subexpr_begin(const _Tagger& __t) + { + this->push_back(_StateT(_S_opcode_subexpr_begin, _M_subexpr_count++, __t)); + return this->size()-1; + } + + _StateIdT + _M_insert_subexpr_end(unsigned int __i, const _Tagger& __t) + { + this->push_back(_StateT(_S_opcode_subexpr_end, __i, __t)); + return this->size()-1; + } + +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_dot(std::ostream& __ostr) const; +#endif + + private: + _FlagT _M_flags; + _StateIdT _M_start_state; + _StateSet _M_accepting_states; + _SizeT _M_subexpr_count; + }; + + // Describes a sequence of one or more %_State, its current start and end(s). + // + // This structure contains fragments of an NFA during construction. + class _StateSeq + { + public: + // Constructs a single-node sequence + _StateSeq(_Nfa& __ss, _StateIdT __s, _StateIdT __e = _S_invalid_state_id) + : _M_nfa(__ss), _M_start(__s), _M_end1(__s), _M_end2(__e) + { } + // Constructs a split sequence from two other sequencces + _StateSeq(const _StateSeq& __e1, const _StateSeq& __e2) + : _M_nfa(__e1._M_nfa), + _M_start(_M_nfa._M_insert_alt(__e1._M_start, __e2._M_start)), + _M_end1(__e1._M_end1), _M_end2(__e2._M_end1) + { } + + // Constructs a split sequence from a single sequence + _StateSeq(const _StateSeq& __e, _StateIdT __id) + : _M_nfa(__e._M_nfa), + _M_start(_M_nfa._M_insert_alt(__id, __e._M_start)), + _M_end1(__id), _M_end2(__e._M_end1) + { } + + // Constructs a copy of a %_StateSeq + _StateSeq(const _StateSeq& __rhs) + : _M_nfa(__rhs._M_nfa), _M_start(__rhs._M_start), + _M_end1(__rhs._M_end1), _M_end2(__rhs._M_end2) + { } + + + _StateSeq& operator=(const _StateSeq& __rhs); + + _StateIdT + _M_front() const + { return _M_start; } + + // Extends a sequence by one. + void + _M_push_back(_StateIdT __id); + + // Extends and maybe joins a sequence. + void + _M_append(_StateIdT __id); + + void + _M_append(_StateSeq& __rhs); + + // Clones an entire sequence. + _StateIdT + _M_clone(); + + private: + _Nfa& _M_nfa; + _StateIdT _M_start; + _StateIdT _M_end1; + _StateIdT _M_end2; + + }; + +} // namespace __regex +} // namespace std + +#include <bits/regex_nfa.tcc> + diff --git a/libstdc++-v3/include/bits/regex_nfa.tcc b/libstdc++-v3/include/bits/regex_nfa.tcc new file mode 100644 index 00000000000..38ab7e0b2ae --- /dev/null +++ b/libstdc++-v3/include/bits/regex_nfa.tcc @@ -0,0 +1,170 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +/** + * @file regex_nfa.cc + */ +#include <regex> + +namespace std +{ +namespace __regex +{ +#ifdef _GLIBCXX_DEBUG +inline std::ostream& _State:: +_M_print(std::ostream& ostr) const +{ + switch (_M_opcode) + { + case _S_opcode_alternative: + ostr << "alt next=" << _M_next << " alt=" << _M_alt; + break; + case _S_opcode_subexpr_begin: + ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr; + break; + case _S_opcode_subexpr_end: + ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr; + break; + case _S_opcode_match: + ostr << "match next=" << _M_next; + break; + case _S_opcode_accept: + ostr << "accept next=" << _M_next; + break; + default: + ostr << "unknown next=" << _M_next; + break; + } + return ostr; +} + +// Prints graphviz dot commands for state. +inline std::ostream& _State:: +_M_dot(std::ostream& __ostr, _StateIdT __id) const +{ + switch (_M_opcode) + { + case _S_opcode_alternative: + __ostr << __id << " [label=\"" << __id << "\\nALT\"];\n" + << __id << " -> " << _M_next + << " [label=\"epsilon\", tailport=\"s\"];\n" + << __id << " -> " << _M_alt + << " [label=\"epsilon\", tailport=\"n\"];\n"; + break; + case _S_opcode_subexpr_begin: + __ostr << __id << " [label=\"" << __id << "\\nSBEGIN " + << _M_subexpr << "\"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_subexpr_end: + __ostr << __id << " [label=\"" << __id << "\\nSEND " + << _M_subexpr << "\"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_match: + __ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n" + << __id << " -> " << _M_next << " [label=\"<match>\"];\n"; + break; + case _S_opcode_accept: + __ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ; + break; + default: + __ostr << __id << " [label=\"" << __id << "\\nUNK\"];\n" + << __id << " -> " << _M_next << " [label=\"?\"];\n"; + break; + } + return __ostr; +} + +inline std::ostream& _Nfa:: +_M_dot(std::ostream& __ostr) const +{ + __ostr << "digraph _Nfa {\n" + << " rankdir=LR;\n"; + for (unsigned int __i = 0; __i < this->size(); ++__i) + { this->at(__i)._M_dot(__ostr, __i); } + __ostr << "}\n"; + return __ostr; +} +#endif + +inline _StateSeq& _StateSeq:: +operator=(const _StateSeq& __rhs) +{ + _M_start = __rhs._M_start; + _M_end1 = __rhs._M_end1; + _M_end2 = __rhs._M_end2; + return *this; +} + +inline void _StateSeq:: +_M_push_back(_StateIdT __id) +{ + if (_M_end1 != _S_invalid_state_id) + _M_nfa[_M_end1]._M_next = __id; + _M_end1 = __id; +} + +inline void _StateSeq:: +_M_append(_StateIdT __id) +{ + if (_M_end2 != _S_invalid_state_id) + { + if (_M_end2 == _M_end1) + _M_nfa[_M_end2]._M_alt = __id; + else + _M_nfa[_M_end2]._M_next = __id; + _M_end2 = _S_invalid_state_id; + } + if (_M_end1 != _S_invalid_state_id) + _M_nfa[_M_end1]._M_next = __id; + _M_end1 = __id; +} + +inline void _StateSeq:: +_M_append(_StateSeq& __rhs) +{ + if (_M_end2 != _S_invalid_state_id) + { + if (_M_end2 == _M_end1) + _M_nfa[_M_end2]._M_alt = __rhs._M_start; + else + _M_nfa[_M_end2]._M_next = __rhs._M_start; + _M_end2 = _S_invalid_state_id; + } + if (__rhs._M_end2 != _S_invalid_state_id) + _M_end2 = __rhs._M_end2; + if (_M_end1 != _S_invalid_state_id) + _M_nfa[_M_end1]._M_next = __rhs._M_start; + _M_end1 = __rhs._M_end1; +} + +// @todo implement this function. +inline _StateIdT _StateSeq:: +_M_clone() +{ return 0; } + +} // namespace __regex +} // namespace std + diff --git a/libstdc++-v3/include/bits/shared_ptr.h b/libstdc++-v3/include/bits/shared_ptr.h index 5e1960012c9..4f87dd459cf 100644 --- a/libstdc++-v3/include/bits/shared_ptr.h +++ b/libstdc++-v3/include/bits/shared_ptr.h @@ -123,6 +123,23 @@ _GLIBCXX_BEGIN_NAMESPACE(std) shared_ptr(_Tp1* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, __d) { } /** + * @brief Construct a %shared_ptr that owns a null pointer + * and the deleter @a __d. + * @param __p A null pointer constant. + * @param __d A deleter. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw + * + * The last owner will call __d(__p) + */ + template<typename _Deleter> + shared_ptr(nullptr_t __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, __d) { } + + /** * @brief Construct a %shared_ptr that owns the pointer @a __p * and the deleter @a __d. * @param __p A pointer. @@ -141,6 +158,25 @@ _GLIBCXX_BEGIN_NAMESPACE(std) shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a) : __shared_ptr<_Tp>(__p, __d, __a) { } + /** + * @brief Construct a %shared_ptr that owns a null pointer + * and the deleter @a __d. + * @param __p A null pointer constant. + * @param __d A deleter. + * @param __a An allocator. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw _Alloc's copy constructor and destructor must not + * throw. + * + * The last owner will call __d(__p) + */ + template<typename _Deleter, typename _Alloc> + shared_ptr(nullptr_t __p, _Deleter __d, const _Alloc& __a) + : __shared_ptr<_Tp>(__p, __d, __a) { } + // Aliasing constructor /** @@ -212,6 +248,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std) shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } + /** + * @brief Construct an empty %shared_ptr. + * @param __p A null pointer constant. + * @post use_count() == 0 && get() == nullptr + */ + shared_ptr(nullptr_t __p) : __shared_ptr<_Tp>(__p) { } + template<typename _Tp1> shared_ptr& operator=(const shared_ptr<_Tp1>& __r) // never throws @@ -471,6 +514,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) std::forward<_Args>(__args)...); } + /// std::hash specialization for shared_ptr. + template<typename _Tp> + struct hash<shared_ptr<_Tp>> + : public std::unary_function<shared_ptr<_Tp>, size_t> + { + size_t + operator()(const shared_ptr<_Tp>& __s) const + { return std::hash<_Tp*>()(__s.get()); } + }; + // @} group pointer_abstractions _GLIBCXX_END_NAMESPACE diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index 0c366b8ef1a..0a69d2b2411 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -85,6 +85,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) class _Sp_counted_ptr : public _Sp_counted_base<_Lp> { public: + explicit _Sp_counted_ptr(_Ptr __p) : _M_ptr(__p) { } @@ -107,6 +108,18 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ptr _M_ptr; // copy constructor must not throw }; + template<> + inline void + _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() { } + + template<> + inline void + _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() { } + + template<> + inline void + _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() { } + // Support for custom deleter and/or allocator template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp> class _Sp_counted_deleter : public _Sp_counted_ptr<_Ptr, _Lp> @@ -181,6 +194,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Base_type; public: + explicit _Sp_counted_ptr_inplace(_Alloc __a) : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a) , _M_storage() @@ -237,6 +251,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { } template<typename _Ptr> + explicit __shared_count(_Ptr __p) : _M_pi(0) { __try @@ -316,6 +331,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) #if _GLIBCXX_DEPRECATED // Special case for auto_ptr<_Tp> to provide the strong guarantee. template<typename _Tp> + explicit __shared_count(std::auto_ptr<_Tp>&& __r) : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) { __r.release(); } @@ -323,6 +339,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee. template<typename _Tp, typename _Del> + explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(_S_create_from_up(std::move(__r))) { __r.release(); } @@ -567,6 +584,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __enable_shared_from_this_helper(_M_refcount, __p, __p); } + template<typename _Deleter> + __shared_ptr(nullptr_t __p, _Deleter __d) + : _M_ptr(0), _M_refcount(__p, __d) + { } + + template<typename _Deleter, typename _Alloc> + __shared_ptr(nullptr_t __p, _Deleter __d, const _Alloc& __a) + : _M_ptr(0), _M_refcount(__p, __d, __a) + { } + template<typename _Tp1> __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws @@ -631,6 +658,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } #endif + /* TODO: use delegating constructor */ + __shared_ptr(nullptr_t) : _M_ptr(0), _M_refcount() // never throws + { } + template<typename _Tp1> __shared_ptr& operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws @@ -1133,6 +1164,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) std::forward<_Args>(__args)...); } + /// std::hash specialization for __shared_ptr. + template<typename _Tp, _Lock_policy _Lp> + struct hash<__shared_ptr<_Tp, _Lp>> + : public std::unary_function<__shared_ptr<_Tp, _Lp>, size_t> + { + size_t + operator()(const __shared_ptr<_Tp, _Lp>& __s) const + { return std::hash<_Tp*>()(__s.get()); } + }; + _GLIBCXX_END_NAMESPACE #endif // _SHARED_PTR_BASE_H diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h index 0489c413b95..cfaeef8f645 100644 --- a/libstdc++-v3/include/bits/stl_algobase.h +++ b/libstdc++-v3/include/bits/stl_algobase.h @@ -58,7 +58,6 @@ #define _STL_ALGOBASE_H 1 #include <bits/c++config.h> -#include <cstddef> #include <bits/functexcept.h> #include <bits/cpp_type_traits.h> #include <ext/type_traits.h> @@ -395,7 +394,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename iterator_traits<_II>::value_type _ValueTypeI; typedef typename iterator_traits<_OI>::value_type _ValueTypeO; typedef typename iterator_traits<_II>::iterator_category _Category; - const bool __simple = (__is_pod(_ValueTypeI) + const bool __simple = (__is_trivial(_ValueTypeI) && __is_pointer<_II>::__value && __is_pointer<_OI>::__value && __are_same<_ValueTypeI, _ValueTypeO>::__value); @@ -590,7 +589,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename iterator_traits<_BI1>::value_type _ValueType1; typedef typename iterator_traits<_BI2>::value_type _ValueType2; typedef typename iterator_traits<_BI1>::iterator_category _Category; - const bool __simple = (__is_pod(_ValueType1) + const bool __simple = (__is_trivial(_ValueType1) && __is_pointer<_BI1>::__value && __is_pointer<_BI2>::__value && __are_same<_ValueType1, _ValueType2>::__value); diff --git a/libstdc++-v3/include/bits/stl_construct.h b/libstdc++-v3/include/bits/stl_construct.h index 06a2902ca69..d84b8f164fd 100644 --- a/libstdc++-v3/include/bits/stl_construct.h +++ b/libstdc++-v3/include/bits/stl_construct.h @@ -67,19 +67,21 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * Constructs an object in existing memory by invoking an allocated * object's constructor with an initializer. */ - template<typename _T1, typename _T2> - inline void #ifdef __GXX_EXPERIMENTAL_CXX0X__ - // Allow perfect forwarding - _Construct(_T1* __p, _T2&& __value) + template<typename _T1, typename... _Args> + inline void + _Construct(_T1* __p, _Args&&... __args) + { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); } #else + template<typename _T1, typename _T2> + inline void _Construct(_T1* __p, const _T2& __value) -#endif { // _GLIBCXX_RESOLVE_LIB_DEFECTS // 402. wrong new expression in [some_]allocator::construct - ::new(static_cast<void*>(__p)) _T1(_GLIBCXX_FORWARD(_T2, __value)); + ::new(static_cast<void*>(__p)) _T1(__value); } +#endif /** * Destroy the object pointed to by a pointer type. diff --git a/libstdc++-v3/include/bits/stl_deque.h b/libstdc++-v3/include/bits/stl_deque.h index 19022b0cf34..d3cd73997e9 100644 --- a/libstdc++-v3/include/bits/stl_deque.h +++ b/libstdc++-v3/include/bits/stl_deque.h @@ -449,6 +449,10 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) : _M_impl() { _M_initialize_map(0); } + _Deque_base(size_t __num_elements) + : _M_impl() + { _M_initialize_map(__num_elements); } + _Deque_base(const allocator_type& __a, size_t __num_elements) : _M_impl(__a) { _M_initialize_map(__num_elements); } @@ -773,6 +777,32 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) deque(const allocator_type& __a) : _Base(__a, 0) { } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Creates a %deque with default constructed elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %deque with @a n default + * constructed elements. + */ + explicit + deque(size_type __n) + : _Base(__n) + { _M_default_initialize(); } + + /** + * @brief Creates a %deque with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * @param a An allocator. + * + * This constructor fills the %deque with @a n copies of @a value. + */ + deque(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__a, __n) + { _M_fill_initialize(__value); } +#else /** * @brief Creates a %deque with copies of an exemplar element. * @param n The number of elements to initially create. @@ -786,6 +816,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) const allocator_type& __a = allocator_type()) : _Base(__a, __n) { _M_fill_initialize(__value); } +#endif /** * @brief %Deque copy constructor. @@ -824,11 +855,11 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) */ deque(initializer_list<value_type> __l, const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_range_initialize(__l.begin(), __l.end(), - random_access_iterator_tag()); - } + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } #endif /** @@ -1086,6 +1117,49 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) max_size() const { return _M_get_Tp_allocator().max_size(); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Resizes the %deque to the specified number of elements. + * @param new_size Number of elements the %deque should contain. + * + * This function will %resize the %deque to the specified + * number of elements. If the number is smaller than the + * %deque's current size the %deque is truncated, otherwise + * default constructed elements are appended. + */ + void + resize(size_type __new_size) + { + const size_type __len = size(); + if (__new_size > __len) + _M_default_append(__new_size - __len); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); + } + + /** + * @brief Resizes the %deque to the specified number of elements. + * @param new_size Number of elements the %deque should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %deque to the specified + * number of elements. If the number is smaller than the + * %deque's current size the %deque is truncated, otherwise the + * %deque is extended and new elements are populated with given + * data. + */ + void + resize(size_type __new_size, const value_type& __x) + { + const size_type __len = size(); + if (__new_size > __len) + insert(this->_M_impl._M_finish, __new_size - __len, __x); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); + } +#else /** * @brief Resizes the %deque to the specified number of elements. * @param new_size Number of elements the %deque should contain. @@ -1101,11 +1175,13 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) resize(size_type __new_size, value_type __x = value_type()) { const size_type __len = size(); - if (__new_size < __len) - _M_erase_at_end(this->_M_impl._M_start + difference_type(__new_size)); - else + if (__new_size > __len) insert(this->_M_impl._M_finish, __new_size - __len, __x); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ /** A non-binding request to reduce memory use. */ @@ -1564,6 +1640,12 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void _M_fill_initialize(const value_type& __value); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // called by deque(n). + void + _M_default_initialize(); +#endif + // Internal assign functions follow. The *_aux functions do the actual // assignment work for the range versions. @@ -1752,6 +1834,12 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) this->_M_impl._M_finish = __pos; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Called by resize(sz). + void + _M_default_append(size_type __n); +#endif + //@{ /// Memory-handling helpers for the previous internal insert functions. iterator diff --git a/libstdc++-v3/include/bits/stl_iterator_base_types.h b/libstdc++-v3/include/bits/stl_iterator_base_types.h index 07687bd2cd3..d934f434e6d 100644 --- a/libstdc++-v3/include/bits/stl_iterator_base_types.h +++ b/libstdc++-v3/include/bits/stl_iterator_base_types.h @@ -63,7 +63,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> _GLIBCXX_BEGIN_NAMESPACE(std) diff --git a/libstdc++-v3/include/bits/stl_list.h b/libstdc++-v3/include/bits/stl_list.h index 56357ed07da..d6f9255752f 100644 --- a/libstdc++-v3/include/bits/stl_list.h +++ b/libstdc++-v3/include/bits/stl_list.h @@ -508,6 +508,32 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) list(const allocator_type& __a) : _Base(__a) { } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Creates a %list with default constructed elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %list with @a n default + * constructed elements. + */ + explicit + list(size_type __n) + : _Base() + { _M_default_initialize(__n); } + + /** + * @brief Creates a %list with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * @param a An allocator object. + * + * This constructor fills the %list with @a n copies of @a value. + */ + list(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { _M_fill_initialize(__n, __value); } +#else /** * @brief Creates a %list with copies of an exemplar element. * @param n The number of elements to initially create. @@ -521,6 +547,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) const allocator_type& __a = allocator_type()) : _Base(__a) { _M_fill_initialize(__n, __value); } +#endif /** * @brief %List copy constructor. @@ -811,6 +838,32 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) max_size() const { return _M_get_Node_allocator().max_size(); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Resizes the %list to the specified number of elements. + * @param new_size Number of elements the %list should contain. + * + * This function will %resize the %list to the specified number + * of elements. If the number is smaller than the %list's + * current size the %list is truncated, otherwise default + * constructed elements are appended. + */ + void + resize(size_type __new_size); + + /** + * @brief Resizes the %list to the specified number of elements. + * @param new_size Number of elements the %list should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %list to the specified number + * of elements. If the number is smaller than the %list's + * current size the %list is truncated, otherwise the %list is + * extended and new elements are populated with given data. + */ + void + resize(size_type __new_size, const value_type& __x); +#else /** * @brief Resizes the %list to the specified number of elements. * @param new_size Number of elements the %list should contain. @@ -823,6 +876,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) */ void resize(size_type __new_size, value_type __x = value_type()); +#endif // element access /** @@ -1394,10 +1448,23 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void _M_fill_initialize(size_type __n, const value_type& __x) { - for (; __n > 0; --__n) + for (; __n; --__n) push_back(__x); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Called by list(n). + void + _M_default_initialize(size_type __n) + { + for (; __n; --__n) + emplace_back(); + } + + // Called by resize(sz). + void + _M_default_append(size_type __n); +#endif // Internal assign functions follow. diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h index 6c2b51e4c6b..c5f2986fb77 100644 --- a/libstdc++-v3/include/bits/stl_pair.h +++ b/libstdc++-v3/include/bits/stl_pair.h @@ -120,10 +120,6 @@ _GLIBCXX_BEGIN_NAMESPACE(std) : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } - pair(pair&& __p) - : first(std::move(__p.first)), - second(std::move(__p.second)) { } - template<class... _Args1, class... _Args2> pair(piecewise_construct_t, tuple<_Args1...> __first_args, @@ -141,8 +137,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) #ifdef __GXX_EXPERIMENTAL_CXX0X__ template<class _U1, class _U2> pair(pair<_U1, _U2>&& __p) - : first(std::move(__p.first)), - second(std::move(__p.second)) { } + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } pair& operator=(pair&& __p) diff --git a/libstdc++-v3/include/bits/stl_tempbuf.h b/libstdc++-v3/include/bits/stl_tempbuf.h index a08b1ee1324..47571179c87 100644 --- a/libstdc++-v3/include/bits/stl_tempbuf.h +++ b/libstdc++-v3/include/bits/stl_tempbuf.h @@ -59,7 +59,6 @@ #include <bits/stl_algobase.h> #include <bits/stl_construct.h> -#include <bits/stl_uninitialized.h> _GLIBCXX_BEGIN_NAMESPACE(std) @@ -176,6 +175,70 @@ _GLIBCXX_BEGIN_NAMESPACE(std) operator=(const _Temporary_buffer&); }; + + template<bool> + struct __uninitialized_construct_buf_dispatch + { + template<typename _ForwardIterator, typename _Tp> + static void + __ucr(_ForwardIterator __first, _ForwardIterator __last, + _Tp& __value) + { + if(__first == __last) + return; + + _ForwardIterator __cur = __first; + __try + { + std::_Construct(std::__addressof(*__first), + _GLIBCXX_MOVE(__value)); + _ForwardIterator __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + _GLIBCXX_MOVE(*__prev)); + __value = _GLIBCXX_MOVE(*__prev); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch<true> + { + template<typename _ForwardIterator, typename _Tp> + static void + __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { } + }; + + // Constructs objects in the range [first, last). + // Note that while these new objects will take valid values, + // their exact value is not defined. In particular they may + // be 'moved from'. + // + // While __value may altered during this algorithm, it will have + // the same value when the algorithm finishes, unless one of the + // constructions throws. + // + // Requirements: _ForwardIterator::value_type(_Tp&&) is valid. + template<typename _ForwardIterator, typename _Tp> + inline void + __uninitialized_construct_buf(_ForwardIterator __first, + _ForwardIterator __last, + _Tp& __value) + { + typedef typename std::iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __value); + } + template<typename _ForwardIterator, typename _Tp> _Temporary_buffer<_ForwardIterator, _Tp>:: _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) @@ -189,8 +252,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _M_buffer = __p.first; _M_len = __p.second; if(_M_buffer) - std::__uninitialized_construct_range(_M_buffer, _M_buffer + _M_len, - *__first); + std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len, + *__first); } __catch(...) { diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h index 58c63cf4376..4e9fdf73b55 100644 --- a/libstdc++-v3/include/bits/stl_tree.h +++ b/libstdc++-v3/include/bits/stl_tree.h @@ -1358,7 +1358,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // DR 130. Associative erase should return an iterator. template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc> - inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: erase(iterator __position) { @@ -1377,7 +1377,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // DR 130. Associative erase should return an iterator. template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc> - inline typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: erase(const_iterator __position) { diff --git a/libstdc++-v3/include/bits/stl_uninitialized.h b/libstdc++-v3/include/bits/stl_uninitialized.h index b78f92025c3..c5cbde0c1a4 100644 --- a/libstdc++-v3/include/bits/stl_uninitialized.h +++ b/libstdc++-v3/include/bits/stl_uninitialized.h @@ -60,13 +60,13 @@ _GLIBCXX_BEGIN_NAMESPACE(std) - template<bool> + template<bool _TrivialValueTypes> struct __uninitialized_copy { template<typename _InputIterator, typename _ForwardIterator> static _ForwardIterator - uninitialized_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) { _ForwardIterator __cur = __result; __try @@ -88,8 +88,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { template<typename _InputIterator, typename _ForwardIterator> static _ForwardIterator - uninitialized_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) { return std::copy(__first, __last, __result); } }; @@ -112,19 +112,19 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; - return std::__uninitialized_copy<(__is_pod(_ValueType1) - && __is_pod(_ValueType2))>:: - uninitialized_copy(__first, __last, __result); + return std::__uninitialized_copy<(__is_trivial(_ValueType1) + && __is_trivial(_ValueType2))>:: + __uninit_copy(__first, __last, __result); } - template<bool> + template<bool _TrivialValueType> struct __uninitialized_fill { template<typename _ForwardIterator, typename _Tp> static void - uninitialized_fill(_ForwardIterator __first, - _ForwardIterator __last, const _Tp& __x) + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) { _ForwardIterator __cur = __first; __try @@ -145,8 +145,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { template<typename _ForwardIterator, typename _Tp> static void - uninitialized_fill(_ForwardIterator __first, - _ForwardIterator __last, const _Tp& __x) + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) { std::fill(__first, __last, __x); } }; @@ -167,82 +167,18 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; - std::__uninitialized_fill<__is_pod(_ValueType)>:: - uninitialized_fill(__first, __last, __x); + std::__uninitialized_fill<__is_trivial(_ValueType)>:: + __uninit_fill(__first, __last, __x); } - template<bool> - struct __uninitialized_construct_range_dispatch - { - template<typename _ForwardIterator, typename _Tp> - static void - __ucr(_ForwardIterator __first, _ForwardIterator __last, - _Tp& __value) - { - if(__first == __last) - return; - - _ForwardIterator __cur = __first; - __try - { - std::_Construct(std::__addressof(*__first), - _GLIBCXX_MOVE(__value)); - _ForwardIterator __prev = __cur; - ++__cur; - for(; __cur != __last; ++__cur, ++__prev) - std::_Construct(std::__addressof(*__cur), - _GLIBCXX_MOVE(*__prev)); - __value = _GLIBCXX_MOVE(*__prev); - } - __catch(...) - { - std::_Destroy(__first, __cur); - __throw_exception_again; - } - } - }; - - template<> - struct __uninitialized_construct_range_dispatch<true> - { - template<typename _ForwardIterator, typename _Tp> - static void - __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { } - }; - - // Constructs objects in the range [first, last). - // Note that while these new objects will take valid values, - // their exact value is not defined. In particular they may - // be 'moved from'. - // - // While __value may altered during this algorithm, it will have - // the same value when the algorithm finishes, unless one of the - // constructions throws. - // - // Requirements: _ForwardIterator::value_type(_Tp&&) is valid. - template<typename _ForwardIterator, typename _Tp> - inline void - __uninitialized_construct_range(_ForwardIterator __first, - _ForwardIterator __last, - _Tp& __value) - { - typedef typename std::iterator_traits<_ForwardIterator>::value_type - _ValueType; - - std::__uninitialized_construct_range_dispatch< - __has_trivial_constructor(_ValueType)>:: - __ucr(__first, __last, __value); - } - - - template<bool> + template<bool _TrivialValueType> struct __uninitialized_fill_n { template<typename _ForwardIterator, typename _Size, typename _Tp> static void - uninitialized_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) { _ForwardIterator __cur = __first; __try @@ -263,8 +199,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { template<typename _ForwardIterator, typename _Size, typename _Tp> static void - uninitialized_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) { std::fill_n(__first, __n, __x); } }; @@ -284,8 +220,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; - std::__uninitialized_fill_n<__is_pod(_ValueType)>:: - uninitialized_fill_n(__first, __n, __x); + std::__uninitialized_fill_n<__is_trivial(_ValueType)>:: + __uninit_fill_n(__first, __n, __x); } // Extensions: versions of uninitialized_copy, uninitialized_fill, @@ -491,6 +427,166 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } #ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Extensions: __uninitialized_default, __uninitialized_default_n, + // __uninitialized_default_a, __uninitialized_default_n_a. + + template<bool _TrivialValueType> + struct __uninitialized_default_1 + { + template<typename _ForwardIterator> + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + __try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_default_1<true> + { + template<typename _ForwardIterator> + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::fill(__first, __last, _ValueType()); + } + }; + + template<bool _TrivialValueType> + struct __uninitialized_default_n_1 + { + template<typename _ForwardIterator, typename _Size> + static void + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + __try + { + for (; __n > 0; --__n, ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_default_n_1<true> + { + template<typename _ForwardIterator, typename _Size> + static void + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::fill_n(__first, __n, _ValueType()); + } + }; + + // __uninitialized_default + // Fills [first, last) with std::distance(first, last) default + // constructed value_types(s). + template<typename _ForwardIterator> + inline void + __uninitialized_default(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_default_1<__is_trivial(_ValueType)>:: + __uninit_default(__first, __last); + } + + // __uninitialized_default_n + // Fills [first, first + n) with n default constructed value_type(s). + template<typename _ForwardIterator, typename _Size> + inline void + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_default_n_1<__is_trivial(_ValueType)>:: + __uninit_default_n(__first, __n); + } + + + // __uninitialized_default_a + // Fills [first, last) with std::distance(first, last) default + // constructed value_types(s), constructed with the allocator alloc. + template<typename _ForwardIterator, typename _Allocator> + void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + for (; __cur != __last; ++__cur) + __alloc.construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template<typename _ForwardIterator, typename _Tp> + inline void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + allocator<_Tp>&) + { std::__uninitialized_default(__first, __last); } + + + // __uninitialized_default_n_a + // Fills [first, first + n) with n default constructed value_types(s), + // constructed with the allocator alloc. + template<typename _ForwardIterator, typename _Size, typename _Allocator> + void + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + for (; __n > 0; --__n, ++__cur) + __alloc.construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template<typename _ForwardIterator, typename _Size, typename _Tp> + inline void + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + allocator<_Tp>&) + { std::__uninitialized_default_n(__first, __n); } + + template<typename _InputIterator, typename _Size, typename _ForwardIterator> _ForwardIterator @@ -501,8 +597,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __try { for (; __n > 0; --__n, ++__first, ++__cur) - ::new(static_cast<void*>(std::__addressof(*__cur))) typename - iterator_traits<_ForwardIterator>::value_type(*__first); + std::_Construct(std::__addressof(*__cur), *__first); return __cur; } __catch(...) diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index f025b4eeb45..d51578c9e05 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -107,6 +107,14 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) _Vector_base(const allocator_type& __a) : _M_impl(__a) { } + _Vector_base(size_t __n) + : _M_impl() + { + this->_M_impl._M_start = this->_M_allocate(__n); + this->_M_impl._M_finish = this->_M_impl._M_start; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + _Vector_base(size_t __n, const allocator_type& __a) : _M_impl(__a) { @@ -215,6 +223,32 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) vector(const allocator_type& __a) : _Base(__a) { } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Creates a %vector with default constructed elements. + * @param n The number of elements to initially create. + * + * This constructor fills the %vector with @a n default + * constructed elements. + */ + explicit + vector(size_type __n) + : _Base(__n) + { _M_default_initialize(__n); } + + /** + * @brief Creates a %vector with copies of an exemplar element. + * @param n The number of elements to initially create. + * @param value An element to copy. + * @param a An allocator. + * + * This constructor fills the %vector with @a n copies of @a value. + */ + vector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__n, __a) + { _M_fill_initialize(__n, __value); } +#else /** * @brief Creates a %vector with copies of an exemplar element. * @param n The number of elements to initially create. @@ -228,6 +262,7 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) const allocator_type& __a = allocator_type()) : _Base(__n, __a) { _M_fill_initialize(__n, __value); } +#endif /** * @brief %Vector copy constructor. @@ -538,6 +573,25 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) max_size() const { return _M_get_Tp_allocator().max_size(); } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + /** + * @brief Resizes the %vector to the specified number of elements. + * @param new_size Number of elements the %vector should contain. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * default constructed elements are appended. + */ + void + resize(size_type __new_size) + { + if (__new_size > size()) + _M_default_append(__new_size - size()); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } + /** * @brief Resizes the %vector to the specified number of elements. * @param new_size Number of elements the %vector should contain. @@ -550,13 +604,34 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) * given data. */ void - resize(size_type __new_size, value_type __x = value_type()) + resize(size_type __new_size, const value_type& __x) { - if (__new_size < size()) + if (__new_size > size()) + insert(end(), __new_size - size(), __x); + else if (__new_size < size()) _M_erase_at_end(this->_M_impl._M_start + __new_size); - else + } +#else + /** + * @brief Resizes the %vector to the specified number of elements. + * @param new_size Number of elements the %vector should contain. + * @param x Data with which new elements should be populated. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * the %vector is extended and new elements are populated with + * given data. + */ + void + resize(size_type __new_size, value_type __x = value_type()) + { + if (__new_size > size()) insert(end(), __new_size - size(), __x); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ /** A non-binding request to reduce capacity() to size(). */ @@ -1049,6 +1124,16 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Called by the vector(n) constructor. + void + _M_default_initialize(size_type __n) + { + std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; + } +#endif // Internal assign functions follow. The *_aux functions do the actual // assignment work for the range versions. @@ -1131,6 +1216,12 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + // Called by resize(n). + void + _M_default_append(size_type __n); +#endif + // Called by insert(p,x) #ifndef __GXX_EXPERIMENTAL_CXX0X__ void diff --git a/libstdc++-v3/include/bits/unique_ptr.h b/libstdc++-v3/include/bits/unique_ptr.h index 7b07ca477f4..ac62ff7f304 100644 --- a/libstdc++-v3/include/bits/unique_ptr.h +++ b/libstdc++-v3/include/bits/unique_ptr.h @@ -81,7 +81,6 @@ _GLIBCXX_BEGIN_NAMESPACE(std) class unique_ptr { typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type; - typedef _Tp* unique_ptr::* __unspecified_pointer_type; // use SFINAE to determine whether _Del::pointer exists class _Pointer @@ -126,6 +125,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { static_assert(!std::is_reference<deleter_type>::value, "rvalue deleter bound to reference"); } + unique_ptr(nullptr_t) + : _M_t(pointer(), deleter_type()) + { } + // Move constructors. unique_ptr(unique_ptr&& __u) : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } @@ -157,7 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } unique_ptr& - operator=(__unspecified_pointer_type) + operator=(nullptr_t) { reset(); return *this; @@ -230,11 +233,10 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // [unique.ptr.runtime] // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 740 - omit specialization for array objects with a compile time length - template<typename _Tp, typename _Tp_Deleter> + template<typename _Tp, typename _Tp_Deleter> class unique_ptr<_Tp[], _Tp_Deleter> { typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type; - typedef _Tp* unique_ptr::* __unspecified_pointer_type; public: typedef _Tp* pointer; @@ -264,6 +266,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { static_assert(!std::is_reference<deleter_type>::value, "rvalue deleter bound to reference"); } + /* TODO: use delegating constructor */ + unique_ptr(nullptr_t) + : _M_t(pointer(), deleter_type()) + { } + // Move constructors. unique_ptr(unique_ptr&& __u) : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { } @@ -295,7 +302,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } unique_ptr& - operator=(__unspecified_pointer_type) + operator=(nullptr_t) { reset(); return *this; @@ -338,7 +345,16 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { using std::swap; swap(std::get<0>(_M_t), __p); - if (__p != pointer()) + if (__p != nullptr) + get_deleter()(__p); + } + + void + reset(nullptr_t) + { + pointer __p = get(); + std::get<0>(_M_t) = pointer(); + if (__p != nullptr) get_deleter()(__p); } @@ -428,6 +444,19 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const unique_ptr<_Up, _Up_Deleter>& __y) { return !(__x.get() < __y.get()); } + /// std::hash specialization for unique_ptr. + template<typename _Tp, typename _Tp_Deleter> + struct hash<unique_ptr<_Tp, _Tp_Deleter>> + : public std::unary_function<unique_ptr<_Tp, _Tp_Deleter>, size_t> + { + size_t + operator()(const unique_ptr<_Tp, _Tp_Deleter>& __u) const + { + typedef unique_ptr<_Tp, _Tp_Deleter> _UP; + return std::hash<typename _UP::pointer>()(__u.get()); + } + }; + // @} group pointer_abstractions _GLIBCXX_END_NAMESPACE diff --git a/libstdc++-v3/include/bits/unordered_map.h b/libstdc++-v3/include/bits/unordered_map.h index 74998ff7725..80b970c8cf5 100644 --- a/libstdc++-v3/include/bits/unordered_map.h +++ b/libstdc++-v3/include/bits/unordered_map.h @@ -82,6 +82,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a) { } + __unordered_map(const __unordered_map& __x) = default; + __unordered_map(__unordered_map&& __x) : _Base(std::forward<_Base>(__x)) { } }; @@ -137,6 +139,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) __eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a) { } + __unordered_multimap(const __unordered_multimap& __x) = default; + __unordered_multimap(__unordered_multimap&& __x) : _Base(std::forward<_Base>(__x)) { } }; @@ -246,6 +250,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) : _Base(__f, __l, __n, __hf, __eql, __a) { } + unordered_map(const unordered_map& __x) = default; + unordered_map(unordered_map&& __x) : _Base(std::forward<_Base>(__x)) { } @@ -258,6 +264,9 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { } unordered_map& + operator=(const unordered_map& __x) = default; + + unordered_map& operator=(unordered_map&& __x) { // NB: DR 1204. @@ -328,6 +337,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) : _Base(__f, __l, __n, __hf, __eql, __a) { } + unordered_multimap(const unordered_multimap& __x) = default; + unordered_multimap(unordered_multimap&& __x) : _Base(std::forward<_Base>(__x)) { } @@ -340,6 +351,9 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { } unordered_multimap& + operator=(const unordered_multimap& __x) = default; + + unordered_multimap& operator=(unordered_multimap&& __x) { // NB: DR 1204. diff --git a/libstdc++-v3/include/bits/unordered_set.h b/libstdc++-v3/include/bits/unordered_set.h index 50dee215e16..8682f2d7237 100644 --- a/libstdc++-v3/include/bits/unordered_set.h +++ b/libstdc++-v3/include/bits/unordered_set.h @@ -82,6 +82,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) std::_Identity<_Value>(), __a) { } + __unordered_set(const __unordered_set& __x) = default; + __unordered_set(__unordered_set&& __x) : _Base(std::forward<_Base>(__x)) { } }; @@ -135,6 +137,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) std::_Identity<_Value>(), __a) { } + __unordered_multiset(const __unordered_multiset& __x) = default; + __unordered_multiset(__unordered_multiset&& __x) : _Base(std::forward<_Base>(__x)) { } }; @@ -239,6 +243,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) : _Base(__f, __l, __n, __hf, __eql, __a) { } + unordered_set(const unordered_set& __x) = default; + unordered_set(unordered_set&& __x) : _Base(std::forward<_Base>(__x)) { } @@ -251,6 +257,9 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { } unordered_set& + operator=(const unordered_set& __x) = default; + + unordered_set& operator=(unordered_set&& __x) { // NB: DR 1204. @@ -318,6 +327,8 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) : _Base(__f, __l, __n, __hf, __eql, __a) { } + unordered_multiset(const unordered_multiset& __x) = default; + unordered_multiset(unordered_multiset&& __x) : _Base(std::forward<_Base>(__x)) { } @@ -330,6 +341,9 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) { } unordered_multiset& + operator=(const unordered_multiset& __x) = default; + + unordered_multiset& operator=(unordered_multiset&& __x) { // NB: DR 1204. diff --git a/libstdc++-v3/include/bits/valarray_array.h b/libstdc++-v3/include/bits/valarray_array.h index a12b3347b9d..7aa61f14d81 100644 --- a/libstdc++-v3/include/bits/valarray_array.h +++ b/libstdc++-v3/include/bits/valarray_array.h @@ -1,7 +1,7 @@ // The template and inlines for the -*- C++ -*- internal _Array helper class. // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2008, 2009 +// 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -127,7 +127,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) inline void __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t) { - _Array_init_ctor<_Tp, __is_pod(_Tp)>::_S_do_it(__b, __e, __t); + _Array_init_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __t); } // @@ -160,7 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __valarray_copy_construct(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) { - _Array_copy_ctor<_Tp, __is_pod(_Tp)>::_S_do_it(__b, __e, __o); + _Array_copy_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __o); } // copy-construct raw array [__o, *) from strided array __a[<__n : __s>] @@ -169,7 +169,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n, size_t __s, _Tp* __restrict__ __o) { - if (__is_pod(_Tp)) + if (__is_trivial(_Tp)) while (__n--) { *__o++ = *__a; @@ -190,7 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) const size_t* __restrict__ __i, _Tp* __restrict__ __o, size_t __n) { - if (__is_pod(_Tp)) + if (__is_trivial(_Tp)) while (__n--) *__o++ = __a[*__i++]; else @@ -203,7 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) inline void __valarray_destroy_elements(_Tp* __b, _Tp* __e) { - if (!__is_pod(_Tp)) + if (!__is_trivial(_Tp)) while (__b != __e) { __b->~_Tp(); @@ -267,7 +267,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) __valarray_copy(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) { - _Array_copier<_Tp, __is_pod(_Tp)>::_S_do_it(__a, __n, __b); + _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b); } // Copy strided array __a[<__n : __s>] in plain __b[<__n>] diff --git a/libstdc++-v3/include/bits/vector.tcc b/libstdc++-v3/include/bits/vector.tcc index e1097931048..846a0645d57 100644 --- a/libstdc++-v3/include/bits/vector.tcc +++ b/libstdc++-v3/include/bits/vector.tcc @@ -458,6 +458,59 @@ _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D) } } +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + template<typename _Tp, typename _Alloc> + void + vector<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n != 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + std::__uninitialized_default_n_a(this->_M_impl._M_finish, + __n, _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_default_append"); + const size_type __old_size = this->size(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + __new_finish = + std::__uninitialized_move_a(this->_M_impl._M_start, + this->_M_impl._M_finish, + __new_start, + _M_get_Tp_allocator()); + std::__uninitialized_default_n_a(__new_finish, __n, + _M_get_Tp_allocator()); + __new_finish += __n; + } + __catch(...) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } +#endif + template<typename _Tp, typename _Alloc> template<typename _InputIterator> void diff --git a/libstdc++-v3/include/c_global/cstddef b/libstdc++-v3/include/c_global/cstddef index ce2d310244c..d9a7383e68d 100644 --- a/libstdc++-v3/include/c_global/cstddef +++ b/libstdc++-v3/include/c_global/cstddef @@ -42,15 +42,3 @@ #include <bits/c++config.h> #include <stddef.h> - -#ifndef _GLIBCXX_CSTDDEF -#define _GLIBCXX_CSTDDEF 1 - -_GLIBCXX_BEGIN_NAMESPACE(std) - - using ::ptrdiff_t; - using ::size_t; - -_GLIBCXX_END_NAMESPACE - -#endif diff --git a/libstdc++-v3/include/c_global/cstdio b/libstdc++-v3/include/c_global/cstdio index f87af196936..b547fbe40b8 100644 --- a/libstdc++-v3/include/c_global/cstdio +++ b/libstdc++-v3/include/c_global/cstdio @@ -41,7 +41,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #include <stdio.h> #ifndef _GLIBCXX_CSTDIO @@ -151,13 +150,13 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) #if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC extern "C" int - (snprintf)(char * restrict, size_t, const char * restrict, ...) throw (); + (snprintf)(char * restrict, std::size_t, const char * restrict, ...) throw (); extern "C" int (vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list); extern "C" int (vscanf)(const char * restrict, __gnuc_va_list); extern "C" int - (vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list) - throw (); + (vsnprintf)(char * restrict, std::size_t, const char * restrict, + __gnuc_va_list) throw (); extern "C" int (vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list) throw (); diff --git a/libstdc++-v3/include/c_global/cstdlib b/libstdc++-v3/include/c_global/cstdlib index f4ff810cf71..da95c0fe56c 100644 --- a/libstdc++-v3/include/c_global/cstdlib +++ b/libstdc++-v3/include/c_global/cstdlib @@ -41,7 +41,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #ifndef _GLIBCXX_CSTDLIB #define _GLIBCXX_CSTDLIB 1 diff --git a/libstdc++-v3/include/c_global/cstring b/libstdc++-v3/include/c_global/cstring index 445202035d5..21721be67ed 100644 --- a/libstdc++-v3/include/c_global/cstring +++ b/libstdc++-v3/include/c_global/cstring @@ -41,7 +41,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #include <string.h> #ifndef _GLIBCXX_CSTRING diff --git a/libstdc++-v3/include/c_global/ctime b/libstdc++-v3/include/c_global/ctime index 55f1f069766..f5bb49ccbc9 100644 --- a/libstdc++-v3/include/c_global/ctime +++ b/libstdc++-v3/include/c_global/ctime @@ -40,7 +40,7 @@ #pragma GCC system_header -#include <cstddef> +#include <bits/c++config.h> #include <time.h> #ifndef _GLIBCXX_CTIME diff --git a/libstdc++-v3/include/c_global/cwchar b/libstdc++-v3/include/c_global/cwchar index 537f39a023b..b16eb468572 100644 --- a/libstdc++-v3/include/c_global/cwchar +++ b/libstdc++-v3/include/c_global/cwchar @@ -41,7 +41,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #if _GLIBCXX_HAVE_WCHAR_H #include <wchar.h> diff --git a/libstdc++-v3/include/c_global/cwctype b/libstdc++-v3/include/c_global/cwctype index be649a28950..2ac1155aa9b 100644 --- a/libstdc++-v3/include/c_global/cwctype +++ b/libstdc++-v3/include/c_global/cwctype @@ -43,9 +43,15 @@ #include <bits/c++config.h> #if _GLIBCXX_HAVE_WCTYPE_H -#include <wctype.h> + +#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 10 +// Work around glibc BZ 9694 +#include <stddef.h> #endif +#include <wctype.h> +#endif // _GLIBCXX_HAVE_WCTYPE_H + #ifndef _GLIBCXX_CWCTYPE #define _GLIBCXX_CWCTYPE 1 diff --git a/libstdc++-v3/include/c_std/cstddef b/libstdc++-v3/include/c_std/cstddef index 93fed5db6ac..006c432d7bc 100644 --- a/libstdc++-v3/include/c_std/cstddef +++ b/libstdc++-v3/include/c_std/cstddef @@ -45,11 +45,4 @@ #include <bits/c++config.h> #include <stddef.h> -_GLIBCXX_BEGIN_NAMESPACE(std) - - using ::ptrdiff_t; - using ::size_t; - -_GLIBCXX_END_NAMESPACE - #endif diff --git a/libstdc++-v3/include/c_std/cstdio b/libstdc++-v3/include/c_std/cstdio index a697437a662..4a8acdddb62 100644 --- a/libstdc++-v3/include/c_std/cstdio +++ b/libstdc++-v3/include/c_std/cstdio @@ -43,8 +43,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> - #include <stdio.h> // Get rid of those macros defined in <stdio.h> in lieu of real functions. @@ -151,13 +149,13 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) #if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC extern "C" int - (snprintf)(char * restrict, size_t, const char * restrict, ...) throw (); + (snprintf)(char * restrict, std::size_t, const char * restrict, ...) throw (); extern "C" int (vfscanf)(FILE * restrict, const char * restrict, __gnuc_va_list); extern "C" int (vscanf)(const char * restrict, __gnuc_va_list); extern "C" int - (vsnprintf)(char * restrict, size_t, const char * restrict, __gnuc_va_list) - throw (); + (vsnprintf)(char * restrict, std::size_t, const char * restrict, + __gnuc_va_list) throw (); extern "C" int (vsscanf)(const char * restrict, const char * restrict, __gnuc_va_list) throw (); diff --git a/libstdc++-v3/include/c_std/cstdlib b/libstdc++-v3/include/c_std/cstdlib index c1e3379c121..734745a6775 100644 --- a/libstdc++-v3/include/c_std/cstdlib +++ b/libstdc++-v3/include/c_std/cstdlib @@ -43,7 +43,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #if !_GLIBCXX_HOSTED // The C standard does not require a freestanding implementation to diff --git a/libstdc++-v3/include/c_std/cstring b/libstdc++-v3/include/c_std/cstring index 914365655ec..06bf12fba9d 100644 --- a/libstdc++-v3/include/c_std/cstring +++ b/libstdc++-v3/include/c_std/cstring @@ -44,7 +44,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #include <string.h> // Get rid of those macros defined in <string.h> in lieu of real functions. diff --git a/libstdc++-v3/include/c_std/ctime b/libstdc++-v3/include/c_std/ctime index dca90eb8d88..459c8fc7b60 100644 --- a/libstdc++-v3/include/c_std/ctime +++ b/libstdc++-v3/include/c_std/ctime @@ -42,7 +42,7 @@ #pragma GCC system_header -#include <cstddef> +#include <bits/c++config.h> #include <time.h> // Get rid of those macros defined in <time.h> in lieu of real functions. diff --git a/libstdc++-v3/include/c_std/cwchar b/libstdc++-v3/include/c_std/cwchar index 3d503674ed1..20c6ca3512a 100644 --- a/libstdc++-v3/include/c_std/cwchar +++ b/libstdc++-v3/include/c_std/cwchar @@ -44,7 +44,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #if _GLIBCXX_HAVE_WCHAR_H #include <wchar.h> diff --git a/libstdc++-v3/include/c_std/cwctype b/libstdc++-v3/include/c_std/cwctype index 4af425067b9..d6750390a0a 100644 --- a/libstdc++-v3/include/c_std/cwctype +++ b/libstdc++-v3/include/c_std/cwctype @@ -45,9 +45,15 @@ #include <bits/c++config.h> #if _GLIBCXX_HAVE_WCTYPE_H -#include <wctype.h> + +#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 10 +// Work around glibc BZ 9694 +#include <stddef.h> #endif +#include <wctype.h> +#endif // _GLIBCXX_HAVE_WCTYPE_H + // Get rid of those macros defined in <wctype.h> in lieu of real functions. #undef iswalnum #undef iswalpha diff --git a/libstdc++-v3/include/debug/deque b/libstdc++-v3/include/debug/deque index 0c98006badb..31f708a9c9d 100644 --- a/libstdc++-v3/include/debug/deque +++ b/libstdc++-v3/include/debug/deque @@ -67,12 +67,24 @@ namespace __debug typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // 23.2.1.1 construct/copy/destroy: - explicit deque(const _Allocator& __a = _Allocator()) + explicit + deque(const _Allocator& __a = _Allocator()) : _Base(__a) { } - explicit deque(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + deque(size_type __n) + : _Base(__n) { } + + deque(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#else + explicit + deque(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } +#endif template<class _InputIterator> deque(_InputIterator __first, _InputIterator __last, @@ -208,6 +220,39 @@ namespace __debug using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { + typedef typename _Base::const_iterator _Base_const_iterator; + typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth; + + bool __invalidate_all = __sz > this->size(); + if (__sz < this->size()) + this->_M_invalidate_if(_After_nth(__sz, _M_base().begin())); + + _Base::resize(__sz); + + if (__invalidate_all) + this->_M_invalidate_all(); + } + + void + resize(size_type __sz, const _Tp& __c) + { + typedef typename _Base::const_iterator _Base_const_iterator; + typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth; + + bool __invalidate_all = __sz > this->size(); + if (__sz < this->size()) + this->_M_invalidate_if(_After_nth(__sz, _M_base().begin())); + + _Base::resize(__sz, __c); + + if (__invalidate_all) + this->_M_invalidate_all(); + } +#else void resize(size_type __sz, _Tp __c = _Tp()) { @@ -223,6 +268,7 @@ namespace __debug if (__invalidate_all) this->_M_invalidate_all(); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ using _Base::shrink_to_fit; diff --git a/libstdc++-v3/include/debug/formatter.h b/libstdc++-v3/include/debug/formatter.h index b4b43896d04..a98ebd84a8d 100644 --- a/libstdc++-v3/include/debug/formatter.h +++ b/libstdc++-v3/include/debug/formatter.h @@ -338,7 +338,7 @@ namespace __gnu_debug const _Error_formatter& _M_iterator(const _Iterator& __it, const char* __name = 0) const { - if (_M_num_parameters < size_t(__max_parameters)) + if (_M_num_parameters < std::size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__it, __name, _Is_iterator()); return *this; @@ -347,7 +347,7 @@ namespace __gnu_debug const _Error_formatter& _M_integer(long __value, const char* __name = 0) const { - if (_M_num_parameters < size_t(__max_parameters)) + if (_M_num_parameters < std::size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); return *this; } @@ -355,7 +355,7 @@ namespace __gnu_debug const _Error_formatter& _M_string(const char* __value, const char* __name = 0) const { - if (_M_num_parameters < size_t(__max_parameters)) + if (_M_num_parameters < std::size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); return *this; } @@ -364,7 +364,7 @@ namespace __gnu_debug const _Error_formatter& _M_sequence(const _Sequence& __seq, const char* __name = 0) const { - if (_M_num_parameters < size_t(__max_parameters)) + if (_M_num_parameters < std::size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name, _Is_sequence()); return *this; @@ -381,7 +381,7 @@ namespace __gnu_debug _M_error() const; private: - _Error_formatter(const char* __file, size_t __line) + _Error_formatter(const char* __file, std::size_t __line) : _M_file(__file), _M_line(__line), _M_num_parameters(0), _M_text(0), _M_max_length(78), _M_column(1), _M_first_line(true), _M_wordwrap(false) { _M_get_max_length(); } @@ -402,19 +402,19 @@ namespace __gnu_debug enum { __max_parameters = 9 }; const char* _M_file; - size_t _M_line; + std::size_t _M_line; mutable _Parameter _M_parameters[__max_parameters]; - mutable size_t _M_num_parameters; + mutable std::size_t _M_num_parameters; mutable const char* _M_text; - mutable size_t _M_max_length; + mutable std::size_t _M_max_length; enum { _M_indent = 4 } ; - mutable size_t _M_column; + mutable std::size_t _M_column; mutable bool _M_first_line; mutable bool _M_wordwrap; public: static _Error_formatter - _M_at(const char* __file, size_t __line) + _M_at(const char* __file, std::size_t __line) { return _Error_formatter(__file, __line); } }; } // namespace __gnu_debug diff --git a/libstdc++-v3/include/debug/functions.h b/libstdc++-v3/include/debug/functions.h index a4b1d785844..237c0e66909 100644 --- a/libstdc++-v3/include/debug/functions.h +++ b/libstdc++-v3/include/debug/functions.h @@ -1,6 +1,6 @@ // Debugging support implementation -*- C++ -*- -// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -31,7 +31,6 @@ #define _GLIBCXX_DEBUG_FUNCTIONS_H 1 #include <bits/c++config.h> -#include <cstddef> // for ptrdiff_t #include <bits/stl_iterator_base_types.h> // for iterator_traits, categories #include <bits/cpp_type_traits.h> // for __is_integer diff --git a/libstdc++-v3/include/debug/list b/libstdc++-v3/include/debug/list index 39a64818830..c65ed5829f2 100644 --- a/libstdc++-v3/include/debug/list +++ b/libstdc++-v3/include/debug/list @@ -67,12 +67,24 @@ namespace __debug typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // 23.2.2.1 construct/copy/destroy: - explicit list(const _Allocator& __a = _Allocator()) + explicit + list(const _Allocator& __a = _Allocator()) : _Base(__a) { } - explicit list(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + list(size_type __n) + : _Base(__n) { } + + list(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#else + explicit + list(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } +#endif template<class _InputIterator> list(_InputIterator __first, _InputIterator __last, @@ -208,6 +220,63 @@ namespace __debug using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + iterator __victim = begin(); + iterator __end = end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + while (__victim != __end) + { + iterator __real_victim = __victim++; + __real_victim._M_invalidate(); + } + + __try + { + _Base::resize(__sz); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } + + void + resize(size_type __sz, const _Tp& __c) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + iterator __victim = begin(); + iterator __end = end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + while (__victim != __end) + { + iterator __real_victim = __victim++; + __real_victim._M_invalidate(); + } + + __try + { + _Base::resize(__sz, __c); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } +#else void resize(size_type __sz, _Tp __c = _Tp()) { @@ -235,6 +304,7 @@ namespace __debug __throw_exception_again; } } +#endif // element access: reference diff --git a/libstdc++-v3/include/debug/vector b/libstdc++-v3/include/debug/vector index ea55b080442..c81f956212e 100644 --- a/libstdc++-v3/include/debug/vector +++ b/libstdc++-v3/include/debug/vector @@ -72,12 +72,24 @@ namespace __debug typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // 23.2.4.1 construct/copy/destroy: - explicit vector(const _Allocator& __a = _Allocator()) + explicit + vector(const _Allocator& __a = _Allocator()) : _Base(__a), _M_guaranteed_capacity(0) { } - explicit vector(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + vector(size_type __n) + : _Base(__n), _M_guaranteed_capacity(__n) { } + + vector(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { } +#else + explicit + vector(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { } +#endif template<class _InputIterator> vector(_InputIterator __first, _InputIterator __last, @@ -226,6 +238,31 @@ namespace __debug using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { + bool __realloc = _M_requires_reallocation(__sz); + if (__sz < this->size()) + this->_M_invalidate_if(_After_nth(__sz, _M_base().begin())); + _Base::resize(__sz); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } + + void + resize(size_type __sz, const _Tp& __c) + { + bool __realloc = _M_requires_reallocation(__sz); + if (__sz < this->size()) + this->_M_invalidate_if(_After_nth(__sz, _M_base().begin())); + _Base::resize(__sz, __c); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } +#else void resize(size_type __sz, _Tp __c = _Tp()) { @@ -237,6 +274,7 @@ namespace __debug this->_M_invalidate_all(); _M_update_guaranteed_capacity(); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ using _Base::shrink_to_fit; diff --git a/libstdc++-v3/include/ext/algorithm b/libstdc++-v3/include/ext/algorithm index 5956e24bcd0..cac4ff70e8e 100644 --- a/libstdc++-v3/include/ext/algorithm +++ b/libstdc++-v3/include/ext/algorithm @@ -123,8 +123,8 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, typename iterator_traits<_InputIterator>::value_type>) - return __copy_n(__first, __count, __result, - std::__iterator_category(__first)); + return __gnu_cxx::__copy_n(__first, __count, __result, + std::__iterator_category(__first)); } template<typename _InputIterator1, typename _InputIterator2> diff --git a/libstdc++-v3/include/ext/array_allocator.h b/libstdc++-v3/include/ext/array_allocator.h index 36f15fe936c..ca4d0d19b01 100644 --- a/libstdc++-v3/include/ext/array_allocator.h +++ b/libstdc++-v3/include/ext/array_allocator.h @@ -30,7 +30,7 @@ #ifndef _ARRAY_ALLOCATOR_H #define _ARRAY_ALLOCATOR_H 1 -#include <cstddef> +#include <bits/c++config.h> #include <new> #include <bits/functexcept.h> #include <tr1/array> @@ -114,7 +114,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) struct rebind { typedef array_allocator<_Tp1, _Array1> other; }; - array_allocator(array_type* __array = NULL) throw() + array_allocator(array_type* __array = 0) throw() : _M_array(__array), _M_used(size_type()) { } array_allocator(const array_allocator& __o) throw() @@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) template<typename _Tp1, typename _Array1> array_allocator(const array_allocator<_Tp1, _Array1>&) throw() - : _M_array(NULL), _M_used(size_type()) { } + : _M_array(0), _M_used(size_type()) { } ~array_allocator() throw() { } diff --git a/libstdc++-v3/include/ext/bitmap_allocator.h b/libstdc++-v3/include/ext/bitmap_allocator.h index 05285f548cc..2aa08706c9d 100644 --- a/libstdc++-v3/include/ext/bitmap_allocator.h +++ b/libstdc++-v3/include/ext/bitmap_allocator.h @@ -30,9 +30,8 @@ #ifndef _BITMAP_ALLOCATOR_H #define _BITMAP_ALLOCATOR_H 1 -#include <cstddef> // For std::size_t, and ptrdiff_t. -#include <bits/functexcept.h> // For __throw_bad_alloc(). #include <utility> // For std::pair. +#include <bits/functexcept.h> // For __throw_bad_alloc(). #include <functional> // For greater_equal, and less_equal. #include <new> // For operator new. #include <debug/debug.h> // _GLIBCXX_DEBUG_ASSERT diff --git a/libstdc++-v3/include/ext/codecvt_specializations.h b/libstdc++-v3/include/ext/codecvt_specializations.h index 89adb3f20d4..53295891bac 100644 --- a/libstdc++-v3/include/ext/codecvt_specializations.h +++ b/libstdc++-v3/include/ext/codecvt_specializations.h @@ -1,7 +1,8 @@ // Locale support (codecvt) -*- C++ -*- -// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 -// Free Software Foundation, Inc. +// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, +// 2008, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -381,7 +382,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // Argument list for iconv specifies a byte sequence. Thus, // all to/from arrays must be brutally casted to char*. char* __cto = reinterpret_cast<char*>(__to); - size_t __conv = __iconv_adaptor(iconv,__desc, NULL, NULL, + size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0, &__cto, &__tlen); if (__conv != size_t(-1)) diff --git a/libstdc++-v3/include/ext/functional b/libstdc++-v3/include/ext/functional index 546b9c68d6c..7cf6a45a0a3 100644 --- a/libstdc++-v3/include/ext/functional +++ b/libstdc++-v3/include/ext/functional @@ -1,6 +1,6 @@ // Functional extensions -*- C++ -*- -// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009 +// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -60,7 +60,6 @@ #pragma GCC system_header #include <functional> -#include <cstddef> _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) diff --git a/libstdc++-v3/include/ext/mt_allocator.h b/libstdc++-v3/include/ext/mt_allocator.h index 8fdb2f6393b..1f6561db464 100644 --- a/libstdc++-v3/include/ext/mt_allocator.h +++ b/libstdc++-v3/include/ext/mt_allocator.h @@ -154,11 +154,11 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) explicit __pool_base() - : _M_options(_Tune()), _M_binmap(NULL), _M_init(false) { } + : _M_options(_Tune()), _M_binmap(0), _M_init(false) { } explicit __pool_base(const _Tune& __options) - : _M_options(__options), _M_binmap(NULL), _M_init(false) { } + : _M_options(__options), _M_binmap(0), _M_init(false) { } private: explicit @@ -235,10 +235,10 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) { } explicit __pool() - : _M_bin(NULL), _M_bin_size(1) { } + : _M_bin(0), _M_bin_size(1) { } explicit __pool(const __pool_base::_Tune& __tune) - : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1) { } + : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { } private: // An "array" of bin_records each of which represents a specific @@ -358,12 +358,12 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) _M_get_thread_id(); explicit __pool() - : _M_bin(NULL), _M_bin_size(1), _M_thread_freelist(NULL) + : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) { } explicit __pool(const __pool_base::_Tune& __tune) - : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1), - _M_thread_freelist(NULL) + : __pool_base(__tune), _M_bin(0), _M_bin_size(1), + _M_thread_freelist(0) { } private: diff --git a/libstdc++-v3/include/ext/new_allocator.h b/libstdc++-v3/include/ext/new_allocator.h index beaddddf9ee..54505654207 100644 --- a/libstdc++-v3/include/ext/new_allocator.h +++ b/libstdc++-v3/include/ext/new_allocator.h @@ -30,6 +30,7 @@ #ifndef _NEW_ALLOCATOR_H #define _NEW_ALLOCATOR_H 1 +#include <bits/c++config.h> #include <new> #include <bits/functexcept.h> #include <bits/move.h> diff --git a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp index dca953b4911..9cec3b72c54 100644 --- a/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp +++ b/libstdc++-v3/include/ext/pb_ds/assoc_container.hpp @@ -41,6 +41,7 @@ #ifndef PB_DS_ASSOC_CNTNR_HPP #define PB_DS_ASSOC_CNTNR_HPP +#include <bits/c++config.h> #include <ext/typelist.h> #include <ext/pb_ds/tag_and_trait.hpp> #include <ext/pb_ds/detail/standard_policies.hpp> diff --git a/libstdc++-v3/include/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp b/libstdc++-v3/include/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp index 757b90956de..d9cc2dbfc44 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp @@ -38,8 +38,8 @@ * Contains an implementation class for tree-like classes. */ -#ifndef PB_DS_NULL_NODE_METADATA_HPP -#define PB_DS_NULL_NODE_METADATA_HPP +#ifndef PB_DS_0_NODE_METADATA_HPP +#define PB_DS_0_NODE_METADATA_HPP #include <ext/pb_ds/detail/types_traits.hpp> diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp index 925d204dc6b..b9f80e960aa 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/constructors_destructor_fn_imps.hpp @@ -92,7 +92,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : __try { m_p_head->m_p_parent = recursive_copy_node(other.m_p_head->m_p_parent); - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) m_p_head->m_p_parent->m_p_parent = m_p_head; m_size = other.m_size; initialize_min_max(); @@ -142,7 +142,7 @@ void PB_DS_CLASS_C_DEC:: initialize() { - m_p_head->m_p_parent = NULL; + m_p_head->m_p_parent = 0; m_p_head->m_p_left = m_p_head; m_p_head->m_p_right = m_p_head; m_size = 0; @@ -153,8 +153,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: recursive_copy_node(const node_pointer p_nd) { - if (p_nd == NULL) - return (NULL); + if (p_nd == 0) + return (0); node_pointer p_ret = s_node_allocator.allocate(1); __try @@ -167,7 +167,7 @@ recursive_copy_node(const node_pointer p_nd) __throw_exception_again; } - p_ret->m_p_left = p_ret->m_p_right = NULL; + p_ret->m_p_left = p_ret->m_p_right = 0; __try { @@ -180,10 +180,10 @@ recursive_copy_node(const node_pointer p_nd) __throw_exception_again; } - if (p_ret->m_p_left != NULL) + if (p_ret->m_p_left != 0) p_ret->m_p_left->m_p_parent = p_ret; - if (p_ret->m_p_right != NULL) + if (p_ret->m_p_right != 0) p_ret->m_p_right->m_p_parent = p_ret; _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_ret);) @@ -195,7 +195,7 @@ void PB_DS_CLASS_C_DEC:: initialize_min_max() { - if (m_p_head->m_p_parent == NULL) + if (m_p_head->m_p_parent == 0) { m_p_head->m_p_left = m_p_head->m_p_right = m_p_head; return; @@ -203,14 +203,14 @@ initialize_min_max() { node_pointer p_min = m_p_head->m_p_parent; - while (p_min->m_p_left != NULL) + while (p_min->m_p_left != 0) p_min = p_min->m_p_left; m_p_head->m_p_left = p_min; } { node_pointer p_max = m_p_head->m_p_parent; - while (p_max->m_p_right != NULL) + while (p_max->m_p_right != 0) p_max = p_max->m_p_right; m_p_head->m_p_right = p_max; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp index e3447bd4bec..e1013e78f1b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/debug_fn_imps.hpp @@ -49,7 +49,7 @@ assert_valid() const assert_consistent_with_debug_base(); assert_size(); assert_iterators(); - if (m_p_head->m_p_parent == NULL) + if (m_p_head->m_p_parent == 0) { _GLIBCXX_DEBUG_ASSERT(m_size == 0); } @@ -64,8 +64,8 @@ void PB_DS_CLASS_C_DEC:: structure_only_assert_valid() const { - _GLIBCXX_DEBUG_ASSERT(m_p_head != NULL); - if (m_p_head->m_p_parent == NULL) + _GLIBCXX_DEBUG_ASSERT(m_p_head != 0); + if (m_p_head->m_p_parent == 0) { _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_left == m_p_head); _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right == m_p_head); @@ -77,7 +77,7 @@ structure_only_assert_valid() const _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right != m_p_head); } - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) assert_node_consistent(m_p_head->m_p_parent); assert_min(); assert_max(); @@ -96,8 +96,8 @@ typename PB_DS_CLASS_C_DEC::node_consistent_t PB_DS_CLASS_C_DEC:: assert_node_consistent_(const node_pointer p_nd) const { - if (p_nd == NULL) - return (std::make_pair((const_pointer)NULL,(const_pointer)NULL)); + if (p_nd == 0) + return (std::make_pair((const_pointer)0,(const_pointer)0)); assert_node_consistent_with_left(p_nd); assert_node_consistent_with_right(p_nd); @@ -105,18 +105,18 @@ assert_node_consistent_(const node_pointer p_nd) const const std::pair<const_pointer, const_pointer> l_range = assert_node_consistent_(p_nd->m_p_left); - if (l_range.second != NULL) + if (l_range.second != 0) _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(*l_range.second), PB_DS_V2F(p_nd->m_value))); const std::pair<const_pointer, const_pointer> r_range = assert_node_consistent_(p_nd->m_p_right); - if (r_range.first != NULL) + if (r_range.first != 0) _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), PB_DS_V2F(*r_range.first))); - return (std::make_pair((l_range.first != NULL)? l_range.first :& p_nd->m_value,(r_range.second != NULL)? r_range.second :& p_nd->m_value)); + return (std::make_pair((l_range.first != 0)? l_range.first :& p_nd->m_value,(r_range.second != 0)? r_range.second :& p_nd->m_value)); } PB_DS_CLASS_T_DEC @@ -124,7 +124,7 @@ void PB_DS_CLASS_C_DEC:: assert_node_consistent_with_left(const node_pointer p_nd) const { - if (p_nd->m_p_left == NULL) + if (p_nd->m_p_left == 0) return; _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left->m_p_parent == p_nd); _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), @@ -136,7 +136,7 @@ void PB_DS_CLASS_C_DEC:: assert_node_consistent_with_right(const node_pointer p_nd) const { - if (p_nd->m_p_right == NULL) + if (p_nd->m_p_right == 0) return; _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right->m_p_parent == p_nd); _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_p_right->m_value), @@ -156,13 +156,13 @@ void PB_DS_CLASS_C_DEC:: assert_min_imp(const node_pointer p_nd) const { - if (p_nd == NULL) + if (p_nd == 0) { _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_left == m_p_head); return; } - if (p_nd->m_p_left == NULL) + if (p_nd->m_p_left == 0) { _GLIBCXX_DEBUG_ASSERT(p_nd == m_p_head->m_p_left); return; @@ -183,13 +183,13 @@ void PB_DS_CLASS_C_DEC:: assert_max_imp(const node_pointer p_nd) const { - if (p_nd == NULL) + if (p_nd == 0) { _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_right == m_p_head); return; } - if (p_nd->m_p_right == NULL) + if (p_nd->m_p_right == 0) { _GLIBCXX_DEBUG_ASSERT(p_nd == m_p_head->m_p_right); return; @@ -254,7 +254,7 @@ void PB_DS_CLASS_C_DEC:: assert_consistent_with_debug_base(const node_pointer p_nd) const { - if (p_nd == NULL) + if (p_nd == 0) return; debug_base::check_key_exists(PB_DS_V2F(p_nd->m_value)); assert_consistent_with_debug_base(p_nd->m_p_left); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp index a000c744cc3..a050a4be7b1 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/erase_fn_imps.hpp @@ -106,7 +106,7 @@ void PB_DS_CLASS_C_DEC:: clear_imp(node_pointer p_nd) { - if (p_nd == NULL) + if (p_nd == 0) return; clear_imp(p_nd->m_p_left); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp index 413304b80a0..74af48a7327 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/find_fn_imps.hpp @@ -46,7 +46,7 @@ lower_bound(const_key_reference r_key) const node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (Cmp_Fn::operator()( PB_DS_V2F(p_nd->m_value), r_key)) @@ -69,7 +69,7 @@ lower_bound(const_key_reference r_key) node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (Cmp_Fn::operator()( PB_DS_V2F(p_nd->m_value), r_key)) @@ -92,7 +92,7 @@ upper_bound(const_key_reference r_key) const node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value))) { @@ -114,7 +114,7 @@ upper_bound(const_key_reference r_key) node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value))) { @@ -138,7 +138,7 @@ find(const_key_reference r_key) node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key)) { p_pot = p_nd; @@ -164,7 +164,7 @@ find(const_key_reference r_key) const node_pointer p_pot = m_p_head; node_pointer p_nd = m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key)) { p_pot = p_nd; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp index 3abf0a08d3c..6714c6f10be 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/insert_fn_imps.hpp @@ -53,7 +53,7 @@ insert_leaf(const_reference r_value) node_pointer p_nd = m_p_head->m_p_parent; node_pointer p_pot = m_p_head; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()( PB_DS_V2F(p_nd->m_value), PB_DS_V2F(r_value))) @@ -86,12 +86,12 @@ insert_leaf(const_reference r_value) PB_DS_V2F(r_value))); p_nd = p_pot->m_p_left; - if (p_nd == NULL) + if (p_nd == 0) return (std::make_pair( insert_leaf_new(r_value, p_pot, true), true)); - while (p_nd->m_p_right != NULL) + while (p_nd->m_p_right != 0) p_nd = p_nd->m_p_right; return (std::make_pair( @@ -109,7 +109,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd) if (left_nd) { - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_left == 0); _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()( PB_DS_V2F(r_value), PB_DS_V2F(p_nd->m_value))); @@ -121,7 +121,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd) } else { - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right == NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_right == 0); _GLIBCXX_DEBUG_ASSERT(Cmp_Fn::operator()( PB_DS_V2F(p_nd->m_value), PB_DS_V2F(r_value))); @@ -134,7 +134,7 @@ insert_leaf_new(const_reference r_value, node_pointer p_nd, bool left_nd) p_new_nd->m_p_parent = p_nd; - p_new_nd->m_p_left = p_new_nd->m_p_right = NULL; + p_new_nd->m_p_left = p_new_nd->m_p_right = 0; _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_nd)); @@ -159,7 +159,7 @@ insert_imp_empty(const_reference r_value) p_new_node->m_p_parent = m_p_head; - p_new_node->m_p_left = p_new_node->m_p_right = NULL; + p_new_node->m_p_left = p_new_node->m_p_right = 0; _GLIBCXX_DEBUG_ONLY(debug_base::insert_new( PB_DS_V2F(r_value))); @@ -184,7 +184,7 @@ get_new_node_for_leaf_insert(const_reference r_val, false_type) cond.set_no_action(); - p_new_nd->m_p_left = p_new_nd->m_p_right = NULL; + p_new_nd->m_p_left = p_new_nd->m_p_right = 0; ++m_size; @@ -202,7 +202,7 @@ get_new_node_for_leaf_insert(const_reference r_val, true_type) static_cast<const void* >(&p_new_nd->m_value))) typename node::value_type(r_val); - p_new_nd->m_p_left = p_new_nd->m_p_right = NULL; + p_new_nd->m_p_left = p_new_nd->m_p_right = 0; ++m_size; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp index ed7f1b172c8..e20a4134a8b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/iterators_fn_imps.hpp @@ -123,7 +123,7 @@ inline typename PB_DS_CLASS_C_DEC::const_node_iterator PB_DS_CLASS_C_DEC:: node_end() const { - return (const_node_iterator(NULL)); + return (const_node_iterator(0)); } PB_DS_CLASS_T_DEC @@ -131,6 +131,6 @@ inline typename PB_DS_CLASS_C_DEC::node_iterator PB_DS_CLASS_C_DEC:: node_end() { - return (node_iterator(NULL)); + return (node_iterator(0)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp index 365f02b6ef8..284c0e9bcc9 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp @@ -105,7 +105,7 @@ namespace __gnu_pbds */ inline - bin_search_tree_const_node_it_(const node_pointer p_nd = NULL) : m_p_nd(const_cast<node_pointer>(p_nd)) + bin_search_tree_const_node_it_(const node_pointer p_nd = 0) : m_p_nd(const_cast<node_pointer>(p_nd)) { } // Access. @@ -197,7 +197,7 @@ namespace __gnu_pbds */ inline - bin_search_tree_node_it_(const node_pointer p_nd = NULL) : PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC( + bin_search_tree_node_it_(const node_pointer p_nd = 0) : PB_DS_TREE_CONST_NODE_ITERATOR_CLASS_C_DEC( const_cast<node_pointer>(p_nd)) { } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp index bb249e07057..5bf3f229f5d 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp @@ -124,7 +124,7 @@ namespace __gnu_pbds public: inline - bin_search_tree_const_it_(const Node_Pointer p_nd = NULL) + bin_search_tree_const_it_(const Node_Pointer p_nd = 0) : m_p_nd(const_cast<Node_Pointer>(p_nd)) { } @@ -152,14 +152,14 @@ namespace __gnu_pbds inline const_pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0); return &m_p_nd->m_value; } inline const_reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0); return m_p_nd->m_value; } @@ -182,7 +182,7 @@ namespace __gnu_pbds inline PB_DS_TREE_CONST_IT_C_DEC& operator++() { - _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0); inc(integral_constant<int,Is_Forward_Iterator>()); return *this; } @@ -225,10 +225,10 @@ namespace __gnu_pbds return; } - if (m_p_nd->m_p_right != NULL) + if (m_p_nd->m_p_right != 0) { m_p_nd = m_p_nd->m_p_right; - while (m_p_nd->m_p_left != NULL) + while (m_p_nd->m_p_left != 0) m_p_nd = m_p_nd->m_p_left; return; } @@ -257,10 +257,10 @@ namespace __gnu_pbds return; } - if (m_p_nd->m_p_left != NULL) + if (m_p_nd->m_p_left != 0) { Node_Pointer p_y = m_p_nd->m_p_left; - while (p_y->m_p_right != NULL) + while (p_y->m_p_right != 0) p_y = p_y->m_p_right; m_p_nd = p_y; return; @@ -297,7 +297,7 @@ namespace __gnu_pbds public: inline - bin_search_tree_it_(const Node_Pointer p_nd = NULL) + bin_search_tree_it_(const Node_Pointer p_nd = 0) : PB_DS_TREE_CONST_IT_C_DEC((Node_Pointer)p_nd) { } @@ -325,14 +325,14 @@ namespace __gnu_pbds inline typename PB_DS_TREE_CONST_IT_C_DEC::pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0); return &base_it_type::m_p_nd->m_value; } inline typename PB_DS_TREE_CONST_IT_C_DEC::reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(base_it_type::m_p_nd != 0); return base_it_type::m_p_nd->m_value; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp index 667ef84704f..76c543f149a 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/r_erase_fn_imps.hpp @@ -106,7 +106,7 @@ void PB_DS_CLASS_C_DEC:: clear_imp(node_pointer p_nd) { - if (p_nd == NULL) + if (p_nd == 0) return; clear_imp(p_nd->m_p_left); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp index 0598657fe04..b21e98102df 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/rotate_fn_imps.hpp @@ -47,7 +47,7 @@ rotate_left(node_pointer p_x) p_x->m_p_right = p_y->m_p_left; - if (p_y->m_p_left != NULL) + if (p_y->m_p_left != 0) p_y->m_p_left->m_p_parent = p_x; p_y->m_p_parent = p_x->m_p_parent; @@ -78,7 +78,7 @@ rotate_right(node_pointer p_x) p_x->m_p_left = p_y->m_p_right; - if (p_y->m_p_right != NULL) + if (p_y->m_p_right != 0) p_y->m_p_right->m_p_parent = p_x; p_y->m_p_parent = p_x->m_p_parent; @@ -131,7 +131,7 @@ apply_update(node_pointer p_nd, Node_Update_* /*p_update*/) { node_update::operator()( node_iterator(p_nd), - const_node_iterator(static_cast<node_pointer>(NULL))); + const_node_iterator(static_cast<node_pointer>(0))); } PB_DS_CLASS_T_DEC diff --git a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp index 9d2bd6d742d..2c027f6ab98 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/bin_search_tree_/split_join_fn_imps.hpp @@ -139,7 +139,7 @@ typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: recursive_count(node_pointer p) const { - if (p == NULL) + if (p == 0) return 0; return 1 + recursive_count(p->m_p_left) + recursive_count(p->m_p_right); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp index 9cb13f99cca..76cf80bd544 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_iterator.hpp @@ -125,7 +125,7 @@ namespace __gnu_pbds inline PB_DS_CLASS_C_DEC& operator++() { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_e != NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_e != 0); inc(); return *this; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp index d4013db16fe..ab5efe2bb64 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp @@ -92,7 +92,7 @@ namespace __gnu_pbds // Default constructor. inline - binary_heap_const_point_iterator_() : m_p_e(NULL) { } + binary_heap_const_point_iterator_() : m_p_e(0) { } // Copy constructor. inline @@ -104,7 +104,7 @@ namespace __gnu_pbds inline const_pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(m_p_e != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_e != 0); return to_ptr(integral_constant<int, Simple>()); } @@ -112,7 +112,7 @@ namespace __gnu_pbds inline const_reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(m_p_e != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_e != 0); return *to_ptr(integral_constant<int, Simple>()); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp index 04b7d548f2e..dfceb689132 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binary_heap_/split_join_fn_imps.hpp @@ -68,8 +68,8 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) const size_type other_actual_size = other.get_new_size_for_arbitrary(ersd); - entry_pointer a_entries = NULL; - entry_pointer a_other_entries = NULL; + entry_pointer a_entries = 0; + entry_pointer a_other_entries = 0; __try { @@ -79,10 +79,10 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) } __catch(...) { - if (a_entries != NULL) + if (a_entries != 0) s_entry_allocator.deallocate(a_entries, actual_size); - if (a_other_entries != NULL) + if (a_other_entries != 0) s_entry_allocator.deallocate(a_other_entries, other_actual_size); __throw_exception_again; @@ -128,8 +128,8 @@ join(PB_DS_CLASS_C_DEC& other) const size_type len = m_size + other.m_size; const size_type actual_size = resize_policy::get_new_size_for_arbitrary(len); - entry_pointer a_entries = NULL; - entry_pointer a_other_entries = NULL; + entry_pointer a_entries = 0; + entry_pointer a_other_entries = 0; __try { @@ -138,10 +138,10 @@ join(PB_DS_CLASS_C_DEC& other) } __catch(...) { - if (a_entries != NULL) + if (a_entries != 0) s_entry_allocator.deallocate(a_entries, actual_size); - if (a_other_entries != NULL) + if (a_other_entries != 0) s_entry_allocator.deallocate(a_other_entries, resize_policy::min_size); __throw_exception_again; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp index 274c93378fd..983df099dd7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/constructors_destructor_fn_imps.hpp @@ -53,7 +53,7 @@ copy_from_range(It first_it, It last_it) PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: binomial_heap_base_() : - m_p_max(NULL) + m_p_max(0) { _GLIBCXX_DEBUG_ONLY(assert_valid(false);) } @@ -62,7 +62,7 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: binomial_heap_base_(const Cmp_Fn& r_cmp_fn) : PB_DS_BASE_C_DEC(r_cmp_fn), - m_p_max(NULL) + m_p_max(0) { _GLIBCXX_DEBUG_ONLY(assert_valid(false);) } @@ -71,7 +71,7 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: binomial_heap_base_(const PB_DS_CLASS_C_DEC& other) : PB_DS_BASE_C_DEC(other), - m_p_max(NULL) + m_p_max(0) { _GLIBCXX_DEBUG_ONLY(assert_valid(false);) } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp index 9a07f0e7d51..1ccee551402 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/debug_fn_imps.hpp @@ -55,9 +55,9 @@ void PB_DS_CLASS_C_DEC:: assert_max() const { - if (m_p_max == NULL) + if (m_p_max == 0) return; - _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == 0); for (const_iterator it = base_type::begin(); it != base_type::end(); ++it) _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(m_p_max->m_value, it.m_p_nd->m_value)); @@ -71,14 +71,14 @@ assert_node_consistent(const_node_pointer p_nd, bool strictly_binomial, { _GLIBCXX_DEBUG_ASSERT(increasing || strictly_binomial); base_type::assert_node_consistent(p_nd, false); - if (p_nd == NULL) + if (p_nd == 0) return; _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == base_type::degree(p_nd)); _GLIBCXX_DEBUG_ASSERT(base_type::size_under_node(p_nd) == static_cast<size_type>(1 << p_nd->m_metadata)); assert_node_consistent(p_nd->m_p_next_sibling, strictly_binomial, increasing); assert_node_consistent(p_nd->m_p_l_child, true, false); - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) { if (increasing) { diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp index a4cf90c20f1..d6ead1e51c3 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/erase_fn_imps.hpp @@ -46,10 +46,10 @@ pop() _GLIBCXX_DEBUG_ONLY(assert_valid(true);) _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); - if (m_p_max == NULL) + if (m_p_max == 0) find_max(); - _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_max != 0); node_pointer p_nd = m_p_max; @@ -57,7 +57,7 @@ pop() base_type::actual_erase_node(p_nd); - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) } @@ -67,33 +67,33 @@ void PB_DS_CLASS_C_DEC:: remove_parentless_node(node_pointer p_nd) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - _GLIBCXX_DEBUG_ASSERT(base_type::parent(p_nd) == NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + _GLIBCXX_DEBUG_ASSERT(base_type::parent(p_nd) == 0); node_pointer p_cur_root = p_nd == base_type::m_p_root? p_nd->m_p_next_sibling : base_type::m_p_root; - if (p_cur_root != NULL) - p_cur_root->m_p_prev_or_parent = NULL; + if (p_cur_root != 0) + p_cur_root->m_p_prev_or_parent = 0; - if (p_nd->m_p_prev_or_parent != NULL) + if (p_nd->m_p_prev_or_parent != 0) p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling; - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; node_pointer p_child = p_nd->m_p_l_child; - if (p_child != NULL) + if (p_child != 0) { - p_child->m_p_prev_or_parent = NULL; + p_child->m_p_prev_or_parent = 0; - while (p_child->m_p_next_sibling != NULL) + while (p_child->m_p_next_sibling != 0) p_child = p_child->m_p_next_sibling; } - m_p_max = NULL; + m_p_max = 0; base_type::m_p_root = join(p_cur_root, p_child); } @@ -105,7 +105,7 @@ clear() { base_type::clear(); - m_p_max = NULL; + m_p_max = 0; } PB_DS_CLASS_T_DEC @@ -122,7 +122,7 @@ erase(point_iterator it) base_type::actual_erase_node(it.m_p_nd); - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) } @@ -148,7 +148,7 @@ erase_if(Pred pred) size_type ersd = 0; - while (p_out != NULL) + while (p_out != 0) { ++ersd; @@ -161,19 +161,19 @@ erase_if(Pred pred) node_pointer p_cur = base_type::m_p_root; - base_type::m_p_root = NULL; + base_type::m_p_root = 0; - while (p_cur != NULL) + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; - p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = NULL; + p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0; p_cur->m_metadata = 0; p_cur->m_p_next_sibling = base_type::m_p_root; - if (base_type::m_p_root != NULL) + if (base_type::m_p_root != 0) base_type::m_p_root->m_p_prev_or_parent = p_cur; base_type::m_p_root = p_cur; @@ -183,7 +183,7 @@ erase_if(Pred pred) p_cur = p_next; } - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp index ad7f65129ba..3c8ff109def 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/find_fn_imps.hpp @@ -46,10 +46,10 @@ top() const _GLIBCXX_DEBUG_ONLY(assert_valid(false);) _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); - if (m_p_max == NULL) + if (m_p_max == 0) const_cast<PB_DS_CLASS_C_DEC* >(this)->find_max(); - _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_max != 0); return m_p_max->m_value; } @@ -62,7 +62,7 @@ find_max() m_p_max = p_cur; - while (p_cur != NULL) + while (p_cur != 0) { if (Cmp_Fn::operator()(m_p_max->m_value, p_cur->m_value)) m_p_max = p_cur; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp index e67d0df148f..735bddbb71a 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/insert_fn_imps.hpp @@ -49,7 +49,7 @@ push(const_reference r_val) insert_node(p_nd); - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) @@ -61,10 +61,10 @@ inline void PB_DS_CLASS_C_DEC:: insert_node(node_pointer p_nd) { - if (base_type::m_p_root == NULL) + if (base_type::m_p_root == 0) { p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = - p_nd->m_p_l_child = NULL; + p_nd->m_p_l_child = 0; p_nd->m_metadata = 0; @@ -75,7 +75,7 @@ insert_node(node_pointer p_nd) if (base_type::m_p_root->m_metadata > 0) { - p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = NULL; + p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0; p_nd->m_p_next_sibling = base_type::m_p_root; @@ -92,7 +92,7 @@ insert_node(node_pointer p_nd) { p_nd->m_p_next_sibling = base_type::m_p_root->m_p_next_sibling; - p_nd->m_p_prev_or_parent = NULL; + p_nd->m_p_prev_or_parent = 0; p_nd->m_metadata = 1; @@ -100,15 +100,15 @@ insert_node(node_pointer p_nd) base_type::m_p_root->m_p_prev_or_parent = p_nd; - base_type::m_p_root->m_p_next_sibling = NULL; + base_type::m_p_root->m_p_next_sibling = 0; base_type::m_p_root = p_nd; } else { - p_nd->m_p_next_sibling = NULL; + p_nd->m_p_next_sibling = 0; - p_nd->m_p_l_child = NULL; + p_nd->m_p_l_child = 0; p_nd->m_p_prev_or_parent = base_type::m_p_root; @@ -128,7 +128,7 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: fix(node_pointer p_nd) const { - while (p_nd->m_p_next_sibling != NULL&& + while (p_nd->m_p_next_sibling != 0&& p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata) { node_pointer p_next = p_nd->m_p_next_sibling; @@ -138,7 +138,7 @@ fix(node_pointer p_nd) const p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; - if (p_nd->m_p_prev_or_parent != NULL) + if (p_nd->m_p_prev_or_parent != 0) p_nd->m_p_prev_or_parent->m_p_next_sibling = p_next; base_type::make_child_of(p_nd, p_next); @@ -151,8 +151,8 @@ fix(node_pointer p_nd) const { p_nd->m_p_next_sibling = p_next->m_p_next_sibling; - if (p_nd->m_p_next_sibling != NULL) - p_next->m_p_next_sibling = NULL; + if (p_nd->m_p_next_sibling != 0) + p_next->m_p_next_sibling = 0; base_type::make_child_of(p_next, p_nd); @@ -160,7 +160,7 @@ fix(node_pointer p_nd) const } } - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd; return p_nd; @@ -174,7 +174,7 @@ modify(point_iterator it, const_reference r_new_val) _GLIBCXX_DEBUG_ONLY(assert_valid(true);) node_pointer p_nd = it.m_p_nd; - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false);) const bool bubble_up = Cmp_Fn::operator()(p_nd->m_value, r_new_val); @@ -185,7 +185,7 @@ modify(point_iterator it, const_reference r_new_val) { node_pointer p_parent = base_type::parent(p_nd); - while (p_parent != NULL&& + while (p_parent != 0&& Cmp_Fn::operator()(p_parent->m_value, p_nd->m_value)) { base_type::swap_with_parent(p_nd, p_parent); @@ -193,10 +193,10 @@ modify(point_iterator it, const_reference r_new_val) p_parent = base_type::parent(p_nd); } - if (p_nd->m_p_prev_or_parent == NULL) + if (p_nd->m_p_prev_or_parent == 0) base_type::m_p_root = p_nd; - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) @@ -209,7 +209,7 @@ modify(point_iterator it, const_reference r_new_val) insert_node(p_nd); - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp index a701937cb99..2a96236fb9e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/binomial_heap_base_/split_join_fn_imps.hpp @@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_out = base_type::prune(pred); - while (p_out != NULL) + while (p_out != 0) { _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0); --base_type::m_size; @@ -70,13 +70,13 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_next = p_out->m_p_next_sibling; - p_out->m_p_l_child = p_out->m_p_prev_or_parent = NULL; + p_out->m_p_l_child = p_out->m_p_prev_or_parent = 0; p_out->m_metadata = 0; p_out->m_p_next_sibling = other.m_p_root; - if (other.m_p_root != NULL) + if (other.m_p_root != 0) other.m_p_root->m_p_prev_or_parent = p_out; other.m_p_root = p_out; @@ -90,19 +90,19 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_cur = base_type::m_p_root; - base_type::m_p_root = NULL; + base_type::m_p_root = 0; - while (p_cur != NULL) + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; - p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = NULL; + p_cur->m_p_l_child = p_cur->m_p_prev_or_parent = 0; p_cur->m_metadata = 0; p_cur->m_p_next_sibling = base_type::m_p_root; - if (base_type::m_p_root != NULL) + if (base_type::m_p_root != 0) base_type::m_p_root->m_p_prev_or_parent = p_cur; base_type::m_p_root = p_cur; @@ -112,7 +112,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) p_cur = p_next; } - m_p_max = NULL; + m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) _GLIBCXX_DEBUG_ONLY(other.assert_valid(true);) @@ -128,7 +128,7 @@ join(PB_DS_CLASS_C_DEC& other) node_pointer p_other = other.m_p_root; - if (p_other != NULL) + if (p_other != 0) do { node_pointer p_next = p_other->m_p_next_sibling; @@ -137,15 +137,15 @@ join(PB_DS_CLASS_C_DEC& other) p_other = p_next; } - while (p_other != NULL); + while (p_other != 0); base_type::m_p_root = join(base_type::m_p_root, other.m_p_root); base_type::m_size += other.m_size; - m_p_max = NULL; + m_p_max = 0; - other.m_p_root = NULL; + other.m_p_root = 0; other.m_size = 0; - other.m_p_max = NULL; + other.m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid(true);) _GLIBCXX_DEBUG_ONLY(other.assert_valid(true);) @@ -156,15 +156,15 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: join(node_pointer p_lhs, node_pointer p_rhs) const { - node_pointer p_ret = NULL; + node_pointer p_ret = 0; - node_pointer p_cur = NULL; + node_pointer p_cur = 0; - while (p_lhs != NULL || p_rhs != NULL) + while (p_lhs != 0 || p_rhs != 0) { - if (p_rhs == NULL) + if (p_rhs == 0) { - if (p_cur == NULL) + if (p_cur == 0) p_ret = p_cur = p_lhs; else { @@ -173,11 +173,11 @@ join(node_pointer p_lhs, node_pointer p_rhs) const p_lhs->m_p_prev_or_parent = p_cur; } - p_cur = p_lhs = NULL; + p_cur = p_lhs = 0; } - else if (p_lhs == NULL || p_rhs->m_metadata < p_lhs->m_metadata) + else if (p_lhs == 0 || p_rhs->m_metadata < p_lhs->m_metadata) { - if (p_cur == NULL) + if (p_cur == 0) { p_ret = p_cur = p_rhs; @@ -196,7 +196,7 @@ join(node_pointer p_lhs, node_pointer p_rhs) const } else if (p_lhs->m_metadata < p_rhs->m_metadata) { - if (p_cur == NULL) + if (p_cur == 0) p_ret = p_cur = p_lhs; else { @@ -221,11 +221,11 @@ join(node_pointer p_lhs, node_pointer p_rhs) const } } - if (p_cur != NULL) - p_cur->m_p_next_sibling = NULL; + if (p_cur != 0) + p_cur->m_p_next_sibling = 0; - if (p_ret != NULL) - p_ret->m_p_prev_or_parent = NULL; + if (p_ret != 0) + p_ret->m_p_prev_or_parent = 0; return p_ret; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp index f5efabe0840..2bace9c5ebd 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cc_ht_map_.hpp @@ -374,7 +374,7 @@ namespace __gnu_pbds entry_pointer p_e = m_entries[pos]; resize_base::notify_insert_search_start(); - while (p_e != NULL + while (p_e != 0 && !hash_eq_fn_base::operator()(p_e->m_value.first, r_key)) { resize_base::notify_insert_search_collision(); @@ -382,7 +382,7 @@ namespace __gnu_pbds } resize_base::notify_insert_search_end(); - if (p_e != NULL) + if (p_e != 0) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);) return (p_e->m_value.second); @@ -399,7 +399,7 @@ namespace __gnu_pbds comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_insert_search_start(); - while (p_e != NULL && + while (p_e != 0 && !hash_eq_fn_base::operator()(p_e->m_value.first, p_e->m_hash, r_key, pos_hash_pair.second)) { resize_base::notify_insert_search_collision(); @@ -407,7 +407,7 @@ namespace __gnu_pbds } resize_base::notify_insert_search_end(); - if (p_e != NULL) + if (p_e != 0) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);) return p_e->m_value.second; @@ -468,7 +468,7 @@ namespace __gnu_pbds { entry_pointer p_e = m_entries[ranged_hash_fn_base::operator()(r_key)]; resize_base::notify_find_search_start(); - while (p_e != NULL && + while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) { resize_base::notify_find_search_collision(); @@ -478,7 +478,7 @@ namespace __gnu_pbds resize_base::notify_find_search_end(); #ifdef _GLIBCXX_DEBUG - if (p_e == NULL) + if (p_e == 0) debug_base::check_key_does_not_exist(r_key); else debug_base::check_key_exists(r_key); @@ -492,7 +492,7 @@ namespace __gnu_pbds comp_hash pos_hash_pair = ranged_hash_fn_base::operator()(r_key); entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_find_search_start(); - while (p_e != NULL && + while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash, r_key, pos_hash_pair.second)) @@ -504,7 +504,7 @@ namespace __gnu_pbds resize_base::notify_find_search_end(); #ifdef _GLIBCXX_DEBUG - if (p_e == NULL) + if (p_e == 0) debug_base::check_key_does_not_exist(r_key); else debug_base::check_key_exists(r_key); @@ -534,22 +534,22 @@ namespace __gnu_pbds inc_it_state(const_pointer& r_p_value, std::pair<entry_pointer, size_type>& r_pos) const { - _GLIBCXX_DEBUG_ASSERT(r_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(r_p_value != 0); r_pos.first = r_pos.first->m_p_next; - if (r_pos.first != NULL) + if (r_pos.first != 0) { r_p_value = &r_pos.first->m_value; return; } for (++r_pos.second; r_pos.second < m_num_e; ++r_pos.second) - if (m_entries[r_pos.second] != NULL) + if (m_entries[r_pos.second] != 0) { r_pos.first = m_entries[r_pos.second]; r_p_value = &r_pos.first->m_value; return; } - r_p_value = NULL; + r_p_value = 0; } void @@ -557,13 +557,13 @@ namespace __gnu_pbds std::pair<entry_pointer, size_type>& r_pos) const { for (r_pos.second = 0; r_pos.second < m_num_e; ++r_pos.second) - if (m_entries[r_pos.second] != NULL) + if (m_entries[r_pos.second] != 0) { r_pos.first = m_entries[r_pos.second]; r_p_value = &r_pos.first->m_value; return; } - r_p_value = NULL; + r_p_value = 0; } #ifdef _GLIBCXX_DEBUG diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp index 1a61893d105..c5268447232 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/cmp_fn_imps.hpp @@ -64,7 +64,7 @@ cmp_with_other(const Other_Map_Type& other) const const_cast<PB_DS_CLASS_C_DEC& >(*this). find_key_pointer(r_key, traits_base::m_store_extra_indicator); - if (p_mapped_value == NULL) + if (p_mapped_value == 0) return false; #ifdef PB_DS_DATA_TRUE_INDICATOR diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp index 24294ad9135..f67254169b7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/constructor_destructor_fn_imps.hpp @@ -87,7 +87,7 @@ PB_DS_CLASS_NAME(const Hash_Fn& r_hash_fn, const Eq_Fn& r_eq_fn) : m_num_e(resize_base::get_nearest_larger_size(1)), m_num_used_e(0), m_entries(s_entry_pointer_allocator.allocate(m_num_e)) { - std::fill(m_entries, m_entries + m_num_e, (entry_pointer)NULL); + std::fill(m_entries, m_entries + m_num_e, (entry_pointer)0); Resize_Policy::notify_cleared(); ranged_hash_fn_base::notify_resized(m_num_e); _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) @@ -184,7 +184,7 @@ void PB_DS_CLASS_C_DEC:: initialize() { - std::fill(m_entries, m_entries + m_num_e, entry_pointer(NULL)); + std::fill(m_entries, m_entries + m_num_e, entry_pointer(0)); Resize_Policy::notify_resized(m_num_e); Resize_Policy::notify_cleared(); ranged_hash_fn_base::notify_resized(m_num_e); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp index 4219eef3885..81d68e3311e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/debug_fn_imps.hpp @@ -58,7 +58,7 @@ assert_entry_pointer_array_valid(const entry_pointer_array a_p_entries) const for (size_type pos = 0; pos < m_num_e; ++pos) { entry_pointer p_e = a_p_entries[pos]; - while (p_e != NULL) + while (p_e != 0) { ++iterated_num_used_e; assert_entry_pointer_valid(p_e, traits_base::m_store_extra_indicator); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp index fa09f734843..912535f9390 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/entry_list_fn_imps.hpp @@ -43,7 +43,7 @@ void PB_DS_CLASS_C_DEC:: deallocate_links_in_list(entry_pointer p_e) { - while (p_e != NULL) + while (p_e != 0) { entry_pointer p_dealloc_e = p_e; p_e = p_e->m_p_next; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp index 9f9178bc911..e1260c0d9bd 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_fn_imps.hpp @@ -61,7 +61,7 @@ erase_if(Pred pred) size_type num_ersd = 0; for (size_type pos = 0; pos < m_num_e; ++pos) { - while (m_entries[pos] != NULL && pred(m_entries[pos]->m_value)) + while (m_entries[pos] != 0 && pred(m_entries[pos]->m_value)) { ++num_ersd; entry_pointer p_next_e = m_entries[pos]->m_p_next; @@ -70,7 +70,7 @@ erase_if(Pred pred) } entry_pointer p_e = m_entries[pos]; - while (p_e != NULL && p_e->m_p_next != NULL) + while (p_e != 0 && p_e->m_p_next != 0) { if (pred(p_e->m_p_next->m_value)) { @@ -92,7 +92,7 @@ PB_DS_CLASS_C_DEC:: clear() { for (size_type pos = 0; pos < m_num_e; ++pos) - while (m_entries[pos] != NULL) + while (m_entries[pos] != 0) erase_entry_pointer(m_entries[pos]); do_resize_if_needed_no_throw(); resize_base::notify_cleared(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp index d24fc31f9dc..1f8fa06bda3 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_no_store_hash_fn_imps.hpp @@ -56,7 +56,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos) _GLIBCXX_DEBUG_ONLY(assert_valid();) entry_pointer p_e = m_entries[pos]; resize_base::notify_erase_search_start(); - if (p_e == NULL) + if (p_e == 0) { resize_base::notify_erase_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) @@ -77,7 +77,7 @@ erase_in_pos_imp(const_key_reference r_key, size_type pos) while (true) { entry_pointer p_next_e = p_e->m_p_next; - if (p_next_e == NULL) + if (p_next_e == 0) { resize_base::notify_erase_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp index d72df696221..01192b4cefd 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/erase_store_hash_fn_imps.hpp @@ -47,7 +47,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair) _GLIBCXX_DEBUG_ONLY(assert_valid();) entry_pointer p_e = m_entries[r_pos_hash_pair.first]; resize_base::notify_erase_search_start(); - if (p_e == NULL) + if (p_e == 0) { resize_base::notify_erase_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base:: check_key_does_not_exist(r_key);) @@ -69,7 +69,7 @@ erase_in_pos_imp(const_key_reference r_key, const comp_hash& r_pos_hash_pair) while (true) { entry_pointer p_next_e = p_e->m_p_next; - if (p_next_e == NULL) + if (p_next_e == 0) { resize_base::notify_erase_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp index 6ca9a03b4fa..03db9f84f28 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/find_fn_imps.hpp @@ -61,11 +61,11 @@ PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::point_iterator PB_DS_CLASS_C_DEC:: find_end() -{ return NULL; } +{ return 0; } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::const_point_iterator PB_DS_CLASS_C_DEC:: find_end() const -{ return NULL; } +{ return 0; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp index dc1519df7b3..5722c775def 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/info_fn_imps.hpp @@ -81,7 +81,7 @@ cmp_with_other(const Other_Map_Type& other) const const_cast<PB_DS_CLASS_C_DEC& >(*this). find_key_pointer(r_key, traits_base::m_store_extra_indicator); - if (p_mapped_value == NULL) + if (p_mapped_value == 0) return false; #ifdef PB_DS_DATA_TRUE_INDICATOR diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp index 7215ccd86bc..3d23eab5c35 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_no_store_hash_fn_imps.hpp @@ -50,7 +50,7 @@ insert_imp(const_reference r_val, false_type) entry_pointer p_e = m_entries[pos]; resize_base::notify_insert_search_start(); - while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), + while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), r_key)) { resize_base::notify_insert_search_collision(); @@ -58,7 +58,7 @@ insert_imp(const_reference r_val, false_type) } resize_base::notify_insert_search_end(); - if (p_e != NULL) + if (p_e != 0) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(r_key);) return std::make_pair(&p_e->m_value, false); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp index fbc284f80b9..b35570690af 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/insert_store_hash_fn_imps.hpp @@ -50,7 +50,7 @@ insert_imp(const_reference r_val, true_type) entry_pointer p_e = m_entries[pos_hash_pair.first]; resize_base::notify_insert_search_start(); - while (p_e != NULL && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), + while (p_e != 0 && !hash_eq_fn_base::operator()(PB_DS_V2F(p_e->m_value), p_e->m_hash, key, pos_hash_pair.second)) { @@ -59,7 +59,7 @@ insert_imp(const_reference r_val, true_type) } resize_base::notify_insert_search_end(); - if (p_e != NULL) + if (p_e != 0) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(key);) return std::make_pair(&p_e->m_value, false); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp index 66333ec85c2..11e2583bc47 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/resize_fn_imps.hpp @@ -112,12 +112,12 @@ PB_DS_CLASS_C_DEC:: resize_imp_no_exceptions(size_type new_size, entry_pointer_array a_p_entries_resized, size_type old_size) { std::fill(a_p_entries_resized, a_p_entries_resized + m_num_e, - entry_pointer(NULL)); + entry_pointer(0)); for (size_type pos = 0; pos < old_size; ++pos) { entry_pointer p_e = m_entries[pos]; - while (p_e != NULL) + while (p_e != 0) p_e = resize_imp_no_exceptions_reassign_pointer(p_e, a_p_entries_resized, traits_base::m_store_extra_indicator); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp index 6fa5676b9df..77735aeafdd 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/cc_hash_table_map_/trace_fn_imps.hpp @@ -62,7 +62,7 @@ PB_DS_CLASS_C_DEC:: trace_list(const_entry_pointer p_l) const { size_type iterated_num_used_e = 0; - while (p_l != NULL) + while (p_l != 0) { std::cerr << PB_DS_V2F(p_l->m_value) << " "; p_l = p_l->m_p_next; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp index 69d53763ad5..d39735c5632 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/find_fn_imps.hpp @@ -60,11 +60,11 @@ PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::point_iterator PB_DS_CLASS_C_DEC:: find_end() -{ return NULL; } +{ return 0; } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::const_point_iterator PB_DS_CLASS_C_DEC:: find_end() const -{ return NULL; } +{ return 0; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp index 4741afec090..5b2df85a8c2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/gp_ht_map_.hpp @@ -490,7 +490,7 @@ namespace __gnu_pbds resize_base::notify_find_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);) - return NULL; + return 0; } break; case valid_entry_status: @@ -513,7 +513,7 @@ namespace __gnu_pbds _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);) resize_base::notify_find_search_end(); - return NULL; + return 0; } inline pointer @@ -538,7 +538,7 @@ namespace __gnu_pbds resize_base::notify_find_search_end(); _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);) - return NULL; + return 0; } break; case valid_entry_status: @@ -562,7 +562,7 @@ namespace __gnu_pbds _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(key);) resize_base::notify_find_search_end(); - return NULL; + return 0; } inline bool @@ -583,7 +583,7 @@ namespace __gnu_pbds void inc_it_state(const_pointer& r_p_value, size_type& r_pos) const { - _GLIBCXX_DEBUG_ASSERT(r_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(r_p_value != 0); for (++r_pos; r_pos < m_num_e; ++r_pos) { const_entry_pointer p_e =& m_entries[r_pos]; @@ -593,7 +593,7 @@ namespace __gnu_pbds return; } } - r_p_value = NULL; + r_p_value = 0; } void @@ -608,7 +608,7 @@ namespace __gnu_pbds return; } } - r_p_value = NULL; + r_p_value = 0; } void @@ -623,7 +623,7 @@ namespace __gnu_pbds return; } } - r_p_value = NULL; + r_p_value = 0; } #ifdef _GLIBCXX_DEBUG diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp index 0492a47928b..115a8bf0dda 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/resize_fn_imps.hpp @@ -87,7 +87,7 @@ resize_imp(size_type new_size) _GLIBCXX_DEBUG_ONLY(assert_valid();) const size_type old_size = m_num_e; - entry_array a_entries_resized = NULL; + entry_array a_entries_resized = 0; // Following line might throw an exception. a_entries_resized = s_entry_allocator.allocate(new_size); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp index 479725fd51b..dac063927f6 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/gp_hash_table_map_/standard_policies.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -60,7 +60,7 @@ namespace __gnu_pbds typedef typename __conditional_type< is_same< - __gnu_pbds::direct_mask_range_hashing<size_t>, + __gnu_pbds::direct_mask_range_hashing<std::size_t>, Comb_Probe_Fn>::value, __gnu_pbds::linear_probe_fn<size_type>, __gnu_pbds::quadratic_probe_fn<size_type> >::__type diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp index dad6451d06f..7dcd82588c1 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_probe_fn.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -48,7 +48,7 @@ class sample_probe_fn public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; public: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp index 0912e7f27e8..988f111ea20 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_range_hashing.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -48,7 +48,7 @@ class sample_range_hashing public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; public: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp index 6120231e2e2..8fa04d140e5 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_hash_fn.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -48,7 +48,7 @@ class sample_ranged_hash_fn public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; public: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp index 915f108df83..2bcfdf51a54 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/hash_fn/sample_ranged_probe_fn.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -48,7 +48,7 @@ class sample_ranged_probe_fn public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; public: @@ -70,7 +70,7 @@ protected: // Transforms the const key reference r_key into the i-th position within the table. This method is called for each collision within the probe sequence. inline size_type - operator()(const_key_reference r_key, size_t hash, size_type i) const; + operator()(const_key_reference r_key, std::size_t hash, size_type i) const; }; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp index 5955df16164..4c085d4c69d 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_iterator.hpp @@ -118,7 +118,7 @@ namespace __gnu_pbds inline PB_DS_CLASS_C_DEC& operator++() { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_nd != 0); inc(); return (*this); } @@ -135,10 +135,10 @@ namespace __gnu_pbds void inc() { - if (base_type::m_p_nd->m_p_next_sibling != NULL) + if (base_type::m_p_nd->m_p_next_sibling != 0) { base_type::m_p_nd = base_type::m_p_nd->m_p_next_sibling; - while (base_type::m_p_nd->m_p_l_child != NULL) + while (base_type::m_p_nd->m_p_l_child != 0) base_type::m_p_nd = base_type::m_p_nd->m_p_l_child; return; } @@ -147,7 +147,7 @@ namespace __gnu_pbds { node_pointer p_next = base_type::m_p_nd; base_type::m_p_nd = base_type::m_p_nd->m_p_prev_or_parent; - if (base_type::m_p_nd == NULL || base_type::m_p_nd->m_p_l_child == p_next) + if (base_type::m_p_nd == 0 || base_type::m_p_nd->m_p_l_child == p_next) return; } } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp index 7d682526b4c..8eb1574446b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp @@ -107,7 +107,7 @@ namespace __gnu_pbds // Default constructor. inline - left_child_next_sibling_heap_node_const_point_iterator_() : m_p_nd(NULL) + left_child_next_sibling_heap_node_const_point_iterator_() : m_p_nd(0) { } // Copy constructor. @@ -119,7 +119,7 @@ namespace __gnu_pbds inline const_pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0); return &m_p_nd->m_value; } @@ -127,7 +127,7 @@ namespace __gnu_pbds inline const_reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(m_p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_nd != 0); return m_p_nd->m_value; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp index ea0572527c2..536ac66ea4b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/constructors_destructor_fn_imps.hpp @@ -49,7 +49,7 @@ PB_DS_CLASS_C_DEC::s_no_throw_copies_ind; PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: left_child_next_sibling_heap_() : - m_p_root(NULL), + m_p_root(0), m_size(0) { _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -59,7 +59,7 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: left_child_next_sibling_heap_(const Cmp_Fn& r_cmp_fn) : Cmp_Fn(r_cmp_fn), - m_p_root(NULL), + m_p_root(0), m_size(0) { _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -68,7 +68,7 @@ left_child_next_sibling_heap_(const Cmp_Fn& r_cmp_fn) : PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: left_child_next_sibling_heap_(const PB_DS_CLASS_C_DEC& other) -: Cmp_Fn(other), m_p_root(NULL), m_size(0) +: Cmp_Fn(other), m_p_root(0), m_size(0) { m_size = other.m_size; _GLIBCXX_DEBUG_ONLY(other.assert_valid();) @@ -111,8 +111,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: recursive_copy_node(const_node_pointer p_nd) { - if (p_nd == NULL) - return (NULL); + if (p_nd == 0) + return (0); node_pointer p_ret = s_node_allocator.allocate(1); @@ -127,7 +127,7 @@ recursive_copy_node(const_node_pointer p_nd) } p_ret->m_p_l_child = p_ret->m_p_next_sibling = - p_ret->m_p_prev_or_parent = NULL; + p_ret->m_p_prev_or_parent = 0; __try { @@ -140,12 +140,12 @@ recursive_copy_node(const_node_pointer p_nd) __throw_exception_again; } - if (p_ret->m_p_l_child != NULL) + if (p_ret->m_p_l_child != 0) p_ret->m_p_l_child->m_p_prev_or_parent = p_ret; - if (p_ret->m_p_next_sibling != NULL) + if (p_ret->m_p_next_sibling != 0) p_ret->m_p_next_sibling->m_p_prev_or_parent = - p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : NULL; + p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd ? p_ret : 0; return p_ret; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp index 86871ac3817..16b8217bd61 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/debug_fn_imps.hpp @@ -45,9 +45,9 @@ void PB_DS_CLASS_C_DEC:: assert_valid() const { - _GLIBCXX_DEBUG_ASSERT(m_p_root == NULL || m_p_root->m_p_prev_or_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_root == 0 || m_p_root->m_p_prev_or_parent == 0); - if (m_p_root != NULL) + if (m_p_root != 0) assert_node_consistent(m_p_root, Single_Link_Roots); assert_size(); assert_iterators(); @@ -58,22 +58,22 @@ void PB_DS_CLASS_C_DEC:: assert_node_consistent(const_node_pointer p_nd, bool single_link) const { - if (p_nd == NULL) + if (p_nd == 0) return; assert_node_consistent(p_nd->m_p_l_child, false); assert_node_consistent(p_nd->m_p_next_sibling, single_link); if (single_link) - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent == NULL); - else if (p_nd->m_p_next_sibling != NULL) + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent == 0); + else if (p_nd->m_p_next_sibling != 0) _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling->m_p_prev_or_parent == p_nd); - if (p_nd->m_p_l_child == NULL) + if (p_nd->m_p_l_child == 0) return; const_node_pointer p_child = p_nd->m_p_l_child; - while (p_child != NULL) + while (p_child != 0) { const_node_pointer p_next_child = p_child->m_p_next_sibling; _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(p_nd->m_value, p_child->m_value)); @@ -115,7 +115,7 @@ PB_DS_CLASS_C_DEC:: size_from_node(const_node_pointer p_nd) { size_type ret = 0; - while (p_nd != NULL) + while (p_nd != 0) { ret += 1 + size_from_node(p_nd->m_p_l_child); p_nd = p_nd->m_p_next_sibling; @@ -130,7 +130,7 @@ degree(const_node_pointer p_nd) { size_type ret = 0; const_node_pointer p_child = p_nd->m_p_l_child; - while (p_child != NULL) + while (p_child != 0) { ++ret; p_child = p_child->m_p_next_sibling; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp index 9fa09f49bbb..605457fd4cb 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/erase_fn_imps.hpp @@ -45,7 +45,7 @@ clear() { clear_imp(m_p_root); _GLIBCXX_DEBUG_ASSERT(m_size == 0); - m_p_root = NULL; + m_p_root = 0; } PB_DS_CLASS_T_DEC @@ -64,7 +64,7 @@ void PB_DS_CLASS_C_DEC:: clear_imp(node_pointer p_nd) { - while (p_nd != NULL) + while (p_nd != 0) { clear_imp(p_nd->m_p_l_child); node_pointer p_next = p_nd->m_p_next_sibling; @@ -80,8 +80,8 @@ to_linked_list() { _GLIBCXX_DEBUG_ONLY(assert_valid();) node_pointer p_cur = m_p_root; - while (p_cur != NULL) - if (p_cur->m_p_l_child != NULL) + while (p_cur != 0) + if (p_cur->m_p_l_child != 0) { node_pointer p_child_next = p_cur->m_p_l_child->m_p_next_sibling; p_cur->m_p_l_child->m_p_next_sibling = p_cur->m_p_next_sibling; @@ -94,10 +94,10 @@ to_linked_list() #ifdef _GLIBCXX_DEBUG const_node_pointer p_counter = m_p_root; size_type count = 0; - while (p_counter != NULL) + while (p_counter != 0) { ++count; - _GLIBCXX_DEBUG_ASSERT(p_counter->m_p_l_child == NULL); + _GLIBCXX_DEBUG_ASSERT(p_counter->m_p_l_child == 0); p_counter = p_counter->m_p_next_sibling; } _GLIBCXX_DEBUG_ASSERT(count == m_size); @@ -111,22 +111,22 @@ PB_DS_CLASS_C_DEC:: prune(Pred pred) { node_pointer p_cur = m_p_root; - m_p_root = NULL; - node_pointer p_out = NULL; - while (p_cur != NULL) + m_p_root = 0; + node_pointer p_out = 0; + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; if (pred(p_cur->m_value)) { p_cur->m_p_next_sibling = p_out; - if (p_out != NULL) + if (p_out != 0) p_out->m_p_prev_or_parent = p_cur; p_out = p_cur; } else { p_cur->m_p_next_sibling = m_p_root; - if (m_p_root != NULL) + if (m_p_root != 0) m_p_root->m_p_prev_or_parent = p_cur; m_p_root = p_cur; } @@ -141,7 +141,7 @@ PB_DS_CLASS_C_DEC:: bubble_to_top(node_pointer p_nd) { node_pointer p_parent = parent(p_nd); - while (p_parent != NULL) + while (p_parent != 0) { swap_with_parent(p_nd, p_parent); p_parent = parent(p_nd); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp index 926ccd39c22..478abe018b0 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/insert_fn_imps.hpp @@ -87,12 +87,12 @@ inline void PB_DS_CLASS_C_DEC:: make_child_of(node_pointer p_nd, node_pointer p_new_parent) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - _GLIBCXX_DEBUG_ASSERT(p_new_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + _GLIBCXX_DEBUG_ASSERT(p_new_parent != 0); p_nd->m_p_next_sibling = p_new_parent->m_p_l_child; - if (p_new_parent->m_p_l_child != NULL) + if (p_new_parent->m_p_l_child != 0) p_new_parent->m_p_l_child->m_p_prev_or_parent = p_nd; p_nd->m_p_prev_or_parent = p_new_parent; @@ -109,7 +109,7 @@ parent(node_pointer p_nd) { node_pointer p_pot = p_nd->m_p_prev_or_parent; - if (p_pot == NULL || p_pot->m_p_l_child == p_nd) + if (p_pot == 0 || p_pot->m_p_l_child == p_nd) return p_pot; p_nd = p_pot; @@ -124,12 +124,12 @@ swap_with_parent(node_pointer p_nd, node_pointer p_parent) if (p_parent == m_p_root) m_p_root = p_nd; - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - _GLIBCXX_DEBUG_ASSERT(p_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + _GLIBCXX_DEBUG_ASSERT(p_parent != 0); _GLIBCXX_DEBUG_ASSERT(parent(p_nd) == p_parent); const bool nd_direct_child = p_parent->m_p_l_child == p_nd; - const bool parent_root = p_parent->m_p_prev_or_parent == NULL; + const bool parent_root = p_parent->m_p_prev_or_parent == 0; const bool parent_direct_child = !parent_root&& p_parent->m_p_prev_or_parent->m_p_l_child == p_parent; @@ -138,16 +138,16 @@ swap_with_parent(node_pointer p_nd, node_pointer p_parent) std::swap(p_parent->m_p_l_child, p_nd->m_p_l_child); std::swap(p_parent->m_metadata, p_nd->m_metadata); - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != NULL); - _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child != 0); + _GLIBCXX_DEBUG_ASSERT(p_parent->m_p_prev_or_parent != 0); - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd; - if (p_parent->m_p_next_sibling != NULL) + if (p_parent->m_p_next_sibling != 0) p_parent->m_p_next_sibling->m_p_prev_or_parent = p_parent; - if (p_parent->m_p_l_child != NULL) + if (p_parent->m_p_l_child != 0) p_parent->m_p_l_child->m_p_prev_or_parent = p_parent; if (parent_direct_child) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp index dca70fdd509..b6587e229f2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/iterators_fn_imps.hpp @@ -45,10 +45,10 @@ begin() { node_pointer p_nd = m_p_root; - if (p_nd == NULL) - return (iterator(NULL)); + if (p_nd == 0) + return (iterator(0)); - while (p_nd->m_p_l_child != NULL) + while (p_nd->m_p_l_child != 0) p_nd = p_nd->m_p_l_child; return (iterator(p_nd)); @@ -61,10 +61,10 @@ begin() const { node_pointer p_nd = m_p_root; - if (p_nd == NULL) - return (const_iterator(NULL)); + if (p_nd == 0) + return (const_iterator(0)); - while (p_nd->m_p_l_child != NULL) + while (p_nd->m_p_l_child != 0) p_nd = p_nd->m_p_l_child; return (const_iterator(p_nd)); @@ -75,7 +75,7 @@ inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: end() { - return (iterator(NULL)); + return (iterator(0)); } PB_DS_CLASS_T_DEC @@ -83,6 +83,6 @@ inline typename PB_DS_CLASS_C_DEC::const_iterator PB_DS_CLASS_C_DEC:: end() const { - return (const_iterator(NULL)); + return (const_iterator(0)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp index 040466e8e84..7ba4bf6ee8b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp @@ -38,8 +38,8 @@ * Contains an implementation struct for this type of heap's node. */ -#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP -#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP +#ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP +#define PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP namespace __gnu_pbds { @@ -52,4 +52,4 @@ namespace __gnu_pbds } // namespace detail } // namespace __gnu_pbds -#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP +#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_0_METADATA_HPP diff --git a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp index 2b90cfa1dc0..8d33baa10ac 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/left_child_next_sibling_heap_/trace_fn_imps.hpp @@ -57,7 +57,7 @@ void PB_DS_CLASS_C_DEC:: trace_node(const_node_pointer p_nd, size_type level) { - while (p_nd != NULL) + while (p_nd != 0) { for (size_type i = 0; i < level; ++i) std::cerr << ' '; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp index c998c3e67c1..662f40f34e8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/constructor_destructor_fn_imps.hpp @@ -67,13 +67,13 @@ copy_from_range(It first_it, It last_it) PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME() : m_p_l(NULL) +PB_DS_CLASS_NAME() : m_p_l(0) { _GLIBCXX_DEBUG_ONLY(assert_valid();) } PB_DS_CLASS_T_DEC template<typename It> PB_DS_CLASS_C_DEC:: -PB_DS_CLASS_NAME(It first_it, It last_it) : m_p_l(NULL) +PB_DS_CLASS_NAME(It first_it, It last_it) : m_p_l(0) { copy_from_range(first_it, last_it); _GLIBCXX_DEBUG_ONLY(assert_valid();); @@ -85,7 +85,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : #ifdef _GLIBCXX_DEBUG debug_base(), #endif -m_p_l(NULL) +m_p_l(0) { __try { @@ -125,13 +125,13 @@ PB_DS_CLASS_C_DEC:: deallocate_all() { entry_pointer p_l = m_p_l; - while (p_l != NULL) + while (p_l != 0) { entry_pointer p_next_l = p_l->m_p_next; actual_erase_entry(p_l); p_l = p_next_l; } - m_p_l = NULL; + m_p_l = 0; } PB_DS_CLASS_T_DEC diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp index cdc59208fa3..a7d0fbadf89 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/erase_fn_imps.hpp @@ -44,7 +44,7 @@ PB_DS_CLASS_C_DEC:: erase(const_key_reference r_key) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) - if (m_p_l == NULL) + if (m_p_l == 0) return false; if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value))) @@ -56,7 +56,7 @@ erase(const_key_reference r_key) } entry_pointer p_l = m_p_l; - while (p_l->m_p_next != NULL) + while (p_l->m_p_next != 0) if (s_eq_fn(r_key, PB_DS_V2F(p_l->m_p_next->m_value))) { erase_next(p_l); @@ -83,7 +83,7 @@ erase_if(Pred pred) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) size_type num_ersd = 0; - while (m_p_l != NULL && pred(m_p_l->m_value)) + while (m_p_l != 0 && pred(m_p_l->m_value)) { entry_pointer p_next = m_p_l->m_p_next; ++num_ersd; @@ -91,11 +91,11 @@ erase_if(Pred pred) m_p_l = p_next; } - if (m_p_l == NULL) + if (m_p_l == 0) return num_ersd; entry_pointer p_l = m_p_l; - while (p_l->m_p_next != NULL) + while (p_l->m_p_next != 0) { if (pred(p_l->m_p_next->m_value)) { @@ -115,9 +115,9 @@ void PB_DS_CLASS_C_DEC:: erase_next(entry_pointer p_l) { - _GLIBCXX_DEBUG_ASSERT(p_l != NULL); + _GLIBCXX_DEBUG_ASSERT(p_l != 0); _GLIBCXX_DEBUG_ASSERT(p_l != m_p_l); - _GLIBCXX_DEBUG_ASSERT(p_l->m_p_next != NULL); + _GLIBCXX_DEBUG_ASSERT(p_l->m_p_next != 0); entry_pointer p_next_l = p_l->m_p_next->m_p_next; actual_erase_entry(p_l->m_p_next); p_l->m_p_next = p_next_l; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp index 50347ac5fca..e7f5ed1d3f8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/find_fn_imps.hpp @@ -43,8 +43,8 @@ inline typename PB_DS_CLASS_C_DEC::entry_pointer PB_DS_CLASS_C_DEC:: find_imp(const_key_reference r_key) const { - if (m_p_l == NULL) - return NULL; + if (m_p_l == 0) + return 0; if (s_eq_fn(r_key, PB_DS_V2F(m_p_l->m_value))) { apply_update(m_p_l, s_metadata_type_indicator); @@ -53,7 +53,7 @@ find_imp(const_key_reference r_key) const } entry_pointer p_l = m_p_l; - while (p_l->m_p_next != NULL) + while (p_l->m_p_next != 0) { entry_pointer p_next = p_l->m_p_next; if (s_eq_fn(r_key, PB_DS_V2F(p_next->m_value))) @@ -72,7 +72,7 @@ find_imp(const_key_reference r_key) const } _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) - return NULL; + return 0; } PB_DS_CLASS_T_DEC diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp index 5ad39709d5d..1aaaf1edd92 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/info_fn_imps.hpp @@ -54,4 +54,4 @@ PB_DS_CLASS_T_DEC inline bool PB_DS_CLASS_C_DEC:: empty() const -{ return (m_p_l == NULL); } +{ return (m_p_l == 0); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp index 5efe2a13a66..197cfbc6d18 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/insert_fn_imps.hpp @@ -48,7 +48,7 @@ insert(const_reference r_val) _GLIBCXX_DEBUG_ONLY(assert_valid();) entry_pointer p_l = find_imp(PB_DS_V2F(r_val)); - if (p_l != NULL) + if (p_l != 0) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val));) return std::make_pair(point_iterator(&p_l->m_value), false); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp index e3247c5b080..4d4e0b417c2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/iterators_fn_imps.hpp @@ -43,7 +43,7 @@ inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: begin() { - if (m_p_l == NULL) + if (m_p_l == 0) { _GLIBCXX_DEBUG_ASSERT(empty()); return end(); @@ -56,7 +56,7 @@ inline typename PB_DS_CLASS_C_DEC::const_iterator PB_DS_CLASS_C_DEC:: begin() const { - if (m_p_l == NULL) + if (m_p_l == 0) { _GLIBCXX_DEBUG_ASSERT(empty()); return end(); @@ -68,13 +68,13 @@ PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::iterator PB_DS_CLASS_C_DEC:: end() -{ return iterator(NULL, NULL, this); } +{ return iterator(0, 0, this); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::const_iterator PB_DS_CLASS_C_DEC:: end() const { - return const_iterator(NULL, NULL, const_cast<PB_DS_CLASS_C_DEC* const>(this)); + return const_iterator(0, 0, const_cast<PB_DS_CLASS_C_DEC* const>(this)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp index 0e9336b57ca..cf43064e504 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/lu_map_.hpp @@ -233,7 +233,7 @@ namespace __gnu_pbds { _GLIBCXX_DEBUG_ONLY(assert_valid();) entry_pointer p_e = find_imp(r_key); - return point_iterator(p_e == NULL ? NULL: &p_e->m_value); + return point_iterator(p_e == 0 ? 0: &p_e->m_value); } inline const_point_iterator @@ -241,7 +241,7 @@ namespace __gnu_pbds { _GLIBCXX_DEBUG_ONLY(assert_valid();) entry_pointer p_e = find_imp(r_key); - return const_point_iterator(p_e == NULL ? NULL: &p_e->m_value); + return const_point_iterator(p_e == 0 ? 0: &p_e->m_value); } inline bool @@ -315,7 +315,7 @@ namespace __gnu_pbds inc_it_state(const_pointer& r_p_value, entry_pointer& r_pos) const { r_pos = r_pos->m_p_next; - r_p_value = (r_pos == NULL) ? NULL : &r_pos->m_value; + r_p_value = (r_pos == 0) ? 0 : &r_pos->m_value; } template<typename Metadata> diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp index 908aacc19cd..7c8defcdf06 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_map_/trace_fn_imps.hpp @@ -47,7 +47,7 @@ trace() const { std::cerr << m_p_l << std::endl << std::endl; const_entry_pointer p_l = m_p_l; - while (p_l != NULL) + while (p_l != 0) { std::cerr << PB_DS_V2F(p_l->m_value) << std::endl; p_l = p_l->m_p_next; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp b/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp index 4ef7fe48a82..8e476cb91b9 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -47,7 +47,7 @@ namespace __gnu_pbds // A list-update metadata type that moves elements to the front of // the list based on the counter algorithm. - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class counter_lu_metadata { public: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp index 545b9816293..3245566e39a 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/constructors_destructor_fn_imps.hpp @@ -49,9 +49,9 @@ PB_DS_CLASS_C_DEC::s_metadata_alloc; PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: PB_DS_OV_TREE_CLASS_NAME() : - m_a_values(NULL), - m_a_metadata(NULL), - m_end_it(NULL), + m_a_values(0), + m_a_metadata(0), + m_end_it(0), m_size(0) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) } @@ -59,9 +59,9 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: PB_DS_OV_TREE_CLASS_NAME(const Cmp_Fn& r_cmp_fn) : cmp_fn_base(r_cmp_fn), - m_a_values(NULL), - m_a_metadata(NULL), - m_end_it(NULL), + m_a_values(0), + m_a_metadata(0), + m_end_it(0), m_size(0) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) } @@ -70,9 +70,9 @@ PB_DS_CLASS_C_DEC:: PB_DS_OV_TREE_CLASS_NAME(const Cmp_Fn& r_cmp_fn, const node_update& r_node_update) : cmp_fn_base(r_cmp_fn), node_update(r_node_update), - m_a_values(NULL), - m_a_metadata(NULL), - m_end_it(NULL), + m_a_values(0), + m_a_metadata(0), + m_end_it(0), m_size(0) { _GLIBCXX_DEBUG_ONLY(PB_DS_CLASS_C_DEC::assert_valid();) } @@ -87,9 +87,9 @@ PB_DS_OV_TREE_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : #endif cmp_fn_base(other), node_update(other), - m_a_values(NULL), - m_a_metadata(NULL), - m_end_it(NULL), + m_a_values(0), + m_a_metadata(0), + m_end_it(0), m_size(0) { copy_from_ordered_range(other.begin(), other.end()); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp index c32a8af48c7..9b7011b1ff6 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/debug_fn_imps.hpp @@ -47,8 +47,8 @@ assert_valid() const { std::cout << "av1" << std::endl; - if (m_a_values == NULL || m_end_it == NULL || m_size == 0) - _GLIBCXX_DEBUG_ASSERT(m_a_values == NULL && m_end_it == NULL && m_size == 0); + if (m_a_values == 0 || m_end_it == 0 || m_size == 0) + _GLIBCXX_DEBUG_ASSERT(m_a_values == 0 && m_end_it == 0 && m_size == 0); std::cout << "av2" << std::endl; assert_iterators(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp index 05e7d1a1107..dd24114f490 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/erase_fn_imps.hpp @@ -56,7 +56,7 @@ clear() } _GLIBCXX_DEBUG_ONLY(debug_base::clear();) - m_a_values = NULL; + m_a_values = 0; m_size = 0; m_end_it = m_a_values; _GLIBCXX_DEBUG_ONLY(assert_valid();) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp index 91d277b0cae..08d6bfc2293 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/insert_fn_imps.hpp @@ -50,9 +50,9 @@ void PB_DS_CLASS_C_DEC:: reallocate_metadata(Node_Update_* , size_type new_size) { - metadata_pointer a_new_metadata_vec =(new_size == 0) ? NULL : s_metadata_alloc.allocate(new_size); + metadata_pointer a_new_metadata_vec =(new_size == 0) ? 0 : s_metadata_alloc.allocate(new_size); - if (m_a_metadata != NULL) + if (m_a_metadata != 0) { for (size_type i = 0; i < m_size; ++i) m_a_metadata[i].~metadata_type(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp index 7652c4c2ea2..0417ae1dd9e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/iterators_fn_imps.hpp @@ -69,8 +69,8 @@ PB_DS_node_begin_imp() const { return const_node_iterator(const_cast<pointer>(mid_pointer(begin(), end())), const_cast<pointer>(begin()), - const_cast<pointer>(end()),(m_a_metadata == NULL)? - NULL : + const_cast<pointer>(end()),(m_a_metadata == 0)? + 0 : mid_pointer(m_a_metadata, m_a_metadata + m_size)); } @@ -80,7 +80,7 @@ PB_DS_CLASS_C_DEC:: PB_DS_node_end_imp() const { return const_node_iterator(end(), end(), end(), - (m_a_metadata == NULL) ? NULL : m_a_metadata + m_size); + (m_a_metadata == 0) ? 0 : m_a_metadata + m_size); } PB_DS_CLASS_T_DEC @@ -89,7 +89,7 @@ PB_DS_CLASS_C_DEC:: PB_DS_node_begin_imp() { return node_iterator(mid_pointer(begin(), end()), begin(), end(), - (m_a_metadata == NULL) ? NULL : mid_pointer(m_a_metadata, m_a_metadata + m_size)); + (m_a_metadata == 0) ? 0 : mid_pointer(m_a_metadata, m_a_metadata + m_size)); } PB_DS_CLASS_T_DEC @@ -98,6 +98,6 @@ PB_DS_CLASS_C_DEC:: PB_DS_node_end_imp() { return node_iterator(end(), end(), - end(),(m_a_metadata == NULL) ? NULL : m_a_metadata + m_size); + end(),(m_a_metadata == 0) ? 0 : m_a_metadata + m_size); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp index 68fedc0eb05..1c45c51c1d8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp @@ -118,7 +118,7 @@ namespace __gnu_pbds public: inline - ov_tree_node_const_it_(const_pointer p_nd = NULL, const_pointer p_begin_nd = NULL, const_pointer p_end_nd = NULL, const_metadata_pointer p_metadata = NULL) : m_p_value(const_cast<pointer>(p_nd)), m_p_begin_value(const_cast<pointer>(p_begin_nd)), m_p_end_value(const_cast<pointer>(p_end_nd)), m_p_metadata(p_metadata) + ov_tree_node_const_it_(const_pointer p_nd = 0, const_pointer p_begin_nd = 0, const_pointer p_end_nd = 0, const_metadata_pointer p_metadata = 0) : m_p_value(const_cast<pointer>(p_nd)), m_p_begin_value(const_cast<pointer>(p_begin_nd)), m_p_end_value(const_cast<pointer>(p_end_nd)), m_p_metadata(p_metadata) { } inline const_reference @@ -134,7 +134,7 @@ namespace __gnu_pbds }; PB_DS_STATIC_ASSERT(should_have_metadata, has_metadata); - _GLIBCXX_DEBUG_ASSERT(m_p_metadata != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_metadata != 0); return *m_p_metadata; } @@ -164,8 +164,8 @@ namespace __gnu_pbds return (this_type(mid_pointer(m_p_value + 1, m_p_end_value), m_p_value + 1, - m_p_end_value,(m_p_metadata == NULL) ? - NULL : mid_pointer(m_p_metadata + 1, p_end_metadata))); + m_p_end_value,(m_p_metadata == 0) ? + 0 : mid_pointer(m_p_metadata + 1, p_end_metadata))); } inline bool @@ -241,7 +241,7 @@ namespace __gnu_pbds public: inline - ov_tree_node_it_(const_pointer p_nd = NULL, const_pointer p_begin_nd = NULL, const_pointer p_end_nd = NULL, const_metadata_pointer p_metadata = NULL) : base_type(p_nd, p_begin_nd, p_end_nd, p_metadata) + ov_tree_node_it_(const_pointer p_nd = 0, const_pointer p_begin_nd = 0, const_pointer p_end_nd = 0, const_metadata_pointer p_metadata = 0) : base_type(p_nd, p_begin_nd, p_end_nd, p_metadata) { } // Access. @@ -277,8 +277,8 @@ namespace __gnu_pbds return (this_type(base_type::mid_pointer(base_type::m_p_value + 1, base_type::m_p_end_value), base_type::m_p_value + 1, - base_type::m_p_end_value,(base_type::m_p_metadata == NULL)? - NULL : base_type::mid_pointer(base_type::m_p_metadata + 1, p_end_metadata))); + base_type::m_p_end_value,(base_type::m_p_metadata == 0)? + 0 : base_type::mid_pointer(base_type::m_p_metadata + 1, p_end_metadata))); } }; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp index 7c9fc13456a..51afa4fab92 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/debug_fn_imps.hpp @@ -45,8 +45,8 @@ void PB_DS_CLASS_C_DEC:: assert_valid() const { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_root == NULL - || base_type::m_p_root->m_p_next_sibling == NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_root == 0 + || base_type::m_p_root->m_p_next_sibling == 0); base_type::assert_valid(); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp index 905be1098cf..226e9531ada 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/erase_fn_imps.hpp @@ -48,8 +48,8 @@ pop() node_pointer p_new_root = join_node_children(base_type::m_p_root); _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_new_root, false);) - if (p_new_root != NULL) - p_new_root->m_p_prev_or_parent = NULL; + if (p_new_root != 0) + p_new_root->m_p_prev_or_parent = 0; base_type::actual_erase_node(base_type::m_p_root); base_type::m_p_root = p_new_root; @@ -78,27 +78,27 @@ remove_node(node_pointer p_nd) node_pointer p_new_child = join_node_children(p_nd); #ifdef _GLIBCXX_DEBUG - if (p_new_child != NULL) + if (p_new_child != 0) base_type::assert_node_consistent(p_new_child, false); #endif if (p_nd == base_type::m_p_root) { - if (p_new_child != NULL) - p_new_child->m_p_prev_or_parent = NULL; + if (p_new_child != 0) + p_new_child->m_p_prev_or_parent = 0; base_type::m_p_root = p_new_child; _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(base_type::m_p_root, false);) return; } - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_prev_or_parent != 0); if (p_nd->m_p_prev_or_parent->m_p_l_child == p_nd) { - if (p_new_child != NULL) + if (p_new_child != 0) { p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling; - if (p_new_child->m_p_next_sibling != NULL) + if (p_new_child->m_p_next_sibling != 0) p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child; p_nd->m_p_prev_or_parent->m_p_l_child = p_new_child; _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);) @@ -106,17 +106,17 @@ remove_node(node_pointer p_nd) } p_nd->m_p_prev_or_parent->m_p_l_child = p_nd->m_p_next_sibling; - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);) return; } - if (p_new_child != NULL) + if (p_new_child != 0) { p_new_child->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; p_new_child->m_p_next_sibling = p_nd->m_p_next_sibling; - if (p_new_child->m_p_next_sibling != NULL) + if (p_new_child->m_p_next_sibling != 0) p_new_child->m_p_next_sibling->m_p_prev_or_parent = p_new_child; p_new_child->m_p_prev_or_parent->m_p_next_sibling = p_new_child; _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);) @@ -124,7 +124,7 @@ remove_node(node_pointer p_nd) } p_nd->m_p_prev_or_parent->m_p_next_sibling = p_nd->m_p_next_sibling; - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd->m_p_prev_or_parent, false);) } @@ -134,11 +134,11 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: join_node_children(node_pointer p_nd) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); node_pointer p_ret = p_nd->m_p_l_child; - if (p_ret == NULL) - return NULL; - while (p_ret->m_p_next_sibling != NULL) + if (p_ret == 0) + return 0; + while (p_ret->m_p_next_sibling != 0) p_ret = forward_join(p_ret, p_ret->m_p_next_sibling); while (p_ret->m_p_prev_or_parent != p_nd) p_ret = back_join(p_ret->m_p_prev_or_parent, p_ret); @@ -151,17 +151,17 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: forward_join(node_pointer p_nd, node_pointer p_next) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == p_next); if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value)) { p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; base_type::make_child_of(p_nd, p_next); - return p_next->m_p_next_sibling == NULL + return p_next->m_p_next_sibling == 0 ? p_next : p_next->m_p_next_sibling; } - if (p_next->m_p_next_sibling != NULL) + if (p_next->m_p_next_sibling != 0) { p_next->m_p_next_sibling->m_p_prev_or_parent = p_nd; p_nd->m_p_next_sibling = p_next->m_p_next_sibling; @@ -169,7 +169,7 @@ forward_join(node_pointer p_nd, node_pointer p_next) return p_nd->m_p_next_sibling; } - p_nd->m_p_next_sibling = NULL; + p_nd->m_p_next_sibling = 0; base_type::make_child_of(p_next, p_nd); _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false)); return p_nd; @@ -180,8 +180,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: back_join(node_pointer p_nd, node_pointer p_next) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == 0); if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value)) { @@ -191,7 +191,7 @@ back_join(node_pointer p_nd, node_pointer p_next) return p_next; } - p_nd->m_p_next_sibling = NULL; + p_nd->m_p_next_sibling = 0; base_type::make_child_of(p_next, p_nd); _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false)); return p_nd; @@ -212,7 +212,7 @@ erase_if(Pred pred) base_type::to_linked_list(); node_pointer p_out = base_type::prune(pred); size_type ersd = 0; - while (p_out != NULL) + while (p_out != 0) { ++ersd; node_pointer p_next = p_out->m_p_next_sibling; @@ -221,11 +221,11 @@ erase_if(Pred pred) } node_pointer p_cur = base_type::m_p_root; - base_type::m_p_root = NULL; - while (p_cur != NULL) + base_type::m_p_root = 0; + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; - p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = NULL; + p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0; push_imp(p_cur); p_cur = p_next; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp index b00e9d13cdf..af929e58131 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/insert_fn_imps.hpp @@ -59,17 +59,17 @@ inline void PB_DS_CLASS_C_DEC:: push_imp(node_pointer p_nd) { - p_nd->m_p_l_child = NULL; + p_nd->m_p_l_child = 0; - if (base_type::m_p_root == NULL) + if (base_type::m_p_root == 0) { - p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = NULL; + p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0; base_type::m_p_root = p_nd; } else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, p_nd->m_value)) { - p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = NULL; + p_nd->m_p_next_sibling = p_nd->m_p_prev_or_parent = 0; base_type::make_child_of(base_type::m_p_root, p_nd); _GLIBCXX_DEBUG_ONLY(base_type::assert_node_consistent(p_nd, false)); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp index 85d4ddf074a..12032734f4e 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pairing_heap_/split_join_fn_imps.hpp @@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_out = base_type::prune(pred); - while (p_out != NULL) + while (p_out != 0) { _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0); --base_type::m_size; @@ -70,7 +70,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_next = p_out->m_p_next_sibling; - p_out->m_p_l_child = p_out->m_p_next_sibling = p_out->m_p_prev_or_parent = NULL; + p_out->m_p_l_child = p_out->m_p_next_sibling = p_out->m_p_prev_or_parent = 0; other.push_imp(p_out); @@ -81,13 +81,13 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_cur = base_type::m_p_root; - base_type::m_p_root = NULL; + base_type::m_p_root = 0; - while (p_cur != NULL) + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; - p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = NULL; + p_cur->m_p_l_child = p_cur->m_p_next_sibling = p_cur->m_p_prev_or_parent = 0; push_imp(p_cur); @@ -106,7 +106,7 @@ join(PB_DS_CLASS_C_DEC& other) _GLIBCXX_DEBUG_ONLY(assert_valid();) _GLIBCXX_DEBUG_ONLY(other.assert_valid();) - if (other.m_p_root == NULL) + if (other.m_p_root == 0) { _GLIBCXX_DEBUG_ONLY(assert_valid();) _GLIBCXX_DEBUG_ONLY(other.assert_valid();) @@ -114,7 +114,7 @@ join(PB_DS_CLASS_C_DEC& other) return; } - if (base_type::m_p_root == NULL) + if (base_type::m_p_root == 0) base_type::m_p_root = other.m_p_root; else if (Cmp_Fn::operator()(base_type::m_p_root->m_value, other.m_p_root->m_value)) { @@ -131,7 +131,7 @@ join(PB_DS_CLASS_C_DEC& other) base_type::m_size += other.m_size; - other.m_p_root = NULL; + other.m_p_root = 0; other.m_size = 0; _GLIBCXX_DEBUG_ONLY(assert_valid();) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp index 15f349efbed..8decad5a7f0 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/child_iterator.hpp @@ -48,8 +48,8 @@ public: typedef node_pointer_reference reference; inline - iterator(node_pointer_pointer p_p_cur = NULL, - node_pointer_pointer p_p_end = NULL) + iterator(node_pointer_pointer p_p_cur = 0, + node_pointer_pointer p_p_end = 0) : const_iterator(p_p_cur, p_p_end) { } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp index bc349cf2dbd..5cc9c2234c6 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/const_child_iterator.hpp @@ -53,8 +53,8 @@ public: public: inline - const_iterator(node_pointer_pointer p_p_cur = NULL, - node_pointer_pointer p_p_end = NULL) + const_iterator(node_pointer_pointer p_p_cur = 0, + node_pointer_pointer p_p_end = 0) : m_p_p_cur(p_p_cur), m_p_p_end(p_p_end) { } @@ -71,7 +71,7 @@ public: { do ++m_p_p_cur; - while (m_p_p_cur != m_p_p_end&& * m_p_p_cur == NULL); + while (m_p_p_cur != m_p_p_end&& * m_p_p_cur == 0); return *this; } @@ -101,7 +101,7 @@ protected: #ifdef _GLIBCXX_DEBUG void assert_referencible() const - { _GLIBCXX_DEBUG_ASSERT(m_p_p_cur != m_p_p_end&& * m_p_p_cur != NULL); } + { _GLIBCXX_DEBUG_ASSERT(m_p_p_cur != m_p_p_end&& * m_p_p_cur != 0); } #endif public: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp index ca38f932a62..4d4b52a55eb 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/constructors_destructor_fn_imps.hpp @@ -85,7 +85,7 @@ PB_DS_CLASS_NAME(const PB_DS_CLASS_C_DEC& other) : initialize(); m_size = other.m_size; _GLIBCXX_DEBUG_ONLY(other.assert_valid();) - if (other.m_p_head->m_p_parent == NULL) + if (other.m_p_head->m_p_parent == 0) { _GLIBCXX_DEBUG_ONLY(assert_valid();) return; @@ -143,7 +143,7 @@ PB_DS_CLASS_C_DEC:: initialize() { new (m_p_head) head(); - m_p_head->m_p_parent = NULL; + m_p_head->m_p_parent = 0; m_p_head->m_p_min = m_p_head; m_p_head->m_p_max = m_p_head; m_size = 0; @@ -164,7 +164,7 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: recursive_copy_node(const_node_pointer p_other_nd) { - _GLIBCXX_DEBUG_ASSERT(p_other_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_other_nd != 0); if (p_other_nd->m_type == pat_trie_leaf_node_type) { const_leaf_pointer p_other_leaf = static_cast<const_leaf_pointer>(p_other_nd); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp index de75657881b..664206499b2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/debug_fn_imps.hpp @@ -45,11 +45,11 @@ void PB_DS_CLASS_C_DEC:: assert_valid() const { - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) m_p_head->m_p_parent->assert_valid(this); assert_iterators(); assert_reverse_iterators(); - if (m_p_head->m_p_parent == NULL) + if (m_p_head->m_p_parent == 0) { _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_min == m_p_head); _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_max == m_p_head); @@ -99,7 +99,7 @@ typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: recursive_count_leafs(const_node_pointer p_nd) { - if (p_nd == NULL) + if (p_nd == 0) return (0); if (p_nd->m_type == pat_trie_leaf_node_type) return (1); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp index 90988184a8d..57e998981a8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/erase_fn_imps.hpp @@ -44,7 +44,7 @@ PB_DS_CLASS_C_DEC:: erase(const_key_reference r_key) { node_pointer p_nd = find_imp(r_key); - if (p_nd == NULL || p_nd->m_type == pat_trie_internal_node_type) + if (p_nd == 0 || p_nd->m_type == pat_trie_internal_node_type) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key)); return false; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp index 2552ead8bc5..f53af256339 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/find_fn_imps.hpp @@ -46,7 +46,7 @@ find(const_key_reference r_key) _GLIBCXX_DEBUG_ONLY(assert_valid();) node_pointer p_nd = find_imp(r_key); - if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type) + if (p_nd == 0 || p_nd->m_type != pat_trie_leaf_node_type) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) return end(); @@ -71,7 +71,7 @@ find(const_key_reference r_key) const const_node_pointer p_nd = const_cast<PB_DS_CLASS_C_DEC* >(this)->find_imp(r_key); - if (p_nd == NULL || p_nd->m_type != pat_trie_leaf_node_type) + if (p_nd == 0 || p_nd->m_type != pat_trie_leaf_node_type) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_does_not_exist(r_key);) return end(); @@ -93,7 +93,7 @@ PB_DS_CLASS_C_DEC:: find_imp(const_key_reference r_key) { if (empty()) - return (NULL); + return (0); typename synth_e_access_traits::const_iterator b_it = synth_e_access_traits::begin(r_key); @@ -101,14 +101,14 @@ find_imp(const_key_reference r_key) synth_e_access_traits::end(r_key); node_pointer p_nd = m_p_head->m_p_parent; - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); while (p_nd->m_type != pat_trie_leaf_node_type) { _GLIBCXX_DEBUG_ASSERT(p_nd->m_type == pat_trie_internal_node_type); node_pointer p_next_nd = static_cast<internal_node_pointer>(p_nd)->get_child_node(b_it, e_it, this); - if (p_next_nd == NULL) + if (p_next_nd == 0) return p_nd; p_nd = p_next_nd; } @@ -124,7 +124,7 @@ lower_bound_imp(const_key_reference r_key) return (m_p_head); node_pointer p_nd = m_p_head->m_p_parent; - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); typename PB_DS_CLASS_C_DEC::const_e_iterator b_it = synth_e_access_traits::begin(r_key); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp index e6049743f61..de3cb35276b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/insert_join_fn_imps.hpp @@ -165,7 +165,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r, it != p_r->end(); ++ it) { const_node_pointer p_l_join_child = p_l->get_join_child(*it, this); - if (p_l_join_child != NULL) + if (p_l_join_child != 0) rec_join_prep(p_l_join_child, * it, r_bag); } return; @@ -175,7 +175,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r, p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this)) { const_node_pointer p_r_join_child = p_r->get_join_child(p_l, this); - if (p_r_join_child != NULL) + if (p_r_join_child != 0) rec_join_prep(p_r_join_child, p_l, r_bag); return; } @@ -184,7 +184,7 @@ rec_join_prep(const_internal_node_pointer p_l, const_internal_node_pointer p_r, p_r->should_be_mine(p_l->pref_b_it(), p_l->pref_e_it(), 0, this)) { const_node_pointer p_r_join_child = p_r->get_join_child(p_l, this); - if (p_r_join_child != NULL) + if (p_r_join_child != 0) rec_join_prep(p_r_join_child, p_l, r_bag); return; } @@ -196,8 +196,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: rec_join(node_pointer p_l, node_pointer p_r, size_type checked_ind, split_join_branch_bag& r_bag) { - _GLIBCXX_DEBUG_ASSERT(p_r != NULL); - if (p_l == NULL) + _GLIBCXX_DEBUG_ASSERT(p_r != 0); + if (p_l == 0) { apply_update(p_r, (node_update* )this); return (p_r); @@ -245,8 +245,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: rec_join(leaf_pointer p_l, leaf_pointer p_r, split_join_branch_bag& r_bag) { - _GLIBCXX_DEBUG_ASSERT(p_r != NULL); - if (p_l == NULL) + _GLIBCXX_DEBUG_ASSERT(p_r != 0); + if (p_l == 0) return (p_r); node_pointer p_ret = insert_branch(p_l, p_r, r_bag); _GLIBCXX_DEBUG_ASSERT(recursive_count_leafs(p_ret) == 2); @@ -264,7 +264,7 @@ rec_join(leaf_pointer p_l, internal_node_pointer p_r, size_type checked_ind, const size_type rhs_leafs = recursive_count_leafs(p_r); #endif - _GLIBCXX_DEBUG_ASSERT(p_r != NULL); + _GLIBCXX_DEBUG_ASSERT(p_r != 0); node_pointer p_ret = rec_join(p_r, p_l, checked_ind, r_bag); _GLIBCXX_DEBUG_ASSERT(recursive_count_leafs(p_ret) == lhs_leafs + rhs_leafs); return p_ret; @@ -275,8 +275,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: rec_join(internal_node_pointer p_l, leaf_pointer p_r, size_type checked_ind, split_join_branch_bag& r_bag) { - _GLIBCXX_DEBUG_ASSERT(p_l != NULL); - _GLIBCXX_DEBUG_ASSERT(p_r != NULL); + _GLIBCXX_DEBUG_ASSERT(p_l != 0); + _GLIBCXX_DEBUG_ASSERT(p_r != 0); #ifdef _GLIBCXX_DEBUG const size_type lhs_leafs = recursive_count_leafs(p_l); @@ -313,8 +313,8 @@ typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: rec_join(internal_node_pointer p_l, internal_node_pointer p_r, split_join_branch_bag& r_bag) { - _GLIBCXX_DEBUG_ASSERT(p_l != NULL); - _GLIBCXX_DEBUG_ASSERT(p_r != NULL); + _GLIBCXX_DEBUG_ASSERT(p_l != 0); + _GLIBCXX_DEBUG_ASSERT(p_r != 0); #ifdef _GLIBCXX_DEBUG const size_type lhs_leafs = recursive_count_leafs(p_l); @@ -378,7 +378,7 @@ PB_DS_CLASS_C_DEC:: insert(const_reference r_val) { node_pointer p_lf = find_imp(PB_DS_V2F(r_val)); - if (p_lf != NULL && p_lf->m_type == pat_trie_leaf_node_type && + if (p_lf != 0 && p_lf->m_type == pat_trie_leaf_node_type && synth_e_access_traits::equal_keys(PB_DS_V2F(static_cast<leaf_pointer>(p_lf)->value()), PB_DS_V2F(r_val))) { _GLIBCXX_DEBUG_ONLY(debug_base::check_key_exists(PB_DS_V2F(r_val))); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/internal_node.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/internal_node.hpp index bf2f42916dd..56cf1330497 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/internal_node.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/internal_node.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -226,7 +226,7 @@ namespace __gnu_pbds get_pref_pos(const_e_iterator b_it, const_e_iterator e_it, const_e_access_traits_pointer p_traits) const { - if (static_cast<size_t>(std::distance(b_it, e_it)) <= m_e_ind) + if (static_cast<std::size_t>(std::distance(b_it, e_it)) <= m_e_ind) return 0; std::advance(b_it, m_e_ind); return 1 + p_traits->e_pos(*b_it); @@ -240,7 +240,7 @@ namespace __gnu_pbds { std::advance(m_pref_e_it, m_e_ind); std::fill(m_a_p_children, m_a_p_children + arr_size, - static_cast<node_pointer>(NULL)); + static_cast<node_pointer>(0)); } PB_DS_CLASS_T_DEC @@ -317,7 +317,7 @@ namespace __gnu_pbds { const size_type i = get_pref_pos(b_it, e_it, p_traits); _GLIBCXX_DEBUG_ASSERT(i < arr_size); - _GLIBCXX_DEBUG_ASSERT(m_a_p_children[i] != NULL); + _GLIBCXX_DEBUG_ASSERT(m_a_p_children[i] != 0); return iterator(m_a_p_children + i, m_a_p_children + i); } @@ -345,11 +345,11 @@ namespace __gnu_pbds size_type i = get_pref_pos(b_it, e_it, p_traits); _GLIBCXX_DEBUG_ASSERT(i < arr_size); - if (m_a_p_children[i] != NULL) + if (m_a_p_children[i] != 0) return m_a_p_children[i]; while (++i < arr_size) - if (m_a_p_children[i] != NULL) + if (m_a_p_children[i] != 0) { if (m_a_p_children[i]->m_type == pat_trie_leaf_node_type) return m_a_p_children[i]; @@ -370,7 +370,7 @@ namespace __gnu_pbds { const size_type i = get_pref_pos(b_it, e_it, p_traits); _GLIBCXX_DEBUG_ASSERT(i < arr_size); - if (m_a_p_children[i] == NULL) + if (m_a_p_children[i] == 0) { m_a_p_children[i] = p_nd; p_nd->m_p_parent = this; @@ -423,7 +423,7 @@ namespace __gnu_pbds for (; i < arr_size; ++i) if (m_a_p_children[i] == p_nd) { - m_a_p_children[i] = NULL; + m_a_p_children[i] = 0; return; } _GLIBCXX_DEBUG_ASSERT(i != arr_size); @@ -436,7 +436,7 @@ namespace __gnu_pbds { iterator ret = it; ++ret; - * it.m_p_p_cur = NULL; + * it.m_p_p_cur = 0; return ret; } @@ -558,7 +558,7 @@ namespace __gnu_pbds get_begin_pos() const { size_type i; - for (i = 0; i < arr_size && m_a_p_children[i] == NULL; ++i) + for (i = 0; i < arr_size && m_a_p_children[i] == 0; ++i) ; return i; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp index 9902d96dbb1..893a762056d 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/iterators_fn_imps.hpp @@ -110,11 +110,11 @@ PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::const_node_iterator PB_DS_CLASS_C_DEC:: node_end() const -{ return const_node_iterator(NULL, this); } +{ return const_node_iterator(0, this); } PB_DS_CLASS_T_DEC inline typename PB_DS_CLASS_C_DEC::node_iterator PB_DS_CLASS_C_DEC:: node_end() -{ return node_iterator(NULL, this); } +{ return node_iterator(0, this); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp index 37250091d00..eb5e0002b9f 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/node_iterators.hpp @@ -180,8 +180,8 @@ namespace __gnu_pbds pat_trie_const_node_it_() */ inline - pat_trie_const_node_it_(node_pointer p_nd = NULL, - const_e_access_traits_pointer p_traits = NULL) + pat_trie_const_node_it_(node_pointer p_nd = 0, + const_e_access_traits_pointer p_traits = 0) : m_p_nd(const_cast<node_pointer>(p_nd)), m_p_traits(p_traits) { } @@ -299,7 +299,7 @@ namespace __gnu_pbds */ inline - pat_trie_node_it_(node_pointer p_nd = NULL, const_e_access_traits_pointer p_traits = NULL) : base_type(p_nd, p_traits) + pat_trie_node_it_(node_pointer p_nd = 0, const_e_access_traits_pointer p_traits = 0) : base_type(p_nd, p_traits) { } // Access; returns the iterator* associated with the current leaf. diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp index cada9071c51..0a142478eb8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/point_iterators.hpp @@ -145,7 +145,7 @@ namespace __gnu_pbds public: inline - pat_trie_const_it_(node_pointer p_nd = NULL) : m_p_nd(p_nd) + pat_trie_const_it_(node_pointer p_nd = 0) : m_p_nd(p_nd) { } inline @@ -245,7 +245,7 @@ namespace __gnu_pbds node_pointer p_y = m_p_nd->m_p_parent; while (p_y->m_type != pat_trie_head_node_type && - get_larger_sibling(m_p_nd) == NULL) + get_larger_sibling(m_p_nd) == 0) { m_p_nd = p_y; p_y = p_y->m_p_parent; @@ -274,7 +274,7 @@ namespace __gnu_pbds node_pointer p_y = m_p_nd->m_p_parent; while (p_y->m_type != pat_trie_head_node_type && - get_smaller_sibling(m_p_nd) == NULL) + get_smaller_sibling(m_p_nd) == 0) { m_p_nd = p_y; p_y = p_y->m_p_parent; @@ -300,7 +300,7 @@ namespace __gnu_pbds typename Internal_Node::iterator next_it = it; ++next_it; - return ((next_it == p_parent->end())? NULL :* next_it); + return ((next_it == p_parent->end())? 0 :* next_it); } inline static node_pointer @@ -312,7 +312,7 @@ namespace __gnu_pbds typename Internal_Node::iterator it = p_parent->begin(); if (*it == p_nd) - return (NULL); + return (0); typename Internal_Node::iterator prev_it; do { @@ -324,7 +324,7 @@ namespace __gnu_pbds while (true); _GLIBCXX_DEBUG_ASSERT(false); - return (NULL); + return (0); } inline static leaf_pointer @@ -397,7 +397,7 @@ namespace __gnu_pbds typedef typename Type_Traits::reference reference; inline - pat_trie_it_(node_pointer p_nd = NULL) : PB_DS_CONST_IT_C_DEC((node_pointer)p_nd) + pat_trie_it_(node_pointer p_nd = 0) : PB_DS_CONST_IT_C_DEC((node_pointer)p_nd) { } inline diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp index 52edf250635..bfb456392b2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/r_erase_fn_imps.hpp @@ -93,7 +93,7 @@ void PB_DS_CLASS_C_DEC:: clear_imp(node_pointer p_nd) { - if (p_nd == NULL) + if (p_nd == 0) return; clear_imp(p_nd->m_p_left); clear_imp(p_nd->m_p_right); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp index c0809fa48bc..40dc38c71b4 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/rotate_fn_imps.hpp @@ -46,7 +46,7 @@ rotate_left(node_pointer p_x) node_pointer p_y = p_x->m_p_right; p_x->m_p_right = p_y->m_p_left; - if (p_y->m_p_left != NULL) + if (p_y->m_p_left != 0) p_y->m_p_left->m_p_parent = p_x; p_y->m_p_parent = p_x->m_p_parent; @@ -75,7 +75,7 @@ rotate_right(node_pointer p_x) node_pointer p_y = p_x->m_p_left; p_x->m_p_left = p_y->m_p_right; - if (p_y->m_p_right != NULL) + if (p_y->m_p_right != 0) p_y->m_p_right->m_p_parent = p_x; p_y->m_p_parent = p_x->m_p_parent; @@ -122,10 +122,10 @@ inline void PB_DS_CLASS_C_DEC:: apply_update(node_pointer p_nd, Node_Update_* p_update) { - p_update->operator()(& PB_DS_V2F(p_nd->m_value),(p_nd->m_p_left == NULL) ? - NULL : - & PB_DS_V2F(p_nd->m_p_left->m_value),(p_nd->m_p_right == NULL) ? - NULL : + p_update->operator()(& PB_DS_V2F(p_nd->m_value),(p_nd->m_p_left == 0) ? + 0 : + & PB_DS_V2F(p_nd->m_p_left->m_value),(p_nd->m_p_right == 0) ? + 0 : & PB_DS_V2F(p_nd->m_p_right->m_value)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp index 9779a4bcd22..320d32c0667 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/split_fn_imps.hpp @@ -47,7 +47,7 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other) _GLIBCXX_DEBUG_ONLY(other.assert_valid();); split_join_branch_bag bag; leaf_pointer p_split_lf = split_prep(r_key, other, bag); - if (p_split_lf == NULL) + if (p_split_lf == 0) { _GLIBCXX_DEBUG_ASSERT(bag.empty()); _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -88,7 +88,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc other.clear(); _GLIBCXX_DEBUG_ONLY(assert_valid();); _GLIBCXX_DEBUG_ONLY(other.assert_valid();); - return (NULL); + return (0); } if (synth_e_access_traits::cmp_keys(r_key, @@ -98,7 +98,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc value_swap(other); _GLIBCXX_DEBUG_ONLY(assert_valid();); _GLIBCXX_DEBUG_ONLY(other.assert_valid();); - return (NULL); + return (0); } if (!synth_e_access_traits::cmp_keys(r_key, @@ -106,7 +106,7 @@ split_prep(const_key_reference r_key, PB_DS_CLASS_C_DEC& other, split_join_branc { _GLIBCXX_DEBUG_ONLY(assert_valid();); _GLIBCXX_DEBUG_ONLY(other.assert_valid();); - return (NULL); + return (0); } iterator it = lower_bound(r_key); @@ -134,7 +134,7 @@ rec_split(node_pointer p_nd, const_e_iterator b_it, const_e_iterator e_it, PB_DS { if (p_nd->m_type == pat_trie_leaf_node_type) { - _GLIBCXX_DEBUG_ASSERT(other.m_p_head->m_p_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(other.m_p_head->m_p_parent == 0); return (p_nd); } @@ -202,27 +202,27 @@ PB_DS_CLASS_C_DEC:: split_insert_branch(size_type e_ind, const_e_iterator b_it, typename internal_node::iterator child_b_it, size_type num_children, split_join_branch_bag& r_bag) { #ifdef _GLIBCXX_DEBUG - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) m_p_head->m_p_parent->assert_valid(this); #endif - const size_type total_num_children =((m_p_head->m_p_parent == NULL)? 0 : 1) + num_children; + const size_type total_num_children =((m_p_head->m_p_parent == 0)? 0 : 1) + num_children; if (total_num_children == 0) { - _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0); return; } if (total_num_children == 1) { - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) { _GLIBCXX_DEBUG_ONLY(m_p_head->m_p_parent->assert_valid(this);) return; } - _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_head->m_p_parent == 0); m_p_head->m_p_parent =* child_b_it; m_p_head->m_p_parent->m_p_parent = m_p_head; apply_update(m_p_head->m_p_parent, (node_update* )this); @@ -242,7 +242,7 @@ split_insert_branch(size_type e_ind, const_e_iterator b_it, typename internal_no ++child_b_it; } - if (m_p_head->m_p_parent != NULL) + if (m_p_head->m_p_parent != 0) p_new_root->add_child(m_p_head->m_p_parent, pref_begin(m_p_head->m_p_parent), pref_end(m_p_head->m_p_parent), this); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp index e4b20943be6..e6af80413a4 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/trace_fn_imps.hpp @@ -46,7 +46,7 @@ PB_DS_CLASS_C_DEC:: trace() const { std::cerr << std::endl; - if (m_p_head->m_p_parent == NULL) + if (m_p_head->m_p_parent == 0) return; trace_node(m_p_head->m_p_parent, 0); std::cerr << std::endl; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp index 6d275e731d1..1eecdc10990 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/pat_trie_/update_fn_imps.hpp @@ -51,5 +51,5 @@ PB_DS_CLASS_C_DEC:: apply_update(node_pointer p_nd, Node_Update_* /*p_update*/) { Node_Update_::operator()(node_iterator(p_nd, this), - const_node_iterator(NULL, this)); + const_node_iterator(0, this)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp index 18ecc4230ed..7cdadfc5f83 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/debug_fn_imps.hpp @@ -45,7 +45,7 @@ typename PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: assert_node_consistent(const node_pointer p_nd) const { - if (p_nd == NULL) + if (p_nd == 0) return 1; const size_type l_height = assert_node_consistent(p_nd->m_p_left); @@ -67,7 +67,7 @@ assert_valid() const base_type::assert_valid(); const node_pointer p_head = base_type::m_p_head; _GLIBCXX_DEBUG_ASSERT(p_head->m_red); - if (p_head->m_p_parent != NULL) + if (p_head->m_p_parent != 0) { _GLIBCXX_DEBUG_ASSERT(!p_head->m_p_parent->m_red); assert_node_consistent(p_head->m_p_parent); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp index 685b8a51b6b..2ae4cef072c 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/erase_fn_imps.hpp @@ -123,17 +123,17 @@ remove_node(node_pointer p_z) { update_min_max_for_erased_node(p_z); node_pointer p_y = p_z; - node_pointer p_x = NULL; - node_pointer p_new_x_parent = NULL; + node_pointer p_x = 0; + node_pointer p_new_x_parent = 0; - if (p_y->m_p_left == NULL) + if (p_y->m_p_left == 0) p_x = p_y->m_p_right; - else if (p_y->m_p_right == NULL) + else if (p_y->m_p_right == 0) p_x = p_y->m_p_left; else { p_y = p_y->m_p_right; - while (p_y->m_p_left != NULL) + while (p_y->m_p_left != 0) p_y = p_y->m_p_left; p_x = p_y->m_p_right; } @@ -141,7 +141,7 @@ remove_node(node_pointer p_z) if (p_y == p_z) { p_new_x_parent = p_y->m_p_parent; - if (p_x != NULL) + if (p_x != 0) p_x->m_p_parent = p_y->m_p_parent; if (base_type::m_p_head->m_p_parent == p_z) @@ -153,7 +153,7 @@ remove_node(node_pointer p_z) } else { - p_y->m_p_left = NULL; + p_y->m_p_left = 0; p_z->m_p_parent->m_p_right = p_x; } } @@ -164,7 +164,7 @@ remove_node(node_pointer p_z) if (p_y != p_z->m_p_right) { p_new_x_parent = p_y->m_p_parent; - if (p_x != NULL) + if (p_x != 0) p_x->m_p_parent = p_y->m_p_parent; p_y->m_p_parent->m_p_left = p_x; p_y->m_p_right = p_z->m_p_right; @@ -198,7 +198,7 @@ void PB_DS_CLASS_C_DEC:: remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) { - _GLIBCXX_DEBUG_ASSERT(p_x == NULL || p_x->m_p_parent == p_new_x_parent); + _GLIBCXX_DEBUG_ASSERT(p_x == 0 || p_x->m_p_parent == p_new_x_parent); while (p_x != base_type::m_p_head->m_p_parent && is_effectively_black(p_x)) if (p_x == p_new_x_parent->m_p_left) @@ -223,7 +223,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) { if (is_effectively_black(p_w->m_p_right)) { - if (p_w->m_p_left != NULL) + if (p_w->m_p_left != 0) p_w->m_p_left->m_red = false; p_w->m_red = true; @@ -234,7 +234,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) p_w->m_red = p_new_x_parent->m_red; p_new_x_parent->m_red = false; - if (p_w->m_p_right != NULL) + if (p_w->m_p_right != 0) p_w->m_p_right->m_red = false; base_type::rotate_left(p_new_x_parent); @@ -264,7 +264,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) { if (is_effectively_black(p_w->m_p_left)) { - if (p_w->m_p_right != NULL) + if (p_w->m_p_right != 0) p_w->m_p_right->m_red = false; p_w->m_red = true; @@ -275,7 +275,7 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) p_w->m_red = p_new_x_parent->m_red; p_new_x_parent->m_red = false; - if (p_w->m_p_left != NULL) + if (p_w->m_p_left != 0) p_w->m_p_left->m_red = false; base_type::rotate_right(p_new_x_parent); @@ -284,6 +284,6 @@ remove_fixup(node_pointer p_x, node_pointer p_new_x_parent) } } - if (p_x != NULL) + if (p_x != 0) p_x->m_red = false; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp index 6b43b1a994c..97eba22f6f8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/info_fn_imps.hpp @@ -42,5 +42,5 @@ PB_DS_CLASS_T_DEC inline bool PB_DS_CLASS_C_DEC:: is_effectively_black(const node_pointer p_nd) -{ return (p_nd == NULL || !p_nd->m_red); } +{ return (p_nd == 0 || !p_nd->m_red); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp index 16a5d1edb29..a6a60160cca 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/insert_fn_imps.hpp @@ -67,7 +67,7 @@ insert_fixup(node_pointer p_nd) if (p_nd->m_p_parent == p_nd->m_p_parent->m_p_parent->m_p_left) { node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_right; - if (p_y != NULL && p_y->m_red) + if (p_y != 0 && p_y->m_red) { p_nd->m_p_parent->m_red = false; p_y->m_red = false; @@ -89,7 +89,7 @@ insert_fixup(node_pointer p_nd) else { node_pointer p_y = p_nd->m_p_parent->m_p_parent->m_p_left; - if (p_y != NULL && p_y->m_red) + if (p_y != 0 && p_y->m_red) { p_nd->m_p_parent->m_red = false; p_y->m_red = false; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp index 9776a8d9a34..96280564dd2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rb_tree_map_/split_join_fn_imps.hpp @@ -67,8 +67,8 @@ void PB_DS_CLASS_C_DEC:: join_imp(node_pointer p_x, node_pointer p_r) { - _GLIBCXX_DEBUG_ASSERT(p_x != NULL); - if (p_r != NULL) + _GLIBCXX_DEBUG_ASSERT(p_x != 0); + if (p_r != 0) p_r->m_red = false; const size_type h = black_height(base_type::m_p_head->m_p_parent); @@ -88,7 +88,7 @@ join_imp(node_pointer p_x, node_pointer p_r) { p_x_l = base_type::m_p_head->m_p_parent; base_type::m_p_head->m_p_parent = p_r; - if (p_r != NULL) + if (p_r != 0) p_r->m_p_parent = base_type::m_p_head; join_pos = find_join_pos_left(base_type::m_p_head->m_p_parent, @@ -112,11 +112,11 @@ join_imp(node_pointer p_x, node_pointer p_r) } p_x->m_p_left = p_x_l; - if (p_x_l != NULL) + if (p_x_l != 0) p_x_l->m_p_parent = p_x; p_x->m_p_right = p_x_r; - if (p_x_r != NULL) + if (p_x_r != 0) p_x_r->m_p_parent = p_x; p_x->m_red = true; @@ -153,8 +153,8 @@ find_join_pos_right(node_pointer p_l, size_type h_l, size_type h_r) { _GLIBCXX_DEBUG_ASSERT(h_l >= h_r); - if (base_type::m_p_head->m_p_parent == NULL) - return (std::make_pair((node_pointer)NULL, base_type::m_p_head)); + if (base_type::m_p_head->m_p_parent == 0) + return (std::make_pair((node_pointer)0, base_type::m_p_head)); node_pointer p_l_parent = base_type::m_p_head; while (h_l > h_r) @@ -177,7 +177,7 @@ find_join_pos_right(node_pointer p_l, size_type h_l, size_type h_r) _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_l)); _GLIBCXX_DEBUG_ASSERT(black_height(p_l) == h_r); - _GLIBCXX_DEBUG_ASSERT(p_l == NULL || p_l->m_p_parent == p_l_parent); + _GLIBCXX_DEBUG_ASSERT(p_l == 0 || p_l->m_p_parent == p_l_parent); return std::make_pair(p_l, p_l_parent); } @@ -189,8 +189,8 @@ PB_DS_CLASS_C_DEC:: find_join_pos_left(node_pointer p_r, size_type h_l, size_type h_r) { _GLIBCXX_DEBUG_ASSERT(h_r > h_l); - if (base_type::m_p_head->m_p_parent == NULL) - return (std::make_pair((node_pointer)NULL, + if (base_type::m_p_head->m_p_parent == 0) + return (std::make_pair((node_pointer)0, base_type::m_p_head)); node_pointer p_r_parent = base_type::m_p_head; while (h_r > h_l) @@ -213,7 +213,7 @@ find_join_pos_left(node_pointer p_r, size_type h_l, size_type h_r) _GLIBCXX_DEBUG_ASSERT(is_effectively_black(p_r)); _GLIBCXX_DEBUG_ASSERT(black_height(p_r) == h_l); - _GLIBCXX_DEBUG_ASSERT(p_r == NULL || p_r->m_p_parent == p_r_parent); + _GLIBCXX_DEBUG_ASSERT(p_r == 0 || p_r->m_p_parent == p_r_parent); return std::make_pair(p_r, p_r_parent); } @@ -223,7 +223,7 @@ PB_DS_CLASS_C_DEC:: black_height(node_pointer p_nd) { size_type h = 1; - while (p_nd != NULL) + while (p_nd != 0) { if (p_nd->m_red == false) ++h; @@ -275,7 +275,7 @@ void PB_DS_CLASS_C_DEC:: split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); node_pointer p_l = p_nd->m_p_left; node_pointer p_r = p_nd->m_p_right; @@ -283,7 +283,7 @@ split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other) if (p_parent == base_type::m_p_head) { base_type::m_p_head->m_p_parent = p_l; - if (p_l != NULL) + if (p_l != 0) { p_l->m_p_parent = base_type::m_p_head; p_l->m_red = false; @@ -296,7 +296,7 @@ split_at_node(node_pointer p_nd, PB_DS_CLASS_C_DEC& other) else p_parent->m_p_right = p_l; - if (p_l != NULL) + if (p_l != 0) p_l->m_p_parent = p_parent; update_to_top(p_parent, (node_update* )this); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp index 0194905c4c7..4b8878ee84c 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp @@ -48,7 +48,7 @@ assert_valid() const base_type::assert_valid(false); if (!base_type::empty()) { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_max != NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_max != 0); base_type::assert_max(); } @@ -57,7 +57,7 @@ assert_valid() const if (m_rc.empty()) { base_type::assert_valid(true); - _GLIBCXX_DEBUG_ASSERT(next_2_pointer(base_type::m_p_root) == NULL); + _GLIBCXX_DEBUG_ASSERT(next_2_pointer(base_type::m_p_root) == 0); return; } @@ -65,13 +65,13 @@ assert_valid() const typename rc_t::const_iterator it = m_rc.end(); --it; - while (p_nd != NULL) + while (p_nd != 0) { _GLIBCXX_DEBUG_ASSERT(*it == p_nd); const_node_pointer p_next = p_nd->m_p_next_sibling; - _GLIBCXX_DEBUG_ASSERT(p_next != NULL); + _GLIBCXX_DEBUG_ASSERT(p_next != 0); _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_next->m_metadata); - _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == NULL || + _GLIBCXX_DEBUG_ASSERT(p_next->m_p_next_sibling == 0 || p_next->m_metadata < p_next->m_p_next_sibling->m_metadata); --it; @@ -85,13 +85,13 @@ typename PB_DS_CLASS_C_DEC::const_node_pointer PB_DS_CLASS_C_DEC:: next_2_pointer(const_node_pointer p_nd) { - if (p_nd == NULL) - return NULL; + if (p_nd == 0) + return 0; node_pointer p_next = p_nd->m_p_next_sibling; - if (p_next == NULL) - return NULL; + if (p_next == 0) + return 0; if (p_nd->m_metadata == p_next->m_metadata) return p_nd; @@ -104,13 +104,13 @@ typename PB_DS_CLASS_C_DEC::const_node_pointer PB_DS_CLASS_C_DEC:: next_after_0_pointer(const_node_pointer p_nd) { - if (p_nd == NULL) - return NULL; + if (p_nd == 0) + return 0; node_pointer p_next = p_nd->m_p_next_sibling; - if (p_next == NULL) - return NULL; + if (p_next == 0) + return 0; if (p_nd->m_metadata < p_next->m_metadata) return p_next; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp index 1113ffa6669..1f187a55749 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp @@ -64,10 +64,10 @@ PB_DS_CLASS_C_DEC:: make_binomial_heap() { node_pointer p_nd = base_type::m_p_root; - while (p_nd != NULL) + while (p_nd != 0) { node_pointer p_next = p_nd->m_p_next_sibling; - if (p_next == NULL) + if (p_next == 0) p_nd = p_next; else if (p_nd->m_metadata == p_next->m_metadata) p_nd = link_with_next_sibling(p_nd); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp index aef4b928e16..2a3badccb5b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp @@ -51,20 +51,20 @@ push(const_reference r_val) node_pointer p_nd = base_type::get_new_node_for_insert(r_val); - p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = NULL; + p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = 0; p_nd->m_metadata = 0; - if (base_type::m_p_max == NULL || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val)) + if (base_type::m_p_max == 0 || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val)) base_type::m_p_max = p_nd; p_nd->m_p_next_sibling = base_type::m_p_root; - if (base_type::m_p_root != NULL) + if (base_type::m_p_root != 0) base_type::m_p_root->m_p_prev_or_parent = p_nd; base_type::m_p_root = p_nd; - if (p_nd->m_p_next_sibling != NULL&& p_nd->m_p_next_sibling->m_metadata == 0) + if (p_nd->m_p_next_sibling != 0&& p_nd->m_p_next_sibling->m_metadata == 0) m_rc.push(p_nd); _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -95,14 +95,14 @@ link_with_next_sibling(node_pointer p_nd) { node_pointer p_next = p_nd->m_p_next_sibling; - _GLIBCXX_DEBUG_ASSERT(p_next != NULL); + _GLIBCXX_DEBUG_ASSERT(p_next != 0); _GLIBCXX_DEBUG_ASSERT(p_next->m_p_prev_or_parent == p_nd); if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value)) { p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; - if (p_next->m_p_prev_or_parent == NULL) + if (p_next->m_p_prev_or_parent == 0) base_type::m_p_root = p_next; else p_next->m_p_prev_or_parent->m_p_next_sibling = p_next; @@ -119,7 +119,7 @@ link_with_next_sibling(node_pointer p_nd) p_nd->m_p_next_sibling = p_next->m_p_next_sibling; - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd; if (base_type::m_p_max == p_next) @@ -144,11 +144,11 @@ make_0_exposed() m_rc.pop(); - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != 0); _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata); node_pointer p_res = link_with_next_sibling(p_nd); - if (p_res->m_p_next_sibling != NULL&& p_res->m_metadata == p_res->m_p_next_sibling->m_metadata) + if (p_res->m_p_next_sibling != 0&& p_res->m_metadata == p_res->m_p_next_sibling->m_metadata) m_rc.push(p_res); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp index a28f5ede5e6..c816cfdeac8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/hash_prime_size_policy_imp.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -150,7 +150,7 @@ inline PB_DS_CLASS_C_DEC::size_type PB_DS_CLASS_C_DEC:: get_nearest_smaller_size(size_type n) const { - const size_t* p_lower = std::lower_bound(detail::g_a_sizes, + const std::size_t* p_lower = std::lower_bound(detail::g_a_sizes, detail::g_a_sizes + detail::num_distinct_sizes, n); if (*p_lower >= n && p_lower != detail::g_a_sizes) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp index ed70b951121..33aecdf5fcc 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_policy.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -47,7 +47,7 @@ class sample_resize_policy public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; // Default constructor. sample_resize_policy(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp index a27dd942702..963c5530a46 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_resize_trigger.hpp @@ -1,6 +1,7 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -47,7 +48,7 @@ class sample_resize_trigger public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; // Default constructor. sample_resize_trigger(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp index 1f2d3a9c125..9b3ba031c4b 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/resize_policy/sample_size_policy.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -47,7 +47,7 @@ class sample_size_policy public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; // Default constructor. sample_size_policy(); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp index 084e25d26de..f673877aed2 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/debug_fn_imps.hpp @@ -55,7 +55,7 @@ void PB_DS_CLASS_C_DEC:: assert_special_imp(const node_pointer p_nd) const { - if (p_nd == NULL) + if (p_nd == 0) return; if (p_nd == base_type::m_p_head) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp index 508f586d78d..507b8ba407c 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/erase_fn_imps.hpp @@ -108,7 +108,7 @@ void PB_DS_CLASS_C_DEC:: erase_node(node_pointer p_nd) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); splay(p_nd); _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -119,27 +119,27 @@ erase_node(node_pointer p_nd) base_type::update_min_max_for_erased_node(p_nd); base_type::actual_erase_node(p_nd); - if (p_r == NULL) + if (p_r == 0) { base_type::m_p_head->m_p_parent = p_l; - if (p_l != NULL) + if (p_l != 0) p_l->m_p_parent = base_type::m_p_head; _GLIBCXX_DEBUG_ONLY(assert_valid();) return; } node_pointer p_target_r = leftmost(p_r); - _GLIBCXX_DEBUG_ASSERT(p_target_r != NULL); + _GLIBCXX_DEBUG_ASSERT(p_target_r != 0); p_r->m_p_parent = base_type::m_p_head; base_type::m_p_head->m_p_parent = p_r; splay(p_target_r); - _GLIBCXX_DEBUG_ONLY(p_target_r->m_p_left = NULL); + _GLIBCXX_DEBUG_ONLY(p_target_r->m_p_left = 0); _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_parent == this->m_p_head); _GLIBCXX_DEBUG_ASSERT(this->m_p_head->m_p_parent == p_target_r); p_target_r->m_p_left = p_l; - if (p_l != NULL) + if (p_l != 0) p_l->m_p_parent = p_target_r; _GLIBCXX_DEBUG_ONLY(assert_valid();) apply_update(p_target_r, (node_update* )this); @@ -150,8 +150,8 @@ inline typename PB_DS_CLASS_C_DEC::node_pointer PB_DS_CLASS_C_DEC:: leftmost(node_pointer p_nd) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - while (p_nd->m_p_left != NULL) + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + while (p_nd->m_p_left != 0) p_nd = p_nd->m_p_left; return p_nd; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp index 182425a8f30..e27142c17ec 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/find_fn_imps.hpp @@ -67,7 +67,7 @@ find_imp(const_key_reference r_key) { _GLIBCXX_DEBUG_ONLY(base_type::structure_only_assert_valid();) node_pointer p_nd = base_type::m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key)) { if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value))) @@ -86,7 +86,7 @@ find_imp(const_key_reference r_key) const { _GLIBCXX_DEBUG_ONLY(assert_valid();) node_pointer p_nd = base_type::m_p_head->m_p_parent; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), r_key)) { if (!Cmp_Fn::operator()(r_key, PB_DS_V2F(p_nd->m_value))) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp index e9ae987b09d..8381174d29f 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/insert_fn_imps.hpp @@ -64,7 +64,7 @@ insert_leaf_imp(const_reference r_value) node_pointer p_nd = base_type::m_p_head->m_p_parent; node_pointer p_pot = base_type::m_p_head; - while (p_nd != NULL) + while (p_nd != 0) if (!Cmp_Fn::operator()(PB_DS_V2F(p_nd->m_value), PB_DS_V2F(r_value))) { if (!Cmp_Fn::operator()(PB_DS_V2F(r_value), PB_DS_V2F(p_nd->m_value))) @@ -83,10 +83,10 @@ insert_leaf_imp(const_reference r_value) _GLIBCXX_DEBUG_ONLY(base_type::check_key_does_not_exist(PB_DS_V2F(r_value))); p_nd = p_pot->m_p_left; - if (p_nd == NULL) + if (p_nd == 0) return (std::make_pair(base_type::insert_leaf_new(r_value, p_pot, true), true)); - while (p_nd->m_p_right != NULL) + while (p_nd->m_p_right != 0) p_nd = p_nd->m_p_right; return std::make_pair(insert_leaf_new(r_value, p_nd, false), true); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp index e4f3556a5f0..b6993590acb 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/splay_fn_imps.hpp @@ -114,11 +114,11 @@ splay_zig_zag_left(node_pointer p_nd, node_pointer p_parent, p_grandparent->m_p_parent = p_nd; p_parent->m_p_left = p_b; - if (p_b != NULL) + if (p_b != 0) p_b->m_p_parent = p_parent; p_grandparent->m_p_right = p_c; - if (p_c != NULL) + if (p_c != 0) p_c->m_p_parent = p_grandparent; splay_zz_end(p_nd, p_parent, p_grandparent); @@ -150,11 +150,11 @@ splay_zig_zag_right(node_pointer p_nd, node_pointer p_parent, p_grandparent->m_p_parent = p_nd; p_parent->m_p_right = p_b; - if (p_b != NULL) + if (p_b != 0) p_b->m_p_parent = p_parent; p_grandparent->m_p_left = p_c; - if (p_c != NULL) + if (p_c != 0) p_c->m_p_parent = p_grandparent; splay_zz_end(p_nd, p_parent, p_grandparent); @@ -186,11 +186,11 @@ splay_zig_zig_left(node_pointer p_nd, node_pointer p_parent, p_grandparent->m_p_parent = p_parent; p_parent->m_p_left = p_b; - if (p_b != NULL) + if (p_b != 0) p_b->m_p_parent = p_parent; p_grandparent->m_p_left = p_c; - if (p_c != NULL) + if (p_c != 0) p_c->m_p_parent = p_grandparent; splay_zz_end(p_nd, p_parent, p_grandparent); @@ -220,11 +220,11 @@ splay_zig_zig_right(node_pointer p_nd, node_pointer p_parent, p_grandparent->m_p_parent = p_parent; p_parent->m_p_right = p_b; - if (p_b != NULL) + if (p_b != 0) p_b->m_p_parent = p_parent; p_grandparent->m_p_right = p_c; - if (p_c != NULL) + if (p_c != 0) p_c->m_p_parent = p_grandparent; base_type::update_to_top(p_grandparent, (node_update* )this); @@ -242,9 +242,9 @@ splay_zz_start(node_pointer p_nd, #endif node_pointer p_grandparent) { - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); - _GLIBCXX_DEBUG_ASSERT(p_parent != NULL); - _GLIBCXX_DEBUG_ASSERT(p_grandparent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); + _GLIBCXX_DEBUG_ASSERT(p_parent != 0); + _GLIBCXX_DEBUG_ASSERT(p_grandparent != 0); const bool grandparent_head = p_grandparent->m_p_parent == base_type::m_p_head; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp index 7f0b2cb205d..401f22c0369 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/splay_tree_/split_join_fn_imps.hpp @@ -53,15 +53,15 @@ join(PB_DS_CLASS_C_DEC& other) } node_pointer p_target_r = other.leftmost(other.m_p_head); - _GLIBCXX_DEBUG_ASSERT(p_target_r != NULL); + _GLIBCXX_DEBUG_ASSERT(p_target_r != 0); other.splay(p_target_r); _GLIBCXX_DEBUG_ASSERT(p_target_r == other.m_p_head->m_p_parent); - _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left == NULL); + _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left == 0); p_target_r->m_p_left = base_type::m_p_head->m_p_parent; - _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left != NULL); + _GLIBCXX_DEBUG_ASSERT(p_target_r->m_p_left != 0); p_target_r->m_p_left->m_p_parent = p_target_r; base_type::m_p_head->m_p_parent = p_target_r; @@ -90,19 +90,19 @@ split(const_key_reference r_key, PB_DS_CLASS_C_DEC& other) } node_pointer p_upper_bound = upper_bound(r_key).m_p_nd; - _GLIBCXX_DEBUG_ASSERT(p_upper_bound != NULL); + _GLIBCXX_DEBUG_ASSERT(p_upper_bound != 0); splay(p_upper_bound); _GLIBCXX_DEBUG_ASSERT(p_upper_bound->m_p_parent == this->m_p_head); node_pointer p_new_root = p_upper_bound->m_p_left; - _GLIBCXX_DEBUG_ASSERT(p_new_root != NULL); + _GLIBCXX_DEBUG_ASSERT(p_new_root != 0); base_type::m_p_head->m_p_parent = p_new_root; p_new_root->m_p_parent = base_type::m_p_head; other.m_p_head->m_p_parent = p_upper_bound; p_upper_bound->m_p_parent = other.m_p_head; - p_upper_bound->m_p_left = NULL; + p_upper_bound->m_p_left = 0; apply_update(p_upper_bound, (node_update* )this); base_type::split_finish(other); diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp index 4d2c45ce047..5a09f7c4020 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/constructors_destructor_fn_imps.hpp @@ -52,7 +52,7 @@ copy_from_range(It first_it, It last_it) PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: thin_heap_() : - m_p_max(NULL) + m_p_max(0) { initialize(); _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -62,7 +62,7 @@ PB_DS_CLASS_T_DEC PB_DS_CLASS_C_DEC:: thin_heap_(const Cmp_Fn& r_cmp_fn) : PB_DS_BASE_C_DEC(r_cmp_fn), - m_p_max(NULL) + m_p_max(0) { initialize(); _GLIBCXX_DEBUG_ONLY(assert_valid();) @@ -75,7 +75,7 @@ thin_heap_(const PB_DS_CLASS_C_DEC& other) : { initialize(); m_p_max = base_type::m_p_root; - for (node_pointer p_nd = base_type::m_p_root; p_nd != NULL; p_nd = p_nd->m_p_next_sibling) + for (node_pointer p_nd = base_type::m_p_root; p_nd != 0; p_nd = p_nd->m_p_next_sibling) if (Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value)) m_p_max = p_nd; @@ -102,5 +102,5 @@ PB_DS_CLASS_T_DEC void PB_DS_CLASS_C_DEC:: initialize() -{ std::fill(m_a_aux, m_a_aux + max_rank, static_cast<node_pointer>(NULL)); } +{ std::fill(m_a_aux, m_a_aux + max_rank, static_cast<node_pointer>(0)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp index f7abe35279c..0aedadb9f84 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/debug_fn_imps.hpp @@ -57,7 +57,7 @@ PB_DS_CLASS_C_DEC:: assert_aux_null() const { for (size_type i = 0; i < max_rank; ++i) - _GLIBCXX_DEBUG_ASSERT(m_a_aux[i] == NULL); + _GLIBCXX_DEBUG_ASSERT(m_a_aux[i] == 0); } PB_DS_CLASS_T_DEC @@ -65,15 +65,15 @@ void PB_DS_CLASS_C_DEC:: assert_max() const { - if (m_p_max == NULL) + if (m_p_max == 0) { _GLIBCXX_DEBUG_ASSERT(base_type::empty()); return; } _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); - _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == NULL); - _GLIBCXX_DEBUG_ASSERT(m_p_max->m_p_prev_or_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::parent(m_p_max) == 0); + _GLIBCXX_DEBUG_ASSERT(m_p_max->m_p_prev_or_parent == 0); for (const_iterator it = base_type::begin(); it != base_type::end(); ++it) _GLIBCXX_DEBUG_ASSERT(!Cmp_Fn::operator()(m_p_max->m_value, it.m_p_nd->m_value)); } @@ -84,7 +84,7 @@ PB_DS_CLASS_C_DEC:: assert_node_consistent(const_node_pointer p_nd, bool root) const { base_type::assert_node_consistent(p_nd, root); - if (p_nd == NULL) + if (p_nd == 0) return; assert_node_consistent(p_nd->m_p_next_sibling, root); @@ -92,17 +92,17 @@ assert_node_consistent(const_node_pointer p_nd, bool root) const if (!root) { if (p_nd->m_metadata == 0) - _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling == 0); else _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata + 1); } - if (p_nd->m_p_l_child != NULL) + if (p_nd->m_p_l_child != 0) _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_l_child->m_metadata + 1 == base_type::degree(p_nd)); - const bool unmarked_valid =(p_nd->m_p_l_child == NULL&& p_nd->m_metadata == 0) ||(p_nd->m_p_l_child != NULL&& p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 1); + const bool unmarked_valid =(p_nd->m_p_l_child == 0&& p_nd->m_metadata == 0) ||(p_nd->m_p_l_child != 0&& p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 1); - const bool marked_valid =(p_nd->m_p_l_child == NULL&& p_nd->m_metadata == 1) ||(p_nd->m_p_l_child != NULL&& p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 2); + const bool marked_valid =(p_nd->m_p_l_child == 0&& p_nd->m_metadata == 1) ||(p_nd->m_p_l_child != 0&& p_nd->m_metadata == p_nd->m_p_l_child->m_metadata + 2); _GLIBCXX_DEBUG_ASSERT(unmarked_valid || marked_valid); if (root) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp index 69afcd39f15..6f1b20b441a 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/erase_fn_imps.hpp @@ -46,7 +46,7 @@ pop() _GLIBCXX_DEBUG_ONLY(assert_valid();) _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); - _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_max != 0); node_pointer p_nd = m_p_max; @@ -85,11 +85,11 @@ to_aux_except_max() p_add = m_p_max->m_p_l_child; - while (p_add != NULL) + while (p_add != 0) { node_pointer p_next_add = p_add->m_p_next_sibling; - p_add->m_metadata = p_add->m_p_l_child == NULL? + p_add->m_metadata = p_add->m_p_l_child == 0? 0 : p_add->m_p_l_child->m_metadata + 1; @@ -100,7 +100,7 @@ to_aux_except_max() p_add = m_p_max->m_p_next_sibling; - while (p_add != NULL) + while (p_add != 0) { node_pointer p_next_add = p_add->m_p_next_sibling; @@ -117,7 +117,7 @@ add_to_aux(node_pointer p_nd) { size_type r = p_nd->m_metadata; - while (m_a_aux[r] != NULL) + while (m_a_aux[r] != 0) { _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata < rank_bound()); @@ -130,7 +130,7 @@ add_to_aux(node_pointer p_nd) p_nd = m_a_aux[r]; } - m_a_aux[r] = NULL; + m_a_aux[r] = 0; ++r; } @@ -159,7 +159,7 @@ inline void PB_DS_CLASS_C_DEC:: make_from_aux() { - base_type::m_p_root = m_p_max = NULL; + base_type::m_p_root = m_p_max = 0; const size_type rnk_bnd = rank_bound(); @@ -167,11 +167,11 @@ make_from_aux() while (i < rnk_bnd) { - if (m_a_aux[i] != NULL) + if (m_a_aux[i] != 0) { make_root_and_link(m_a_aux[i]); - m_a_aux[i] = NULL; + m_a_aux[i] = 0; } ++i; @@ -186,7 +186,7 @@ PB_DS_CLASS_C_DEC:: remove_node(node_pointer p_nd) { node_pointer p_parent = p_nd; - while (base_type::parent(p_parent) != NULL) + while (base_type::parent(p_parent) != 0) p_parent = base_type::parent(p_parent); base_type::bubble_to_top(p_nd); @@ -194,10 +194,10 @@ remove_node(node_pointer p_nd) m_p_max = p_nd; node_pointer p_fix = base_type::m_p_root; - while (p_fix != NULL&& p_fix->m_p_next_sibling != p_parent) + while (p_fix != 0&& p_fix->m_p_next_sibling != p_parent) p_fix = p_fix->m_p_next_sibling; - if (p_fix != NULL) + if (p_fix != 0) p_fix->m_p_next_sibling = p_nd; remove_max_node(); @@ -210,7 +210,7 @@ clear() { base_type::clear(); - m_p_max = NULL; + m_p_max = 0; } PB_DS_CLASS_T_DEC @@ -251,7 +251,7 @@ erase_if(Pred pred) size_type ersd = 0; - while (p_out != NULL) + while (p_out != 0) { ++ersd; @@ -264,9 +264,9 @@ erase_if(Pred pred) node_pointer p_cur = base_type::m_p_root; - m_p_max = base_type::m_p_root = NULL; + m_p_max = base_type::m_p_root = 0; - while (p_cur != NULL) + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp index 52407e6d0ae..700486a60d7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/find_fn_imps.hpp @@ -46,6 +46,6 @@ top() const _GLIBCXX_DEBUG_ONLY(assert_valid();) _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); - _GLIBCXX_DEBUG_ASSERT(m_p_max != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_max != 0); return m_p_max->m_value; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp index 7a6952fdad4..4e8a1c2d8cc 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/insert_fn_imps.hpp @@ -49,11 +49,11 @@ push(const_reference r_val) p_nd->m_metadata = 0; - p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = NULL; + p_nd->m_p_prev_or_parent = p_nd->m_p_l_child = 0; - if (base_type::m_p_root == NULL) + if (base_type::m_p_root == 0) { - p_nd->m_p_next_sibling = NULL; + p_nd->m_p_next_sibling = 0; m_p_max = base_type::m_p_root = p_nd; @@ -64,7 +64,7 @@ push(const_reference r_val) p_nd->m_p_next_sibling = base_type::m_p_root; - base_type::m_p_root->m_p_prev_or_parent = NULL; + base_type::m_p_root->m_p_prev_or_parent = 0; base_type::m_p_root = p_nd; @@ -81,7 +81,7 @@ PB_DS_CLASS_C_DEC:: make_root(node_pointer p_nd) { p_nd->m_metadata = - p_nd->m_p_l_child == NULL? + p_nd->m_p_l_child == 0? 0 : 1 + p_nd->m_p_l_child->m_metadata; } @@ -93,12 +93,12 @@ make_root_and_link(node_pointer p_nd) { make_root(p_nd); - p_nd->m_p_prev_or_parent = NULL; + p_nd->m_p_prev_or_parent = 0; p_nd->m_p_next_sibling = base_type::m_p_root; - if (base_type::m_p_root != NULL) - base_type::m_p_root->m_p_prev_or_parent = NULL; + if (base_type::m_p_root != 0) + base_type::m_p_root->m_p_prev_or_parent = 0; base_type::m_p_root = p_nd; @@ -112,15 +112,15 @@ fix(node_pointer p_y) { while (true) { - if (p_y->m_p_prev_or_parent == NULL) + if (p_y->m_p_prev_or_parent == 0) { fix_root(p_y); return; } - else if (p_y->m_metadata == 1&& p_y->m_p_next_sibling == NULL) + else if (p_y->m_metadata == 1&& p_y->m_p_next_sibling == 0) { - if (p_y->m_p_l_child != NULL) + if (p_y->m_p_l_child != 0) { fix_sibling_rank_1_unmarked(p_y); @@ -133,7 +133,7 @@ fix(node_pointer p_y) } else if (p_y->m_metadata > p_y->m_p_next_sibling->m_metadata + 1) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child != 0); if (p_y->m_metadata != p_y->m_p_l_child->m_metadata + 2) { @@ -146,8 +146,8 @@ fix(node_pointer p_y) p_y = p_y->m_p_prev_or_parent; } - else if ((p_y->m_p_l_child == NULL&& - p_y->m_metadata == 2) ||(p_y->m_p_l_child != NULL&& + else if ((p_y->m_p_l_child == 0&& + p_y->m_metadata == 2) ||(p_y->m_p_l_child != 0&& p_y->m_metadata == p_y->m_p_l_child->m_metadata + 3)) { node_pointer p_z = p_y->m_p_prev_or_parent; @@ -166,7 +166,7 @@ inline void PB_DS_CLASS_C_DEC:: fix_root(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent == NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent == 0); make_root(p_y); @@ -178,18 +178,18 @@ inline void PB_DS_CLASS_C_DEC:: fix_sibling_rank_1_unmarked(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0); _GLIBCXX_DEBUG_ONLY(node_pointer p_w = p_y->m_p_l_child;) - _GLIBCXX_DEBUG_ASSERT(p_w != NULL); - _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling == NULL); - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_next_sibling == NULL); + _GLIBCXX_DEBUG_ASSERT(p_w != 0); + _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling == 0); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_next_sibling == 0); p_y->m_p_next_sibling = p_y->m_p_l_child; p_y->m_p_next_sibling->m_p_prev_or_parent = p_y; - p_y->m_p_l_child = NULL; + p_y->m_p_l_child = 0; _GLIBCXX_DEBUG_ONLY(assert_node_consistent(p_y, false);) } @@ -199,8 +199,8 @@ inline void PB_DS_CLASS_C_DEC:: fix_sibling_rank_1_marked(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL); - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child == NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_l_child == 0); p_y->m_metadata = 0; @@ -212,17 +212,17 @@ inline void PB_DS_CLASS_C_DEC:: fix_sibling_general_unmarked(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0); node_pointer p_w = p_y->m_p_l_child; - _GLIBCXX_DEBUG_ASSERT(p_w != NULL); - _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != NULL); + _GLIBCXX_DEBUG_ASSERT(p_w != 0); + _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0); p_y->m_p_l_child = p_w->m_p_next_sibling; p_w->m_p_next_sibling->m_p_prev_or_parent = p_y; p_w->m_p_next_sibling = p_y->m_p_next_sibling; - _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != NULL); + _GLIBCXX_DEBUG_ASSERT(p_w->m_p_next_sibling != 0); p_w->m_p_next_sibling->m_p_prev_or_parent = p_w; p_y->m_p_next_sibling = p_w; @@ -236,7 +236,7 @@ inline void PB_DS_CLASS_C_DEC:: fix_sibling_general_marked(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0); --p_y->m_metadata; @@ -248,9 +248,9 @@ inline void PB_DS_CLASS_C_DEC:: fix_child(node_pointer p_y) { - _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y->m_p_prev_or_parent != 0); - if (p_y->m_p_next_sibling != NULL) + if (p_y->m_p_next_sibling != 0) p_y->m_p_next_sibling->m_p_prev_or_parent = p_y->m_p_prev_or_parent; if (p_y->m_p_prev_or_parent->m_p_l_child == p_y) @@ -269,7 +269,7 @@ modify(point_iterator it, const_reference r_new_val) _GLIBCXX_DEBUG_ONLY(assert_valid();) node_pointer p_nd = it.m_p_nd; - _GLIBCXX_DEBUG_ASSERT(p_nd != NULL); + _GLIBCXX_DEBUG_ASSERT(p_nd != 0); const bool smaller = Cmp_Fn::operator()(r_new_val, p_nd->m_value); @@ -279,7 +279,7 @@ modify(point_iterator it, const_reference r_new_val) { remove_node(p_nd); - p_nd->m_p_l_child = NULL; + p_nd->m_p_l_child = 0; make_root_and_link(p_nd); @@ -288,7 +288,7 @@ modify(point_iterator it, const_reference r_new_val) return; } - if (p_nd->m_p_prev_or_parent == NULL) + if (p_nd->m_p_prev_or_parent == 0) { update_max(p_nd); @@ -298,9 +298,9 @@ modify(point_iterator it, const_reference r_new_val) } node_pointer p_y = p_nd->m_p_prev_or_parent; - _GLIBCXX_DEBUG_ASSERT(p_y != NULL); + _GLIBCXX_DEBUG_ASSERT(p_y != 0); - if (p_nd->m_p_next_sibling != NULL) + if (p_nd->m_p_next_sibling != 0) p_nd->m_p_next_sibling->m_p_prev_or_parent = p_y; if (p_y->m_p_l_child == p_nd) @@ -320,7 +320,7 @@ inline void PB_DS_CLASS_C_DEC:: update_max(node_pointer p_nd) { - if (m_p_max == NULL || Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value)) + if (m_p_max == 0 || Cmp_Fn::operator()(m_p_max->m_value, p_nd->m_value)) m_p_max = p_nd; } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp index 6acb7bd7571..85ebe4cb400 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/thin_heap_/split_join_fn_imps.hpp @@ -61,7 +61,7 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_out = base_type::prune(pred); - while (p_out != NULL) + while (p_out != 0) { _GLIBCXX_DEBUG_ASSERT(base_type::m_size > 0); --base_type::m_size; @@ -79,11 +79,11 @@ split(Pred pred, PB_DS_CLASS_C_DEC& other) node_pointer p_cur = base_type::m_p_root; - m_p_max = NULL; + m_p_max = 0; - base_type::m_p_root = NULL; + base_type::m_p_root = 0; - while (p_cur != NULL) + while (p_cur != 0) { node_pointer p_next = p_cur->m_p_next_sibling; @@ -106,7 +106,7 @@ join(PB_DS_CLASS_C_DEC& other) node_pointer p_other = other.m_p_root; - while (p_other != NULL) + while (p_other != 0) { node_pointer p_next = p_other->m_p_next_sibling; @@ -117,9 +117,9 @@ join(PB_DS_CLASS_C_DEC& other) base_type::m_size += other.m_size; - other.m_p_root = NULL; + other.m_p_root = 0; other.m_size = 0; - other.m_p_max = NULL; + other.m_p_max = 0; _GLIBCXX_DEBUG_ONLY(assert_valid();) _GLIBCXX_DEBUG_ONLY(other.assert_valid();) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp b/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp index 6ea68995e53..b8c19a587f8 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/tree_policy/sample_tree_node_update.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -56,7 +56,7 @@ class sample_tree_node_update public: // Metadata type. - typedef size_t metadata_type; + typedef std::size_t metadata_type; protected: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp index 4e27ac21e62..cb8e2474121 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/order_statistics_imp.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -50,8 +50,6 @@ find_by_order(size_type order) node_iterator nd_it = node_begin(); - node_iterator end_nd_it = node_end(); - while (true) { if (order > nd_it.get_metadata()) diff --git a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp index 34fbe0cc3e2..2ecad89c9a7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_e_access_traits.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -48,7 +48,7 @@ class sample_trie_e_access_traits public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; // Key type. typedef std::string key_type; diff --git a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp index 55fd99787fb..8b2c6b591f7 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/trie_policy/sample_trie_node_update.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -56,7 +56,7 @@ class sample_trie_node_update public: // Metadata type. - typedef size_t metadata_type; + typedef std::size_t metadata_type; protected: diff --git a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp index 38d4eb1cfbc..71e26261794 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_iterator.hpp @@ -74,7 +74,7 @@ public: inline const_iterator_() - : m_p_tbl(NULL) + : m_p_tbl(0) { } // Increments. diff --git a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp index bc0b2ad624a..5574b28e1e1 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/const_point_iterator.hpp @@ -78,7 +78,7 @@ public: inline const_point_iterator_() - : m_p_value(NULL) + : m_p_value(0) { } // Copy constructor. @@ -99,7 +99,7 @@ public: inline const_pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_value != 0); return (m_p_value); } @@ -108,7 +108,7 @@ public: inline const_reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_value != 0); return (*m_p_value); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp index 3e21aba8bad..2836c17bea5 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/iterator.hpp @@ -74,7 +74,7 @@ public: inline iterator_() - : const_iterator_(NULL, PB_DS_GEN_POS(), NULL) + : const_iterator_(0, PB_DS_GEN_POS(), 0) { } // Conversion to a point-type iterator. @@ -97,7 +97,7 @@ public: inline pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0); return (const_cast<pointer>(base_type::m_p_value)); } @@ -106,7 +106,7 @@ public: inline reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(base_type::m_p_value != 0); return (const_cast<reference>(*base_type::m_p_value)); } diff --git a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp index 37ce90069cf..c009106e0dd 100644 --- a/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp +++ b/libstdc++-v3/include/ext/pb_ds/detail/unordered_iterator/point_iterator.hpp @@ -72,7 +72,7 @@ public: inline point_iterator_() - : m_p_value(NULL) + : m_p_value(0) { } // Copy constructor. @@ -86,7 +86,7 @@ public: inline pointer operator->() const { - _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_value != 0); return (m_p_value); } @@ -95,7 +95,7 @@ public: inline reference operator*() const { - _GLIBCXX_DEBUG_ASSERT(m_p_value != NULL); + _GLIBCXX_DEBUG_ASSERT(m_p_value != 0); return (*m_p_value); } diff --git a/libstdc++-v3/include/ext/pb_ds/exception.hpp b/libstdc++-v3/include/ext/pb_ds/exception.hpp index 4f796b1ef33..b34e3ed26f2 100644 --- a/libstdc++-v3/include/ext/pb_ds/exception.hpp +++ b/libstdc++-v3/include/ext/pb_ds/exception.hpp @@ -1,6 +1,7 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +42,7 @@ #ifndef PB_DS_EXCEPTION_HPP #define PB_DS_EXCEPTION_HPP +#include <bits/c++config.h> #include <stdexcept> #include <cstdlib> diff --git a/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp b/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp index 24c0c4562cc..f3bc86e9731 100644 --- a/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/hash_policy.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +41,7 @@ #ifndef PB_DS_HASH_POLICY_HPP #define PB_DS_HASH_POLICY_HPP +#include <bits/c++config.h> #include <algorithm> #include <vector> #include <cmath> @@ -66,7 +67,7 @@ namespace __gnu_pbds #define PB_DS_CLASS_C_DEC linear_probe_fn<Size_Type> // A probe sequence policy using fixed increments. - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class linear_probe_fn { public: @@ -90,7 +91,7 @@ namespace __gnu_pbds #define PB_DS_CLASS_C_DEC quadratic_probe_fn<Size_Type> // A probe sequence policy using square increments. - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class quadratic_probe_fn { public: @@ -114,7 +115,7 @@ namespace __gnu_pbds #define PB_DS_CLASS_C_DEC direct_mask_range_hashing<Size_Type> // A mask range-hashing class (uses a bit-mask). - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class direct_mask_range_hashing : public detail::mask_based_range_hashing<Size_Type> { @@ -146,7 +147,7 @@ namespace __gnu_pbds #define PB_DS_CLASS_C_DEC direct_mod_range_hashing<Size_Type> // A mod range-hashing class (uses the modulo function). - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class direct_mod_range_hashing : public detail::mod_based_range_hashing<Size_Type> { @@ -180,7 +181,7 @@ namespace __gnu_pbds // A resize trigger policy based on a load check. It keeps the // load factor between some load factors load_min and load_max. - template<bool External_Load_Access = false, typename Size_Type = size_t> + template<bool External_Load_Access = false, typename Size_Type = std::size_t> class hash_load_check_resize_trigger : private PB_DS_SIZE_BASE_C_DEC { public: @@ -295,7 +296,7 @@ namespace __gnu_pbds // A resize trigger policy based on collision checks. It keeps the // simulated load factor lower than some given load factor. - template<bool External_Load_Access = false, typename Size_Type = size_t> + template<bool External_Load_Access = false, typename Size_Type = std::size_t> class cc_hash_max_collision_check_resize_trigger { public: @@ -396,7 +397,7 @@ namespace __gnu_pbds // A size policy whose sequence of sizes form an exponential // sequence (typically powers of 2. - template<typename Size_Type = size_t> + template<typename Size_Type = std::size_t> class hash_exponential_size_policy { public: @@ -438,7 +439,7 @@ namespace __gnu_pbds { public: // Size type. - typedef size_t size_type; + typedef std::size_t size_type; // Default constructor, or onstructor taking a start_size The // policy will use the sequence of sizes approximately @@ -472,7 +473,7 @@ namespace __gnu_pbds template<typename Size_Policy = hash_exponential_size_policy<>, typename Trigger_Policy = hash_load_check_resize_trigger<>, bool External_Size_Access = false, - typename Size_Type = size_t> + typename Size_Type = std::size_t> class hash_standard_resize_policy : public Size_Policy, public Trigger_Policy { diff --git a/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp b/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp index ec05b69c7e6..54a67c6e563 100644 --- a/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/list_update_policy.hpp @@ -1,6 +1,7 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +42,7 @@ #ifndef PB_DS_LU_POLICY_HPP #define PB_DS_LU_POLICY_HPP +#include <bits/c++config.h> #include <cstdlib> #include <ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp> @@ -87,12 +89,13 @@ namespace __gnu_pbds #undef PB_DS_CLASS_T_DEC #undef PB_DS_CLASS_C_DEC -#define PB_DS_CLASS_T_DEC template<size_t Max_Count, class Allocator> +#define PB_DS_CLASS_T_DEC template<std::size_t Max_Count, class Allocator> #define PB_DS_CLASS_C_DEC counter_lu_policy<Max_Count, Allocator> // A list-update policy that moves elements to the front of the list // based on the counter algorithm. - template<size_t Max_Count = 5, typename Allocator = std::allocator<char> > + template<std::size_t Max_Count = 5, + typename Allocator = std::allocator<char> > class counter_lu_policy : private detail::counter_lu_policy_base<typename Allocator::size_type> { diff --git a/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp b/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp index 531f70c65ce..b6088e7d73a 100644 --- a/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp +++ b/libstdc++-v3/include/ext/pb_ds/priority_queue.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +41,7 @@ #ifndef PB_DS_PRIORITY_QUEUE_HPP #define PB_DS_PRIORITY_QUEUE_HPP +#include <bits/c++config.h> #include <ext/pb_ds/tag_and_trait.hpp> #include <ext/pb_ds/detail/priority_queue_base_dispatch.hpp> #include <ext/pb_ds/detail/standard_policies.hpp> @@ -53,10 +54,13 @@ namespace __gnu_pbds typename Tag = pairing_heap_tag, typename Allocator = std::allocator<char> > class priority_queue - : public detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type + : public detail::priority_queue_base_dispatch<Value_Type, + Cmp_Fn,Tag,Allocator>::type { private: - typedef typename detail::priority_queue_base_dispatch<Value_Type,Cmp_Fn,Tag,Allocator>::type base_type; + typedef typename + detail::priority_queue_base_dispatch<Value_Type, Cmp_Fn, + Tag, Allocator>::type base_type; public: typedef Value_Type value_type; diff --git a/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp b/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp index ccd2533cc4f..ef445336137 100644 --- a/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp +++ b/libstdc++-v3/include/ext/pb_ds/tag_and_trait.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -42,6 +42,7 @@ #ifndef PB_DS_TAG_AND_TRAIT_HPP #define PB_DS_TAG_AND_TRAIT_HPP +#include <bits/c++config.h> #include <ext/pb_ds/detail/type_utils.hpp> /** diff --git a/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp b/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp index 990860ec020..4af1adbde70 100644 --- a/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/tree_policy.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +41,7 @@ #ifndef PB_DS_TREE_POLICY_HPP #define PB_DS_TREE_POLICY_HPP +#include <bits/c++config.h> #include <iterator> #include <ext/pb_ds/detail/type_utils.hpp> #include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp> diff --git a/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp b/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp index c10591bb7f3..fc452104f75 100644 --- a/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp +++ b/libstdc++-v3/include/ext/pb_ds/trie_policy.hpp @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +41,7 @@ #ifndef PB_DS_TRIE_POLICY_HPP #define PB_DS_TRIE_POLICY_HPP +#include <bits/c++config.h> #include <string> #include <ext/pb_ds/detail/type_utils.hpp> #include <ext/pb_ds/detail/trie_policy/trie_policy_base.hpp> diff --git a/libstdc++-v3/include/ext/pointer.h b/libstdc++-v3/include/ext/pointer.h index ddb5f3c84a8..8055df226f2 100644 --- a/libstdc++-v3/include/ext/pointer.h +++ b/libstdc++-v3/include/ext/pointer.h @@ -1,6 +1,6 @@ // Custom pointer adapter and sample storage policies -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -447,7 +447,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) } inline _Pointer_adapter - operator++(int __unused) + operator++(int) { _Pointer_adapter tmp(*this); _Storage_policy::set(_Storage_policy::get() + 1); diff --git a/libstdc++-v3/include/ext/rc_string_base.h b/libstdc++-v3/include/ext/rc_string_base.h index a18b274fa88..dd18738dc57 100644 --- a/libstdc++-v3/include/ext/rc_string_base.h +++ b/libstdc++-v3/include/ext/rc_string_base.h @@ -554,7 +554,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) // NB: Not required, but considered best practice. if (__is_null_pointer(__beg) && __beg != __end) std::__throw_logic_error(__N("__rc_string_base::" - "_S_construct NULL not valid")); + "_S_construct null not valid")); const size_type __dnew = static_cast<size_type>(std::distance(__beg, __end)); diff --git a/libstdc++-v3/include/ext/sso_string_base.h b/libstdc++-v3/include/ext/sso_string_base.h index b0500cf17e0..43d44528999 100644 --- a/libstdc++-v3/include/ext/sso_string_base.h +++ b/libstdc++-v3/include/ext/sso_string_base.h @@ -434,7 +434,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) // NB: Not required, but considered best practice. if (__is_null_pointer(__beg) && __beg != __end) std::__throw_logic_error(__N("__sso_string_base::" - "_M_construct NULL not valid")); + "_M_construct null not valid")); size_type __dnew = static_cast<size_type>(std::distance(__beg, __end)); diff --git a/libstdc++-v3/include/ext/string_conversions.h b/libstdc++-v3/include/ext/string_conversions.h index 36c19e0a97a..a4276f30ba2 100644 --- a/libstdc++-v3/include/ext/string_conversions.h +++ b/libstdc++-v3/include/ext/string_conversions.h @@ -1,6 +1,6 @@ // String Conversions -*- C++ -*- -// Copyright (C) 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -27,9 +27,9 @@ #pragma GCC system_header +#include <bits/c++config.h> #include <ext/numeric_traits.h> #include <bits/functexcept.h> -#include <cstddef> #include <cstdlib> #include <cwchar> #include <cstdio> diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h index 70b197a705d..669d433e272 100644 --- a/libstdc++-v3/include/ext/throw_allocator.h +++ b/libstdc++-v3/include/ext/throw_allocator.h @@ -110,7 +110,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) void insert(void* p, size_t size) { - if (p == NULL) + if (!p) { std::string error("annotate_base::insert null insert!\n"); log_to_string(error, make_entry(p, size)); diff --git a/libstdc++-v3/include/parallel/base.h b/libstdc++-v3/include/parallel/base.h index 1a8c3cb60a8..3e3041d27df 100644 --- a/libstdc++-v3/include/parallel/base.h +++ b/libstdc++-v3/include/parallel/base.h @@ -140,13 +140,13 @@ namespace __gnu_parallel /** @brief Equivalent to std::min. */ template<typename _Tp> - const _Tp& + inline const _Tp& min(const _Tp& __a, const _Tp& __b) { return (__a < __b) ? __a : __b; } /** @brief Equivalent to std::max. */ template<typename _Tp> - const _Tp& + inline const _Tp& max(const _Tp& __a, const _Tp& __b) { return (__a > __b) ? __a : __b; } @@ -267,8 +267,8 @@ namespace __gnu_parallel /** @brief Similar to std::plus, but allows two different types. */ template<typename _Tp1, typename _Tp2, typename _Result - = __typeof__(*static_cast<_Tp1*>(NULL) - + *static_cast<_Tp2*>(NULL))> + = __typeof__(*static_cast<_Tp1*>(0) + + *static_cast<_Tp2*>(0))> struct _Plus : public std::binary_function<_Tp1, _Tp2, _Result> { _Result @@ -283,8 +283,8 @@ namespace __gnu_parallel /** @brief Similar to std::multiplies, but allows two different types. */ template<typename _Tp1, typename _Tp2, typename _Result - = __typeof__(*static_cast<_Tp1*>(NULL) - * *static_cast<_Tp2*>(NULL))> + = __typeof__(*static_cast<_Tp1*>(0) + * *static_cast<_Tp2*>(0))> struct _Multiplies : public std::binary_function<_Tp1, _Tp2, _Result> { _Result @@ -300,7 +300,7 @@ namespace __gnu_parallel /** @brief _Iterator associated with __gnu_parallel::_PseudoSequence. * If features the usual random-access iterator functionality. * @param _Tp Sequence _M_value type. - * @param _DifferenceType Sequence difference type. + * @param _DifferenceTp Sequence difference type. */ template<typename _Tp, typename _DifferenceTp> class _PseudoSequenceIterator @@ -353,7 +353,7 @@ namespace __gnu_parallel the same element. * The copies are not stored explicitly, of course. * @param _Tp Sequence _M_value type. - * @param _DifferenceType Sequence difference type. + * @param _DifferenceTp Sequence difference type. */ template<typename _Tp, typename _DifferenceTp> class _PseudoSequence diff --git a/libstdc++-v3/include/parallel/basic_iterator.h b/libstdc++-v3/include/parallel/basic_iterator.h index c5c067a0b0d..a624edc1a3b 100644 --- a/libstdc++-v3/include/parallel/basic_iterator.h +++ b/libstdc++-v3/include/parallel/basic_iterator.h @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2007, 2009 Free Software Foundation, Inc. +// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -34,7 +34,6 @@ #define _GLIBCXX_PARALLEL_BASIC_ITERATOR_H 1 #include <bits/c++config.h> -#include <cstddef> #include <bits/stl_iterator_base_types.h> #include <bits/stl_iterator_base_funcs.h> #include <bits/stl_iterator.h> diff --git a/libstdc++-v3/include/parallel/find.h b/libstdc++-v3/include/parallel/find.h index b4e581488ae..eb37d8aace1 100644 --- a/libstdc++-v3/include/parallel/find.h +++ b/libstdc++-v3/include/parallel/find.h @@ -168,9 +168,7 @@ namespace __gnu_parallel * @param __selector _Functionality (e. g. std::find_if(), std::equal(),...) * @return Place of finding in both sequences. * @see __gnu_parallel::_Settings::find_sequential_search_size - * @see __gnu_parallel::_Settings::find_initial_block_size - * @see __gnu_parallel::_Settings::find_maximum_block_size - * @see __gnu_parallel::_Settings::find_increasing_factor + * @see __gnu_parallel::_Settings::find_scale_factor * * There are two main differences between the growing blocks and * the constant-size blocks variants. @@ -218,6 +216,8 @@ namespace __gnu_parallel omp_lock_t __result_lock; omp_init_lock(&__result_lock); + const float __scale_factor = __s.find_scale_factor; + _ThreadIndex __num_threads = __get_max_threads(); # pragma omp parallel shared(__result) num_threads(__num_threads) { @@ -227,7 +227,8 @@ namespace __gnu_parallel // Not within first __k elements -> start parallel. _ThreadIndex __iam = omp_get_thread_num(); - _DifferenceType __block_size = __s.find_initial_block_size; + _DifferenceType __block_size = + std::max<_DifferenceType>(1, __scale_factor * __next_block_start); _DifferenceType __start = __fetch_and_add<_DifferenceType> (&__next_block_start, __block_size); @@ -265,15 +266,14 @@ namespace __gnu_parallel omp_unset_lock(&__result_lock); } - __block_size = std::min<_DifferenceType> - (__block_size * __s.find_increasing_factor, - __s.find_maximum_block_size); + _DifferenceType __block_size = + std::max<_DifferenceType>(1, __scale_factor * __next_block_start); // Get new block, update pointer to next block. __start = __fetch_and_add<_DifferenceType>(&__next_block_start, __block_size); - __stop = (__length < (__start + __block_size) - ? __length : (__start + __block_size)); + __stop = + std::min<_DifferenceType>(__length, __start + __block_size); } } //parallel diff --git a/libstdc++-v3/include/parallel/multiseq_selection.h b/libstdc++-v3/include/parallel/multiseq_selection.h index 1fab257ccdd..e77653aeefa 100644 --- a/libstdc++-v3/include/parallel/multiseq_selection.h +++ b/libstdc++-v3/include/parallel/multiseq_selection.h @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -230,7 +230,7 @@ namespace __gnu_parallel __n /= 2; _SeqNumber __lmax_seq = -1; // to avoid warning - const _ValueType* __lmax = NULL; // impossible to avoid the warning? + const _ValueType* __lmax = 0; // impossible to avoid the warning? for (_SeqNumber __i = 0; __i < __m; __i++) { if (__a[__i] > 0) @@ -332,8 +332,8 @@ namespace __gnu_parallel // Compare the keys on both edges of the border. // Maximum of left edge, minimum of right edge. - _ValueType* __maxleft = NULL; - _ValueType* __minright = NULL; + _ValueType* __maxleft = 0; + _ValueType* __minright = 0; for (_SeqNumber __i = 0; __i < __m; __i++) { if (__a[__i] > 0) @@ -482,7 +482,7 @@ namespace __gnu_parallel { __n /= 2; - const _Tp* __lmax = NULL; + const _Tp* __lmax = 0; for (_SeqNumber __i = 0; __i < __m; ++__i) { if (__a[__i] > 0) diff --git a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h index 445184ae5ec..1baf76beb9c 100644 --- a/libstdc++-v3/include/parallel/multiway_merge.h +++ b/libstdc++-v3/include/parallel/multiway_merge.h @@ -502,11 +502,11 @@ namespace __gnu_parallel _LT __lt(__k, __comp); // Default value for potentially non-default-constructible types. - _ValueType* __arbitrary_element = NULL; + _ValueType* __arbitrary_element = 0; for (_SeqNumber __t = 0; __t < __k; ++__t) { - if(__arbitrary_element == NULL + if(!__arbitrary_element && _GLIBCXX_PARALLEL_LENGTH(__seqs_begin[__t]) > 0) __arbitrary_element = &(*__seqs_begin[__t].first); } diff --git a/libstdc++-v3/include/parallel/multiway_mergesort.h b/libstdc++-v3/include/parallel/multiway_mergesort.h index 85894719dc0..8e2c53ec661 100644 --- a/libstdc++-v3/include/parallel/multiway_mergesort.h +++ b/libstdc++-v3/include/parallel/multiway_mergesort.h @@ -434,7 +434,7 @@ namespace __gnu_parallel (::operator new(__size * sizeof(_ValueType))); } else - __sd._M_samples = NULL; + __sd._M_samples = 0; __sd._M_offsets = new _DifferenceType[__num_threads - 1]; __sd._M_pieces diff --git a/libstdc++-v3/include/parallel/partial_sum.h b/libstdc++-v3/include/parallel/partial_sum.h index 966d9db0572..d398c4585a2 100644 --- a/libstdc++-v3/include/parallel/partial_sum.h +++ b/libstdc++-v3/include/parallel/partial_sum.h @@ -127,10 +127,13 @@ namespace __gnu_parallel equally_split(__n, __num_threads + 1, __borders); else { + _DifferenceType __first_part_length = + std::max<_DifferenceType>(1, + __n / (1.0f + __s.partial_sum_dilation * __num_threads)); _DifferenceType __chunk_length = - ((double)__n - / ((double)__num_threads + __s.partial_sum_dilation)), - __borderstart = __n - __num_threads * __chunk_length; + (__n - __first_part_length) / __num_threads; + _DifferenceType __borderstart = + __n - __num_threads * __chunk_length; __borders[0] = 0; for (_ThreadIndex __i = 1; __i < (__num_threads + 1); ++__i) { diff --git a/libstdc++-v3/include/parallel/partition.h b/libstdc++-v3/include/parallel/partition.h index 0d5a139968c..27b3871f41b 100644 --- a/libstdc++-v3/include/parallel/partition.h +++ b/libstdc++-v3/include/parallel/partition.h @@ -73,7 +73,7 @@ namespace __gnu_parallel __leftnew, __rightnew; // just 0 or 1, but int to allow atomic operations - int* __reserved_left = NULL, * __reserved_right = NULL; + int* __reserved_left = 0, * __reserved_right = 0; _DifferenceType __chunk_size = __s.partition_chunk_size; diff --git a/libstdc++-v3/include/parallel/set_operations.h b/libstdc++-v3/include/parallel/set_operations.h index 346fb97775d..f6b076f0655 100644 --- a/libstdc++-v3/include/parallel/set_operations.h +++ b/libstdc++-v3/include/parallel/set_operations.h @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -345,11 +345,11 @@ namespace __gnu_parallel template<typename _IIter, typename _OutputIterator, - typename Operation> + typename _Operation> _OutputIterator __parallel_set_operation(_IIter __begin1, _IIter __end1, _IIter __begin2, _IIter __end2, - _OutputIterator __result, Operation __op) + _OutputIterator __result, _Operation __op) { _GLIBCXX_CALL((__end1 - __begin1) + (__end2 - __begin2)) diff --git a/libstdc++-v3/include/parallel/settings.h b/libstdc++-v3/include/parallel/settings.h index 3b326ff8e47..5d00b026944 100644 --- a/libstdc++-v3/include/parallel/settings.h +++ b/libstdc++-v3/include/parallel/settings.h @@ -272,6 +272,9 @@ namespace __gnu_parallel /// Minimal input size for search and search_n. _SequenceIndex search_minimal_n; + /// Block size scale-down factor with respect to current position. + float find_scale_factor; + /// Get the global settings. _GLIBCXX_CONST static const _Settings& get() throw(); @@ -331,7 +334,8 @@ namespace __gnu_parallel TLB_size(128), cache_line_size(64), qsb_steals(0), - search_minimal_n(1000) + search_minimal_n(1000), + find_scale_factor(0.01f) { } }; } diff --git a/libstdc++-v3/include/profile/base.h b/libstdc++-v3/include/profile/base.h index de7bfe9a56f..88dd0b1f197 100644 --- a/libstdc++-v3/include/profile/base.h +++ b/libstdc++-v3/include/profile/base.h @@ -38,9 +38,7 @@ #ifndef _GLIBCXX_PROFILE_BASE_H #define _GLIBCXX_PROFILE_BASE_H 1 -#include <cstdio> #include <functional> -#include <bits/c++config.h> #include <profile/impl/profiler.h> // Profiling mode namespaces. diff --git a/libstdc++-v3/include/profile/deque b/libstdc++-v3/include/profile/deque index 55e8d49d686..9f8ce70c9db 100644 --- a/libstdc++-v3/include/profile/deque +++ b/libstdc++-v3/include/profile/deque @@ -60,12 +60,24 @@ namespace __profile typedef typename _Base::const_pointer const_pointer; // 23.2.1.1 construct/copy/destroy: - explicit deque(const _Allocator& __a = _Allocator()) + explicit + deque(const _Allocator& __a = _Allocator()) : _Base(__a) { } - explicit deque(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + deque(size_type __n) + : _Base(__n) { } + + deque(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { } +#else + explicit + deque(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#endif template<class _InputIterator> deque(_InputIterator __first, _InputIterator __last, @@ -195,11 +207,25 @@ namespace __profile using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { + _Base::resize(__sz); + } + + void + resize(size_type __sz, const _Tp& __c) + { + _Base::resize(__sz, __c); + } +#else void resize(size_type __sz, _Tp __c = _Tp()) { _Base::resize(__sz, __c); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ using _Base::shrink_to_fit; diff --git a/libstdc++-v3/include/profile/impl/profiler.h b/libstdc++-v3/include/profile/impl/profiler.h index 07ed50d8e4c..ab9cd903030 100644 --- a/libstdc++-v3/include/profile/impl/profiler.h +++ b/libstdc++-v3/include/profile/impl/profiler.h @@ -37,11 +37,7 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_H #define _GLIBCXX_PROFILE_PROFILER_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstddef> -#else -#include <stddef.h> -#endif +#include <bits/c++config.h> // Mechanism to define data with inline linkage. #define _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__type, __name) \ @@ -109,47 +105,50 @@ namespace __gnu_profile bool __is_on(); bool __is_off(); void __report(void); - void __trace_hashtable_size_resize(const void*, size_t, size_t); - void __trace_hashtable_size_destruct(const void*, size_t, size_t); - void __trace_hashtable_size_construct(const void*, size_t); - void __trace_vector_size_resize(const void*, size_t, size_t); - void __trace_vector_size_destruct(const void*, size_t, size_t); - void __trace_vector_size_construct(const void*, size_t); - void __trace_hash_func_destruct(const void*, size_t, size_t, size_t); + void __trace_hashtable_size_resize(const void*, std::size_t, std::size_t); + void __trace_hashtable_size_destruct(const void*, std::size_t, std::size_t); + void __trace_hashtable_size_construct(const void*, std::size_t); + void __trace_vector_size_resize(const void*, std::size_t, std::size_t); + void __trace_vector_size_destruct(const void*, std::size_t, std::size_t); + void __trace_vector_size_construct(const void*, std::size_t); + void __trace_hash_func_destruct(const void*, std::size_t, std::size_t, + std::size_t); void __trace_hash_func_construct(const void*); void __trace_vector_to_list_destruct(const void*); void __trace_vector_to_list_construct(const void*); - void __trace_vector_to_list_insert(const void*, size_t, size_t); - void __trace_vector_to_list_iterate(const void*, size_t); + void __trace_vector_to_list_insert(const void*, std::size_t, std::size_t); + void __trace_vector_to_list_iterate(const void*, std::size_t); void __trace_vector_to_list_invalid_operator(const void*); - void __trace_vector_to_list_resize(const void*, size_t, size_t); - void __trace_vector_to_list_find(const void*, size_t); + void __trace_vector_to_list_resize(const void*, std::size_t, std::size_t); + void __trace_vector_to_list_find(const void*, std::size_t); void __trace_list_to_slist_destruct(const void*); void __trace_list_to_slist_construct(const void*); - void __trace_list_to_slist_rewind(const void*); + void __trace_list_to_slist_rewind(const void*); void __trace_list_to_slist_operation(const void*); void __trace_list_to_vector_destruct(const void*); void __trace_list_to_vector_construct(const void*); - void __trace_list_to_vector_insert(const void*, size_t, size_t); - void __trace_list_to_vector_iterate(const void*, size_t); + void __trace_list_to_vector_insert(const void*, std::size_t, std::size_t); + void __trace_list_to_vector_iterate(const void*, std::size_t); void __trace_list_to_vector_invalid_operator(const void*); - void __trace_list_to_vector_resize(const void*, size_t, size_t); + void __trace_list_to_vector_resize(const void*, std::size_t, std::size_t); void __trace_list_to_set_destruct(const void*); void __trace_list_to_set_construct(const void*); - void __trace_list_to_set_insert(const void*, size_t, size_t); - void __trace_list_to_set_iterate(const void*, size_t); + void __trace_list_to_set_insert(const void*, std::size_t, std::size_t); + void __trace_list_to_set_iterate(const void*, std::size_t); void __trace_list_to_set_invalid_operator(const void*); - void __trace_list_to_set_find(const void*, size_t); + void __trace_list_to_set_find(const void*, std::size_t); void __trace_map_to_unordered_map_construct(const void*); void __trace_map_to_unordered_map_invalidate(const void*); - void __trace_map_to_unordered_map_insert(const void*, size_t, size_t); - void __trace_map_to_unordered_map_erase(const void*, size_t, size_t); - void __trace_map_to_unordered_map_iterate(const void*, size_t); - void __trace_map_to_unordered_map_find(const void*, size_t); + void __trace_map_to_unordered_map_insert(const void*, std::size_t, + std::size_t); + void __trace_map_to_unordered_map_erase(const void*, std::size_t, + std::size_t); + void __trace_map_to_unordered_map_iterate(const void*, std::size_t); + void __trace_map_to_unordered_map_find(const void*, std::size_t); void __trace_map_to_unordered_map_destruct(const void*); } // namespace __gnu_profile diff --git a/libstdc++-v3/include/profile/impl/profiler_container_size.h b/libstdc++-v3/include/profile/impl/profiler_container_size.h index bfbab85199b..5c7d08b92b9 100644 --- a/libstdc++-v3/include/profile/impl/profiler_container_size.h +++ b/libstdc++-v3/include/profile/impl/profiler_container_size.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,16 +37,6 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif - #include <sstream> #include "profile/impl/profiler.h" @@ -55,188 +45,178 @@ namespace __gnu_profile { - -/** @brief A container size instrumentation line in the object table. */ -class __container_size_info: public __object_info_base -{ - public: - __container_size_info(); - __container_size_info(const __container_size_info& __o); - __container_size_info(__stack_t __stack, size_t __num); - virtual ~__container_size_info() {} - - void __write(FILE* f) const; - float __magnitude() const { return static_cast<float>(_M_cost); } - const char* __advice() const; - - void __merge(const __container_size_info& __o); - // Call if a container is destructed or cleaned. - void __destruct(size_t __num, size_t __inum); - // Estimate the cost of resize/rehash. - float __resize_cost(size_t __from, size_t __to) { return __from; } - // Call if container is resized. - void __resize(size_t __from, size_t __to); - - private: - size_t _M_init; - size_t _M_max; // range of # buckets - size_t _M_min; - size_t _M_total; - size_t _M_item_min; // range of # items - size_t _M_item_max; - size_t _M_item_total; - size_t _M_count; - size_t _M_resize; - size_t _M_cost; -}; - -inline const char* __container_size_info::__advice() const -{ - std::stringstream __message; - if (_M_init < _M_item_max) - __message << "change initial container size from " << _M_init - << " to " << _M_item_max; - - return strdup(__message.str().c_str()); -} - -inline void __container_size_info::__destruct(size_t __num, size_t __inum) -{ - _M_max = __max(_M_max, __num); - _M_item_max = __max(_M_item_max, __inum); - if (_M_min == 0) { - _M_min = __num; - _M_item_min = __inum; - } else { - _M_min = __min(_M_min, __num); - _M_item_min = __min(_M_item_min, __inum); - } - _M_total += __num; - _M_item_total += __inum; - _M_count += 1; -} - -inline void __container_size_info::__resize(size_t __from, size_t __to) -{ - _M_cost += this->__resize_cost(__from, __to); - _M_resize += 1; - _M_max = __max(_M_max, __to); -} - -inline __container_size_info::__container_size_info(__stack_t __stack, - size_t __num) - : __object_info_base(__stack), _M_init(0), _M_max(0), _M_item_max(0), - _M_min(0), _M_item_min(0), _M_total(0), _M_item_total(0), _M_cost(0), - _M_count(0), _M_resize(0) -{ - _M_init = _M_max = __num; - _M_item_min = _M_item_max = _M_item_total = _M_total = 0; - _M_min = 0; - _M_count = 0; - _M_resize = 0; -} - -inline void __container_size_info::__merge(const __container_size_info& __o) -{ - _M_init = __max(_M_init, __o._M_init); - _M_max = __max(_M_max, __o._M_max); - _M_item_max = __max(_M_item_max, __o._M_item_max); - _M_min = __min(_M_min, __o._M_min); - _M_item_min = __min(_M_item_min, __o._M_item_min); - _M_total += __o._M_total; - _M_item_total += __o._M_item_total; - _M_count += __o._M_count; - _M_cost += __o._M_cost; - _M_resize += __o._M_resize; -} - -inline __container_size_info::__container_size_info() - : _M_init(0), _M_max(0), _M_item_max(0), _M_min(0), _M_item_min(0), - _M_total(0), _M_item_total(0), _M_cost(0), _M_count(0), _M_resize(0) -{ -} - -inline __container_size_info::__container_size_info( - const __container_size_info& __o) - : __object_info_base(__o) -{ - _M_init = __o._M_init; - _M_max = __o._M_max; - _M_item_max = __o._M_item_max; - _M_min = __o._M_min; - _M_item_min = __o._M_item_min; - _M_total = __o._M_total; - _M_item_total = __o._M_item_total; - _M_cost = __o._M_cost; - _M_count = __o._M_count; - _M_resize = __o._M_resize; -} - -/** @brief A container size instrumentation line in the stack table. */ -class __container_size_stack_info: public __container_size_info -{ - public: - __container_size_stack_info(const __container_size_info& __o) - : __container_size_info(__o) {} -}; - -/** @brief Container size instrumentation trace producer. */ -class __trace_container_size - : public __trace_base<__container_size_info, __container_size_stack_info> -{ - public: - ~__trace_container_size() {} - __trace_container_size() - : __trace_base<__container_size_info, __container_size_stack_info>() {}; - - // Insert a new node at construct with object, callstack and initial size. - void __insert(const __object_t __obj, __stack_t __stack, size_t __num); - // Call at destruction/clean to set container final size. - void __destruct(const void* __obj, size_t __num, size_t __inum); - void __construct(const void* __obj, size_t __inum); - // Call at resize to set resize/cost information. - void __resize(const void* __obj, int __from, int __to); -}; - -inline void __trace_container_size::__insert(const __object_t __obj, - __stack_t __stack, size_t __num) -{ - __add_object(__obj, __container_size_info(__stack, __num)); -} - -inline void __container_size_info::__write(FILE* __f) const -{ - fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", - _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, _M_total, - _M_item_min, _M_item_max, _M_item_total); -} - -inline void __trace_container_size::__destruct(const void* __obj, - size_t __num, size_t __inum) -{ - if (!__is_on()) return; - - __object_t __obj_handle = static_cast<__object_t>(__obj); - - __container_size_info* __object_info = __get_object_info(__obj_handle); - if (!__object_info) - return; - - __object_info->__destruct(__num, __inum); - __retire_object(__obj_handle); -} - -inline void __trace_container_size::__resize(const void* __obj, int __from, - int __to) -{ - if (!__is_on()) return; - - __container_size_info* __object_info = __get_object_info(__obj); - if (!__object_info) - return; - - __object_info->__resize(__from, __to); -} + /** @brief A container size instrumentation line in the object table. */ + class __container_size_info + : public __object_info_base + { + public: + __container_size_info() + : _M_init(0), _M_max(0), _M_min(0), _M_total(0), _M_item_min(0), + _M_item_max(0), _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0) + { } + + __container_size_info(const __container_size_info& __o) + : __object_info_base(__o), _M_init(__o._M_init), _M_max(__o._M_max), + _M_min(__o._M_min), _M_total(__o._M_total), + _M_item_min(__o._M_item_min), _M_item_max(__o._M_item_max), + _M_item_total(__o._M_item_total), _M_count(__o._M_count), + _M_resize(__o._M_resize), _M_cost(__o._M_cost) + { } + + __container_size_info(__stack_t __stack, std::size_t __num) + : __object_info_base(__stack), _M_init(__num), _M_max(__num), + _M_min(0), _M_total(0), _M_item_min(0), _M_item_max(0), + _M_item_total(0), _M_count(0), _M_resize(0), _M_cost(0) + { } + + virtual ~__container_size_info() { } + + void + __write(FILE* __f) const + { + std::fprintf(__f, "%Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu %Zu\n", + _M_init, _M_count, _M_cost, _M_resize, _M_min, _M_max, + _M_total, _M_item_min, _M_item_max, _M_item_total); + } + + float + __magnitude() const + { return static_cast<float>(_M_cost); } + + std::string + __advice() const + { + std::stringstream __message; + if (_M_init < _M_item_max) + __message << "change initial container size from " << _M_init + << " to " << _M_item_max; + return __message.str(); + } + + void + __merge(const __container_size_info& __o) + { + _M_init = std::max(_M_init, __o._M_init); + _M_max = std::max(_M_max, __o._M_max); + _M_item_max = std::max(_M_item_max, __o._M_item_max); + _M_min = std::min(_M_min, __o._M_min); + _M_item_min = std::min(_M_item_min, __o._M_item_min); + _M_total += __o._M_total; + _M_item_total += __o._M_item_total; + _M_count += __o._M_count; + _M_cost += __o._M_cost; + _M_resize += __o._M_resize; + } + + // Call if a container is destructed or cleaned. + void + __destruct(std::size_t __num, std::size_t __inum) + { + _M_max = std::max(_M_max, __num); + _M_item_max = std::max(_M_item_max, __inum); + if (_M_min == 0) + { + _M_min = __num; + _M_item_min = __inum; + } + else + { + _M_min = std::min(_M_min, __num); + _M_item_min = std::min(_M_item_min, __inum); + } + _M_total += __num; + _M_item_total += __inum; + _M_count += 1; + } + + // Estimate the cost of resize/rehash. + float + __resize_cost(std::size_t __from, std::size_t) + { return __from; } + + // Call if container is resized. + void + __resize(std::size_t __from, std::size_t __to) + { + _M_cost += this->__resize_cost(__from, __to); + _M_resize += 1; + _M_max = std::max(_M_max, __to); + } + + private: + std::size_t _M_init; + std::size_t _M_max; // range of # buckets + std::size_t _M_min; + std::size_t _M_total; + std::size_t _M_item_min; // range of # items + std::size_t _M_item_max; + std::size_t _M_item_total; + std::size_t _M_count; + std::size_t _M_resize; + std::size_t _M_cost; + }; + + + /** @brief A container size instrumentation line in the stack table. */ + class __container_size_stack_info + : public __container_size_info + { + public: + __container_size_stack_info(const __container_size_info& __o) + : __container_size_info(__o) { } + }; + + + /** @brief Container size instrumentation trace producer. */ + class __trace_container_size + : public __trace_base<__container_size_info, __container_size_stack_info> + { + public: + ~__trace_container_size() { } + + __trace_container_size() + : __trace_base<__container_size_info, __container_size_stack_info>() { }; + + // Insert a new node at construct with object, callstack and initial size. + void + __insert(const __object_t __obj, __stack_t __stack, std::size_t __num) + { __add_object(__obj, __container_size_info(__stack, __num)); } + + // XXX Undefined? + void + __construct(const void* __obj, std::size_t __inum); + + // Call at destruction/clean to set container final size. + void + __destruct(const void* __obj, std::size_t __num, std::size_t __inum) + { + if (!__is_on()) + return; + + __object_t __obj_handle = static_cast<__object_t>(__obj); + + __container_size_info* __object_info = __get_object_info(__obj_handle); + if (!__object_info) + return; + + __object_info->__destruct(__num, __inum); + __retire_object(__obj_handle); + } + + // Call at resize to set resize/cost information. + void + __resize(const void* __obj, int __from, int __to) + { + if (!__is_on()) + return; + + __container_size_info* __object_info = __get_object_info(__obj); + if (!__object_info) + return; + + __object_info->__resize(__from, __to); + } + }; } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_CONTAINER_SIZE_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_hash_func.h b/libstdc++-v3/include/profile/impl/profiler_hash_func.h index 95fad192590..3e01760afba 100644 --- a/libstdc++-v3/include/profile/impl/profiler_hash_func.h +++ b/libstdc++-v3/include/profile/impl/profiler_hash_func.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,149 +37,145 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H #define _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { - -/** @brief A hash performance instrumentation line in the object table. */ -class __hashfunc_info: public __object_info_base -{ - public: - __hashfunc_info() - :_M_longest_chain(0), _M_accesses(0), _M_hops(0) {} - __hashfunc_info(const __hashfunc_info& o); - __hashfunc_info(__stack_t __stack) - : __object_info_base(__stack), - _M_longest_chain(0), _M_accesses(0), _M_hops(0){} - virtual ~__hashfunc_info() {} - - void __merge(const __hashfunc_info& __o); - void __destruct(size_t __chain, size_t __accesses, size_t __hops); - void __write(FILE* __f) const; - float __magnitude() const { return static_cast<float>(_M_hops); } - const char* __advice() const { return strdup("change hash function"); } - -private: - size_t _M_longest_chain; - size_t _M_accesses; - size_t _M_hops; -}; - -inline __hashfunc_info::__hashfunc_info(const __hashfunc_info& __o) - : __object_info_base(__o) -{ - _M_longest_chain = __o._M_longest_chain; - _M_accesses = __o._M_accesses; - _M_hops = __o._M_hops; -} - -inline void __hashfunc_info::__merge(const __hashfunc_info& __o) -{ - _M_longest_chain = __max(_M_longest_chain, __o._M_longest_chain); - _M_accesses += __o._M_accesses; - _M_hops += __o._M_hops; -} - -inline void __hashfunc_info::__destruct(size_t __chain, size_t __accesses, - size_t __hops) -{ - _M_longest_chain = __max(_M_longest_chain, __chain); - _M_accesses += __accesses; - _M_hops += __hops; -} - -/** @brief A hash performance instrumentation line in the stack table. */ -class __hashfunc_stack_info: public __hashfunc_info { - public: - __hashfunc_stack_info(const __hashfunc_info& __o) : __hashfunc_info(__o) {} -}; - -/** @brief Hash performance instrumentation producer. */ -class __trace_hash_func - : public __trace_base<__hashfunc_info, __hashfunc_stack_info> -{ - public: - __trace_hash_func(); - ~__trace_hash_func() {} - - // Insert a new node at construct with object, callstack and initial size. - void __insert(__object_t __obj, __stack_t __stack); - // Call at destruction/clean to set container final size. - void __destruct(const void* __obj, size_t __chain, - size_t __accesses, size_t __hops); -}; - -inline __trace_hash_func::__trace_hash_func() + /** @brief A hash performance instrumentation line in the object table. */ + class __hashfunc_info + : public __object_info_base + { + public: + __hashfunc_info() + : _M_longest_chain(0), _M_accesses(0), _M_hops(0) { } + + __hashfunc_info(const __hashfunc_info& __o) + : __object_info_base(__o), _M_longest_chain(__o._M_longest_chain), + _M_accesses(__o._M_accesses), _M_hops(__o._M_hops) { } + + __hashfunc_info(__stack_t __stack) + : __object_info_base(__stack), _M_longest_chain(0), + _M_accesses(0), _M_hops(0) { } + + virtual ~__hashfunc_info() { } + + void + __merge(const __hashfunc_info& __o) + { + _M_longest_chain = std::max(_M_longest_chain, __o._M_longest_chain); + _M_accesses += __o._M_accesses; + _M_hops += __o._M_hops; + } + + void + __destruct(std::size_t __chain, std::size_t __accesses, + std::size_t __hops) + { + _M_longest_chain = std::max(_M_longest_chain, __chain); + _M_accesses += __accesses; + _M_hops += __hops; + } + + void + __write(FILE* __f) const + { std::fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, + _M_accesses, _M_longest_chain); } + + float + __magnitude() const + { return static_cast<float>(_M_hops); } + + std::string + __advice() const + { return "change hash function"; } + + private: + std::size_t _M_longest_chain; + std::size_t _M_accesses; + std::size_t _M_hops; + }; + + + /** @brief A hash performance instrumentation line in the stack table. */ + class __hashfunc_stack_info + : public __hashfunc_info + { + public: + __hashfunc_stack_info(const __hashfunc_info& __o) + : __hashfunc_info(__o) { } + }; + + + /** @brief Hash performance instrumentation producer. */ + class __trace_hash_func + : public __trace_base<__hashfunc_info, __hashfunc_stack_info> + { + public: + __trace_hash_func() : __trace_base<__hashfunc_info, __hashfunc_stack_info>() -{ - __id = "hash-distr"; -} - -inline void __trace_hash_func::__insert(__object_t __obj, __stack_t __stack) -{ - __add_object(__obj, __hashfunc_info(__stack)); -} - -inline void __hashfunc_info::__write(FILE* __f) const -{ - fprintf(__f, "%Zu %Zu %Zu\n", _M_hops, _M_accesses, _M_longest_chain); -} - -inline void __trace_hash_func::__destruct(const void* __obj, size_t __chain, - size_t __accesses, size_t __hops) -{ - if (!__is_on()) return; - - // First find the item from the live objects and update the informations. - __hashfunc_info* __objs = __get_object_info(__obj); - if (!__objs) - return; - - __objs->__destruct(__chain, __accesses, __hops); - __retire_object(__obj); -} - -inline void __trace_hash_func_init() -{ - _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); -} - -inline void __trace_hash_func_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_hash_func)) { - _GLIBCXX_PROFILE_DATA(_S_hash_func)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_hash_func)->__write(__f); + { __id = "hash-distr"; } + + ~__trace_hash_func() {} + + // Insert a new node at construct with object, callstack and initial size. + void + __insert(__object_t __obj, __stack_t __stack) + { __add_object(__obj, __hashfunc_info(__stack)); } + + // Call at destruction/clean to set container final size. + void + __destruct(const void* __obj, std::size_t __chain, + std::size_t __accesses, std::size_t __hops) + { + if (!__is_on()) + return; + + // First find the item from the live objects and update the informations. + __hashfunc_info* __objs = __get_object_info(__obj); + if (!__objs) + return; + + __objs->__destruct(__chain, __accesses, __hops); + __retire_object(__obj); + } + }; + + + inline void + __trace_hash_func_init() + { _GLIBCXX_PROFILE_DATA(_S_hash_func) = new __trace_hash_func(); } + + inline void + __trace_hash_func_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_hash_func)) + { + _GLIBCXX_PROFILE_DATA(_S_hash_func)->__collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_hash_func)->__write(__f); + } } -} -inline void __trace_hash_func_construct(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_hash_func_construct(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_hash_func)->__insert(__obj, __get_stack()); -} + _GLIBCXX_PROFILE_DATA(_S_hash_func)->__insert(__obj, __get_stack()); + } -inline void __trace_hash_func_destruct(const void* __obj, size_t __chain, - size_t __accesses, size_t __hops) -{ - if (!__profcxx_init()) return; + inline void + __trace_hash_func_destruct(const void* __obj, std::size_t __chain, + std::size_t __accesses, std::size_t __hops) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj, __chain, __accesses, - __hops); -} + _GLIBCXX_PROFILE_DATA(_S_hash_func)->__destruct(__obj, __chain, + __accesses, __hops); + } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_HASH_FUNC_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h b/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h index 8248f47e75d..9d5cbc793ef 100644 --- a/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h +++ b/libstdc++-v3/include/profile/impl/profiler_hashtable_size.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,15 +37,6 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_HASHTABLE_SIZE_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" @@ -54,54 +45,60 @@ namespace __gnu_profile { - -/** @brief Hashtable size instrumentation trace producer. */ -class __trace_hashtable_size : public __trace_container_size -{ - public: - __trace_hashtable_size() : __trace_container_size() + /** @brief Hashtable size instrumentation trace producer. */ + class __trace_hashtable_size + : public __trace_container_size { - __id = "hashtable-size"; - } -}; - -inline void __trace_hashtable_size_init() -{ - _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); -} - -inline void __trace_hashtable_size_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size)) { - _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__write(__f); + public: + __trace_hashtable_size() + : __trace_container_size() + { __id = "hashtable-size"; } + }; + + inline void + __trace_hashtable_size_init() + { _GLIBCXX_PROFILE_DATA(_S_hashtable_size) = new __trace_hashtable_size(); } + + inline void + __trace_hashtable_size_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_hashtable_size)) + { + _GLIBCXX_PROFILE_DATA(_S_hashtable_size)-> + __collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__write(__f); + } } -} -inline void __trace_hashtable_size_construct(const void* __obj, size_t __num) -{ - if (!__profcxx_init()) return; + inline void + __trace_hashtable_size_construct(const void* __obj, std::size_t __num) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__insert(__obj, __get_stack(), - __num); -} + _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__insert(__obj, __get_stack(), + __num); + } -inline void __trace_hashtable_size_destruct(const void* __obj, size_t __num, - size_t __inum) -{ - if (!__profcxx_init()) return; + inline void + __trace_hashtable_size_destruct(const void* __obj, std::size_t __num, + std::size_t __inum) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__destruct(__obj, __num, __inum); -} + _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__destruct(__obj, __num, __inum); + } -inline void __trace_hashtable_size_resize(const void* __obj, size_t __from, - size_t __to) -{ - if (!__profcxx_init()) return; + inline void + __trace_hashtable_size_resize(const void* __obj, std::size_t __from, + std::size_t __to) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__resize(__obj, __from, __to); -} + _GLIBCXX_PROFILE_DATA(_S_hashtable_size)->__resize(__obj, __from, __to); + } } // namespace __gnu_profile diff --git a/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h b/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h index 073bdf27587..299a17d5af6 100644 --- a/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h +++ b/libstdc++-v3/include/profile/impl/profiler_list_to_slist.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,146 +37,179 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H #define _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { - -class __list2slist_info: public __object_info_base -{ - public: - __list2slist_info() : _M_rewind(false), _M_operations(0) {} - __list2slist_info(__stack_t __stack) - : _M_rewind(false), _M_operations(0),__object_info_base(__stack) {} - virtual ~__list2slist_info() {} - __list2slist_info(const __list2slist_info& __o) : __object_info_base(__o) - { _M_rewind = __o._M_rewind; _M_operations = __o._M_operations; } - // XXX: the magnitude should be multiplied with a constant factor F, - // where F is 1 when the malloc size class of list nodes is different - // from the malloc size class of slist nodes. When they fall into the same - // class, the only slist benefit is from having to set fewer links, so - // the factor F should be much smaller, closer to 0 than to 1. - // This could be implemented by passing the size classes in the config file. - // For now, we always assume F to be 1. - float __magnitude() const - { if (!_M_rewind) return _M_operations; else return 0; } - void __merge(const __list2slist_info& __o) {}; - void __write(FILE* __f) const; - const char* __advice() const - { return strdup("change std::list to std::forward_list"); } - void __opr_rewind() { _M_rewind = true; _M_valid = false;} - void __record_operation() { _M_operations++; } - bool __has_rewind() { return _M_rewind; } - -private: - bool _M_rewind; - size_t _M_operations; -}; - -class __list2slist_stack_info: public __list2slist_info { - public: - __list2slist_stack_info(const __list2slist_info& __o) - : __list2slist_info(__o) {} -}; - -class __trace_list_to_slist - : public __trace_base<__list2slist_info, __list2slist_stack_info> -{ - public: - ~__trace_list_to_slist() {} - __trace_list_to_slist() - : __trace_base<__list2slist_info, __list2slist_stack_info>() - { __id = "list-to-slist"; } - void __opr_rewind(const void* __obj); - void __record_operation(const void* __obj); - void __insert(const __object_t __obj, __stack_t __stack) - { __add_object(__obj, __list2slist_info(__stack)); } - void __destruct(const void* __obj); -}; - -inline void __list2slist_info::__write(FILE* __f) const -{ - fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); -} - -inline void __trace_list_to_slist::__destruct(const void* __obj) -{ - if (!__is_on()) - return; - - __list2slist_info* __res = __get_object_info(__obj); - if (!__res) - return; - - __retire_object(__obj); -} - -inline void __trace_list_to_slist_init() -{ - _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); -} - -inline void __trace_list_to_slist_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist)) { - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__write(__f); + class __list2slist_info + : public __object_info_base + { + public: + __list2slist_info() + : _M_rewind(false), _M_operations(0) { } + + __list2slist_info(__stack_t __stack) + : __object_info_base(__stack), _M_rewind(false), _M_operations(0) { } + + virtual ~__list2slist_info() { } + + __list2slist_info(const __list2slist_info& __o) + : __object_info_base(__o), _M_rewind(__o._M_rewind), + _M_operations(__o._M_operations) { } + + // XXX: the magnitude should be multiplied with a constant factor F, + // where F is 1 when the malloc size class of list nodes is different + // from the malloc size class of slist nodes. When they fall into the same + // class, the only slist benefit is from having to set fewer links, so + // the factor F should be much smaller, closer to 0 than to 1. + // This could be implemented by passing the size classes in the config + // file. For now, we always assume F to be 1. + + float + __magnitude() const + { + if (!_M_rewind) + return _M_operations; + else + return 0; + } + + void + __merge(const __list2slist_info&) { } + + void + __write(FILE* __f) const + { std::fprintf(__f, "%s\n", _M_rewind ? "invalid" : "valid"); } + + std::string + __advice() const + { return "change std::list to std::forward_list"; } + + void + __opr_rewind() + { + _M_rewind = true; + _M_valid = false; + } + + void + __record_operation() + { ++_M_operations; } + + bool + __has_rewind() + { return _M_rewind; } + + private: + bool _M_rewind; + std::size_t _M_operations; + }; + + class __list2slist_stack_info + : public __list2slist_info + { + public: + __list2slist_stack_info(const __list2slist_info& __o) + : __list2slist_info(__o) { } + }; + + class __trace_list_to_slist + : public __trace_base<__list2slist_info, __list2slist_stack_info> + { + public: + ~__trace_list_to_slist() { } + + __trace_list_to_slist() + : __trace_base<__list2slist_info, __list2slist_stack_info>() + { __id = "list-to-slist"; } + + void + __opr_rewind(const void* __obj) + { + __list2slist_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_rewind(); + } + + void + __record_operation(const void* __obj) + { + __list2slist_info* __res = __get_object_info(__obj); + if (__res) + __res->__record_operation(); + } + + void + __insert(const __object_t __obj, __stack_t __stack) + { __add_object(__obj, __list2slist_info(__stack)); } + + void + __destruct(const void* __obj) + { + if (!__is_on()) + return; + + __list2slist_info* __res = __get_object_info(__obj); + if (!__res) + return; + + __retire_object(__obj); + } + }; + + + inline void + __trace_list_to_slist_init() + { _GLIBCXX_PROFILE_DATA(_S_list_to_slist) = new __trace_list_to_slist(); } + + inline void + __trace_list_to_slist_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_list_to_slist)) + { + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)-> + __collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__write(__f); + } } -} -inline void __trace_list_to_slist::__opr_rewind(const void* __obj) -{ - __list2slist_info* __res = __get_object_info(__obj); - if (__res) - __res->__opr_rewind(); -} - -inline void __trace_list_to_slist::__record_operation(const void* __obj) -{ - __list2slist_info* __res = __get_object_info(__obj); - if (__res) - __res->__record_operation(); -} + inline void + __trace_list_to_slist_rewind(const void* __obj) + { + if (!__profcxx_init()) + return; -inline void __trace_list_to_slist_rewind(const void* __obj) -{ - if (!__profcxx_init()) return; - - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__opr_rewind(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__opr_rewind(__obj); + } -inline void __trace_list_to_slist_operation(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_slist_operation(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__record_operation(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__record_operation(__obj); + } -inline void __trace_list_to_slist_construct(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_slist_construct(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__insert(__obj, __get_stack()); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__insert(__obj, __get_stack()); + } -inline void __trace_list_to_slist_destruct(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_slist_destruct(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_slist)->__destruct(__obj); + } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_SLIST_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h b/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h index d3a3713954c..df03267bd44 100644 --- a/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h +++ b/libstdc++-v3/include/profile/impl/profiler_list_to_vector.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,277 +37,295 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H #define _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdio> -#include <cstdlib> -#include <cstring> -#else -#include <stdio.h> -#include <stdint.h> -#include <string.h> -#endif -#include <string> #include <sstream> + #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { - -/** @brief A list-to-vector instrumentation line in the object table. */ -class __list2vector_info: public __object_info_base -{ - public: - __list2vector_info() - :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), - _M_vector_cost(0), _M_valid(true), _M_max_size(0) {} - __list2vector_info(__stack_t __stack) - : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), - _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true), - _M_max_size(0) {} - virtual ~__list2vector_info() {} - __list2vector_info(const __list2vector_info& __o); - void __merge(const __list2vector_info& __o); - void __write(FILE* __f) const; - float __magnitude() const { return _M_list_cost - _M_vector_cost; } - const char* __advice() const; - size_t __shift_count() { return _M_shift_count; } - size_t __iterate() { return _M_iterate; } - float __list_cost() { return _M_list_cost; } - size_t __resize() { return _M_resize; } - void __set_list_cost(float __lc) { _M_list_cost = __lc; } - void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } - bool __is_valid() { return _M_valid; } - void __set_invalid() { _M_valid = false; } - - void __opr_insert(size_t __shift, size_t __size); - void __opr_iterate(size_t __num) { _M_iterate += __num;} - - void __resize(size_t __from, size_t __to); - -private: - size_t _M_shift_count; - size_t _M_iterate; - size_t _M_resize; - float _M_list_cost; - float _M_vector_cost; - bool _M_valid; - size_t _M_max_size; -}; - -inline __list2vector_info::__list2vector_info(const __list2vector_info& __o) - : __object_info_base(__o) -{ - _M_shift_count = __o._M_shift_count; - _M_iterate = __o._M_iterate; - _M_vector_cost = __o._M_vector_cost; - _M_list_cost = __o._M_list_cost; - _M_valid = __o._M_valid; - _M_resize = __o._M_resize; - _M_max_size = __o._M_max_size; -} - -inline const char* __list2vector_info::__advice() const { - std::stringstream __sstream; - __sstream - << "change std::list to std::vector and its initial size from 0 to " - << _M_max_size; - return strdup(__sstream.str().c_str()); -} - -inline void __list2vector_info::__merge(const __list2vector_info& __o) -{ - _M_shift_count += __o._M_shift_count; - _M_iterate += __o._M_iterate; - _M_vector_cost += __o._M_vector_cost; - _M_list_cost += __o._M_list_cost; - _M_valid &= __o._M_valid; - _M_resize += __o._M_resize; - _M_max_size = __max( _M_max_size, __o._M_max_size); -} - -inline void __list2vector_info::__opr_insert(size_t __shift, size_t __size) -{ - _M_shift_count += __shift; - _M_max_size = __max(_M_max_size, __size); -} - -inline void __list2vector_info::__resize(size_t __from, size_t __to) -{ - _M_resize += __from; -} - -class __list2vector_stack_info: public __list2vector_info { - public: - __list2vector_stack_info(const __list2vector_info& __o) - : __list2vector_info(__o) {} -}; - -class __trace_list_to_vector - : public __trace_base<__list2vector_info, __list2vector_stack_info> -{ - public: - __trace_list_to_vector(); - ~__trace_list_to_vector() {} - - // Insert a new node at construct with object, callstack and initial size. - void __insert(__object_t __obj, __stack_t __stack); - // Call at destruction/clean to set container final size. - void __destruct(const void* __obj); - - // Find the node in the live map. - __list2vector_info* __find(const void* __obj); - - // Collect cost of operations. - void __opr_insert(const void* __obj, size_t __shift, size_t __size); - void __opr_iterate(const void* __obj, size_t __num); - void __invalid_operator(const void* __obj); - void __resize(const void* __obj, size_t __from, size_t __to); - float __vector_cost(size_t __shift, size_t __iterate); - float __list_cost(size_t __shift, size_t __iterate); -}; - -inline __trace_list_to_vector::__trace_list_to_vector() + /** @brief A list-to-vector instrumentation line in the object table. */ + class __list2vector_info + : public __object_info_base + { + public: + __list2vector_info() + : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), + _M_vector_cost(0), _M_valid(true), _M_max_size(0) { } + + __list2vector_info(__stack_t __stack) + : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), + _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true), + _M_max_size(0) { } + + virtual ~__list2vector_info() { } + + __list2vector_info(const __list2vector_info& __o) + : __object_info_base(__o), _M_shift_count(__o._M_shift_count), + _M_iterate(__o._M_iterate), _M_resize(__o._M_resize), + _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost), + _M_valid(__o._M_valid), _M_max_size(__o._M_max_size) { } + + void + __merge(const __list2vector_info& __o) + { + _M_shift_count += __o._M_shift_count; + _M_iterate += __o._M_iterate; + _M_vector_cost += __o._M_vector_cost; + _M_list_cost += __o._M_list_cost; + _M_valid &= __o._M_valid; + _M_resize += __o._M_resize; + _M_max_size = std::max( _M_max_size, __o._M_max_size); + } + + void + __write(FILE* __f) const + { + std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, + _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); + } + + float + __magnitude() const + { return _M_list_cost - _M_vector_cost; } + + std::string + __advice() const + { + std::stringstream __sstream; + __sstream + << "change std::list to std::vector and its initial size from 0 to " + << _M_max_size; + return __sstream.str(); + } + + std::size_t + __shift_count() + { return _M_shift_count; } + + std::size_t + __iterate() + { return _M_iterate; } + + float + __list_cost() + { return _M_list_cost; } + + std::size_t + __resize() + { return _M_resize; } + + void + __set_list_cost(float __lc) + { _M_list_cost = __lc; } + + void + __set_vector_cost(float __vc) + { _M_vector_cost = __vc; } + + bool + __is_valid() + { return _M_valid; } + + void + __set_invalid() + { _M_valid = false; } + + void + __opr_insert(std::size_t __shift, std::size_t __size) + { + _M_shift_count += __shift; + _M_max_size = std::max(_M_max_size, __size); + } + + void + __opr_iterate(std::size_t __num) + { _M_iterate += __num;} + + void + __resize(std::size_t __from, std::size_t) + { _M_resize += __from; } + + private: + std::size_t _M_shift_count; + std::size_t _M_iterate; + std::size_t _M_resize; + float _M_list_cost; + float _M_vector_cost; + bool _M_valid; + std::size_t _M_max_size; + }; + + class __list2vector_stack_info + : public __list2vector_info + { + public: + __list2vector_stack_info(const __list2vector_info& __o) + : __list2vector_info(__o) {} + }; + + class __trace_list_to_vector + : public __trace_base<__list2vector_info, __list2vector_stack_info> + { + public: + __trace_list_to_vector() : __trace_base<__list2vector_info, __list2vector_stack_info>() -{ - __id = "list-to-vector"; -} - -inline void __trace_list_to_vector::__insert(__object_t __obj, - __stack_t __stack) -{ - __add_object(__obj, __list2vector_info(__stack)); -} - -inline void __list2vector_info::__write(FILE* __f) const -{ - fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", - _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); -} - -inline float __trace_list_to_vector::__vector_cost(size_t __shift, - size_t __iterate) -{ - // The resulting vector will use a 'reserve' method. - return __shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + - __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value; -} - -inline float __trace_list_to_vector::__list_cost(size_t __shift, - size_t __iterate) -{ - return __shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + - __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value; -} - -inline void __trace_list_to_vector::__destruct(const void* __obj) -{ - if (!__is_on()) - return; - - __list2vector_info* __res = __get_object_info(__obj); - if (!__res) - return; - - float __vc = __vector_cost(__res->__shift_count(), __res->__iterate()); - float __lc = __list_cost(__res->__shift_count(), __res->__iterate()); - __res->__set_vector_cost(__vc); - __res->__set_list_cost(__lc); - __retire_object(__obj); -} - -inline void __trace_list_to_vector::__opr_insert(const void* __obj, - size_t __shift, size_t __size) -{ - __list2vector_info* __res = __get_object_info(__obj); - if (__res) - __res->__opr_insert(__shift, __size); -} - -inline void __trace_list_to_vector::__opr_iterate(const void* __obj, - size_t __num) -{ - __list2vector_info* __res = __get_object_info(__obj); - if (__res) { - __res->__opr_iterate(__num); + { __id = "list-to-vector"; } + + ~__trace_list_to_vector() { } + + // Insert a new node at construct with object, callstack and initial size. + void + __insert(__object_t __obj, __stack_t __stack) + { __add_object(__obj, __list2vector_info(__stack)); } + + // Call at destruction/clean to set container final size. + void + __destruct(const void* __obj) + { + if (!__is_on()) + return; + + __list2vector_info* __res = __get_object_info(__obj); + if (!__res) + return; + + float __vc = __vector_cost(__res->__shift_count(), __res->__iterate()); + float __lc = __list_cost(__res->__shift_count(), __res->__iterate()); + __res->__set_vector_cost(__vc); + __res->__set_list_cost(__lc); + __retire_object(__obj); + } + + // Find the node in the live map. + __list2vector_info* __find(const void* __obj); + + // Collect cost of operations. + void + __opr_insert(const void* __obj, std::size_t __shift, std::size_t __size) + { + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_insert(__shift, __size); + } + + void + __opr_iterate(const void* __obj, std::size_t __num) + { + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_iterate(__num); + } + + void + __invalid_operator(const void* __obj) + { + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__set_invalid(); + } + + void + __resize(const void* __obj, std::size_t __from, std::size_t __to) + { + __list2vector_info* __res = __get_object_info(__obj); + if (__res) + __res->__resize(__from, __to); + } + + float + __vector_cost(std::size_t __shift, std::size_t __iterate) + { + // The resulting vector will use a 'reserve' method. + return (__shift + * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + + __iterate + * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value); + } + + float + __list_cost(std::size_t __shift, std::size_t __iterate) + { + return (__shift + * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + + __iterate + * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value); + } + }; + + + inline void + __trace_list_to_vector_init() + { _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); } + + inline void + __trace_list_to_vector_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector)) + { + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)-> + __collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__write(__f); + } } -} - -inline void __trace_list_to_vector::__invalid_operator(const void* __obj) -{ - __list2vector_info* __res = __get_object_info(__obj); - if (__res) - __res->__set_invalid(); -} -inline void __trace_list_to_vector::__resize(const void* __obj, size_t __from, - size_t __to) -{ - __list2vector_info* __res = __get_object_info(__obj); - if (__res) - __res->__resize(__from, __to); -} + inline void + __trace_list_to_vector_construct(const void* __obj) + { + if (!__profcxx_init()) + return; -inline void __trace_list_to_vector_init() -{ - _GLIBCXX_PROFILE_DATA(_S_list_to_vector) = new __trace_list_to_vector(); -} - -inline void __trace_list_to_vector_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_list_to_vector)) { - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__write(__f); + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__insert(__obj, __get_stack()); } -} - -inline void __trace_list_to_vector_construct(const void* __obj) -{ - if (!__profcxx_init()) return; - - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__insert(__obj, __get_stack()); -} -inline void __trace_list_to_vector_destruct(const void* __obj) -{ - if (!__profcxx_init()) return; - - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj); -} + inline void + __trace_list_to_vector_destruct(const void* __obj) + { + if (!__profcxx_init()) + return; -inline void __trace_list_to_vector_insert(const void* __obj, - size_t __shift, size_t __size) -{ - if (!__profcxx_init()) return; + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__destruct(__obj); + } - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_insert(__obj, __shift, - __size); -} + inline void + __trace_list_to_vector_insert(const void* __obj, + std::size_t __shift, std::size_t __size) + { + if (!__profcxx_init()) + return; + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_insert(__obj, __shift, + __size); + } -inline void __trace_list_to_vector_iterate(const void* __obj, size_t __num = 1) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_vector_iterate(const void* __obj, std::size_t __num = 1) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_iterate(__obj, __num); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__opr_iterate(__obj, __num); + } -inline void __trace_list_to_vector_invalid_operator(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_vector_invalid_operator(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__invalid_operator(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__invalid_operator(__obj); + } -inline void __trace_list_to_vector_resize(const void* __obj, - size_t __from, size_t __to) -{ - if (!__profcxx_init()) return; + inline void + __trace_list_to_vector_resize(const void* __obj, + std::size_t __from, std::size_t __to) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__resize(__obj, __from, __to); -} + _GLIBCXX_PROFILE_DATA(_S_list_to_vector)->__resize(__obj, __from, __to); + } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_LIST_TO_VECTOR_H__ */ diff --git a/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h index e715e4cd467..cc7c849a422 100644 --- a/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h +++ b/libstdc++-v3/include/profile/impl/profiler_map_to_unordered_map.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,256 +37,261 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H #define _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { - -inline int __log2(size_t __size) -{ - for (int __bit_count = sizeof(size_t) - 1; __bit_count >= 0; -- __bit_count) + inline int + __log2(std::size_t __size) { - if ((2 << __bit_count) & __size) { - return __bit_count; - } + for (int __bit_count = sizeof(std::size_t) - 1; __bit_count >= 0; + -- __bit_count) + if ((2 << __bit_count) & __size) + return __bit_count; + return 0; } - return 0; -} - -inline float __map_insert_cost(size_t __size) -{ - return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value - * static_cast<float>(__log2(__size))); -} - -inline float __map_erase_cost(size_t __size) -{ - return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value - * static_cast<float>(__log2(__size))); -} -inline float __map_find_cost(size_t __size) -{ - return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value - * static_cast<float>(__log2(__size))); -} - -/** @brief A map-to-unordered_map instrumentation line in the object table. */ -class __map2umap_info: public __object_info_base -{ - public: - __map2umap_info() - : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), - _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {} - __map2umap_info(__stack_t __stack) - : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), - _M_iterate(0), _M_map_cost(0.0), _M_umap_cost(0.0), _M_valid(true) {} - virtual ~__map2umap_info() {} - __map2umap_info(const __map2umap_info& o); - void __merge(const __map2umap_info& o); - void __write(FILE* __f) const; - float __magnitude() const { return _M_map_cost - _M_umap_cost; } - const char* __advice() const; - - void __record_insert(size_t __size, size_t __count); - void __record_erase(size_t __size, size_t __count); - void __record_find(size_t __size); - void __record_iterate(size_t __count); - void __record_invalidate(); - - private: - size_t _M_insert; - size_t _M_erase; - size_t _M_find; - size_t _M_iterate; - float _M_umap_cost; - float _M_map_cost; - bool _M_valid; -}; - -inline const char* __map2umap_info::__advice() const -{ - return strdup("change std::map to std::unordered_map"); -} - -inline __map2umap_info::__map2umap_info(const __map2umap_info& __o) - : __object_info_base(__o), - _M_insert(__o._M_insert), - _M_erase(__o._M_erase), - _M_find(__o._M_find), - _M_iterate(__o._M_iterate), - _M_map_cost(__o._M_map_cost), - _M_umap_cost(__o._M_umap_cost), - _M_valid(__o._M_valid) -{} - -inline void __map2umap_info::__merge(const __map2umap_info& __o) -{ - _M_insert += __o._M_insert; - _M_erase += __o._M_erase; - _M_find += __o._M_find; - _M_map_cost += __o._M_map_cost; - _M_umap_cost += __o._M_umap_cost; - _M_valid &= __o._M_valid; -} - -inline void __map2umap_info:: __record_insert(size_t __size, size_t __count) -{ - _M_insert += __count; - _M_map_cost += __count * __map_insert_cost(__size); - _M_umap_cost += (__count - * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value); -} - -inline void __map2umap_info:: __record_erase(size_t __size, size_t __count) -{ - _M_erase += __count; - _M_map_cost += __count * __map_erase_cost(__size); - _M_umap_cost += (__count - * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value); -} + inline float + __map_insert_cost(std::size_t __size) + { return (_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor).__value + * static_cast<float>(__log2(__size))); } + + inline float + __map_erase_cost(std::size_t __size) + { return (_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor).__value + * static_cast<float>(__log2(__size))); } + + inline float + __map_find_cost(std::size_t __size) + { return (_GLIBCXX_PROFILE_DATA(__map_find_cost_factor).__value + * static_cast<float>(__log2(__size))); } + + /** @brief A map-to-unordered_map instrumentation line in the + object table. */ + class __map2umap_info + : public __object_info_base + { + public: + __map2umap_info() + : _M_insert(0), _M_erase(0), _M_find(0), _M_iterate(0), + _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { } + + __map2umap_info(__stack_t __stack) + : __object_info_base(__stack), _M_insert(0), _M_erase(0), _M_find(0), + _M_iterate(0), _M_umap_cost(0.0), _M_map_cost(0.0), _M_valid(true) { } + + virtual ~__map2umap_info() { } + + __map2umap_info(const __map2umap_info& __o) + : __object_info_base(__o), _M_insert(__o._M_insert), + _M_erase(__o._M_erase), _M_find(__o._M_find), + _M_iterate(__o._M_iterate), _M_umap_cost(__o._M_umap_cost), + _M_map_cost(__o._M_map_cost), _M_valid(__o._M_valid) { } + + void + __merge(const __map2umap_info& __o) + { + _M_insert += __o._M_insert; + _M_erase += __o._M_erase; + _M_find += __o._M_find; + _M_umap_cost += __o._M_umap_cost; + _M_map_cost += __o._M_map_cost; + _M_valid &= __o._M_valid; + } -inline void __map2umap_info:: __record_find(size_t __size) -{ - _M_find += 1; - _M_map_cost += __map_find_cost(__size); - _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value; -} + void + __write(FILE* __f) const + { + std::fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n", + _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, + _M_umap_cost, _M_valid ? "valid" : "invalid"); + } -inline void __map2umap_info:: __record_iterate(size_t __count) -{ - _M_iterate += __count; - _M_map_cost += (__count - * _GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor).__value); - _M_umap_cost += ( - __count * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value); -} - -inline void __map2umap_info:: __record_invalidate() -{ - _M_valid = false; -} + float + __magnitude() const + { return _M_map_cost - _M_umap_cost; } + + std::string + __advice() const + { return "change std::map to std::unordered_map"; } + + void + __record_insert(std::size_t __size, std::size_t __count) + { + _M_insert += __count; + _M_map_cost += __count * __map_insert_cost(__size); + _M_umap_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor).__value); + } -inline void __map2umap_info::__write(FILE* __f) const -{ - fprintf(__f, "%Zu %Zu %Zu %Zu %.0f %.0f %s\n", - _M_insert, _M_erase, _M_find, _M_iterate, _M_map_cost, _M_umap_cost, - _M_valid ? "valid" : "invalid"); -} + void + __record_erase(std::size_t __size, std::size_t __count) + { + _M_erase += __count; + _M_map_cost += __count * __map_erase_cost(__size); + _M_umap_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor).__value); + } -/** @brief A map-to-unordered_map instrumentation line in the stack table. */ -class __map2umap_stack_info: public __map2umap_info -{ - public: - __map2umap_stack_info(const __map2umap_info& o) : __map2umap_info(o) {} -}; + void + __record_find(std::size_t __size) + { + _M_find += 1; + _M_map_cost += __map_find_cost(__size); + _M_umap_cost += _GLIBCXX_PROFILE_DATA(__umap_find_cost_factor).__value; + } -/** @brief Map-to-unordered_map instrumentation producer. */ -class __trace_map2umap - : public __trace_base<__map2umap_info, __map2umap_stack_info> -{ - public: - __trace_map2umap(); -}; + void + __record_iterate(std::size_t __count) + { + _M_iterate += __count; + _M_map_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor).__value); + _M_umap_cost + += (__count + * _GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor).__value); + } -inline __trace_map2umap::__trace_map2umap() + void + __record_invalidate() + { _M_valid = false; } + + private: + std::size_t _M_insert; + std::size_t _M_erase; + std::size_t _M_find; + std::size_t _M_iterate; + float _M_umap_cost; + float _M_map_cost; + bool _M_valid; + }; + + + /** @brief A map-to-unordered_map instrumentation line in the + stack table. */ + class __map2umap_stack_info + : public __map2umap_info + { + public: + __map2umap_stack_info(const __map2umap_info& __o) + : __map2umap_info(__o) { } + }; + + /** @brief Map-to-unordered_map instrumentation producer. */ + class __trace_map2umap + : public __trace_base<__map2umap_info, __map2umap_stack_info> + { + public: + __trace_map2umap() : __trace_base<__map2umap_info, __map2umap_stack_info>() -{ - __id = "map-to-unordered-map"; -} + { __id = "map-to-unordered-map"; } + }; -inline void __trace_map_to_unordered_map_init() -{ - _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); -} + inline void + __trace_map_to_unordered_map_init() + { _GLIBCXX_PROFILE_DATA(_S_map2umap) = new __trace_map2umap(); } -inline void __trace_map_to_unordered_map_report( - FILE* __f, __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) { - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f); + inline void + __trace_map_to_unordered_map_report(FILE* __f, + __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_map2umap)) + { + _GLIBCXX_PROFILE_DATA(_S_map2umap)->__collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_map2umap)->__write(__f); + } } -} - -inline void __trace_map_to_unordered_map_construct(const void* __obj) -{ - if (!__profcxx_init()) return; - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__add_object( - __obj, __map2umap_info(__get_stack())); -} - -inline void __trace_map_to_unordered_map_destruct(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_map_to_unordered_map_construct(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__retire_object(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_map2umap)-> + __add_object(__obj, __map2umap_info(__get_stack())); + } -inline void __trace_map_to_unordered_map_insert(const void* __obj, - size_t __size, size_t __count) -{ - if (!__profcxx_init()) return; + inline void + __trace_map_to_unordered_map_destruct(const void* __obj) + { + if (!__profcxx_init()) + return; - __map2umap_info* __info = - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + _GLIBCXX_PROFILE_DATA(_S_map2umap)->__retire_object(__obj); + } - if (__info) __info->__record_insert(__size, __count); -} + inline void + __trace_map_to_unordered_map_insert(const void* __obj, + std::size_t __size, std::size_t __count) + { + if (!__profcxx_init()) + return; -inline void __trace_map_to_unordered_map_erase(const void* __obj, - size_t __size, size_t __count) -{ - if (!__profcxx_init()) return; + __map2umap_info* __info + = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); - __map2umap_info* __info = - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + if (__info) + __info->__record_insert(__size, __count); + } - if (__info) __info->__record_erase(__size, __count); -} + inline void + __trace_map_to_unordered_map_erase(const void* __obj, + std::size_t __size, std::size_t __count) + { + if (!__profcxx_init()) + return; -inline void __trace_map_to_unordered_map_find(const void* __obj, size_t __size) -{ - if (!__profcxx_init()) return; + __map2umap_info* __info + = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); - __map2umap_info* __info = - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + if (__info) + __info->__record_erase(__size, __count); + } - if (__info) __info->__record_find(__size); -} + inline void + __trace_map_to_unordered_map_find(const void* __obj, std::size_t __size) + { + if (!__profcxx_init()) + return; -inline void __trace_map_to_unordered_map_iterate(const void* __obj, - size_t __count) -{ - if (!__profcxx_init()) return; + __map2umap_info* __info + = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); - __map2umap_info* __info = - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + if (__info) + __info->__record_find(__size); + } - if (__info) __info->__record_iterate(__count); -} + inline void + __trace_map_to_unordered_map_iterate(const void* __obj, std::size_t __count) + { + if (!__profcxx_init()) + return; + + __map2umap_info* __info + = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + + if (__info) + __info->__record_iterate(__count); + } -inline void __trace_map_to_unordered_map_invalidate(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_map_to_unordered_map_invalidate(const void* __obj) + { + if (!__profcxx_init()) + return; - __map2umap_info* __info = - _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); + __map2umap_info* __info + = _GLIBCXX_PROFILE_DATA(_S_map2umap)->__get_object_info(__obj); - if (__info) __info->__record_invalidate(); -} + if (__info) + __info->__record_invalidate(); + } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_MAP_TO_UNORDERED_MAP_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_node.h b/libstdc++-v3/include/profile/impl/profiler_node.h index 77654a8f813..d22a3e16b48 100644 --- a/libstdc++-v3/include/profile/impl/profiler_node.h +++ b/libstdc++-v3/include/profile/impl/profiler_node.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,15 +37,8 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_NODE_H #define _GLIBCXX_PROFILE_PROFILER_NODE_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdio> -#include <cstdint> -#include <cstring> -#else -#include <stdio.h> -#include <stdint.h> -#include <string.h> -#endif +#include <cstdio> // FILE, fprintf + #include <vector> #if defined _GLIBCXX_HAVE_EXECINFO_H #include <execinfo.h> @@ -53,120 +46,128 @@ namespace __gnu_profile { -typedef const void* __object_t; -typedef void* __instruction_address_t; -typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt; -typedef __stack_npt* __stack_t; + typedef const void* __object_t; + typedef void* __instruction_address_t; + typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt; + typedef __stack_npt* __stack_t; -size_t __stack_max_depth(); + std::size_t __stack_max_depth(); -inline __stack_t __get_stack() -{ + inline __stack_t + __get_stack() + { #if defined _GLIBCXX_HAVE_EXECINFO_H - size_t __max_depth = __stack_max_depth(); - if (__max_depth == 0) - return NULL; - __stack_npt __buffer(__max_depth); - int __depth = backtrace(&__buffer[0], __max_depth); - __stack_t __stack = new __stack_npt(__depth); - memcpy(&(*__stack)[0], &__buffer[0], __depth * sizeof(__object_t)); - return __stack; + std::size_t __max_depth = __stack_max_depth(); + if (__max_depth == 0) + return 0; + __stack_npt __buffer(__max_depth); + int __depth = backtrace(&__buffer[0], __max_depth); + __stack_t __stack = new __stack_npt(__depth); + __builtin_memcpy(&(*__stack)[0], &__buffer[0], + __depth * sizeof(__object_t)); + return __stack; #else - return NULL; -#endif -} - -inline __size(const __stack_t& __stack) -{ - if (!__stack) { return 0; - } else { - return __stack->size(); - } -} - -inline void __write(FILE* __f, const __stack_t __stack) -{ - if (!__stack) { - return; - } - - __stack_npt::const_iterator __it; - for (__it = __stack->begin(); __it != __stack->end(); ++__it) { - fprintf(__f, "%p ", *__it); +#endif } -} -/** @brief Hash function for summary trace using call stack as index. */ -class __stack_hash -{ - public: - size_t operator()(const __stack_t __s) const + inline std::size_t + __size(__stack_t __stack) { - if (!__s) { + if (!__stack) return 0; - } + else + return __stack->size(); + } - uintptr_t __index = 0; + // XXX + inline void + __write(FILE* __f, __stack_t __stack) + { + if (!__stack) + return; + __stack_npt::const_iterator __it; - for (__it = __s->begin(); __it != __s->end(); ++__it) { - __index += reinterpret_cast<uintptr_t>(*__it); - } - return __index; + for (__it = __stack->begin(); __it != __stack->end(); ++__it) + std::fprintf(__f, "%p ", *__it); } - bool operator() (const __stack_t __stack1, const __stack_t __stack2) const + /** @brief Hash function for summary trace using call stack as index. */ + class __stack_hash { - if (!__stack1 && !__stack2) return true; - if (!__stack1 || !__stack2) return false; - if (__stack1->size() != __stack2->size()) return false; - - size_t __byte_size = __stack1->size() * sizeof(__stack_npt::value_type); - return memcmp(&(*__stack1)[0], &(*__stack2)[0], __byte_size) == 0; - } -}; + public: + std::size_t + operator()(__stack_t __s) const + { + if (!__s) + return 0; + + __UINTPTR_TYPE__ __index = 0; + __stack_npt::const_iterator __it; + for (__it = __s->begin(); __it != __s->end(); ++__it) + __index += reinterpret_cast<__UINTPTR_TYPE__>(*__it); + return __index; + } -/** @brief Base class for a line in the object table. */ -class __object_info_base -{ - public: - __object_info_base() {} - __object_info_base(__stack_t __stack); - __object_info_base(const __object_info_base& o); - virtual ~__object_info_base() {} - bool __is_valid() const { return _M_valid; } - __stack_t __stack() const { return _M_stack; } - virtual void __write(FILE* f) const = 0; - - protected: - __stack_t _M_stack; - bool _M_valid; -}; - -inline __object_info_base::__object_info_base(__stack_t __stack) -{ - _M_stack = __stack; - _M_valid = true; -} + bool operator() (__stack_t __stack1, __stack_t __stack2) const + { + if (!__stack1 && !__stack2) + return true; + if (!__stack1 || !__stack2) + return false; + if (__stack1->size() != __stack2->size()) + return false; + + std::size_t __byte_size + = __stack1->size() * sizeof(__stack_npt::value_type); + return __builtin_memcmp(&(*__stack1)[0], &(*__stack2)[0], + __byte_size) == 0; + } + }; -inline __object_info_base::__object_info_base(const __object_info_base& __o) -{ - _M_stack = __o._M_stack; - _M_valid = __o._M_valid; -} -/** @brief Base class for a line in the stack table. */ -template<typename __object_info> -class __stack_info_base -{ - public: - __stack_info_base() {} - __stack_info_base(const __object_info& __info) = 0; - virtual ~__stack_info_base() {} - void __merge(const __object_info& __info) = 0; - virtual float __magnitude() const = 0; - virtual const char* __get_id() const = 0; -}; + /** @brief Base class for a line in the object table. */ + class __object_info_base + { + public: + __object_info_base() { } + + __object_info_base(__stack_t __stack) + : _M_stack(__stack), _M_valid(true) { } + + __object_info_base(const __object_info_base& __o) + : _M_stack(__o._M_stack), _M_valid(__o._M_valid) { } + + virtual ~__object_info_base() { } + + bool + __is_valid() const + { return _M_valid; } + + __stack_t + __stack() const + { return _M_stack; } + + virtual void __write(FILE* f) const = 0; + + protected: + __stack_t _M_stack; + bool _M_valid; + }; + + + /** @brief Base class for a line in the stack table. */ + template<typename __object_info> + class __stack_info_base + { + public: + __stack_info_base() { } + __stack_info_base(const __object_info& __info) = 0; + virtual ~__stack_info_base() {} + void __merge(const __object_info& __info) = 0; + virtual float __magnitude() const = 0; + virtual const char* __get_id() const = 0; + }; } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_NODE_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_state.h b/libstdc++-v3/include/profile/impl/profiler_state.h index 540c3e4bf0c..111b97e0eca 100644 --- a/libstdc++-v3/include/profile/impl/profiler_state.h +++ b/libstdc++-v3/include/profile/impl/profiler_state.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -39,32 +39,35 @@ namespace __gnu_profile { + enum __state_type { __ON, __OFF, __INVALID }; -enum __state_type { __ON, __OFF, __INVALID }; + _GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID); -_GLIBCXX_PROFILE_DEFINE_DATA(__state_type, __state, __INVALID); + inline bool + __turn(__state_type __s) + { return (_GLIBCXX_PROFILE_DATA(__state) + == __sync_val_compare_and_swap(&_GLIBCXX_PROFILE_DATA(__state), + __INVALID, __s)); } -inline bool __turn(__state_type __s) -{ - return (_GLIBCXX_PROFILE_DATA(__state) - == __sync_val_compare_and_swap(&_GLIBCXX_PROFILE_DATA(__state), - __INVALID, __s)); -} - -inline bool __turn_on() -{ return __turn(__ON); } + inline bool + __turn_on() + { return __turn(__ON); } -inline bool __turn_off() -{ return __turn(__OFF); } + inline bool + __turn_off() + { return __turn(__OFF); } -inline bool __is_on() -{ return _GLIBCXX_PROFILE_DATA(__state) == __ON; } + inline bool + __is_on() + { return _GLIBCXX_PROFILE_DATA(__state) == __ON; } -inline bool __is_off() -{ return _GLIBCXX_PROFILE_DATA(__state) == __OFF; } + inline bool + __is_off() + { return _GLIBCXX_PROFILE_DATA(__state) == __OFF; } -inline bool __is_invalid() -{ return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; } + inline bool + __is_invalid() + { return _GLIBCXX_PROFILE_DATA(__state) == __INVALID; } } // end namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_STATE_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_trace.h b/libstdc++-v3/include/profile/impl/profiler_trace.h index bfa8a6c3b21..1dfdd013b08 100644 --- a/libstdc++-v3/include/profile/impl/profiler_trace.h +++ b/libstdc++-v3/include/profile/impl/profiler_trace.h @@ -37,18 +37,14 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_TRACE_H #define _GLIBCXX_PROFILE_PROFILER_TRACE_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ +#include <cstdio> // fopen, fclose, fprintf, FILE #include <cerrno> -#include <cstdint> -#include <cstdio> -#include <cstdlib> +#include <cstdlib> // atof, atoi, strtol, getenv, atexit, abort + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ #define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_PR::unordered_map #include <unordered_map> #else -#include <errno.h> -#include <stdint.h> -#include <stdio.h> -#include <stdlib.h> #include <tr1/unordered_map> #define _GLIBCXX_IMPL_UNORDERED_MAP std::tr1::unordered_map #endif @@ -65,575 +61,606 @@ namespace __gnu_profile { -/** @brief Internal environment. Values can be set one of two ways: - 1. In config file "var = value". The default config file path is - libstdcxx-profile.conf. - 2. By setting process environment variables. For instance, in a Bash - shell you can set the unit cost of iterating through a map like this: - export __map_iterate_cost_factor=5.0. - If a value is set both in the input file and through an environment - variable, the environment value takes precedence. */ -typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t; -_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env); - -/** @brief Master lock. */ -_GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock); - -/** @brief Representation of a warning. */ -struct __warning_data -{ - float __magnitude; - __stack_t __context; - const char* __warning_id; - const char* __warning_message; - __warning_data() - : __magnitude(0.0), __context(NULL), __warning_id(NULL), - __warning_message(NULL) { } - __warning_data(float __m, __stack_t __c, const char* __id, - const char* __msg) - : __magnitude(__m), __context(__c), __warning_id(__id), - __warning_message(__msg) { } - bool operator<(const struct __warning_data& __other) const - { return __magnitude < __other.__magnitude; } -}; - -typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t; - -// Defined in profiler_<diagnostic name>.h. -class __trace_hash_func; -class __trace_hashtable_size; -class __trace_map2umap; -class __trace_vector_size; -class __trace_vector_to_list; -class __trace_list_to_slist; -class __trace_list_to_vector; -void __trace_vector_size_init(); -void __trace_hashtable_size_init(); -void __trace_hash_func_init(); -void __trace_vector_to_list_init(); -void __trace_list_to_slist_init(); -void __trace_list_to_vector_init(); -void __trace_map_to_unordered_map_init(); -void __trace_vector_size_report(FILE*, __warning_vector_t&); -void __trace_hashtable_size_report(FILE*, __warning_vector_t&); -void __trace_hash_func_report(FILE*, __warning_vector_t&); -void __trace_vector_to_list_report(FILE*, __warning_vector_t&); -void __trace_list_to_slist_report(FILE*, __warning_vector_t&); -void __trace_list_to_vector_report(FILE*, __warning_vector_t&); -void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); - -// Utility functions. -inline size_t __max(size_t __a, size_t __b) -{ - return __a >= __b ? __a : __b; -} + /** @brief Internal environment. Values can be set one of two ways: + 1. In config file "var = value". The default config file path is + libstdcxx-profile.conf. + 2. By setting process environment variables. For instance, in a Bash + shell you can set the unit cost of iterating through a map like this: + export __map_iterate_cost_factor=5.0. + If a value is set both in the input file and through an environment + variable, the environment value takes precedence. */ + typedef _GLIBCXX_IMPL_UNORDERED_MAP<std::string, std::string> __env_t; + + _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__env_t, __env); + + /** @brief Master lock. */ + _GLIBCXX_PROFILE_DEFINE_UNINIT_DATA(__gnu_cxx::__mutex, __global_lock); + + /** @brief Representation of a warning. */ + struct __warning_data + { + float __magnitude; + __stack_t __context; + const char* __warning_id; + std::string __warning_message; + + __warning_data() + : __magnitude(0.0), __context(0), __warning_id(0) { } + + __warning_data(float __m, __stack_t __c, const char* __id, + const std::string& __msg) + : __magnitude(__m), __context(__c), __warning_id(__id), + __warning_message(__msg) { } + + bool + operator<(const __warning_data& __other) const + { return __magnitude < __other.__magnitude; } + }; + + typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t; + + // Defined in profiler_<diagnostic name>.h. + class __trace_hash_func; + class __trace_hashtable_size; + class __trace_map2umap; + class __trace_vector_size; + class __trace_vector_to_list; + class __trace_list_to_slist; + class __trace_list_to_vector; + void __trace_vector_size_init(); + void __trace_hashtable_size_init(); + void __trace_hash_func_init(); + void __trace_vector_to_list_init(); + void __trace_list_to_slist_init(); + void __trace_list_to_vector_init(); + void __trace_map_to_unordered_map_init(); + void __trace_vector_size_report(FILE*, __warning_vector_t&); + void __trace_hashtable_size_report(FILE*, __warning_vector_t&); + void __trace_hash_func_report(FILE*, __warning_vector_t&); + void __trace_vector_to_list_report(FILE*, __warning_vector_t&); + void __trace_list_to_slist_report(FILE*, __warning_vector_t&); + void __trace_list_to_vector_report(FILE*, __warning_vector_t&); + void __trace_map_to_unordered_map_report(FILE*, __warning_vector_t&); + + struct __cost_factor + { + const char* __env_var; + float __value; + }; + + typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector; + + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, 0); + _GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, 0); + + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, + {"__vector_shift_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor, + {"__vector_iterate_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor, + {"__vector_resize_cost_factor", 1.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor, + {"__list_shift_cost_factor", 0.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor, + {"__list_iterate_cost_factor", 10.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor, + {"__list_resize_cost_factor", 0.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor, + {"__map_insert_cost_factor", 1.5}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor, + {"__map_erase_cost_factor", 1.5}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor, + {"__map_find_cost_factor", 1}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor, + {"__map_iterate_cost_factor", 2.3}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor, + {"__umap_insert_cost_factor", 12.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor, + {"__umap_erase_cost_factor", 12.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor, + {"__umap_find_cost_factor", 10.0}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor, + {"__umap_iterate_cost_factor", 1.7}); + _GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, 0); + + _GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name, + _GLIBCXX_PROFILE_TRACE_PATH_ROOT); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_warn_count, + _GLIBCXX_PROFILE_MAX_WARN_COUNT); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_stack_depth, + _GLIBCXX_PROFILE_MAX_STACK_DEPTH); + _GLIBCXX_PROFILE_DEFINE_DATA(std::size_t, _S_max_mem, + _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC); + + inline std::size_t + __stack_max_depth() + { return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); } + + inline std::size_t + __max_mem() + { return _GLIBCXX_PROFILE_DATA(_S_max_mem); } + + /** @brief Base class for all trace producers. */ + template<typename __object_info, typename __stack_info> + class __trace_base + { + public: + // Do not pick the initial size too large, as we don't know which + // diagnostics are more active. + __trace_base() + : __object_table(10000), __stack_table(10000), + __stack_table_byte_size(0), __id(0) { } + + virtual ~__trace_base() { } + + void __add_object(__object_t object, __object_info __info); + __object_info* __get_object_info(__object_t __object); + void __retire_object(__object_t __object); + void __write(FILE* __f); + void __collect_warnings(__warning_vector_t& __warnings); + + private: + __gnu_cxx::__mutex __object_table_lock; + __gnu_cxx::__mutex __stack_table_lock; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, + __object_info> __object_table_t; + typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, + __stack_hash, + __stack_hash> __stack_table_t; + __object_table_t __object_table; + __stack_table_t __stack_table; + std::size_t __stack_table_byte_size; + + protected: + const char* __id; + }; + + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __collect_warnings(__warning_vector_t& __warnings) + { + for (typename __stack_table_t::iterator __it + = __stack_table.begin(); __it != __stack_table.end(); ++__it) + __warnings.push_back(__warning_data((*__it).second.__magnitude(), + (*__it).first, __id, + (*__it).second.__advice())); + } -inline size_t __min(size_t __a, size_t __b) -{ - return __a <= __b ? __a : __b; -} + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __add_object(__object_t __object, __object_info __info) + { + if (__max_mem() == 0 + || __object_table.size() * sizeof(__object_info) <= __max_mem()) + { + this->__object_table_lock.lock(); + __object_table.insert(typename __object_table_t:: + value_type(__object, __info)); + this->__object_table_lock.unlock(); + } + } -struct __cost_factor -{ - const char* __env_var; - float __value; -}; - -typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector; - -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_map2umap*, _S_map2umap, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_size*, _S_vector_size, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_vector_to_list*, _S_vector_to_list, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_slist*, _S_list_to_slist, NULL); -_GLIBCXX_PROFILE_DEFINE_DATA(__trace_list_to_vector*, _S_list_to_vector, NULL); - -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_shift_cost_factor, - {"__vector_shift_cost_factor", 1.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_iterate_cost_factor, - {"__vector_iterate_cost_factor", 1.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __vector_resize_cost_factor, - {"__vector_resize_cost_factor", 1.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_shift_cost_factor, - {"__list_shift_cost_factor", 0.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_iterate_cost_factor, - {"__list_iterate_cost_factor", 10.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __list_resize_cost_factor, - {"__list_resize_cost_factor", 0.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_insert_cost_factor, - {"__map_insert_cost_factor", 1.5}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_erase_cost_factor, - {"__map_erase_cost_factor", 1.5}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_find_cost_factor, - {"__map_find_cost_factor", 1}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __map_iterate_cost_factor, - {"__map_iterate_cost_factor", 2.3}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_insert_cost_factor, - {"__umap_insert_cost_factor", 12.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_erase_cost_factor, - {"__umap_erase_cost_factor", 12.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_find_cost_factor, - {"__umap_find_cost_factor", 10.0}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor, __umap_iterate_cost_factor, - {"__umap_iterate_cost_factor", 1.7}); -_GLIBCXX_PROFILE_DEFINE_DATA(__cost_factor_vector*, __cost_factors, NULL); - -_GLIBCXX_PROFILE_DEFINE_DATA(const char*, _S_trace_file_name, - _GLIBCXX_PROFILE_TRACE_PATH_ROOT); -_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_warn_count, - _GLIBCXX_PROFILE_MAX_WARN_COUNT); -_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_stack_depth, - _GLIBCXX_PROFILE_MAX_STACK_DEPTH); -_GLIBCXX_PROFILE_DEFINE_DATA(size_t, _S_max_mem, - _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC); - -inline size_t __stack_max_depth() -{ - return _GLIBCXX_PROFILE_DATA(_S_max_stack_depth); -} + template<typename __object_info, typename __stack_info> + __object_info* + __trace_base<__object_info, __stack_info>:: + __get_object_info(__object_t __object) + { + // XXX: Revisit this to see if we can decrease mutex spans. + // Without this mutex, the object table could be rehashed during an + // insertion on another thread, which could result in a segfault. + this->__object_table_lock.lock(); + typename __object_table_t::iterator __object_it + = __object_table.find(__object); + + if (__object_it == __object_table.end()) + { + this->__object_table_lock.unlock(); + return 0; + } + else + { + this->__object_table_lock.unlock(); + return &__object_it->second; + } + } -inline size_t __max_mem() -{ - return _GLIBCXX_PROFILE_DATA(_S_max_mem); -} + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __retire_object(__object_t __object) + { + this->__object_table_lock.lock(); + this->__stack_table_lock.lock(); + typename __object_table_t::iterator __object_it + = __object_table.find(__object); + + if (__object_it != __object_table.end()) + { + const __object_info& __info = __object_it->second; + const __stack_t& __stack = __info.__stack(); + typename __stack_table_t::iterator __stack_it + = __stack_table.find(__stack); + + if (__stack_it == __stack_table.end()) + { + // First occurence of this call context. + if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) + { + __stack_table_byte_size + += (sizeof(__instruction_address_t) * __size(__stack) + + sizeof(__stack) + sizeof(__stack_info)); + __stack_table.insert(make_pair(__stack, + __stack_info(__info))); + } + } + else + { + // Merge object info into info summary for this call context. + __stack_it->second.__merge(__info); + delete __stack; + } + __object_table.erase(__object); + } + + this->__object_table_lock.unlock(); + this->__stack_table_lock.unlock(); + } -/** @brief Base class for all trace producers. */ -template <typename __object_info, typename __stack_info> -class __trace_base -{ - public: - __trace_base(); - virtual ~__trace_base() {} - - void __add_object(__object_t object, __object_info __info); - __object_info* __get_object_info(__object_t __object); - void __retire_object(__object_t __object); - void __write(FILE* f); - void __collect_warnings(__warning_vector_t& __warnings); - - private: - __gnu_cxx::__mutex __object_table_lock; - __gnu_cxx::__mutex __stack_table_lock; - typedef _GLIBCXX_IMPL_UNORDERED_MAP<__object_t, - __object_info> __object_table_t; - typedef _GLIBCXX_IMPL_UNORDERED_MAP<__stack_t, __stack_info, __stack_hash, - __stack_hash> __stack_table_t; - __object_table_t __object_table; - __stack_table_t __stack_table; - size_t __stack_table_byte_size; - - protected: - const char* __id; -}; - -template <typename __object_info, typename __stack_info> -void __trace_base<__object_info, __stack_info>::__collect_warnings( - __warning_vector_t& __warnings) -{ - typename __stack_table_t::iterator __i = __stack_table.begin(); - for (; __i != __stack_table.end(); ++__i) + template<typename __object_info, typename __stack_info> + void + __trace_base<__object_info, __stack_info>:: + __write(FILE* __f) + { + for (typename __stack_table_t::iterator __it + = __stack_table.begin(); __it != __stack_table.end(); ++__it) + if (__it->second.__is_valid()) + { + std::fprintf(__f, __id); + std::fprintf(__f, "|"); + __gnu_profile::__write(__f, __it->first); + std::fprintf(__f, "|"); + __it->second.__write(__f); + } + } + + inline std::size_t + __env_to_size_t(const char* __env_var, std::size_t __default_value) { - __warnings.push_back(__warning_data((*__i).second.__magnitude(), - (*__i).first, - __id, - (*__i).second.__advice())); + char* __env_value = std::getenv(__env_var); + if (__env_value) + { + errno = 0; + long __converted_value = std::strtol(__env_value, 0, 10); + if (errno || __converted_value < 0) + { + std::fprintf(stderr, + "Bad value for environment variable '%s'.\n", + __env_var); + std::abort(); + } + else + return static_cast<std::size_t>(__converted_value); + } + else + return __default_value; } -} -template <typename __object_info, typename __stack_info> -__trace_base<__object_info, __stack_info>::__trace_base() -{ - // Do not pick the initial size too large, as we don't know which diagnostics - // are more active. - __object_table.rehash(10000); - __stack_table.rehash(10000); - __stack_table_byte_size = 0; - __id = NULL; -} - -template <typename __object_info, typename __stack_info> -void __trace_base<__object_info, __stack_info>::__add_object( - __object_t __object, __object_info __info) -{ - if (__max_mem() == 0 - || __object_table.size() * sizeof(__object_info) <= __max_mem()) { - this->__object_table_lock.lock(); - __object_table.insert( - typename __object_table_t::value_type(__object, __info)); - this->__object_table_lock.unlock(); + inline void + __set_max_stack_trace_depth() + { + _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) + = __env_to_size_t(_GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, + _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)); } -} -template <typename __object_info, typename __stack_info> -__object_info* __trace_base<__object_info, __stack_info>::__get_object_info( - __object_t __object) -{ - // XXX: Revisit this to see if we can decrease mutex spans. - // Without this mutex, the object table could be rehashed during an - // insertion on another thread, which could result in a segfault. - this->__object_table_lock.lock(); - typename __object_table_t::iterator __object_it = - __object_table.find(__object); - if (__object_it == __object_table.end()){ - this->__object_table_lock.unlock(); - return NULL; - } else { - this->__object_table_lock.unlock(); - return &__object_it->second; + inline void + __set_max_mem() + { + _GLIBCXX_PROFILE_DATA(_S_max_mem) + = __env_to_size_t(_GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, + _GLIBCXX_PROFILE_DATA(_S_max_mem)); } -} -template <typename __object_info, typename __stack_info> -void __trace_base<__object_info, __stack_info>::__retire_object( - __object_t __object) -{ - this->__object_table_lock.lock(); - this->__stack_table_lock.lock(); - typename __object_table_t::iterator __object_it = - __object_table.find(__object); - if (__object_it != __object_table.end()){ - const __object_info& __info = __object_it->second; - const __stack_t& __stack = __info.__stack(); - typename __stack_table_t::iterator __stack_it = - __stack_table.find(__stack); - if (__stack_it == __stack_table.end()) { - // First occurence of this call context. - if (__max_mem() == 0 || __stack_table_byte_size < __max_mem()) { - __stack_table_byte_size += - (sizeof(__instruction_address_t) * __size(__stack) - + sizeof(__stack) + sizeof(__stack_info)); - __stack_table.insert(make_pair(__stack, __stack_info(__info))); + inline int + __log_magnitude(float __f) + { + const float __log_base = 10.0; + int __result = 0; + int __sign = 1; + + if (__f < 0) + { + __f = -__f; + __sign = -1; } - } else { - // Merge object info into info summary for this call context. - __stack_it->second.__merge(__info); - delete __stack; - } - __object_table.erase(__object); - } - this->__object_table_lock.unlock(); - this->__stack_table_lock.unlock(); -} -template <typename __object_info, typename __stack_info> -void __trace_base<__object_info, __stack_info>::__write(FILE* __f) -{ - typename __stack_table_t::iterator __it; - - for (__it = __stack_table.begin(); __it != __stack_table.end(); __it++) { - if (__it->second.__is_valid()) { - fprintf(__f, __id); - fprintf(__f, "|"); - __gnu_profile::__write(__f, __it->first); - fprintf(__f, "|"); - __it->second.__write(__f); - } - } -} - -inline size_t __env_to_size_t(const char* __env_var, size_t __default_value) -{ - char* __env_value = getenv(__env_var); - if (__env_value) { - long int __converted_value = strtol(__env_value, NULL, 10); - if (errno || __converted_value < 0) { - fprintf(stderr, "Bad value for environment variable '%s'.\n", __env_var); - abort(); - } else { - return static_cast<size_t>(__converted_value); - } - } else { - return __default_value; + while (__f > __log_base) + { + ++__result; + __f /= 10.0; + } + return __sign * __result; } -} - -inline void __set_max_stack_trace_depth() -{ - _GLIBCXX_PROFILE_DATA(_S_max_stack_depth) = __env_to_size_t( - _GLIBCXX_PROFILE_MAX_STACK_DEPTH_ENV_VAR, - _GLIBCXX_PROFILE_DATA(_S_max_stack_depth)); -} -inline void __set_max_mem() -{ - _GLIBCXX_PROFILE_DATA(_S_max_mem) = __env_to_size_t( - _GLIBCXX_PROFILE_MEM_PER_DIAGNOSTIC_ENV_VAR, - _GLIBCXX_PROFILE_DATA(_S_max_mem)); -} - -inline int __log_magnitude(float __f) -{ - const float __log_base = 10.0; - int __result = 0; - int __sign = 1; - if (__f < 0) { - __f = -__f; - __sign = -1; - } - while (__f > __log_base) { - ++__result; - __f /= 10.0; - } - return __sign * __result; -} + inline FILE* + __open_output_file(const char* __extension) + { + // The path is made of _S_trace_file_name + "." + extension. + std::size_t __root_len + = __builtin_strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); + std::size_t __ext_len = __builtin_strlen(__extension); + char* __file_name = new char[__root_len + 1 + __ext_len + 1]; + __builtin_memcpy(__file_name, + _GLIBCXX_PROFILE_DATA(_S_trace_file_name), + __root_len); + *(__file_name + __root_len) = '.'; + __builtin_memcpy(__file_name + __root_len + 1, + __extension, __ext_len + 1); + + FILE* __out_file = std::fopen(__file_name, "w"); + if (!__out_file) + { + std::fprintf(stderr, "Could not open trace file '%s'.\n", + __file_name); + std::abort(); + } -inline FILE* __open_output_file(const char* __extension) -{ - // The path is made of _S_trace_file_name + "." + extension. - size_t __root_len = strlen(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); - size_t __ext_len = strlen(__extension); - char* __file_name = new char[__root_len + 1 + __ext_len + 1]; - memcpy(__file_name, _GLIBCXX_PROFILE_DATA(_S_trace_file_name), - __root_len); - *(__file_name + __root_len) = '.'; - memcpy(__file_name + __root_len + 1, __extension, __ext_len + 1); - FILE* __out_file = fopen(__file_name, "w"); - if (__out_file) { + delete[] __file_name; return __out_file; - } else { - fprintf(stderr, "Could not open trace file '%s'.\n", __file_name); - abort(); } -} -struct __warn -{ - FILE* __file; - __warn(FILE* __f) { __file = __f; } + struct __warn + { + FILE* __file; - void operator() (const __warning_data& __info) + __warn(FILE* __f) + { __file = __f; } + + void + operator()(const __warning_data& __info) { - fprintf(__file, __info.__warning_id); - fprintf(__file, ": improvement = %d", - __log_magnitude(__info.__magnitude)); - fprintf(__file, ": call stack = "); + std::fprintf(__file, __info.__warning_id); + std::fprintf(__file, ": improvement = %d", + __log_magnitude(__info.__magnitude)); + std::fprintf(__file, ": call stack = "); __gnu_profile::__write(__file, __info.__context); - fprintf(__file, ": advice = %s\n", __info.__warning_message); - free(const_cast<void*> - (reinterpret_cast<const void*>(__info.__warning_message))); + std::fprintf(__file, ": advice = %s\n", + __info.__warning_message.c_str()); } -}; - -/** @brief Final report method, registered with @b atexit. - * - * This can also be called directly by user code, including signal handlers. - * It is protected against deadlocks by the reentrance guard in profiler.h. - * However, when called from a signal handler that triggers while within - * __gnu_profile (under the guarded zone), no output will be produced. - */ -inline void __report(void) -{ - _GLIBCXX_PROFILE_DATA(__global_lock).lock(); - - __warning_vector_t __warnings, __top_warnings; - - FILE* __raw_file = __open_output_file("raw"); - __trace_vector_size_report(__raw_file, __warnings); - __trace_hashtable_size_report(__raw_file, __warnings); - __trace_hash_func_report(__raw_file, __warnings); - __trace_vector_to_list_report(__raw_file, __warnings); - __trace_list_to_slist_report(__raw_file, __warnings); - __trace_list_to_vector_report(__raw_file, __warnings); - __trace_map_to_unordered_map_report(__raw_file, __warnings); - fclose(__raw_file); - - // Sort data by magnitude, keeping just top N. - size_t __cutoff = __min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count), - __warnings.size()); - __top_n(__warnings, __top_warnings, __cutoff); - - FILE* __warn_file = __open_output_file("txt"); - __for_each(__top_warnings.begin(), __top_warnings.end(), - __warn(__warn_file)); - fclose(__warn_file); - - _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); -} - -inline void __set_trace_path() -{ - char* __env_trace_file_name = getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); - - if (__env_trace_file_name) { - _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name; + }; + + /** @brief Final report method, registered with @b atexit. + * + * This can also be called directly by user code, including signal handlers. + * It is protected against deadlocks by the reentrance guard in profiler.h. + * However, when called from a signal handler that triggers while within + * __gnu_profile (under the guarded zone), no output will be produced. + */ + inline void + __report(void) + { + _GLIBCXX_PROFILE_DATA(__global_lock).lock(); + + __warning_vector_t __warnings, __top_warnings; + + FILE* __raw_file = __open_output_file("raw"); + __trace_vector_size_report(__raw_file, __warnings); + __trace_hashtable_size_report(__raw_file, __warnings); + __trace_hash_func_report(__raw_file, __warnings); + __trace_vector_to_list_report(__raw_file, __warnings); + __trace_list_to_slist_report(__raw_file, __warnings); + __trace_list_to_vector_report(__raw_file, __warnings); + __trace_map_to_unordered_map_report(__raw_file, __warnings); + std::fclose(__raw_file); + + // Sort data by magnitude, keeping just top N. + std::size_t __cutoff = std::min(_GLIBCXX_PROFILE_DATA(_S_max_warn_count), + __warnings.size()); + __top_n(__warnings, __top_warnings, __cutoff); + + FILE* __warn_file = __open_output_file("txt"); + __for_each(__top_warnings.begin(), __top_warnings.end(), + __warn(__warn_file)); + std::fclose(__warn_file); + + _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); } - // Make sure early that we can create the trace file. - fclose(__open_output_file("txt")); -} + inline void + __set_trace_path() + { + char* __env_trace_file_name = std::getenv(_GLIBCXX_PROFILE_TRACE_ENV_VAR); -inline void __set_max_warn_count() -{ - char* __env_max_warn_count_str = getenv( - _GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); + if (__env_trace_file_name) + _GLIBCXX_PROFILE_DATA(_S_trace_file_name) = __env_trace_file_name; - if (__env_max_warn_count_str) { - _GLIBCXX_PROFILE_DATA(_S_max_warn_count) = static_cast<size_t>( - atoi(__env_max_warn_count_str)); + // Make sure early that we can create the trace file. + std::fclose(__open_output_file("txt")); } -} -inline void -__read_cost_factors() -{ - std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); - __conf_file_name += ".conf"; + inline void + __set_max_warn_count() + { + char* __env_max_warn_count_str + = std::getenv(_GLIBCXX_PROFILE_MAX_WARN_COUNT_ENV_VAR); - std::ifstream __conf_file(__conf_file_name.c_str()); + if (__env_max_warn_count_str) + _GLIBCXX_PROFILE_DATA(_S_max_warn_count) + = static_cast<std::size_t>(std::atoi(__env_max_warn_count_str)); + } - if (__conf_file.is_open()) - { - std::string __line; + inline void + __read_cost_factors() + { + std::string __conf_file_name(_GLIBCXX_PROFILE_DATA(_S_trace_file_name)); + __conf_file_name += ".conf"; - while (std::getline(__conf_file, __line)) - { - std::string::size_type __i = __line.find_first_not_of(" \t\n\v"); + std::ifstream __conf_file(__conf_file_name.c_str()); - if (__line.length() <= 0 || __line[__i] == '#') - // Skip empty lines or comments. - continue; - } + if (__conf_file.is_open()) + { + std::string __line; - // Trim. - __line.erase(__remove(__line.begin(), __line.end(), ' '), __line.end()); - std::string::size_type __pos = __line.find("="); - std::string __factor_name = __line.substr(0, __pos); - std::string::size_type __end = __line.find_first_of(";\n"); - std::string __factor_value = __line.substr(__pos + 1, __end - __pos); + while (std::getline(__conf_file, __line)) + { + std::string::size_type __i = __line.find_first_not_of(" \t\n\v"); - _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value; - } -} + if (__line.length() <= 0 || __line[__i] == '#') + // Skip empty lines or comments. + continue; + } -struct __cost_factor_writer -{ - FILE* __file; - __cost_factor_writer(FILE* __f) : __file(__f) {} - void - operator() (const __cost_factor* __factor) - { fprintf(__file, "%s = %f\n", __factor->__env_var, __factor->__value); } -}; - -inline void -__write_cost_factors() -{ - FILE* __file = __open_output_file("conf.out"); - __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), - _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), - __cost_factor_writer(__file)); - fclose(__file); -} - -struct __cost_factor_setter -{ - void operator() (__cost_factor* __factor) + // Trim. + __line.erase(__remove(__line.begin(), __line.end(), ' '), + __line.end()); + std::string::size_type __pos = __line.find("="); + std::string __factor_name = __line.substr(0, __pos); + std::string::size_type __end = __line.find_first_of(";\n"); + std::string __factor_value = __line.substr(__pos + 1, __end - __pos); + + _GLIBCXX_PROFILE_DATA(__env)[__factor_name] = __factor_value; + } + } + + struct __cost_factor_writer + { + FILE* __file; + + __cost_factor_writer(FILE* __f) + : __file(__f) { } + + void + operator() (const __cost_factor* __factor) + { std::fprintf(__file, "%s = %f\n", __factor->__env_var, + __factor->__value); } + }; + + inline void + __write_cost_factors() + { + FILE* __file = __open_output_file("conf.out"); + __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), + _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), + __cost_factor_writer(__file)); + std::fclose(__file); + } + + struct __cost_factor_setter + { + void + operator()(__cost_factor* __factor) { // Look it up in the process environment first. - const char* __env_value = getenv(__factor->__env_var); + const char* __env_value = std::getenv(__factor->__env_var); if (!__env_value) { // Look it up in the config file. - __env_t::iterator it = _GLIBCXX_PROFILE_DATA(__env).find( - __factor->__env_var); - if (it != _GLIBCXX_PROFILE_DATA(__env).end()) - __env_value = (*it).second.c_str(); + __env_t::iterator __it + = _GLIBCXX_PROFILE_DATA(__env).find(__factor->__env_var); + if (__it != _GLIBCXX_PROFILE_DATA(__env).end()) + __env_value = (*__it).second.c_str(); } if (__env_value) - __factor->__value = atof(__env_value); + __factor->__value = std::atof(__env_value); } -}; - -inline void __set_cost_factors() -{ - _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector; - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__map_find_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor)); - _GLIBCXX_PROFILE_DATA(__cost_factors)->push_back( - &_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor)); - __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), - _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), - __cost_factor_setter()); -} - -inline void __profcxx_init_unconditional() -{ - _GLIBCXX_PROFILE_DATA(__global_lock).lock(); - - if (__is_invalid()) { - - __set_max_warn_count(); - - if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) { + }; - __turn_off(); - - } else { - - __set_max_stack_trace_depth(); - __set_max_mem(); - __set_trace_path(); - __read_cost_factors(); - __set_cost_factors(); - __write_cost_factors(); - - __trace_vector_size_init(); - __trace_hashtable_size_init(); - __trace_hash_func_init(); - __trace_vector_to_list_init(); - __trace_list_to_slist_init(); - __trace_list_to_vector_init(); - __trace_map_to_unordered_map_init(); - - atexit(__report); + inline void + __set_cost_factors() + { + _GLIBCXX_PROFILE_DATA(__cost_factors) = new __cost_factor_vector; + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_shift_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__list_resize_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_insert_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_erase_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_find_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__map_iterate_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_insert_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_erase_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_find_cost_factor)); + _GLIBCXX_PROFILE_DATA(__cost_factors)-> + push_back(&_GLIBCXX_PROFILE_DATA(__umap_iterate_cost_factor)); + __for_each(_GLIBCXX_PROFILE_DATA(__cost_factors)->begin(), + _GLIBCXX_PROFILE_DATA(__cost_factors)->end(), + __cost_factor_setter()); + } - __turn_on(); + inline void + __profcxx_init_unconditional() + { + _GLIBCXX_PROFILE_DATA(__global_lock).lock(); + + if (__is_invalid()) + { + __set_max_warn_count(); + + if (_GLIBCXX_PROFILE_DATA(_S_max_warn_count) == 0) + __turn_off(); + else + { + __set_max_stack_trace_depth(); + __set_max_mem(); + __set_trace_path(); + __read_cost_factors(); + __set_cost_factors(); + __write_cost_factors(); + + __trace_vector_size_init(); + __trace_hashtable_size_init(); + __trace_hash_func_init(); + __trace_vector_to_list_init(); + __trace_list_to_slist_init(); + __trace_list_to_vector_init(); + __trace_map_to_unordered_map_init(); + + std::atexit(__report); + + __turn_on(); + } + } - } + _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); } - _GLIBCXX_PROFILE_DATA(__global_lock).unlock(); -} + /** @brief This function must be called by each instrumentation point. + * + * The common path is inlined fully. + */ + inline bool + __profcxx_init() + { + if (__is_invalid()) + __profcxx_init_unconditional(); -/** @brief This function must be called by each instrumentation point. - * - * The common path is inlined fully. - */ -inline bool __profcxx_init(void) -{ - if (__is_invalid()) { - __profcxx_init_unconditional(); + return __is_on(); } - return __is_on(); -} - } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_TRACE_H */ diff --git a/libstdc++-v3/include/profile/impl/profiler_vector_size.h b/libstdc++-v3/include/profile/impl/profiler_vector_size.h index 8d630e4d90b..0af384f4ecb 100644 --- a/libstdc++-v3/include/profile/impl/profiler_vector_size.h +++ b/libstdc++-v3/include/profile/impl/profiler_vector_size.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,15 +37,6 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H #define _GLIBCXX_PROFILE_PROFILER_VECTOR_SIZE_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdlib> -#include <cstdio> -#include <cstring> -#else -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" @@ -54,50 +45,59 @@ namespace __gnu_profile { - -/** @brief Hashtable size instrumentation trace producer. */ -class __trace_vector_size : public __trace_container_size -{ - public: - __trace_vector_size() : __trace_container_size() { __id = "vector-size"; } -}; - -inline void __trace_vector_size_init() -{ - _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); -} - -inline void __trace_vector_size_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_vector_size)) { - _GLIBCXX_PROFILE_DATA(_S_vector_size)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_vector_size)->__write(__f); + /** @brief Hashtable size instrumentation trace producer. */ + class __trace_vector_size + : public __trace_container_size + { + public: + __trace_vector_size() + : __trace_container_size() + { __id = "vector-size"; } + }; + + inline void + __trace_vector_size_init() + { _GLIBCXX_PROFILE_DATA(_S_vector_size) = new __trace_vector_size(); } + + inline void + __trace_vector_size_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_vector_size)) + { + _GLIBCXX_PROFILE_DATA(_S_vector_size)->__collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_vector_size)->__write(__f); + } } -} -inline void __trace_vector_size_construct(const void* __obj, size_t __num) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_size_construct(const void* __obj, std::size_t __num) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(), __num); -} + _GLIBCXX_PROFILE_DATA(_S_vector_size)->__insert(__obj, __get_stack(), + __num); + } -inline void __trace_vector_size_destruct(const void* __obj, size_t __num, - size_t __inum) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_size_destruct(const void* __obj, std::size_t __num, + std::size_t __inum) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_size)->__destruct(__obj, __num, __inum); -} + _GLIBCXX_PROFILE_DATA(_S_vector_size)->__destruct(__obj, __num, __inum); + } -inline void __trace_vector_size_resize(const void* __obj, size_t __from, - size_t __to) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_size_resize(const void* __obj, std::size_t __from, + std::size_t __to) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_size)->__resize(__obj, __from, __to); -} + _GLIBCXX_PROFILE_DATA(_S_vector_size)->__resize(__obj, __from, __to); + } } // namespace __gnu_profile diff --git a/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h b/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h index d4113da8b4e..91963139bd8 100644 --- a/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h +++ b/libstdc++-v3/include/profile/impl/profiler_vector_to_list.h @@ -1,6 +1,6 @@ // -*- C++ -*- // -// Copyright (C) 2009 Free Software Foundation, Inc. +// Copyright (C) 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -37,300 +37,318 @@ #ifndef _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H #define _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H 1 -#ifdef __GXX_EXPERIMENTAL_CXX0X__ -#include <cstdio> -#include <cstdlib> -#include <cstring> -#else -#include <stdio.h> -#include <stdint.h> -#include <string.h> -#endif #include "profile/impl/profiler.h" #include "profile/impl/profiler_node.h" #include "profile/impl/profiler_trace.h" namespace __gnu_profile { - -/** @brief A vector-to-list instrumentation line in the object table. */ -class __vector2list_info: public __object_info_base -{ - public: - __vector2list_info() - :_M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), - _M_vector_cost(0), _M_valid(true) {} - __vector2list_info(__stack_t __stack) - : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), - _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) {} - virtual ~__vector2list_info() {} - __vector2list_info(const __vector2list_info& __o); - void __merge(const __vector2list_info& __o); - void __write(FILE* __f) const; - float __magnitude() const { return _M_vector_cost - _M_list_cost; } - const char* __advice() const - { return strdup("change std::vector to std::list"); } - - size_t __shift_count() { return _M_shift_count; } - size_t __iterate() { return _M_iterate; } - float __list_cost() { return _M_list_cost; } - size_t __resize() { return _M_resize; } - void __set_list_cost(float __lc) { _M_list_cost = __lc; } - void __set_vector_cost(float __vc) { _M_vector_cost = __vc; } - bool __is_valid() { return _M_valid; } - void __set_invalid() { _M_valid = false; } - - void __opr_insert(size_t __pos, size_t __num); - void __opr_iterate(size_t __num); - void __resize(size_t __from, size_t __to); - void __opr_find(size_t __size); - -private: - size_t _M_shift_count; - size_t _M_iterate; - size_t _M_resize; - float _M_list_cost; - float _M_vector_cost; - bool _M_valid; -}; - -inline __vector2list_info::__vector2list_info(const __vector2list_info& __o) - : __object_info_base(__o) -{ - _M_shift_count = __o._M_shift_count; - _M_iterate = __o._M_iterate; - _M_vector_cost = __o._M_vector_cost; - _M_list_cost = __o._M_list_cost; - _M_valid = __o._M_valid; - _M_resize = __o._M_resize; -} - -inline void __vector2list_info::__merge(const __vector2list_info& __o) -{ - _M_shift_count += __o._M_shift_count; - _M_iterate += __o._M_iterate; - _M_vector_cost += __o._M_vector_cost; - _M_list_cost += __o._M_list_cost; - _M_valid &= __o._M_valid; - _M_resize += __o._M_resize; -} - -inline void __vector2list_info::__opr_insert(size_t __pos, size_t __num) -{ - _M_shift_count += __num - __pos; -} - -inline void __vector2list_info::__resize(size_t __from, size_t __to) -{ - _M_resize += __from; -} - -inline void __vector2list_info::__opr_iterate(size_t __num) -{ - _M_iterate += __num; -} - -inline void __vector2list_info::__opr_find(size_t __size) -{ - // Use average case complexity. - _M_iterate += 3.0 / 4.0 * __size; -} - -/** @brief A vector-to-list instrumentation line in the stack table. */ -class __vector2list_stack_info: public __vector2list_info { - public: - __vector2list_stack_info(const __vector2list_info& __o) - : __vector2list_info(__o) {} -}; - -/** @brief Vector-to-list instrumentation producer. */ -class __trace_vector_to_list - : public __trace_base<__vector2list_info, __vector2list_stack_info> -{ - public: - __trace_vector_to_list(); - ~__trace_vector_to_list() {} - - // Insert a new node at construct with object, callstack and initial size. - void __insert(__object_t __obj, __stack_t __stack); - // Call at destruction/clean to set container final size. - void __destruct(const void* __obj); - - // Find the node in the live map. - __vector2list_info* __find(const void* __obj); - - // Collect cost of operations. - void __opr_insert(const void* __obj, size_t __pos, size_t __num); - void __opr_iterate(const void* __obj, size_t __num); - void __invalid_operator(const void* __obj); - void __resize(const void* __obj, size_t __from, size_t __to); - float __vector_cost(size_t __shift, size_t __iterate, size_t __resize); - float __list_cost(size_t __shift, size_t __iterate, size_t __resize); - void __opr_find(const void* __obj, size_t __size); -}; - -inline __trace_vector_to_list::__trace_vector_to_list() + /** @brief A vector-to-list instrumentation line in the object table. */ + class __vector2list_info + : public __object_info_base + { + public: + __vector2list_info() + : _M_shift_count(0), _M_iterate(0), _M_resize(0), _M_list_cost(0), + _M_vector_cost(0), _M_valid(true) { } + + __vector2list_info(__stack_t __stack) + : __object_info_base(__stack), _M_shift_count(0), _M_iterate(0), + _M_resize(0), _M_list_cost(0), _M_vector_cost(0), _M_valid(true) { } + + virtual ~__vector2list_info() { } + + __vector2list_info(const __vector2list_info& __o) + : __object_info_base(__o), _M_shift_count(__o._M_shift_count), + _M_iterate(__o._M_iterate), _M_resize(__o._M_resize), + _M_list_cost(__o._M_list_cost), _M_vector_cost(__o._M_vector_cost), + _M_valid(__o._M_valid) { } + + void + __merge(const __vector2list_info& __o) + { + _M_shift_count += __o._M_shift_count; + _M_iterate += __o._M_iterate; + _M_vector_cost += __o._M_vector_cost; + _M_list_cost += __o._M_list_cost; + _M_valid &= __o._M_valid; + _M_resize += __o._M_resize; + } + + void + __write(FILE* __f) const + { + std::fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", _M_shift_count, + _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); + } + + float + __magnitude() const + { return _M_vector_cost - _M_list_cost; } + + std::string + __advice() const + { return "change std::vector to std::list"; } + + std::size_t + __shift_count() + { return _M_shift_count; } + + std::size_t + __iterate() + { return _M_iterate; } + + float + __list_cost() + { return _M_list_cost; } + + std::size_t + __resize() + { return _M_resize; } + + void + __set_list_cost(float __lc) + { _M_list_cost = __lc; } + + void + __set_vector_cost(float __vc) + { _M_vector_cost = __vc; } + + bool + __is_valid() + { return _M_valid; } + + void + __set_invalid() + { _M_valid = false; } + + void + __opr_insert(std::size_t __pos, std::size_t __num) + { _M_shift_count += __num - __pos; } + + void + __opr_iterate(std::size_t __num) + { _M_iterate += __num; } + + void + __resize(std::size_t __from, std::size_t) + { _M_resize += __from; } + + void + __opr_find(std::size_t __size) + { + // Use average case complexity. + _M_iterate += 3.0 / 4.0 * __size; + } + + private: + std::size_t _M_shift_count; + std::size_t _M_iterate; + std::size_t _M_resize; + float _M_list_cost; + float _M_vector_cost; + bool _M_valid; + }; + + + /** @brief A vector-to-list instrumentation line in the stack table. */ + class __vector2list_stack_info + : public __vector2list_info + { + public: + __vector2list_stack_info(const __vector2list_info& __o) + : __vector2list_info(__o) { } + }; + + + /** @brief Vector-to-list instrumentation producer. */ + class __trace_vector_to_list + : public __trace_base<__vector2list_info, __vector2list_stack_info> + { + public: + __trace_vector_to_list() : __trace_base<__vector2list_info, __vector2list_stack_info>() -{ - __id = "vector-to-list"; -} - -inline void __trace_vector_to_list::__insert(__object_t __obj, - __stack_t __stack) -{ - __add_object(__obj, __vector2list_info(__stack)); -} - -inline void __vector2list_info::__write(FILE* __f) const -{ - fprintf(__f, "%Zu %Zu %Zu %.0f %.0f\n", - _M_shift_count, _M_resize, _M_iterate, _M_vector_cost, _M_list_cost); -} - -inline float __trace_vector_to_list::__vector_cost(size_t __shift, - size_t __iterate, - size_t __resize) -{ - return ( - __shift * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value - + __iterate * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value - + __resize * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value - ); -} - -inline float __trace_vector_to_list::__list_cost(size_t __shift, - size_t __iterate, - size_t __resize) -{ - return ( - __shift * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value - + __iterate * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value - + __resize * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value); -} - -inline void __trace_vector_to_list::__destruct(const void* __obj) -{ - if (!__is_on()) - return; - - __vector2list_info* __res = __get_object_info(__obj); - if (!__res) - return; - - float __vc = __vector_cost(__res->__shift_count(), __res->__iterate(), - __res->__resize()); - float __lc = __list_cost(__res->__shift_count(), __res->__iterate(), - __res->__resize()); - __res->__set_vector_cost(__vc); - __res->__set_list_cost(__lc); - - __retire_object(__obj); -} - -inline void __trace_vector_to_list::__opr_insert(const void* __obj, - size_t __pos, size_t __num) -{ - __vector2list_info* __res = __get_object_info(__obj); - if (__res) - __res->__opr_insert(__pos, __num); -} - -inline void __trace_vector_to_list::__opr_iterate(const void* __obj, - size_t __num) -{ - __vector2list_info* __res = __get_object_info(__obj); - if (__res) - __res->__opr_iterate(__num); -} - -inline void __trace_vector_to_list::__invalid_operator(const void* __obj) -{ - __vector2list_info* __res = __get_object_info(__obj); - if (__res) - __res->__set_invalid(); -} - -inline void __trace_vector_to_list::__resize(const void* __obj, size_t __from, - size_t __to) -{ - __vector2list_info* __res = __get_object_info(__obj); - if (__res) - __res->__resize(__from, __to); -} - -inline void __trace_vector_to_list::__opr_find(const void* __obj, - size_t __size) -{ - __vector2list_info* __res = __get_object_info(__obj); - if (__res) - __res->__opr_find(__size); -} - -inline void __trace_vector_to_list_init() -{ - _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); -} - -inline void __trace_vector_to_list_report(FILE* __f, - __warning_vector_t& __warnings) -{ - if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list)) { - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__collect_warnings(__warnings); - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__write(__f); + { __id = "vector-to-list"; } + + ~__trace_vector_to_list() { } + + // Insert a new node at construct with object, callstack and initial size. + void + __insert(__object_t __obj, __stack_t __stack) + { __add_object(__obj, __vector2list_info(__stack)); } + + // Call at destruction/clean to set container final size. + void + __destruct(const void* __obj) + { + if (!__is_on()) + return; + + __vector2list_info* __res = __get_object_info(__obj); + if (!__res) + return; + + float __vc = __vector_cost(__res->__shift_count(), __res->__iterate(), + __res->__resize()); + float __lc = __list_cost(__res->__shift_count(), __res->__iterate(), + __res->__resize()); + __res->__set_vector_cost(__vc); + __res->__set_list_cost(__lc); + + __retire_object(__obj); + } + + // Find the node in the live map. + // XXX Undefined?!? + __vector2list_info* __find(const void* __obj); + + // Collect cost of operations. + void + __opr_insert(const void* __obj, std::size_t __pos, std::size_t __num) + { + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_insert(__pos, __num); + } + + void + __opr_iterate(const void* __obj, std::size_t __num) + { + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_iterate(__num); + } + + void + __invalid_operator(const void* __obj) + { + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__set_invalid(); + } + + void + __resize(const void* __obj, std::size_t __from, std::size_t __to) + { + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__resize(__from, __to); + } + + float + __vector_cost(std::size_t __shift, std::size_t __iterate, + std::size_t __resize) + { + return (__shift + * _GLIBCXX_PROFILE_DATA(__vector_shift_cost_factor).__value + + __iterate + * _GLIBCXX_PROFILE_DATA(__vector_iterate_cost_factor).__value + + __resize + * _GLIBCXX_PROFILE_DATA(__vector_resize_cost_factor).__value); + } + + float + __list_cost(std::size_t __shift, std::size_t __iterate, + std::size_t __resize) + { + return (__shift + * _GLIBCXX_PROFILE_DATA(__list_shift_cost_factor).__value + + __iterate + * _GLIBCXX_PROFILE_DATA(__list_iterate_cost_factor).__value + + __resize + * _GLIBCXX_PROFILE_DATA(__list_resize_cost_factor).__value); + } + + void + __opr_find(const void* __obj, std::size_t __size) + { + __vector2list_info* __res = __get_object_info(__obj); + if (__res) + __res->__opr_find(__size); + } + }; + + + inline void + __trace_vector_to_list_init() + { _GLIBCXX_PROFILE_DATA(_S_vector_to_list) = new __trace_vector_to_list(); } + + inline void + __trace_vector_to_list_report(FILE* __f, __warning_vector_t& __warnings) + { + if (_GLIBCXX_PROFILE_DATA(_S_vector_to_list)) + { + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)-> + __collect_warnings(__warnings); + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__write(__f); + } } -} - -inline void __trace_vector_to_list_construct(const void* __obj) -{ - if (!__profcxx_init()) return; - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__insert(__obj, __get_stack()); -} + inline void + __trace_vector_to_list_construct(const void* __obj) + { + if (!__profcxx_init()) + return; -inline void __trace_vector_to_list_destruct(const void* __obj) -{ - if (!__profcxx_init()) return; + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__insert(__obj, __get_stack()); + } - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj); -} + inline void + __trace_vector_to_list_destruct(const void* __obj) + { + if (!__profcxx_init()) + return; -inline void __trace_vector_to_list_insert(const void* __obj, - size_t __pos, size_t __num) -{ - if (!__profcxx_init()) return; + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__destruct(__obj); + } - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos, __num); -} + inline void + __trace_vector_to_list_insert(const void* __obj, std::size_t __pos, + std::size_t __num) + { + if (!__profcxx_init()) + return; + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_insert(__obj, __pos, + __num); + } -inline void __trace_vector_to_list_iterate(const void* __obj, size_t __num = 1) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_to_list_iterate(const void* __obj, std::size_t __num = 1) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_iterate(__obj, __num); -} + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_iterate(__obj, __num); + } -inline void __trace_vector_to_list_invalid_operator(const void* __obj) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_to_list_invalid_operator(const void* __obj) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__invalid_operator(__obj); -} + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__invalid_operator(__obj); + } -inline void __trace_vector_to_list_resize(const void* __obj, - size_t __from, size_t __to) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_to_list_resize(const void* __obj, std::size_t __from, + std::size_t __to) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__resize(__obj, __from, __to); -} + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__resize(__obj, __from, __to); + } -inline void __trace_vector_to_list_find(const void* __obj, size_t __size) -{ - if (!__profcxx_init()) return; + inline void + __trace_vector_to_list_find(const void* __obj, std::size_t __size) + { + if (!__profcxx_init()) + return; - _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_find(__obj, __size); -} + _GLIBCXX_PROFILE_DATA(_S_vector_to_list)->__opr_find(__obj, __size); + } } // namespace __gnu_profile #endif /* _GLIBCXX_PROFILE_PROFILER_VECTOR_TO_LIST_H */ diff --git a/libstdc++-v3/include/profile/iterator_tracker.h b/libstdc++-v3/include/profile/iterator_tracker.h index 0febb9babae..faad9e57279 100644 --- a/libstdc++-v3/include/profile/iterator_tracker.h +++ b/libstdc++-v3/include/profile/iterator_tracker.h @@ -36,266 +36,239 @@ namespace std namespace __profile { -template<typename _Iterator, typename _Sequence> -class __iterator_tracker -{ - typedef __iterator_tracker _Self; - // The underlying iterator - _Iterator _M_current; - // The underlying data structure - const _Sequence* _M_ds; - typedef std::iterator_traits<_Iterator> _Traits; - - public: - typedef _Iterator _Base_iterator; - typedef typename _Traits::iterator_category iterator_category; - typedef typename _Traits::value_type value_type; - typedef typename _Traits::difference_type difference_type; - typedef typename _Traits::reference reference; - typedef typename _Traits::pointer pointer; - - __iterator_tracker() : _M_current(), _M_ds(0) { } - __iterator_tracker(const _Iterator& __i, const _Sequence* seq) - : _M_current(__i), _M_ds(seq) { } - __iterator_tracker(const __iterator_tracker& __x) - : _M_current(__x._M_current), _M_ds(__x._M_ds) { } - template<typename _MutableIterator> - __iterator_tracker(const __iterator_tracker<_MutableIterator, typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator, typename _Sequence::iterator::_Base_iterator>::__value), _Sequence>::__type>& __x) - : _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { } - - _Iterator - base() const { return _M_current; } - /** - * @brief Conversion to underlying non-debug iterator to allow - * better interaction with non-profile containers. - */ - operator _Iterator() const { return _M_current; } - - pointer - operator->() const { return &*_M_current; } - - __iterator_tracker& - operator++() - { - _M_ds->_M_profile_iterate(); - ++_M_current; - return *this; - } - - __iterator_tracker& - operator++(int) - { - _M_ds->_M_profile_iterate(); - __iterator_tracker __tmp(*this); - ++_M_current; - return __tmp; - } - - __iterator_tracker& - operator--() - { - _M_ds->_M_profile_iterate(1); - --_M_current; - return *this; - } - - __iterator_tracker& - operator--(int) - { - _M_ds->_M_profile_iterate(1); - __iterator_tracker __tmp(*this); - --_M_current; - return __tmp; - } - - __iterator_tracker& - operator=(const __iterator_tracker& __x) - { - _M_current = __x._M_current; - return *this; - } - - reference - operator*() const - { - return *_M_current; - } - - // ------ Random access iterator requirements ------ - reference - operator[](const difference_type& __n) const - { - return _M_current[__n]; - } - - __iterator_tracker& - operator+=(const difference_type& __n) - { - _M_current += __n; - return *this; - } - - __iterator_tracker - operator+(const difference_type& __n) const - { - __iterator_tracker __tmp(*this); - __tmp += __n; - return __tmp; - } - - __iterator_tracker& - operator-=(const difference_type& __n) - { - _M_current += -__n; - return *this; - } - - __iterator_tracker - operator-(const difference_type& __n) const - { - __iterator_tracker __tmp(*this); - __tmp -= __n; - return __tmp; - } - - void - _M_find() - { - _M_ds->_M_profile_find(); - } - - const _Sequence* - _M_get_sequence() const - { - return static_cast<const _Sequence*>(_M_ds); - } -}; - -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() == __rhs.base(); -} + template<typename _Iterator, typename _Sequence> + class __iterator_tracker + { + typedef __iterator_tracker _Self; -template<typename _Iterator, typename _Sequence> -inline bool -operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() == __rhs.base(); -} + // The underlying iterator + _Iterator _M_current; -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() != __rhs.base(); -} + // The underlying data structure + const _Sequence* _M_ds; + typedef std::iterator_traits<_Iterator> _Traits; -template<typename _Iterator, typename _Sequence> -inline bool -operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() != __rhs.base(); -} + public: + typedef _Iterator _Base_iterator; + typedef typename _Traits::iterator_category iterator_category; + typedef typename _Traits::value_type value_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::reference reference; + typedef typename _Traits::pointer pointer; -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() < __rhs.base(); -} + __iterator_tracker() + : _M_current(), _M_ds(0) { } -template<typename _Iterator, typename _Sequence> -inline bool -operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() < __rhs.base(); -} + __iterator_tracker(const _Iterator& __i, const _Sequence* __seq) + : _M_current(__i), _M_ds(__seq) { } -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() <= __rhs.base(); -} + __iterator_tracker(const __iterator_tracker& __x) + : _M_current(__x._M_current), _M_ds(__x._M_ds) { } -template<typename _Iterator, typename _Sequence> -inline bool -operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() <= __rhs.base(); -} + template<typename _MutableIterator> + __iterator_tracker(const __iterator_tracker<_MutableIterator, + typename __gnu_cxx::__enable_if + <(std::__are_same<_MutableIterator, typename + _Sequence::iterator::_Base_iterator>::__value), + _Sequence>::__type>& __x) + : _M_current(__x.base()), _M_ds(__x._M_get_sequence()) { } + + _Iterator + base() const { return _M_current; } + + /** + * @brief Conversion to underlying non-debug iterator to allow + * better interaction with non-profile containers. + */ + operator _Iterator() const { return _M_current; } + + pointer + operator->() const { return &*_M_current; } + + __iterator_tracker& + operator++() + { + _M_ds->_M_profile_iterate(); + ++_M_current; + return *this; + } + + __iterator_tracker& + operator++(int) + { + _M_ds->_M_profile_iterate(); + __iterator_tracker __tmp(*this); + ++_M_current; + return __tmp; + } + + __iterator_tracker& + operator--() + { + _M_ds->_M_profile_iterate(1); + --_M_current; + return *this; + } + + __iterator_tracker& + operator--(int) + { + _M_ds->_M_profile_iterate(1); + __iterator_tracker __tmp(*this); + --_M_current; + return __tmp; + } + + __iterator_tracker& + operator=(const __iterator_tracker& __x) + { + _M_current = __x._M_current; + return *this; + } + + reference + operator*() const + { return *_M_current; } + + // ------ Random access iterator requirements ------ + reference + operator[](const difference_type& __n) const + { return _M_current[__n]; } + + __iterator_tracker& + operator+=(const difference_type& __n) + { + _M_current += __n; + return *this; + } + + __iterator_tracker + operator+(const difference_type& __n) const + { + __iterator_tracker __tmp(*this); + __tmp += __n; + return __tmp; + } + + __iterator_tracker& + operator-=(const difference_type& __n) + { + _M_current += -__n; + return *this; + } + + __iterator_tracker + operator-(const difference_type& __n) const + { + __iterator_tracker __tmp(*this); + __tmp -= __n; + return __tmp; + } + + void + _M_find() + { _M_ds->_M_profile_find(); } + + const _Sequence* + _M_get_sequence() const + { return static_cast<const _Sequence*>(_M_ds); } + }; -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() > __rhs.base(); -} + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline bool + operator==(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() == __rhs.base(); } -template<typename _Iterator, typename _Sequence> -inline bool -operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() > __rhs.base(); -} + template<typename _Iterator, typename _Sequence> + inline bool + operator==(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() == __rhs.base(); } -template<typename _IteratorL, typename _IteratorR, typename _Sequence> -inline bool -operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() >= __rhs.base(); -} + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline bool + operator!=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() != __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline bool + operator!=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() != __rhs.base(); } -template<typename _Iterator, typename _Sequence> -inline bool -operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() >= __rhs.base(); -} + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline bool + operator<(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() < __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline bool + operator<(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() < __rhs.base(); } -// _GLIBCXX_RESOLVE_LIB_DEFECTS -// According to the resolution of DR179 not only the various comparison -// operators but also operator- must accept mixed iterator/const_iterator -// parameters. template<typename _IteratorL, typename _IteratorR, typename _Sequence> - inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type - operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, - const __iterator_tracker<_IteratorR, _Sequence>& __rhs) -{ - return __lhs.base() - __rhs.base(); -} + inline bool + operator<=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() <= __rhs.base(); } -template<typename _Iterator, typename _Sequence> -inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type -operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs, - const __iterator_tracker<_Iterator, _Sequence>& __rhs) -{ - return __lhs.base() - __rhs.base(); -} - -template<typename _Iterator, typename _Sequence> -inline __iterator_tracker<_Iterator, _Sequence> -operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type - __n, - const __iterator_tracker<_Iterator, _Sequence>& __i) -{ - return __i + __n; -} - + template<typename _Iterator, typename _Sequence> + inline bool + operator<=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() <= __rhs.base(); } + + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline bool + operator>(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() > __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline bool + operator>(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() > __rhs.base(); } + + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline bool + operator>=(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() >= __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline bool + operator>=(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() >= __rhs.base(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // According to the resolution of DR179 not only the various comparison + // operators but also operator- must accept mixed iterator/const_iterator + // parameters. + template<typename _IteratorL, typename _IteratorR, typename _Sequence> + inline typename __iterator_tracker<_IteratorL, _Sequence>::difference_type + operator-(const __iterator_tracker<_IteratorL, _Sequence>& __lhs, + const __iterator_tracker<_IteratorR, _Sequence>& __rhs) + { return __lhs.base() - __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline typename __iterator_tracker<_Iterator, _Sequence>::difference_type + operator-(const __iterator_tracker<_Iterator, _Sequence>& __lhs, + const __iterator_tracker<_Iterator, _Sequence>& __rhs) + { return __lhs.base() - __rhs.base(); } + + template<typename _Iterator, typename _Sequence> + inline __iterator_tracker<_Iterator, _Sequence> + operator+(typename __iterator_tracker<_Iterator,_Sequence>::difference_type + __n, + const __iterator_tracker<_Iterator, _Sequence>& __i) + { return __i + __n; } + } // namespace __profile } // namespace std #endif diff --git a/libstdc++-v3/include/profile/list b/libstdc++-v3/include/profile/list index 01edd2919f6..e5468c44071 100644 --- a/libstdc++-v3/include/profile/list +++ b/libstdc++-v3/include/profile/list @@ -64,20 +64,40 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> > typedef std::reverse_iterator<const_iterator> const_reverse_iterator; // 23.2.2.1 construct/copy/destroy: - explicit list(const _Allocator& __a = _Allocator()) + explicit + list(const _Allocator& __a = _Allocator()) : _Base(__a) { __profcxx_list_construct(this); // list2slist __profcxx_list_construct2(this); // list2vector } - explicit list(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + list(size_type __n) + : _Base(__n) + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + } + + list(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) + { + __profcxx_list_construct(this); + __profcxx_list_construct2(this); + } +#else + explicit + list(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { __profcxx_list_construct(this); __profcxx_list_construct2(this); } +#endif template<class _InputIterator> list(_InputIterator __first, _InputIterator __last, @@ -229,9 +249,19 @@ template<typename _Tp, typename _Allocator = std::allocator<_Tp> > using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { _Base::resize(__sz); } + + void + resize(size_type __sz, const _Tp& __c) + { _Base::resize(__sz, __c); } +#else void resize(size_type __sz, _Tp __c = _Tp()) { _Base::resize(__sz, __c); } +#endif // element access: reference diff --git a/libstdc++-v3/include/profile/map.h b/libstdc++-v3/include/profile/map.h index fc698a9fa84..8a3a8e45c8f 100644 --- a/libstdc++-v3/include/profile/map.h +++ b/libstdc++-v3/include/profile/map.h @@ -71,29 +71,26 @@ namespace __profile using _Base::value_compare; // 23.3.1.1 construct/copy/destroy: - explicit map(const _Compare& __comp = _Compare(), - const _Allocator& __a = _Allocator()) - : _Base(__comp, __a) { - __profcxx_map_to_unordered_map_construct(this); - } + explicit + map(const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) + { __profcxx_map_to_unordered_map_construct(this); } template<typename _InputIterator> map(_InputIterator __first, _InputIterator __last, const _Compare& __comp = _Compare(), const _Allocator& __a = _Allocator()) - : _Base(__first, __last, __comp, __a) { - __profcxx_map_to_unordered_map_construct(this); - } + : _Base(__first, __last, __comp, __a) + { __profcxx_map_to_unordered_map_construct(this); } map(const map& __x) - : _Base(__x) { - __profcxx_map_to_unordered_map_construct(this); - } + : _Base(__x) + { __profcxx_map_to_unordered_map_construct(this); } map(const _Base& __x) - : _Base(__x) { - __profcxx_map_to_unordered_map_construct(this); - } + : _Base(__x) + { __profcxx_map_to_unordered_map_construct(this); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ map(map&& __x) @@ -106,9 +103,8 @@ namespace __profile : _Base(__l, __c, __a) { } #endif - ~map() { - __profcxx_map_to_unordered_map_destruct(this); - } + ~map() + { __profcxx_map_to_unordered_map_destruct(this); } map& operator=(const map& __x) diff --git a/libstdc++-v3/include/profile/vector b/libstdc++-v3/include/profile/vector index ad74137583c..e6c32a38aec 100644 --- a/libstdc++-v3/include/profile/vector +++ b/libstdc++-v3/include/profile/vector @@ -76,20 +76,40 @@ namespace __profile _M_base() const { return *this; } // 23.2.4.1 construct/copy/destroy: - explicit vector(const _Allocator& __a = _Allocator()) + explicit + vector(const _Allocator& __a = _Allocator()) : _Base(__a) { __profcxx_vector_construct(this, this->capacity()); __profcxx_vector_construct2(this); } - explicit vector(size_type __n, const _Tp& __value = _Tp(), - const _Allocator& __a = _Allocator()) +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + explicit + vector(size_type __n) + : _Base(__n) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } + + vector(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) : _Base(__n, __value, __a) { __profcxx_vector_construct(this, this->capacity()); __profcxx_vector_construct2(this); } +#else + explicit + vector(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) + { + __profcxx_vector_construct(this, this->capacity()); + __profcxx_vector_construct2(this); + } +#endif template<class _InputIterator> vector(_InputIterator __first, _InputIterator __last, @@ -218,6 +238,23 @@ namespace __profile using _Base::size; using _Base::max_size; +#ifdef __GXX_EXPERIMENTAL_CXX0X__ + void + resize(size_type __sz) + { + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this, this->capacity(), __sz); + _Base::resize(__sz); + } + + void + resize(size_type __sz, const _Tp& __c) + { + __profcxx_vector_invalid_operator(this); + _M_profile_resize(this, this->capacity(), __sz); + _Base::resize(__sz, __c); + } +#else void resize(size_type __sz, _Tp __c = _Tp()) { @@ -225,6 +262,7 @@ namespace __profile _M_profile_resize(this, this->capacity(), __sz); _Base::resize(__sz, __c); } +#endif #ifdef __GXX_EXPERIMENTAL_CXX0X__ using _Base::shrink_to_fit; diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index 5ef52f3763f..d4f685ced54 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -38,8 +38,8 @@ # include <bits/c++0x_warning.h> #endif +#include <bits/c++config.h> #include <bits/atomic_base.h> -#include <cstddef> _GLIBCXX_BEGIN_NAMESPACE(std) diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset index b23b51a78fe..32ca0917062 100644 --- a/libstdc++-v3/include/std/bitset +++ b/libstdc++-v3/include/std/bitset @@ -45,7 +45,6 @@ #pragma GCC system_header -#include <cstddef> // For size_t #include <string> #include <bits/functexcept.h> // For invalid_argument, out_of_range, // overflow_error diff --git a/libstdc++-v3/include/std/fstream b/libstdc++-v3/include/std/fstream index 9aa4f1ab10f..00690bee938 100644 --- a/libstdc++-v3/include/std/fstream +++ b/libstdc++-v3/include/std/fstream @@ -397,7 +397,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) if (__testout && __off == 0 && _M_buf_size > 1 ) this->setp(_M_buf, _M_buf + _M_buf_size - 1); else - this->setp(NULL, NULL); + this->setp(0, 0); } }; @@ -795,7 +795,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out) - : __iostream_type(NULL), _M_filebuf() + : __iostream_type(0), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); @@ -810,7 +810,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) explicit basic_fstream(const std::string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out) - : __iostream_type(NULL), _M_filebuf() + : __iostream_type(0), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional index b6cc6d5e072..752e78325a3 100644 --- a/libstdc++-v3/include/std/functional +++ b/libstdc++-v3/include/std/functional @@ -1384,13 +1384,6 @@ namespace std class bad_function_call : public std::exception { }; /** - * The integral constant expression 0 can be converted into a - * pointer to this type. It is used by the function template to - * accept NULL pointers. - */ - struct _M_clear_type; - - /** * Trait identifying "location-invariant" types, meaning that the * address of the object (or any of its members) will not escape. * Also implies a trivial copy constructor and assignment operator. @@ -1797,10 +1790,10 @@ namespace std function() : _Function_base() { } /** - * @brief Default construct creates an empty function call wrapper. + * @brief Creates an empty function call wrapper. * @post @c !(bool)*this */ - function(_M_clear_type*) : _Function_base() { } + function(nullptr_t) : _Function_base() { } /** * @brief %Function copy constructor. @@ -1893,7 +1886,7 @@ namespace std * The target of @c *this is deallocated, leaving it empty. */ function& - operator=(_M_clear_type*) + operator=(nullptr_t) { if (_M_manager) { @@ -2139,13 +2132,13 @@ namespace std */ template<typename _Res, typename... _Args> inline bool - operator==(const function<_Res(_Args...)>& __f, _M_clear_type*) + operator==(const function<_Res(_Args...)>& __f, nullptr_t) { return !static_cast<bool>(__f); } /// @overload template<typename _Res, typename... _Args> inline bool - operator==(_M_clear_type*, const function<_Res(_Args...)>& __f) + operator==(nullptr_t, const function<_Res(_Args...)>& __f) { return !static_cast<bool>(__f); } /** @@ -2157,13 +2150,13 @@ namespace std */ template<typename _Res, typename... _Args> inline bool - operator!=(const function<_Res(_Args...)>& __f, _M_clear_type*) + operator!=(const function<_Res(_Args...)>& __f, nullptr_t) { return static_cast<bool>(__f); } /// @overload template<typename _Res, typename... _Args> inline bool - operator!=(_M_clear_type*, const function<_Res(_Args...)>& __f) + operator!=(nullptr_t, const function<_Res(_Args...)>& __f) { return static_cast<bool>(__f); } // [20.7.15.2.7] specialized algorithms diff --git a/libstdc++-v3/include/std/iterator b/libstdc++-v3/include/std/iterator index a15bdf9744c..5395106ae6a 100644 --- a/libstdc++-v3/include/std/iterator +++ b/libstdc++-v3/include/std/iterator @@ -1,6 +1,6 @@ // <iterator> -*- C++ -*- -// Copyright (C) 2001, 2002, 2009 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2009, 2010 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -58,7 +58,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #include <bits/stl_iterator_base_types.h> #include <bits/stl_iterator_base_funcs.h> #include <bits/stl_iterator.h> diff --git a/libstdc++-v3/include/std/mutex b/libstdc++-v3/include/std/mutex index be435cd38e5..b236f0db91d 100644 --- a/libstdc++-v3/include/std/mutex +++ b/libstdc++-v3/include/std/mutex @@ -37,7 +37,6 @@ #else #include <tuple> -#include <cstddef> #include <chrono> #include <exception> #include <type_traits> diff --git a/libstdc++-v3/include/std/regex b/libstdc++-v3/include/std/regex index e8238299b22..95ad4239459 100644 --- a/libstdc++-v3/include/std/regex +++ b/libstdc++-v3/include/std/regex @@ -35,33 +35,30 @@ # include <bits/c++0x_warning.h> #else -#if defined(_GLIBCXX_INCLUDE_AS_TR1) -# error C++0x header cannot be included from TR1 header -#endif - #include <algorithm> #include <bitset> +#include <functional> +#ifdef _GLIBCXX_DEBUG +# include <iosfwd> +#endif #include <iterator> #include <locale> +#include <memory> +#include <set> +#include <sstream> +#include <stack> #include <stdexcept> #include <string> -#include <vector> #include <utility> -#include <sstream> +#include <vector> -#if defined(_GLIBCXX_INCLUDE_AS_CXX0X) -# include <tr1_impl/regex> -#else -# define _GLIBCXX_INCLUDE_AS_CXX0X -# define _GLIBCXX_BEGIN_NAMESPACE_TR1 -# define _GLIBCXX_END_NAMESPACE_TR1 -# define _GLIBCXX_TR1 -# include <tr1_impl/regex> -# undef _GLIBCXX_TR1 -# undef _GLIBCXX_END_NAMESPACE_TR1 -# undef _GLIBCXX_BEGIN_NAMESPACE_TR1 -# undef _GLIBCXX_INCLUDE_AS_CXX0X -#endif +#include <bits/regex_constants.h> +#include <bits/regex_error.h> +#include <bits/regex_cursor.h> +#include <bits/regex_nfa.h> +#include <bits/regex_compiler.h> +#include <bits/regex_grep_matcher.h> +#include <bits/regex.h> #endif // __GXX_EXPERIMENTAL_CXX0X__ diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread index 470f2c0f35c..c348c76bc40 100644 --- a/libstdc++-v3/include/std/thread +++ b/libstdc++-v3/include/std/thread @@ -40,7 +40,6 @@ #include <memory> #include <mutex> #include <condition_variable> -#include <cstddef> #include <bits/functexcept.h> #include <bits/functional_hash.h> #include <bits/gthr.h> diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index f9aa14f2057..8b2252e3686 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -238,8 +238,7 @@ namespace std tuple(_UElements&&... __elements) : _Inherited(std::forward<_UElements>(__elements)...) { } - tuple(const tuple& __in) - : _Inherited(static_cast<const _Inherited&>(__in)) { } + tuple(const tuple&) = default; tuple(tuple&& __in) : _Inherited(static_cast<_Inherited&&>(__in)) { } @@ -321,8 +320,7 @@ namespace std tuple(_U1&& __a1, _U2&& __a2) : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - tuple(const tuple& __in) - : _Inherited(static_cast<const _Inherited&>(__in)) { } + tuple(const tuple&) = default; tuple(tuple&& __in) : _Inherited(static_cast<_Inherited&&>(__in)) { } @@ -341,7 +339,8 @@ namespace std template<typename _U1, typename _U2> tuple(pair<_U1, _U2>&& __in) - : _Inherited(std::move(__in.first), std::move(__in.second)) { } + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } tuple& operator=(const tuple& __in) @@ -690,16 +689,12 @@ namespace std struct _Swallow_assign { template<class _Tp> - _Swallow_assign& - operator=(const _Tp&) + const _Swallow_assign& + operator=(const _Tp&) const { return *this; } }; - // TODO: Put this in some kind of shared file. - namespace - { - _Swallow_assign ignore; - }; // anonymous namespace + const _Swallow_assign ignore{}; /** * Stores a tuple of indices. Used by bind() to extract the elements diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 9831851c4a5..42a462e53a5 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -39,7 +39,7 @@ # error C++0x header cannot be included from TR1 header #endif -#include <cstddef> +#include <bits/c++config.h> #if defined(_GLIBCXX_INCLUDE_AS_CXX0X) # include <tr1_impl/type_traits> @@ -193,7 +193,7 @@ namespace std { }; template<typename _Tp> - typename add_rvalue_reference<_Tp>::type declval(); + typename add_rvalue_reference<_Tp>::type declval() noexcept; template<typename _Tp, typename... _Args> class __is_constructible_helper @@ -234,6 +234,28 @@ namespace std _Args...>::__value> { }; + template<bool, typename _Tp, typename... _Args> + struct __is_nt_constructible_helper + { static const bool __value = false; }; + + template<typename _Tp, typename... _Args> + struct __is_nt_constructible_helper<true, _Tp, _Args...> + { static const bool __value = noexcept(_Tp(declval<_Args>()...)); }; + + template<typename _Tp, typename _Arg> + struct __is_nt_constructible_helper<true, _Tp, _Arg> + { + static const bool __value = noexcept(static_cast<_Tp>(declval<_Arg>())); + }; + + /// is_nothrow_constructible + template<typename _Tp, typename... _Args> + struct is_nothrow_constructible + : public integral_constant<bool, + __is_nt_constructible_helper<is_constructible<_Tp, _Args...>::value, + _Tp, _Args...>::__value> + { }; + /// has_trivial_default_constructor template<typename _Tp> struct has_trivial_default_constructor @@ -246,9 +268,9 @@ namespace std : public integral_constant<bool, __has_trivial_copy(_Tp)> { }; - /// has_trivial_assign + /// has_trivial_copy_assign template<typename _Tp> - struct has_trivial_assign + struct has_trivial_copy_assign : public integral_constant<bool, __has_trivial_assign(_Tp)> { }; @@ -270,9 +292,9 @@ namespace std : public integral_constant<bool, __has_nothrow_copy(_Tp)> { }; - /// has_nothrow_assign + /// has_nothrow_copy_assign template<typename _Tp> - struct has_nothrow_assign + struct has_nothrow_copy_assign : public integral_constant<bool, __has_nothrow_assign(_Tp)> { }; @@ -649,7 +671,7 @@ namespace std template<typename _Tp> inline typename add_rvalue_reference<_Tp>::type - declval() + declval() noexcept { static_assert(__declval_protector<_Tp>::__stop, "declval() must not be used!"); diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray index fa92751791d..f15ac92b0bf 100644 --- a/libstdc++-v3/include/std/valarray +++ b/libstdc++-v3/include/std/valarray @@ -1,7 +1,7 @@ // The template and inlines for the -*- C++ -*- valarray class. // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, -// 2006, 2007, 2008, 2009 +// 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -36,7 +36,6 @@ #pragma GCC system_header #include <bits/c++config.h> -#include <cstddef> #include <cmath> #include <algorithm> #include <debug/debug.h> diff --git a/libstdc++-v3/include/tr1/type_traits b/libstdc++-v3/include/tr1/type_traits index fe28f84785a..33083ff9c73 100644 --- a/libstdc++-v3/include/tr1/type_traits +++ b/libstdc++-v3/include/tr1/type_traits @@ -1,6 +1,7 @@ // TR1 type_traits -*- C++ -*- -// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 +// Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -35,7 +36,7 @@ # error TR1 header cannot be included from C++0x header #endif -#include <cstddef> +#include <bits/c++config.h> #if defined(_GLIBCXX_INCLUDE_AS_TR1) # include <tr1_impl/type_traits> |