diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 93443dfbb9f..144ac4792ad 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,18 @@ +2007-08-21 Benjamin Kosnik + + * include/Makefile.am (install-data-local): Remove pch-install rules. + (host_headers): Add stdc++.h, stdtr1c++.h, extc++.h. + * include/Makefile.in: Regenerate. + * config.h.in: Same. + + * scripts/check_compile: Remove space between outputs. + * include/ext/throw_allocator.h: Correct doxygen markup. + * include/bits/char_traits.h: Correct spacing. + * include/bits/stl_function.h: Same, for 80 column. + * include/std/valarray: Same. + * testsuite/util/testsuite_iterators.h: Same. + * testsuite/25_algorithms/headers/algorithm/synopsis.cc: Format. + 2007-08-17 Daniel Jacobowitz PR testsuite/31884 @@ -24,10 +39,14 @@ testsuite/ext/throw_allocator/check_deallocate_null.cc, testsuite/ext/throw_allocator/check_new.cc, testsuite/ext/throw_allocator/deallocate_local.cc, - testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/cons/gen1.cc, - testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/gen1.cc, - testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/gen1.cc, - testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/gen1.cc, + testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/ + cons/gen1.cc, + testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/ + gen1.cc, + testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/ + gen1.cc, + testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/ + gen1.cc, testsuite/23_containers/list/modifiers/insert/25288.cc: Use dg-require-time. diff --git a/libstdc++-v3/config.h.in b/libstdc++-v3/config.h.in index b6d4967ee8a..30a03cc24d3 100644 --- a/libstdc++-v3/config.h.in +++ b/libstdc++-v3/config.h.in @@ -24,6 +24,9 @@ /* Define to 1 if you have the `atanl' function. */ #undef HAVE_ATANL +/* Define to 1 if the target assembler supports thread-local storage. */ +#undef HAVE_CC_TLS + /* Define to 1 if you have the `ceilf' function. */ #undef HAVE_CEILF diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index f661ed4fe07..b7a2a96c2c4 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -754,7 +754,10 @@ host_headers = \ ${host_srcdir}/os_defines.h \ ${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \ ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \ - ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h + ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \ + ${glibcxx_srcdir}/include/precompiled/stdc++.h \ + ${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \ + ${glibcxx_srcdir}/include/precompiled/extc++.h # Non-installed host_header files. COMPATIBILITY_H = config/abi/compatibility.h @@ -809,10 +812,8 @@ pch_output_anchors = \ PCHFLAGS=-Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS) if GLIBCXX_BUILD_PCH pch_build = ${pch_output} -pch_install = install-pch else pch_build = -pch_install = endif # List of all timestamp files. By keeping only one copy of this list, both @@ -1129,7 +1130,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output} # the rest are taken from the original source tree. if GLIBCXX_HOSTED -install-data-local: install-headers ${pch_install} +install-data-local: install-headers else install-data-local: install-freestanding-headers endif @@ -1219,16 +1220,6 @@ install-headers: ${thread_host_headers}; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done -install-pch: - $(mkinstalldirs) $(DESTDIR)${pch1_output_installdir} - for file in ${pch1_output_builddir}/*; do \ - $(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done - $(mkinstalldirs) $(DESTDIR)${pch2_output_installdir} - for file in ${pch2_output_builddir}/*; do \ - $(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done - $(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir} - $(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir} - # By adding these files here, automake will remove them for 'make clean' CLEANFILES = ${pch_output} ${pch_output_anchors} diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index 9f5c7fb681f..876563f5761 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -981,7 +981,10 @@ host_headers = \ ${host_srcdir}/os_defines.h \ ${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \ ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \ - ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h + ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \ + ${glibcxx_srcdir}/include/precompiled/stdc++.h \ + ${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \ + ${glibcxx_srcdir}/include/precompiled/extc++.h # Non-installed host_header files. @@ -1035,8 +1038,6 @@ pch_output_anchors = \ PCHFLAGS = -Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS) @GLIBCXX_BUILD_PCH_FALSE@pch_build = @GLIBCXX_BUILD_PCH_TRUE@pch_build = ${pch_output} -@GLIBCXX_BUILD_PCH_FALSE@pch_install = -@GLIBCXX_BUILD_PCH_TRUE@pch_install = install-pch # List of all timestamp files. By keeping only one copy of this list, both # CLEANFILES and all-local are kept up-to-date. @@ -1512,7 +1513,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output} # host_headers_extra are taken out of the build tree staging area; # the rest are taken from the original source tree. -@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers ${pch_install} +@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers @GLIBCXX_HOSTED_FALSE@install-data-local: install-freestanding-headers # This is a subset of the full install-headers rule. We only need , @@ -1600,16 +1601,6 @@ install-headers: ${thread_host_headers}; do \ $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done -install-pch: - $(mkinstalldirs) $(DESTDIR)${pch1_output_installdir} - for file in ${pch1_output_builddir}/*; do \ - $(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done - $(mkinstalldirs) $(DESTDIR)${pch2_output_installdir} - for file in ${pch2_output_builddir}/*; do \ - $(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done - $(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir} - $(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir} - # To remove directories. clean-local: rm -rf ${pch_output_dirs} diff --git a/libstdc++-v3/include/bits/char_traits.h b/libstdc++-v3/include/bits/char_traits.h index a4b4e3a0d64..250faf59204 100644 --- a/libstdc++-v3/include/bits/char_traits.h +++ b/libstdc++-v3/include/bits/char_traits.h @@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) * types, but who don't need to change the definitions of any function * defined in char_traits, can specialize __gnu_cxx::_Char_types * while leaving __gnu_cxx::char_traits alone. */ - template + template struct _Char_types { typedef unsigned long int_type; diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h index 1bd11a392f0..7dc5031d46f 100644 --- a/libstdc++-v3/include/bits/stl_function.h +++ b/libstdc++-v3/include/bits/stl_function.h @@ -124,9 +124,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // 20.3.2 arithmetic /** @defgroup s20_3_2_arithmetic Arithmetic Classes - * Because basic math often needs to be done during an algorithm, the library - * provides functors for those operations. See the documentation for - * @link s20_3_1_base the base classes@endlink for examples of their use. + + * Because basic math often needs to be done during an algorithm, + * the library provides functors for those operations. See the + * documentation for @link s20_3_1_base the base classes@endlink + * for examples of their use. * * @{ */ @@ -249,7 +251,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) // 20.3.4 logical operations /** @defgroup s20_3_4_logical Boolean Operations Classes - * Here are wrapper functors for Boolean operations: @c &&, @c ||, and @c !. + * Here are wrapper functors for Boolean operations: @c &&, @c ||, + * and @c !. * * @{ */ @@ -360,15 +363,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std) template class binary_negate : public binary_function + typename _Predicate::second_argument_type, bool> { protected: _Predicate _M_pred; + public: explicit - binary_negate(const _Predicate& __x) - : _M_pred(__x) { } + binary_negate(const _Predicate& __x) : _M_pred(__x) { } bool operator()(const typename _Predicate::first_argument_type& __x, @@ -605,7 +607,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) * * @{ */ - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class mem_fun_t : public unary_function<_Tp*, _Ret> { @@ -621,7 +624,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)(); }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class const_mem_fun_t : public unary_function { @@ -637,7 +641,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)() const; }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class mem_fun_ref_t : public unary_function<_Tp, _Ret> { @@ -653,7 +658,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)(); }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> { @@ -669,7 +675,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)() const; }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> { @@ -685,7 +692,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)(_Arg); }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class const_mem_fun1_t : public binary_function { @@ -701,7 +709,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)(_Arg) const; }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { @@ -717,7 +726,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std) _Ret (_Tp::*_M_f)(_Arg); }; - /// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. + /// One of the @link s20_3_8_memadaptors adaptors for member + /// pointers@endlink. template class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { diff --git a/libstdc++-v3/include/ext/throw_allocator.h b/libstdc++-v3/include/ext/throw_allocator.h index 9a3dbef32fd..78b78f138c0 100644 --- a/libstdc++-v3/include/ext/throw_allocator.h +++ b/libstdc++-v3/include/ext/throw_allocator.h @@ -39,7 +39,7 @@ // purpose. It is provided "as is" without express or implied // warranty. -/** @file ext/vstring.h +/** @file ext/throw_allocator.h * This file is a GNU extension to the Standard C++ Library. * * Contains an exception-throwing allocator, useful for testing @@ -47,10 +47,6 @@ * sanity checked. */ -/** - * @file throw_allocator.h - */ - #ifndef _THROW_ALLOCATOR_H #define _THROW_ALLOCATOR_H 1 diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray index c8084fd2d14..31799c04cce 100644 --- a/libstdc++-v3/include/std/valarray +++ b/libstdc++-v3/include/std/valarray @@ -881,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) valarray<_Tp>::min() const { _GLIBCXX_DEBUG_ASSERT(_M_size > 0); - return *std::min_element(_M_data, _M_data+_M_size); + return *std::min_element(_M_data, _M_data + _M_size); } template @@ -889,7 +889,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) valarray<_Tp>::max() const { _GLIBCXX_DEBUG_ASSERT(_M_size > 0); - return *std::max_element(_M_data, _M_data+_M_size); + return *std::max_element(_M_data, _M_data + _M_size); } template diff --git a/libstdc++-v3/scripts/check_compile b/libstdc++-v3/scripts/check_compile index c969f98c476..76762e675ee 100755 --- a/libstdc++-v3/scripts/check_compile +++ b/libstdc++-v3/scripts/check_compile @@ -28,7 +28,7 @@ PCH_FLAGS=`$flags_script --cxxpchflags` FLAGS=`$flags_script --cxxflags` TEST_FLAGS="-S" COMPILER=`$flags_script --build-cxx` -CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS $TEST_FLAGS" +CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS -Wfatal-errors $TEST_FLAGS" echo "compile line is:" echo $CXX @@ -49,7 +49,6 @@ do # mv $OUTPUT_NAME binaries rm $OUTPUT_NAME fi - echo "" let UNIQUE_ID+=1 fi done diff --git a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc index 032fa31efec..800de340433 100644 --- a/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc +++ b/libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc @@ -20,385 +20,442 @@ #include -namespace std { +namespace std + { // 25.1, non-modifying sequence operations: - template - Function for_each(InputIterator first, InputIterator last, Function f); - template - InputIterator find(InputIterator first, InputIterator last, - const T& value); - template - InputIterator find_if(InputIterator first, InputIterator last, - Predicate pred); - template - ForwardIterator1 - find_end(ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2); - template - ForwardIterator1 - find_end(ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2, - BinaryPredicate pred); - template - ForwardIterator1 - find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2); - template - ForwardIterator1 - find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2, - BinaryPredicate pred); + template + _Funct + for_each(_IIter, _IIter, _Funct); -template - ForwardIterator adjacent_find(ForwardIterator first, - ForwardIterator last); + template + _IIter + find(_IIter, _IIter, const _Tp&); -template - ForwardIterator adjacent_find(ForwardIterator first, - ForwardIterator last, BinaryPredicate pred); + template + _IIter + find_if(_IIter, _IIter, _Predicate); -template - typename iterator_traits::difference_type - count(InputIterator first, InputIterator last, const T& value); + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); -template - typename iterator_traits::difference_type - count_if(InputIterator first, InputIterator last, Predicate pred); -template - pair - mismatch(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2); -template - - pair - mismatch(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, BinaryPredicate pred); -template - bool equal(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2); -template - - bool equal(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, BinaryPredicate pred); + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); -template - ForwardIterator1 search - (ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2); + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); -template - ForwardIterator1 search - (ForwardIterator1 first1, ForwardIterator1 last1, - ForwardIterator2 first2, ForwardIterator2 last2, - BinaryPredicate pred); + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); -template - ForwardIterator search_n(ForwardIterator first, ForwardIterator last, - Size count, const T& value); + template + _FIter + adjacent_find(_FIter, _FIter); -template - ForwardIterator search_n(ForwardIterator first, ForwardIterator last, - Size count, const T& value, - BinaryPredicate pred); + template + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); -// 25.2, modifying sequence operations: -// 25.2.1, copy: -template - OutputIterator copy(InputIterator first, InputIterator last, - OutputIterator result); -template - BidirectionalIterator2 - copy_backward - (BidirectionalIterator1 first, BidirectionalIterator1 last, - BidirectionalIterator2 result); -// 25.2.2, swap: -template void swap(T& a, T& b); -template - ForwardIterator2 swap_ranges(ForwardIterator1 first1, - ForwardIterator1 last1, ForwardIterator2 first2); -template - void iter_swap(ForwardIterator1 a, ForwardIterator2 b); -template - OutputIterator transform(InputIterator first, InputIterator last, - OutputIterator result, UnaryOperation op); -template - OutputIterator transform(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, OutputIterator result, - BinaryOperation binary_op); -template - void replace(ForwardIterator first, ForwardIterator last, - const T& old_value, const T& new_value); -template - void replace_if(ForwardIterator first, ForwardIterator last, - Predicate pred, const T& new_value); -template - OutputIterator replace_copy(InputIterator first, InputIterator last, - OutputIterator result, - const T& old_value, const T& new_value); -template - OutputIterator replace_copy_if(Iterator first, Iterator last, - OutputIterator result, - Predicate pred, const T& new_value); -template - void fill(ForwardIterator first, ForwardIterator last, const T& value); -template - void fill_n(OutputIterator first, Size n, const T& value); -template - void generate(ForwardIterator first, ForwardIterator last, - Generator gen); -template - void generate_n(OutputIterator first, Size n, Generator gen); + template + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); -template - ForwardIterator remove(ForwardIterator first, ForwardIterator last, - const T& value); -template - ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, - Predicate pred); -template - OutputIterator remove_copy(InputIterator first, InputIterator last, - OutputIterator result, const T& value); -template - OutputIterator remove_copy_if(InputIterator first, InputIterator last, - OutputIterator result, Predicate pred); -template - ForwardIterator unique(ForwardIterator first, ForwardIterator last); -template - ForwardIterator unique(ForwardIterator first, ForwardIterator last, - BinaryPredicate pred); -template - OutputIterator unique_copy(InputIterator first, InputIterator last, - OutputIterator result); -template - OutputIterator unique_copy(InputIterator first, InputIterator last, - OutputIterator result, BinaryPredicate pred); -template - void reverse(BidirectionalIterator first, BidirectionalIterator last); -template - OutputIterator reverse_copy(BidirectionalIterator first, - BidirectionalIterator last, - OutputIterator result); -template - void rotate(ForwardIterator first, ForwardIterator middle, - ForwardIterator last); -template - OutputIterator rotate_copy - (ForwardIterator first, ForwardIterator middle, - ForwardIterator last, OutputIterator result); -template - void random_shuffle(RandomAccessIterator first, - RandomAccessIterator last); -template - void random_shuffle(RandomAccessIterator first, - RandomAccessIterator last, - RandomNumberGenerator& rand); -// 25.2.12, partitions: -template - BidirectionalIterator partition(BidirectionalIterator first, - BidirectionalIterator last, - Predicate pred); -template - BidirectionalIterator stable_partition(BidirectionalIterator first, - BidirectionalIterator last, - Predicate pred); -// 25.3, sorting and related operations: -// 25.3.1, sorting: -template - void sort(RandomAccessIterator first, RandomAccessIterator last); -template - void sort(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); -template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last); -template - void stable_sort(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); -template - void partial_sort(RandomAccessIterator first, - RandomAccessIterator middle, - RandomAccessIterator last); -template - void partial_sort(RandomAccessIterator first, - RandomAccessIterator middle, - RandomAccessIterator last, Compare comp); -template - RandomAccessIterator - partial_sort_copy(InputIterator first, InputIterator last, - RandomAccessIterator result_first, - RandomAccessIterator result_last); -template - RandomAccessIterator - partial_sort_copy(InputIterator first, InputIterator last, - RandomAccessIterator result_first, - RandomAccessIterator result_last, - Compare comp); -template - void nth_element(RandomAccessIterator first, RandomAccessIterator nth, - RandomAccessIterator last); -template - void nth_element(RandomAccessIterator first, RandomAccessIterator nth, - RandomAccessIterator last, Compare comp); -// 25.3.3, binary search: -template - ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, - const T& value); -template - ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, - const T& value, Compare comp); -template - ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, - const T& value); -template - ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, - const T& value, Compare comp); -template - pair - equal_range(ForwardIterator first, ForwardIterator last, - const T& value); -template - pair - equal_range(ForwardIterator first, ForwardIterator last, - const T& value, Compare comp); -template - bool binary_search(ForwardIterator first, ForwardIterator last, - const T& value); -template - bool binary_search(ForwardIterator first, ForwardIterator last, - const T& value, Compare comp); -// 25.3.4, merge: -template - OutputIterator merge(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result); -template - OutputIterator merge(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result, Compare comp); -template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last); -template - void inplace_merge(BidirectionalIterator first, - BidirectionalIterator middle, - BidirectionalIterator last, Compare comp); -// 25.3.5, set operations: -template - bool includes(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2); -template - bool includes - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, Compare comp); -template - OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result); -template - OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result, Compare comp); -template - OutputIterator set_intersection - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result); -template - OutputIterator set_intersection - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result, Compare comp); -template - OutputIterator set_difference - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result); -template - OutputIterator set_difference - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result, Compare comp); -template - OutputIterator - set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result); -template - OutputIterator - set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - OutputIterator result, Compare comp); -// 25.3.6, heap operations: -template - void push_heap(RandomAccessIterator first, RandomAccessIterator last); -template - void push_heap(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); -template - void pop_heap(RandomAccessIterator first, RandomAccessIterator last); -template - void pop_heap(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); -template - void make_heap(RandomAccessIterator first, RandomAccessIterator last); -template - void make_heap(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); -template - void sort_heap(RandomAccessIterator first, RandomAccessIterator last); -template - void sort_heap(RandomAccessIterator first, RandomAccessIterator last, - Compare comp); + template + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + bool + equal(_IIter1, _IIter1, _IIter2); + + template + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + // 25.2, modifying sequence operations: + // 25.2.1, copy: + template + _OIter + copy(_IIter, _IIter, _OIter); + + template + _BIter2 + copy_backward (_BIter1, _BIter1, _BIter2); + + // 25.2.2, swap: + template + void + swap(_Tp&, _Tp& b); + + template + _FIter2 + swap_ranges(_FIter1 first1, _FIter1, _FIter2); + + template + void + iter_swap(_FIter1, _FIter2 b); + + template + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation op); + + template + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + template + void + fill(_FIter, _FIter, const _Tp&); + + template + void + fill_n(_OIter, _Size n, const _Tp&); + + template + void + generate(_FIter, _FIter, _Generator); + + template + void + generate_n(_OIter, _Size, _Generator); + + template + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + template + _FIter + unique(_FIter, _FIter); + + template + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + template + void + reverse(_BIter, _BIter); + + template + _OIter + reverse_copy(_BIter, _BIter, _OIter); + + template + void + rotate(_FIter, _FIter, _FIter); + + template + _OIter + rotate_copy (_FIter, _FIter, _FIter, _OIter); + + template + void + random_shuffle(_RAIter, _RAIter); + + template + void + random_shuffle(_RAIter, _RAIter, _Generator&); + + // 25.2.12, partitions: + template + _BIter + partition(_BIter, _BIter, _Predicate); + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); + + // 25.3, sorting and related operations: + // 25.3.1, sorting: + template + void + sort(_RAIter, _RAIter); + + template + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + template + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + // 25.3.3, binary search: + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + // 25.3.4, merge: + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + // 25.3.5, set operations: + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + // 25.3.6, heap operations: + template + void + push_heap(_RAIter, _RAIter); + + template + void + push_heap(_RAIter, _RAIter, _Compare); + + template + void + pop_heap(_RAIter, _RAIter); + + template + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + void + make_heap(_RAIter, _RAIter); + + template + void + make_heap(_RAIter, _RAIter, _Compare); + + template + void + sort_heap(_RAIter, _RAIter); + + template + void + sort_heap(_RAIter, _RAIter, _Compare); // 25.3.7, minimum and maximum: - template const T& min(const T& a, const T& b); - template - const T& min(const T& a, const T& b, Compare comp); - template const T& max(const T& a, const T& b); - template - const T& max(const T& a, const T& b, Compare comp); - template - ForwardIterator min_element - (ForwardIterator first, ForwardIterator last); - template - ForwardIterator min_element(ForwardIterator first, ForwardIterator last, - Compare comp); - template - ForwardIterator max_element - (ForwardIterator first, ForwardIterator last); - template - ForwardIterator max_element(ForwardIterator first, ForwardIterator last, - Compare comp); - template - bool lexicographical_compare - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2); - template - bool lexicographical_compare - (InputIterator1 first1, InputIterator1 last1, - InputIterator2 first2, InputIterator2 last2, - Compare comp); + template + const _Tp& + min(const _Tp&, const _Tp&); + + template + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + template + const _Tp& + max(const _Tp&, const _Tp&); + + template + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + template + _FIter + min_element(_FIter, _FIter); + + template + _FIter + min_element(_FIter, _FIter, _Compare); + + template + _FIter + max_element(_FIter, _FIter); + + template + _FIter + max_element(_FIter, _FIter, _Compare); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); // 25.3.9, permutations - template - bool next_permutation(BidirectionalIterator first, - BidirectionalIterator last); - template - bool next_permutation(BidirectionalIterator first, - BidirectionalIterator last, Compare comp); - template - bool prev_permutation(BidirectionalIterator first, - BidirectionalIterator last); - template - bool prev_permutation(BidirectionalIterator first, - BidirectionalIterator last, Compare comp); + template + bool + next_permutation(_BIter, _BIter); + + template + bool + next_permutation(_BIter, _BIter, _Compare); + + template + bool + prev_permutation(_BIter, _BIter); + + template + bool + prev_permutation(_BIter, _BIter, _Compare); } diff --git a/libstdc++-v3/testsuite/util/testsuite_iterators.h b/libstdc++-v3/testsuite/util/testsuite_iterators.h index 073be0beb94..760086710e6 100644 --- a/libstdc++-v3/testsuite/util/testsuite_iterators.h +++ b/libstdc++-v3/testsuite/util/testsuite_iterators.h @@ -61,8 +61,7 @@ namespace __gnu_test { T* first; T* last; - BoundsContainer(T* _first, T* _last) - : first(_first), last(_last) + BoundsContainer(T* _first, T* _last) : first(_first), last(_last) { } }; @@ -73,7 +72,7 @@ namespace __gnu_test T* incrementedto; bool* writtento; OutputContainer(T* _first, T* _last) - : BoundsContainer(_first, _last), incrementedto(_first) + : BoundsContainer(_first, _last), incrementedto(_first) { writtento = new bool[this->last - this->first]; for(int i = 0; i < this->last - this->first; i++) @@ -114,21 +113,21 @@ namespace __gnu_test * instansiated directly, but generated from a test_container */ template - struct output_iterator_wrapper: public std::iterator - + struct output_iterator_wrapper + : public std::iterator { typedef OutputContainer ContainerType; T* ptr; ContainerType* SharedInfo; output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) - :ptr(_ptr), SharedInfo(SharedInfo_in) + : ptr(_ptr), SharedInfo(SharedInfo_in) { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); } output_iterator_wrapper(const output_iterator_wrapper& in) - :ptr(in.ptr), SharedInfo(in.SharedInfo) + : ptr(in.ptr), SharedInfo(in.SharedInfo) { } WritableObject @@ -175,8 +174,8 @@ namespace __gnu_test * instansiated directly, but generated from a test_container */ template - class input_iterator_wrapper:public std::iterator - + class input_iterator_wrapper + : public std::iterator { protected: input_iterator_wrapper() @@ -188,11 +187,11 @@ namespace __gnu_test ContainerType* SharedInfo; input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) - : ptr(_ptr), SharedInfo(SharedInfo_in) + : ptr(_ptr), SharedInfo(SharedInfo_in) { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); } input_iterator_wrapper(const input_iterator_wrapper& in) - : ptr(in.ptr), SharedInfo(in.SharedInfo) + : ptr(in.ptr), SharedInfo(in.SharedInfo) { } bool @@ -257,16 +256,16 @@ namespace __gnu_test * instansiated directly, but generated from a test_container */ template - struct forward_iterator_wrapper:public input_iterator_wrapper + struct forward_iterator_wrapper : public input_iterator_wrapper { typedef BoundsContainer ContainerType; typedef std::forward_iterator_tag iterator_category; forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) - :input_iterator_wrapper(_ptr, SharedInfo_in) + : input_iterator_wrapper(_ptr, SharedInfo_in) { } forward_iterator_wrapper(const forward_iterator_wrapper& in) - :input_iterator_wrapper(in) + : input_iterator_wrapper(in) { } forward_iterator_wrapper() @@ -311,16 +310,16 @@ namespace __gnu_test * instansiated directly, but generated from a test_container */ template - struct bidirectional_iterator_wrapper:public forward_iterator_wrapper + struct bidirectional_iterator_wrapper : public forward_iterator_wrapper { typedef BoundsContainer ContainerType; typedef std::bidirectional_iterator_tag iterator_category; bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) - :forward_iterator_wrapper(_ptr, SharedInfo_in) + : forward_iterator_wrapper(_ptr, SharedInfo_in) { } bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in) - :forward_iterator_wrapper(in) + : forward_iterator_wrapper(in) { } bidirectional_iterator_wrapper(): forward_iterator_wrapper() @@ -375,16 +374,17 @@ namespace __gnu_test * instansiated directly, but generated from a test_container */ template - struct random_access_iterator_wrapper:public bidirectional_iterator_wrapper + struct random_access_iterator_wrapper + : public bidirectional_iterator_wrapper { typedef BoundsContainer ContainerType; typedef std::random_access_iterator_tag iterator_category; random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) - : bidirectional_iterator_wrapper(_ptr, SharedInfo_in) + : bidirectional_iterator_wrapper(_ptr, SharedInfo_in) { } random_access_iterator_wrapper(const random_access_iterator_wrapper& in) - : bidirectional_iterator_wrapper(in) + : bidirectional_iterator_wrapper(in) { } random_access_iterator_wrapper():bidirectional_iterator_wrapper()