From: Benjamin Kosnik Date: Tue, 15 Mar 2011 00:24:08 +0000 (+0000) Subject: Makefile.am: Add functional.cc, shared_ptr.cc. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=e95992339f9c10fce65d2eea8c95fe9e5a84d43c;p=gcc.git Makefile.am: Add functional.cc, shared_ptr.cc. 2011-03-14 Benjamin Kosnik * src/Makefile.am: Add functional.cc, shared_ptr.cc. * src/Makefile.in: Regenerate. * libsupc++/Makefile.am: Add nested_exception.cc. * libsupc++/Makefile.in: Regenerate. * src/system_error.cc: Add ctor and dtor definitions for error_category. * src/functional.cc: New. Add dtor definition for bad_function_call. * src/stdexcept.cc: Add dtor definitions for domain_error, invalid_argument, length_error, out_of_range, range_error, overflow_error, underflow_error. * src/future.cc: Add dtor definition for __future_base::_Result_base. * src/shared_ptr.cc: New. Add dtor definition for bad_weak_ptr. * src/thread.cc: Add dtor for thread::_Impl_base. * include/std/system_error: Adjust. * include/std/stdexcept: Same. * include/std/future: Same. * include/std/functional: Same. * include/std/thread: Same. * include/bits/shared_ptr_base.h: Same. * libsupc++/nested_exception.cc: New. Add dtor for nested_exception. * libsupc++/nested_exception.h: Adjust. * testsuite/20_util/shared_ptr/cons/43820_neg.cc: Adjust line numbers. * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same. * config/abi/pre/gnu.ver: Add new exports. * include/bits/regex_compiler.h: Nest namespace versioning. * include/bits/regex_grep_matcher.tcc: Same. * include/bits/regex_grep_matcher.h: Same. * include/bits/regex_cursor.h: Same. * include/bits/regex_nfa.h: Same. * include/bits/regex_nfa.tcc: Same. From-SVN: r170975 --- diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 3972fec26b3..870fd9c1634 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,36 @@ +2011-03-14 Benjamin Kosnik + + * src/Makefile.am: Add functional.cc, shared_ptr.cc. + * src/Makefile.in: Regenerate. + * libsupc++/Makefile.am: Add nested_exception.cc. + * libsupc++/Makefile.in: Regenerate. + * src/system_error.cc: Add ctor and dtor definitions for error_category. + * src/functional.cc: New. Add dtor definition for bad_function_call. + * src/stdexcept.cc: Add dtor definitions for domain_error, + invalid_argument, length_error, out_of_range, range_error, + overflow_error, underflow_error. + * src/future.cc: Add dtor definition for __future_base::_Result_base. + * src/shared_ptr.cc: New. Add dtor definition for bad_weak_ptr. + * src/thread.cc: Add dtor for thread::_Impl_base. + * include/std/system_error: Adjust. + * include/std/stdexcept: Same. + * include/std/future: Same. + * include/std/functional: Same. + * include/std/thread: Same. + * include/bits/shared_ptr_base.h: Same. + * libsupc++/nested_exception.cc: New. Add dtor for nested_exception. + * libsupc++/nested_exception.h: Adjust. + * testsuite/20_util/shared_ptr/cons/43820_neg.cc: Adjust line numbers. + * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same. + * config/abi/pre/gnu.ver: Add new exports. + + * include/bits/regex_compiler.h: Nest namespace versioning. + * include/bits/regex_grep_matcher.tcc: Same. + * include/bits/regex_grep_matcher.h: Same. + * include/bits/regex_cursor.h: Same. + * include/bits/regex_nfa.h: Same. + * include/bits/regex_nfa.tcc: Same. + 2011-03-14 Rainer Orth * doc/xml/manual/abi.xml: Replace docs.sun.com URLs by their OTN diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver index b3e5380f76d..c85ba8ed52c 100644 --- a/libstdc++-v3/config/abi/pre/gnu.ver +++ b/libstdc++-v3/config/abi/pre/gnu.ver @@ -124,7 +124,7 @@ GLIBCXX_3.4 { std::messages*; std::money*; # std::n[^u]*; - std::n[^au]*; + std::n[^aue]*; std::nu[^m]*; std::num[^e]*; std::ostrstream*; @@ -1219,6 +1219,31 @@ GLIBCXX_3.4.15 { _ZTISt11regex_error; _ZSt19__throw_regex_errorNSt15regex_constants10error_typeE; + _ZNSt12bad_weak_ptrD*; + _ZNKSt12bad_weak_ptr4whatEv; + _ZTSSt12bad_weak_ptr; + _ZTVSt12bad_weak_ptr; + _ZTISt12bad_weak_ptr; + + _ZNSt14error_categoryC*; + _ZNSt14error_categoryD*; + + _ZNSt13__future_base12_Result_baseC*; + _ZNSt13__future_base12_Result_baseD*; + _ZTINSt13__future_base12_Result_baseE; + _ZTSNSt13__future_base12_Result_baseE; + _ZTVNSt13__future_base12_Result_baseE; + + _ZNSt13__future_base11_State_baseD*; + _ZTINSt13__future_base11_State_baseE; + _ZTSNSt13__future_base11_State_baseE; + _ZTVNSt13__future_base11_State_baseE; + + _ZNSt6thread10_Impl_baseD*; + _ZTINSt6thread10_Impl_baseE; + _ZTSNSt6thread10_Impl_baseE; + _ZTVNSt6thread10_Impl_baseE; + } GLIBCXX_3.4.14; # Symbols in the support library (libsupc++) have their own tag. @@ -1403,4 +1428,10 @@ CXXABI_1.3.5 { _ZTSSt17bad_function_call; _ZTVSt17bad_function_call; + # std::nested_exception + _ZNSt16nested_exceptionD*; + _ZTISt16nested_exception; + _ZTSSt16nested_exception; + _ZTVSt16nested_exception; + } CXXABI_1.3.4; diff --git a/libstdc++-v3/include/bits/regex_compiler.h b/libstdc++-v3/include/bits/regex_compiler.h index f581e64f8a2..025c4fa70a9 100644 --- a/libstdc++-v3/include/bits/regex_compiler.h +++ b/libstdc++-v3/include/bits/regex_compiler.h @@ -30,10 +30,10 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION - namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + struct _Scanner_base { typedef unsigned int _StateT; @@ -41,6 +41,8 @@ namespace __regex static constexpr _StateT _S_state_at_start = 1 << 0; static constexpr _StateT _S_state_in_brace = 1 << 2; static constexpr _StateT _S_state_in_bracket = 1 << 3; + + virtual ~_Scanner_base() { }; }; // @@ -1100,9 +1102,8 @@ namespace __regex { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t, __f)._M_nfa())); } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION -} // namespace +} // namespace __regex +} // namespace std /* vim: set ts=8 sw=2 sts=2: */ diff --git a/libstdc++-v3/include/bits/regex_cursor.h b/libstdc++-v3/include/bits/regex_cursor.h index c53f7594c5f..9feac1d0aa3 100644 --- a/libstdc++-v3/include/bits/regex_cursor.h +++ b/libstdc++-v3/include/bits/regex_cursor.h @@ -30,10 +30,10 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION - namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + // ABC for pattern matching struct _PatternCursor { @@ -88,7 +88,6 @@ namespace __regex __cursor(const _FwdIterT& __b, const _FwdIterT __e) { return _SpecializedCursor<_FwdIterT>(__b, __e); } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace diff --git a/libstdc++-v3/include/bits/regex_grep_matcher.h b/libstdc++-v3/include/bits/regex_grep_matcher.h index 202a36eae74..06193bba3b7 100644 --- a/libstdc++-v3/include/bits/regex_grep_matcher.h +++ b/libstdc++-v3/include/bits/regex_grep_matcher.h @@ -30,7 +30,6 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION template class sub_match; @@ -40,6 +39,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + // A _Results facade specialized for wrapping a templated match_results. template class _SpecializedResults @@ -121,9 +122,8 @@ namespace __regex _Results& _M_results; }; -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace #include diff --git a/libstdc++-v3/include/bits/regex_grep_matcher.tcc b/libstdc++-v3/include/bits/regex_grep_matcher.tcc index 1c125945022..ae28f6fa152 100644 --- a/libstdc++-v3/include/bits/regex_grep_matcher.tcc +++ b/libstdc++-v3/include/bits/regex_grep_matcher.tcc @@ -32,11 +32,8 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION - namespace { - // A stack of states used in evaluating the NFA. typedef std::stack @@ -104,6 +101,8 @@ namespace namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + inline _Grep_matcher:: _Grep_matcher(_PatternCursor& __p, _Results& __r, const _AutomatonPtr& __nfa, @@ -175,7 +174,6 @@ namespace __regex return __e; } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace diff --git a/libstdc++-v3/include/bits/regex_nfa.h b/libstdc++-v3/include/bits/regex_nfa.h index 17982eb884b..c4a65e6722d 100644 --- a/libstdc++-v3/include/bits/regex_nfa.h +++ b/libstdc++-v3/include/bits/regex_nfa.h @@ -30,10 +30,9 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION - namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION // Base class for, um, automata. Could be an NFA or a DFA. Your choice. class _Automaton @@ -43,8 +42,7 @@ namespace __regex public: virtual - ~_Automaton() - { } + ~_Automaton() { } virtual _SizeT _M_sub_count() const = 0; @@ -394,10 +392,9 @@ namespace __regex }; -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION -} // namespace +} // namespace __regex +} // namespace std #include diff --git a/libstdc++-v3/include/bits/regex_nfa.tcc b/libstdc++-v3/include/bits/regex_nfa.tcc index 211ddc7aed4..9e4a6cee774 100644 --- a/libstdc++-v3/include/bits/regex_nfa.tcc +++ b/libstdc++-v3/include/bits/regex_nfa.tcc @@ -1,6 +1,6 @@ // class template regex -*- C++ -*- -// Copyright (C) 2010 Free Software Foundation, Inc. +// Copyright (C) 2010, 2011 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 @@ -31,10 +31,10 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION - namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + #ifdef _GLIBCXX_DEBUG inline std::ostream& _State:: _M_print(std::ostream& ostr) const @@ -169,7 +169,6 @@ inline _StateIdT _StateSeq:: _M_clone() { return 0; } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index acea7443bf1..72bc4f04633 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -61,8 +61,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: virtual char const* - what() const throw() - { return "std::bad_weak_ptr"; } + what() const throw(); + + virtual ~bad_weak_ptr() throw(); }; // Substitute for bad_weak_ptr object in the case of -fno-exceptions. diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional index 3ae95502341..6643b76493c 100644 --- a/libstdc++-v3/include/std/functional +++ b/libstdc++-v3/include/std/functional @@ -83,90 +83,90 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { }; /// Retrieve the result type for a function type. - template + template struct _Weak_result_type_impl<_Res(_ArgTypes...)> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes......)> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes...) const> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes......) const> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile> { typedef _Res result_type; }; /// Retrieve the result type for a function reference. - template + template struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)> { typedef _Res result_type; }; /// Retrieve the result type for a function pointer. - template + template struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)> { typedef _Res result_type; }; - /// Retrieve result type for a member function pointer. - template + /// Retrieve result type for a member function pointer. + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)> { typedef _Res result_type; }; - /// Retrieve result type for a const member function pointer. - template + /// Retrieve result type for a const member function pointer. + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const> { typedef _Res result_type; }; - /// Retrieve result type for a volatile member function pointer. - template + /// Retrieve result type for a volatile member function pointer. + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile> { typedef _Res result_type; }; - /// Retrieve result type for a const volatile member function pointer. - template - struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) + /// Retrieve result type for a const volatile member function pointer. + template + struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const volatile> { typedef _Res result_type; }; - template + template struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const volatile> { typedef _Res result_type; }; @@ -186,7 +186,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { private: template - static __one __test(const volatile unary_function<_T1, _Res>*); + static __one __test(const volatile unary_function<_T1, _Res>*); // It's tempting to change "..." to const volatile void*, but // that fails when _Tp is a function type. @@ -202,7 +202,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { private: template - static __one __test(const volatile binary_function<_T1, _T2, _Res>*); + static __one __test(const volatile binary_function<_T1, _T2, _Res>*); // It's tempting to change "..." to const volatile void*, but // that fails when _Tp is a function type. @@ -232,11 +232,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) template inline typename enable_if< - (!is_member_pointer<_Functor>::value - && !is_function<_Functor>::value - && !is_function::type>::value), - typename result_of<_Functor(_Args...)>::type - >::type + (!is_member_pointer<_Functor>::value + && !is_function<_Functor>::value + && !is_function::type>::value), + typename result_of<_Functor(_Args...)>::type + >::type __invoke(_Functor& __f, _Args&&... __args) { return __f(std::forward<_Args>(__args)...); @@ -246,10 +246,10 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) template inline typename enable_if< - (is_pointer<_Functor>::value - && is_function::type>::value), - typename result_of<_Functor(_Args...)>::type - >::type + (is_pointer<_Functor>::value + && is_function::type>::value), + typename result_of<_Functor(_Args...)>::type + >::type __invoke(_Functor __f, _Args&&... __args) { return __f(std::forward<_Args>(__args)...); @@ -425,7 +425,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // If _Tp is a function type, we can't form result_of<_Tp(...)>, // so turn it into a function pointer type. typedef typename _Function_to_function_pointer<_Tp>::type - _M_func_type; + _M_func_type; _Tp* _M_data; public: @@ -444,8 +444,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) reference_wrapper& operator=(const reference_wrapper<_Tp>& __inref) { - _M_data = __inref._M_data; - return *this; + _M_data = __inref._M_data; + return *this; } operator _Tp&() const @@ -456,9 +456,9 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { return *_M_data; } template - typename result_of<_M_func_type(_Args...)>::type - operator()(_Args&&... __args) const - { + typename result_of<_M_func_type(_Args...)>::type + operator()(_Args&&... __args) const + { return __invoke(get(), std::forward<_Args>(__args)...); } }; @@ -498,16 +498,16 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * nothing, depending on the number of arguments provided. The * primary template is the basis case, which derives nothing. */ - template + template struct _Maybe_unary_or_binary_function { }; - /// Derives from @c unary_function, as appropriate. - template + /// Derives from @c unary_function, as appropriate. + template struct _Maybe_unary_or_binary_function<_Res, _T1> : std::unary_function<_T1, _Res> { }; - /// Derives from @c binary_function, as appropriate. - template + /// Derives from @c binary_function, as appropriate. + template struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> : std::binary_function<_T1, _T2, _Res> { }; @@ -519,15 +519,15 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) typedef _Res (_Class::*_Functor)(_ArgTypes...); template - _Res - _M_call(_Tp& __object, const volatile _Class *, - _ArgTypes... __args) const - { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } template - _Res - _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const - { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } public: typedef _Res result_type; @@ -546,12 +546,12 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Handle smart pointers, references and pointers to derived template - _Res + _Res operator()(_Tp& __object, _ArgTypes... __args) const - { - return _M_call(__object, &__object, - std::forward<_ArgTypes>(__args)...); - } + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } private: _Functor __pmf; @@ -560,21 +560,21 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) /// Implementation of @c mem_fn for const member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const> - : public _Maybe_unary_or_binary_function<_Res, const _Class*, + : public _Maybe_unary_or_binary_function<_Res, const _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) const; template - _Res - _M_call(_Tp& __object, const volatile _Class *, - _ArgTypes... __args) const - { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } template - _Res - _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const - { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } public: typedef _Res result_type; @@ -593,11 +593,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Handle smart pointers, references and pointers to derived template - _Res operator()(_Tp& __object, _ArgTypes... __args) const - { - return _M_call(__object, &__object, - std::forward<_ArgTypes>(__args)...); - } + _Res operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } private: _Functor __pmf; @@ -606,21 +606,21 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) /// Implementation of @c mem_fn for volatile member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile> - : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, + : public _Maybe_unary_or_binary_function<_Res, volatile _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile; template - _Res - _M_call(_Tp& __object, const volatile _Class *, - _ArgTypes... __args) const - { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } template - _Res - _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const - { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } public: typedef _Res result_type; @@ -639,12 +639,12 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Handle smart pointers, references and pointers to derived template - _Res + _Res operator()(_Tp& __object, _ArgTypes... __args) const - { - return _M_call(__object, &__object, - std::forward<_ArgTypes>(__args)...); - } + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } private: _Functor __pmf; @@ -653,21 +653,21 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) /// Implementation of @c mem_fn for const volatile member function pointers. template class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile> - : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, + : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*, _ArgTypes...> { typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile; template - _Res - _M_call(_Tp& __object, const volatile _Class *, - _ArgTypes... __args) const - { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __object, const volatile _Class *, + _ArgTypes... __args) const + { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } template - _Res - _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const - { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } + _Res + _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const + { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); } public: typedef _Res result_type; @@ -675,22 +675,22 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { } // Handle objects - _Res + _Res operator()(const volatile _Class& __object, _ArgTypes... __args) const { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); } // Handle pointers - _Res + _Res operator()(const volatile _Class* __object, _ArgTypes... __args) const { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); } // Handle smart pointers, references and pointers to derived template - _Res operator()(_Tp& __object, _ArgTypes... __args) const - { - return _M_call(__object, &__object, - std::forward<_ArgTypes>(__args)...); - } + _Res operator()(_Tp& __object, _ArgTypes... __args) const + { + return _M_call(__object, &__object, + std::forward<_ArgTypes>(__args)...); + } private: _Functor __pmf; @@ -715,60 +715,60 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // This bit of genius is due to Peter Dimov, improved slightly by // Douglas Gregor. template - _Res& - _M_call(_Tp& __object, _Class *) const - { return __object.*__pm; } + _Res& + _M_call(_Tp& __object, _Class *) const + { return __object.*__pm; } template - _Res& - _M_call(_Tp& __object, _Up * const *) const - { return (*__object).*__pm; } + _Res& + _M_call(_Tp& __object, _Up * const *) const + { return (*__object).*__pm; } template - const _Res& - _M_call(_Tp& __object, const _Up * const *) const - { return (*__object).*__pm; } + const _Res& + _M_call(_Tp& __object, const _Up * const *) const + { return (*__object).*__pm; } template - const _Res& - _M_call(_Tp& __object, const _Class *) const - { return __object.*__pm; } + const _Res& + _M_call(_Tp& __object, const _Class *) const + { return __object.*__pm; } template - const _Res& - _M_call(_Tp& __ptr, const volatile void*) const - { return (*__ptr).*__pm; } + const _Res& + _M_call(_Tp& __ptr, const volatile void*) const + { return (*__ptr).*__pm; } template static _Tp& __get_ref(); template - static __sfinae_types::__one __check_const(_Tp&, _Class*); + static __sfinae_types::__one __check_const(_Tp&, _Class*); template - static __sfinae_types::__one __check_const(_Tp&, _Up * const *); + static __sfinae_types::__one __check_const(_Tp&, _Up * const *); template - static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); + static __sfinae_types::__two __check_const(_Tp&, const _Up * const *); template - static __sfinae_types::__two __check_const(_Tp&, const _Class*); + static __sfinae_types::__two __check_const(_Tp&, const _Class*); template - static __sfinae_types::__two __check_const(_Tp&, const volatile void*); + static __sfinae_types::__two __check_const(_Tp&, const volatile void*); public: template - struct _Result_type + struct _Result_type : _Mem_fn_const_or_non<_Res, (sizeof(__sfinae_types::__two) == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))> - { }; + { }; template - struct result; + struct result; template - struct result<_CVMem(_Tp)> + struct result<_CVMem(_Tp)> : public _Result_type<_Tp> { }; template - struct result<_CVMem(_Tp&)> + struct result<_CVMem(_Tp&)> : public _Result_type<_Tp> { }; explicit @@ -794,9 +794,9 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Handle smart pointers and derived template - typename _Result_type<_Tp>::type - operator()(_Tp& __unknown) const - { return _M_call(__unknown, &__unknown); } + typename _Result_type<_Tp>::type + operator()(_Tp& __unknown) const + { return _M_call(__unknown, &__unknown); } private: _Res _Class::*__pm; @@ -847,7 +847,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * simplify this with variadic templates, because we're introducing * unique names for each. */ - namespace placeholders + namespace placeholders { _GLIBCXX_BEGIN_NAMESPACE_VERSION extern const _Placeholder<1> _1; @@ -894,7 +894,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) : public integral_constant { }; - /** + /** * Used by _Safe_tuple_element to indicate that there is no tuple * element at this position. */ @@ -926,8 +926,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) */ template struct _Safe_tuple_element - : _Safe_tuple_element_impl<__i, _Tuple, - (__i >= 0 && __i < tuple_size<_Tuple>::value)> + : _Safe_tuple_element_impl<__i, _Tuple, + (__i >= 0 && __i < tuple_size<_Tuple>::value)> { }; /** @@ -942,8 +942,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * rest of the arguments. */ template::value, - bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> + bool _IsBindExp = is_bind_expression<_Arg>::value, + bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> class _Mu; /** @@ -961,9 +961,9 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * but not volatile-qualified. This might be a defect in the TR. */ template - result_type - operator()(_CVRef& __arg, _Tuple&) const volatile - { return __arg.get(); } + result_type + operator()(_CVRef& __arg, _Tuple&) const volatile + { return __arg.get(); } }; /** @@ -976,11 +976,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { public: template - auto - operator()(_CVArg& __arg, + auto + operator()(_CVArg& __arg, tuple<_Args...>& __tuple) const volatile - -> decltype(__arg(declval<_Args>()...)) - { + -> decltype(__arg(declval<_Args>()...)) + { // Construct an index tuple and forward to __call typedef typename _Build_index_tuple::__type _Indexes; @@ -989,13 +989,13 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) private: // Invokes the underlying function object __arg by unpacking all - // of the arguments in the tuple. + // of the arguments in the tuple. template - auto - __call(_CVArg& __arg, tuple<_Args...>& __tuple, + auto + __call(_CVArg& __arg, tuple<_Args...>& __tuple, const _Index_tuple<_Indexes...>&) const volatile - -> decltype(__arg(declval<_Args>()...)) - { + -> decltype(__arg(declval<_Args>()...)) + { return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...); } }; @@ -1012,8 +1012,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) template class result; template - class result<_CVMu(_CVArg, _Tuple)> - { + class result<_CVMu(_CVArg, _Tuple)> + { // Add a reference, if it hasn't already been done for us. // This allows us to be a little bit sloppy in constructing // the tuple that we pass to result_of<...>. @@ -1026,11 +1026,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) }; template - typename result<_Mu(_Arg, _Tuple)>::type - operator()(const volatile _Arg&, _Tuple& __tuple) const volatile - { + typename result<_Mu(_Arg, _Tuple)>::type + operator()(const volatile _Arg&, _Tuple& __tuple) const volatile + { return std::forward::type>( - ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); + ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple)); } }; @@ -1046,16 +1046,16 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) template struct result; template - struct result<_CVMu(_CVArg, _Tuple)> - { + struct result<_CVMu(_CVArg, _Tuple)> + { typedef typename add_lvalue_reference<_CVArg>::type type; }; // Pick up the cv-qualifiers of the argument template - _CVArg&& - operator()(_CVArg&& __arg, _Tuple&) const volatile - { return std::forward<_CVArg>(__arg); } + _CVArg&& + operator()(_CVArg&& __arg, _Tuple&) const volatile + { return std::forward<_CVArg>(__arg); } }; /** @@ -1086,7 +1086,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) struct _Maybe_wrap_member_pointer<_Tp _Class::*> { typedef _Mem_fn<_Tp _Class::*> type; - + static type __do_wrap(_Tp _Class::* __pm) { return type(__pm); } @@ -1126,59 +1126,59 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { typedef _Bind __self_type; typedef typename _Build_index_tuple::__type - _Bound_indexes; + _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // Call unqualified template - _Result - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) - { - return _M_f(_Mu<_Bound_args>() - (get<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } // Call as const template - _Result - __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const - { - return _M_f(_Mu<_Bound_args>() - (get<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } // Call as volatile template - _Result - __call_v(tuple<_Args...>&& __args, + _Result + __call_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile - { - return _M_f(_Mu<_Bound_args>() - (__volget<_Indexes>(_M_bound_args), __args)...); - } + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } // Call as const volatile template - _Result - __call_c_v(tuple<_Args...>&& __args, + _Result + __call_c_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile - { - return _M_f(_Mu<_Bound_args>() - (__volget<_Indexes>(_M_bound_args), __args)...); - } + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } public: template - explicit _Bind(const _Functor& __f, _Args&&... __args) - : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) - { } + explicit _Bind(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } template - explicit _Bind(_Functor&& __f, _Args&&... __args) - : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) - { } + explicit _Bind(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } _Bind(const _Bind&) = default; @@ -1188,55 +1188,55 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Call unqualified template()( - _Mu<_Bound_args>()( std::declval<_Bound_args&>(), + = decltype( std::declval<_Functor>()( + _Mu<_Bound_args>()( std::declval<_Bound_args&>(), std::declval&>() )... ) )> - _Result - operator()(_Args&&... __args) - { - return this->__call<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + _Result + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as const template()( + = decltype( std::declval()( _Mu<_Bound_args>()( std::declval(), std::declval&>() )... ) )> - _Result - operator()(_Args&&... __args) const - { - return this->__call_c<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + _Result + operator()(_Args&&... __args) const + { + return this->__call_c<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as volatile template()( - _Mu<_Bound_args>()( std::declval(), - std::declval&>() )... ) )> - _Result - operator()(_Args&&... __args) volatile - { - return this->__call_v<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + = decltype( std::declval()( + _Mu<_Bound_args>()( std::declval(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) volatile + { + return this->__call_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as const volatile template()( - _Mu<_Bound_args>()( std::declval(), - std::declval&>() )... ) )> - _Result - operator()(_Args&&... __args) const volatile - { - return this->__call_c_v<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + = decltype( std::declval()( + _Mu<_Bound_args>()( std::declval(), + std::declval&>() )... ) )> + _Result + operator()(_Args&&... __args) const volatile + { + return this->__call_c_v<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } }; /// Type of the function object returned from bind(). @@ -1247,111 +1247,111 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) class _Bind_result<_Result, _Functor(_Bound_args...)> { typedef _Bind_result __self_type; - typedef typename _Build_index_tuple::__type - _Bound_indexes; + typedef typename _Build_index_tuple::__type + _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; // sfinae types template - struct __enable_if_void : enable_if::value, int> { }; + struct __enable_if_void : enable_if::value, int> { }; template - struct __disable_if_void : enable_if::value, int> { }; + struct __disable_if_void : enable_if::value, int> { }; // Call unqualified template - _Result - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __disable_if_void<_Res>::type = 0) - { - return _M_f(_Mu<_Bound_args>() - (get<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } // Call unqualified, return void template - void - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __enable_if_void<_Res>::type = 0) - { - _M_f(_Mu<_Bound_args>() + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) + { + _M_f(_Mu<_Bound_args>() (get<_Indexes>(_M_bound_args), __args)...); - } + } // Call as const template - _Result - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __disable_if_void<_Res>::type = 0) const - { - return _M_f(_Mu<_Bound_args>() - (get<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const + { + return _M_f(_Mu<_Bound_args>() + (get<_Indexes>(_M_bound_args), __args)...); + } // Call as const, return void template - void - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __enable_if_void<_Res>::type = 0) const - { - _M_f(_Mu<_Bound_args>() + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const + { + _M_f(_Mu<_Bound_args>() (get<_Indexes>(_M_bound_args), __args)...); - } + } // Call as volatile template - _Result - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __disable_if_void<_Res>::type = 0) volatile - { - return _M_f(_Mu<_Bound_args>() - (__volget<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } // Call as volatile, return void template - void - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __enable_if_void<_Res>::type = 0) volatile - { - _M_f(_Mu<_Bound_args>() + void + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) volatile + { + _M_f(_Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); - } + } // Call as const volatile template - _Result - __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, - typename __disable_if_void<_Res>::type = 0) const volatile - { - return _M_f(_Mu<_Bound_args>() - (__volget<_Indexes>(_M_bound_args), __args)...); - } + _Result + __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>, + typename __disable_if_void<_Res>::type = 0) const volatile + { + return _M_f(_Mu<_Bound_args>() + (__volget<_Indexes>(_M_bound_args), __args)...); + } // Call as const volatile, return void template - void - __call(tuple<_Args...>&& __args, - _Index_tuple<_Indexes...>, - typename __enable_if_void<_Res>::type = 0) const volatile - { - _M_f(_Mu<_Bound_args>() + void + __call(tuple<_Args...>&& __args, + _Index_tuple<_Indexes...>, + typename __enable_if_void<_Res>::type = 0) const volatile + { + _M_f(_Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); - } + } public: typedef _Result result_type; template - explicit _Bind_result(const _Functor& __f, _Args&&... __args) - : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) - { } + explicit _Bind_result(const _Functor& __f, _Args&&... __args) + : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) + { } template - explicit _Bind_result(_Functor&& __f, _Args&&... __args) - : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) - { } + explicit _Bind_result(_Functor&& __f, _Args&&... __args) + : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) + { } _Bind_result(const _Bind_result&) = default; @@ -1361,43 +1361,43 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // Call unqualified template - result_type - operator()(_Args&&... __args) - { - return this->__call<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + result_type + operator()(_Args&&... __args) + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as const template - result_type - operator()(_Args&&... __args) const - { - return this->__call<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + result_type + operator()(_Args&&... __args) const + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as volatile template - result_type - operator()(_Args&&... __args) volatile - { - return this->__call<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + result_type + operator()(_Args&&... __args) volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } // Call as const volatile template - result_type - operator()(_Args&&... __args) const volatile - { - return this->__call<_Result>( - std::forward_as_tuple(std::forward<_Args>(__args)...), - _Bound_indexes()); - } + result_type + operator()(_Args&&... __args) const volatile + { + return this->__call<_Result>( + std::forward_as_tuple(std::forward<_Args>(__args)...), + _Bound_indexes()); + } }; /** @@ -1420,7 +1420,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) struct _Bind_helper { typedef _Maybe_wrap_member_pointer::type> - __maybe_type; + __maybe_type; typedef typename __maybe_type::type __functor_type; typedef _Bind<__functor_type(typename decay<_ArgTypes>::type...)> type; }; @@ -1438,18 +1438,18 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) typedef typename __helper_type::__maybe_type __maybe_type; typedef typename __helper_type::type __result_type; return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)), - std::forward<_ArgTypes>(__args)...); - } + std::forward<_ArgTypes>(__args)...); + } template struct _Bindres_helper { typedef _Maybe_wrap_member_pointer::type> - __maybe_type; + __maybe_type; typedef typename __maybe_type::type __functor_type; typedef _Bind_result<_Result, - __functor_type(typename decay<_ArgTypes>::type...)> - type; + __functor_type(typename decay<_ArgTypes>::type...)> + type; }; /** @@ -1465,7 +1465,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) typedef typename __helper_type::__maybe_type __maybe_type; typedef typename __helper_type::type __result_type; return __result_type(__maybe_type::__do_wrap(std::forward<_Functor>(__f)), - std::forward<_ArgTypes>(__args)...); + std::forward<_ArgTypes>(__args)...); } /** @@ -1473,7 +1473,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * operator() is called with an empty target. * @ingroup exceptions */ - class bad_function_call : public std::exception { }; + class bad_function_call : public std::exception + { + public: + virtual ~bad_function_call() throw(); + }; /** * Trait identifying "location-invariant" types, meaning that the @@ -1570,11 +1574,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { protected: static const bool __stored_locally = - (__is_location_invariant<_Functor>::value - && sizeof(_Functor) <= _M_max_size - && __alignof__(_Functor) <= _M_max_align - && (_M_max_align % __alignof__(_Functor) == 0)); - + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <= _M_max_size + && __alignof__(_Functor) <= _M_max_align + && (_M_max_align % __alignof__(_Functor) == 0)); + typedef integral_constant _Local_storage; // Retrieve a pointer to the function object @@ -1611,14 +1615,14 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { __victim._M_access<_Functor>().~_Functor(); } - + // Destroying an object located on the heap. static void _M_destroy(_Any_data& __victim, false_type) { delete __victim._M_access<_Functor*>(); } - + public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, @@ -1634,7 +1638,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) case __get_functor_ptr: __dest._M_access<_Functor*>() = _M_get_pointer(__source); break; - + case __clone_functor: _M_clone(__dest, __source, _Local_storage()); break; @@ -1649,11 +1653,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) static void _M_init_functor(_Any_data& __functor, _Functor&& __f) { _M_init_functor(__functor, std::move(__f), _Local_storage()); } - + template static bool _M_not_empty_function(const function<_Signature>& __f) - { return static_cast(__f); } + { return static_cast(__f); } template static bool @@ -1671,7 +1675,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) { return true; } private: - static void + static void _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) { new (__functor._M_access()) _Functor(std::move(__f)); } @@ -1701,7 +1705,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source); return is_const<_Functor>::value; break; - + default: _Base::_M_manager(__dest, __source, __op); } @@ -1717,7 +1721,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) }; _Function_base() : _M_manager(0) { } - + ~_Function_base() { if (_M_manager) @@ -1728,7 +1732,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) bool _M_empty() const { return !_M_manager; } typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, - _Manager_operation); + _Manager_operation); _Any_data _M_functor; _Manager_type _M_manager; @@ -1747,8 +1751,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { - return (*_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); + return (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); } }; @@ -1762,8 +1766,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { - (*_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); + (*_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); } }; @@ -1777,8 +1781,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { - return __callable_functor(**_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); + return __callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); } }; @@ -1792,32 +1796,32 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { - __callable_functor(**_Base::_M_get_pointer(__functor))( - std::forward<_ArgTypes>(__args)...); + __callable_functor(**_Base::_M_get_pointer(__functor))( + std::forward<_ArgTypes>(__args)...); } }; - template + template class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> : public _Function_handler { typedef _Function_handler - _Base; + _Base; public: static _Res _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { - return mem_fn(_Base::_M_get_pointer(__functor)->__value)( - std::forward<_ArgTypes>(__args)...); + return mem_fn(_Base::_M_get_pointer(__functor)->__value)( + std::forward<_ArgTypes>(__args)...); } }; template class _Function_handler : public _Function_base::_Base_manager< - _Simple_type_wrapper< _Member _Class::* > > + _Simple_type_wrapper< _Member _Class::* > > { typedef _Member _Class::* _Functor; typedef _Simple_type_wrapper<_Functor> _Wrapper; @@ -1826,31 +1830,31 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) + _Manager_operation __op) { - switch (__op) + switch (__op) { #ifdef __GXX_RTTI case __get_type_info: __dest._M_access() = &typeid(_Functor); break; -#endif +#endif case __get_functor_ptr: __dest._M_access<_Functor*>() = &_Base::_M_get_pointer(__source)->__value; break; - + default: _Base::_M_manager(__dest, __source, __op); } - return false; + return false; } static void _M_invoke(const _Any_data& __functor, _ArgTypes... __args) { mem_fn(_Base::_M_get_pointer(__functor)->__value)( - std::forward<_ArgTypes>(__args)...); + std::forward<_ArgTypes>(__args)...); } }; @@ -1866,26 +1870,26 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) private _Function_base { typedef _Res _Signature_type(_ArgTypes...); - + struct _Useless { }; - + public: typedef _Res result_type; - + // [3.7.2.1] construct/copy/destroy - + /** * @brief Default construct creates an empty function call wrapper. * @post @c !(bool)*this */ function() : _Function_base() { } - + /** * @brief Creates an empty function call wrapper. * @post @c !(bool)*this */ function(nullptr_t) : _Function_base() { } - + /** * @brief %Function copy constructor. * @param x A %function object with identical call signature. @@ -1905,11 +1909,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) */ function(function&& __x) : _Function_base() { - __x.swap(*this); + __x.swap(*this); } // TODO: needs allocator_arg_t - + /** * @brief Builds a %function that targets a copy of the incoming * function object. @@ -1927,10 +1931,10 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * reference_wrapper, this function will not throw. */ template - function(_Functor __f, - typename enable_if< - !is_integral<_Functor>::value, _Useless>::type - = _Useless()); + function(_Functor __f, + typename enable_if< + !is_integral<_Functor>::value, _Useless>::type + = _Useless()); /** * @brief %Function assignment operator. @@ -1947,8 +1951,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) function& operator=(const function& __x) { - function(__x).swap(*this); - return *this; + function(__x).swap(*this); + return *this; } /** @@ -1965,8 +1969,8 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) function& operator=(function&& __x) { - function(std::move(__x)).swap(*this); - return *this; + function(std::move(__x)).swap(*this); + return *this; } /** @@ -1979,13 +1983,13 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) function& operator=(nullptr_t) { - if (_M_manager) + if (_M_manager) { _M_manager(_M_functor, _M_functor, __destroy_functor); _M_manager = 0; _M_invoker = 0; } - return *this; + return *this; } /** @@ -2005,7 +2009,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * reference_wrapper, this function will not throw. */ template - typename enable_if::value, function&>::type + typename enable_if::value, function&>::type operator=(_Functor&& __f) { function(std::forward<_Functor>(__f)).swap(*this); @@ -2014,7 +2018,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) /// @overload template - typename enable_if::value, function&>::type + typename enable_if::value, function&>::type operator=(reference_wrapper<_Functor> __f) { function(__f).swap(*this); @@ -2022,7 +2026,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) } // [3.7.2.2] function modifiers - + /** * @brief Swap the targets of two %function objects. * @param f A %function with identical call signature. @@ -2040,14 +2044,14 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) // TODO: needs allocator_arg_t /* template - void - assign(_Functor&& __f, const _Alloc& __a) - { - function(allocator_arg, __a, - std::forward<_Functor>(__f)).swap(*this); - } + void + assign(_Functor&& __f, const _Alloc& __a) + { + function(allocator_arg, __a, + std::forward<_Functor>(__f)).swap(*this); + } */ - + // [3.7.2.3] function capacity /** @@ -2085,7 +2089,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * This function will not throw an %exception. */ const type_info& target_type() const; - + /** * @brief Access the stored target function object. * @@ -2096,7 +2100,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) * This function will not throw an %exception. */ template _Functor* target(); - + /// @overload template const _Functor* target() const; #endif @@ -2125,7 +2129,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) function<_Res(_ArgTypes...)>:: function(_Functor __f, typename enable_if< - !is_integral<_Functor>::value, _Useless>::type) + !is_integral<_Functor>::value, _Useless>::type) : _Function_base() { typedef _Function_handler<_Signature_type, _Functor> _My_handler; @@ -2144,7 +2148,7 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) operator()(_ArgTypes... __args) const { if (_M_empty()) - __throw_bad_function_call(); + __throw_bad_function_call(); return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); } @@ -2155,11 +2159,11 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type) target_type() const { if (_M_manager) - { - _Any_data __typeinfo_result; - _M_manager(__typeinfo_result, _M_functor, __get_type_info); - return *__typeinfo_result._M_access(); - } + { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + return *__typeinfo_result._M_access(); + } else return typeid(void); } diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index e32b2a073dd..17d46dbd431 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -160,7 +160,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { exception_ptr _M_error; - _Result_base() = default; _Result_base(const _Result_base&) = delete; _Result_base& operator=(const _Result_base&) = delete; @@ -173,7 +172,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; protected: - ~_Result_base(); + _Result_base(); + virtual ~_Result_base(); }; /// Result. @@ -273,8 +273,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } - /// Shared state between a promise and one or more associated futures. - class _State + /// Base class for state between a promise and one or more + /// associated futures. + class _State_base { typedef _Ptr<_Result_base>::type _Ptr_type; @@ -285,10 +286,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION once_flag _M_once; public: - _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } - - _State(const _State&) = delete; - _State& operator=(const _State&) = delete; + _State_base() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } + _State_base(const _State_base&) = delete; + _State_base& operator=(const _State_base&) = delete; + virtual ~_State_base(); _Result_base& wait() @@ -296,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_run_deferred(); unique_lock __lock(_M_mutex); if (!_M_ready()) - _M_cond.wait(__lock, std::bind(&_State::_M_ready, this)); + _M_cond.wait(__lock, std::bind(&_State_base::_M_ready, this)); return *_M_result; } @@ -305,7 +306,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION wait_for(const chrono::duration<_Rep, _Period>& __rel) { unique_lock __lock(_M_mutex); - auto __bound = std::bind(&_State::_M_ready, this); + auto __bound = std::bind(&_State_base::_M_ready, this); return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound); } @@ -314,7 +315,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION wait_until(const chrono::time_point<_Clock, _Duration>& __abs) { unique_lock __lock(_M_mutex); - auto __bound = std::bind(&_State::_M_ready, this); + auto __bound = std::bind(&_State_base::_M_ready, this); return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound); } @@ -324,7 +325,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool __set = __ignore_failure; // all calls to this function are serialized, // side-effects of invoking __res only happen once - call_once(_M_once, &_State::_M_do_set, this, ref(__res), + call_once(_M_once, &_State_base::_M_do_set, this, ref(__res), ref(__set)); if (!__set) __throw_future_error(int(future_errc::promise_already_satisfied)); @@ -368,7 +369,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typename promise<_Res>::_Ptr_type operator()() { - _State::_S_check(_M_promise->_M_future); + _State_base::_S_check(_M_promise->_M_future); _M_promise->_M_storage->_M_set(_M_arg); return std::move(_M_promise->_M_storage); } @@ -382,7 +383,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { typename promise<_Res>::_Ptr_type operator()() { - _State::_S_check(_M_promise->_M_future); + _State_base::_S_check(_M_promise->_M_future); _M_promise->_M_storage->_M_set(std::move(_M_arg)); return std::move(_M_promise->_M_storage); } @@ -398,7 +399,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { typename promise<_Res>::_Ptr_type operator()() { - _State::_S_check(_M_promise->_M_future); + _State_base::_S_check(_M_promise->_M_future); _M_promise->_M_storage->_M_error = _M_ex; return std::move(_M_promise->_M_storage); } @@ -463,8 +464,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct _Task_setter; }; - inline __future_base::_Result_base::~_Result_base() = default; - /// Partial specialization for reference types. template struct __future_base::_Result<_Res&> : __future_base::_Result_base @@ -495,7 +494,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION class __basic_future : public __future_base { protected: - typedef shared_ptr<_State> __state_type; + typedef shared_ptr<_State_base> __state_type; typedef __future_base::_Result<_Res>& __result_type; private: @@ -512,7 +511,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void wait() const { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); _M_state->wait(); } @@ -520,7 +519,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool wait_for(const chrono::duration<_Rep, _Period>& __rel) const { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); return _M_state->wait_for(__rel); } @@ -528,7 +527,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION bool wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); return _M_state->wait_until(__abs); } @@ -537,7 +536,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __result_type _M_get_result() { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); _Result_base& __res = _M_state->wait(); if (!(__res._M_error == 0)) rethrow_exception(__res._M_error); @@ -553,7 +552,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION explicit __basic_future(const __state_type& __state) : _M_state(__state) { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); _M_state->_M_set_retrieved_flag(); } @@ -850,9 +849,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template class promise { - typedef __future_base::_State _State; - typedef __future_base::_Result<_Res> _Res_type; - typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + typedef __future_base::_State_base _State; + typedef __future_base::_Result<_Res> _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; template friend class _State::_Setter; shared_ptr<_State> _M_future; @@ -942,9 +941,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template class promise<_Res&> { - typedef __future_base::_State _State; - typedef __future_base::_Result<_Res&> _Res_type; - typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + typedef __future_base::_State_base _State; + typedef __future_base::_Result<_Res&> _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; template friend class _State::_Setter; shared_ptr<_State> _M_future; @@ -1017,9 +1016,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> class promise { - typedef __future_base::_State _State; - typedef __future_base::_Result _Res_type; - typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; + typedef __future_base::_State_base _State; + typedef __future_base::_Result _Res_type; + typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type; template friend class _State::_Setter; shared_ptr<_State> _M_future; @@ -1085,19 +1084,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // set void template<> - struct __future_base::_State::_Setter + struct __future_base::_State_base::_Setter { promise::_Ptr_type operator()() { - _State::_S_check(_M_promise->_M_future); + _State_base::_S_check(_M_promise->_M_future); return std::move(_M_promise->_M_storage); } promise* _M_promise; }; - inline __future_base::_State::_Setter - __future_base::_State::__setter(promise* __prom) + inline __future_base::_State_base::_Setter + __future_base::_State_base::__setter(promise* __prom) { return _Setter{ __prom }; } @@ -1149,7 +1148,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; template - struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State + struct __future_base::_Task_state<_Res(_Args...)> + : __future_base::_State_base { typedef _Res _Res_type; @@ -1263,14 +1263,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION void operator()(_ArgTypes... __args) { - __future_base::_State::_S_check(_M_state); + __future_base::_State_base::_S_check(_M_state); _M_state->_M_run(std::forward<_ArgTypes>(__args)...); } void reset() { - __future_base::_State::_S_check(_M_state); + __future_base::_State_base::_S_check(_M_state); packaged_task(std::move(_M_state->_M_task)).swap(*this); } }; @@ -1288,7 +1288,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template - class __future_base::_Deferred_state : public __future_base::_State + class __future_base::_Deferred_state : public __future_base::_State_base { public: typedef _Res _Res_type; @@ -1314,7 +1314,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; template - class __future_base::_Async_state : public __future_base::_State + class __future_base::_Async_state : public __future_base::_State_base { public: typedef _Res _Res_type; @@ -1347,7 +1347,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION async(launch __policy, _Fn&& __fn, _Args&&... __args) { typedef typename result_of<_Fn(_Args...)>::type result_type; - std::shared_ptr<__future_base::_State> __state; + std::shared_ptr<__future_base::_State_base> __state; if (__policy == launch::async) { typedef typename __future_base::_Async_state _State; diff --git a/libstdc++-v3/include/std/stdexcept b/libstdc++-v3/include/std/stdexcept index de023d12bb8..a461795d7ec 100644 --- a/libstdc++-v3/include/std/stdexcept +++ b/libstdc++-v3/include/std/stdexcept @@ -1,6 +1,6 @@ // Standard exception classes -*- C++ -*- -// Copyright (C) 2001, 2002, 2005, 2007, 2009, 2010 +// Copyright (C) 2001, 2002, 2005, 2007, 2009, 2010, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -62,8 +62,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION explicit logic_error(const string& __arg); - virtual - ~logic_error() throw(); + virtual ~logic_error() throw(); /** Returns a C-style character string describing the general cause of * the current error (the same string passed to the ctor). */ @@ -77,6 +76,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit domain_error(const string& __arg); + virtual ~domain_error() throw(); }; /** Thrown to report invalid arguments to functions. */ @@ -84,6 +84,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit invalid_argument(const string& __arg); + virtual ~invalid_argument() throw(); }; /** Thrown when an object is constructed that would exceed its maximum @@ -92,6 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit length_error(const string& __arg); + virtual ~length_error() throw(); }; /** This represents an argument whose value is not within the expected @@ -100,6 +102,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit out_of_range(const string& __arg); + virtual ~out_of_range() throw(); }; /** Runtime errors represent problems outside the scope of a program; @@ -116,8 +119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION explicit runtime_error(const string& __arg); - virtual - ~runtime_error() throw(); + virtual ~runtime_error() throw(); /** Returns a C-style character string describing the general cause of * the current error (the same string passed to the ctor). */ @@ -130,6 +132,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit range_error(const string& __arg); + virtual ~range_error() throw(); }; /** Thrown to indicate arithmetic overflow. */ @@ -137,6 +140,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit overflow_error(const string& __arg); + virtual ~overflow_error() throw(); }; /** Thrown to indicate arithmetic underflow. */ @@ -144,6 +148,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { public: explicit underflow_error(const string& __arg); + virtual ~underflow_error() throw(); }; // @} group exceptions diff --git a/libstdc++-v3/include/std/system_error b/libstdc++-v3/include/std/system_error index 187c03f01d1..da09a758825 100644 --- a/libstdc++-v3/include/std/system_error +++ b/libstdc++-v3/include/std/system_error @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010, 2011 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 @@ -69,7 +69,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION error_category(); public: - virtual ~error_category() { } + virtual ~error_category(); error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; @@ -102,8 +102,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return this != &__other; } }; - inline error_category::error_category() = default; - // DR 890. _GLIBCXX_CONST const error_category& system_category() throw(); _GLIBCXX_CONST const error_category& generic_category() throw(); diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread index de58e814100..e43c126cdce 100644 --- a/libstdc++-v3/include/std/thread +++ b/libstdc++-v3/include/std/thread @@ -100,7 +100,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { __shared_base_type _M_this_ptr; - inline virtual ~_Impl_base(); + virtual ~_Impl_base(); virtual void _M_run() = 0; }; @@ -195,8 +195,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; - inline thread::_Impl_base::~_Impl_base() = default; - inline void swap(thread& __x, thread& __y) { __x.swap(__y); } diff --git a/libstdc++-v3/libsupc++/Makefile.am b/libstdc++-v3/libsupc++/Makefile.am index 842d87af816..701c2d9a76a 100644 --- a/libstdc++-v3/libsupc++/Makefile.am +++ b/libstdc++-v3/libsupc++/Makefile.am @@ -77,6 +77,7 @@ sources = \ guard.cc \ guard_error.cc \ hash_bytes.cc \ + nested_exception.cc \ new_handler.cc \ new_op.cc \ new_opnt.cc \ @@ -134,6 +135,11 @@ cp-demangle.o: cp-demangle.c $(C_COMPILE) -DIN_GLIBCPP_V3 -Wno-error -c $< +nested_exception.lo: nested_exception.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +nested_exception.o: nested_exception.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + # Libtool notes # 1) Need to explicitly set LTCXXCOMPILE so that AM_CXXFLAGS is diff --git a/libstdc++-v3/libsupc++/Makefile.in b/libstdc++-v3/libsupc++/Makefile.in index c994b07cdd7..18ba840180e 100644 --- a/libstdc++-v3/libsupc++/Makefile.in +++ b/libstdc++-v3/libsupc++/Makefile.in @@ -98,10 +98,10 @@ am__objects_1 = array_type_info.lo atexit_arm.lo bad_alloc.lo \ eh_term_handler.lo eh_terminate.lo eh_throw.lo eh_type.lo \ eh_unex_handler.lo enum_type_info.lo function_type_info.lo \ fundamental_type_info.lo guard.lo guard_error.lo hash_bytes.lo \ - new_handler.lo new_op.lo new_opnt.lo new_opv.lo new_opvnt.lo \ - pbase_type_info.lo pmem_type_info.lo pointer_type_info.lo \ - pure.lo si_class_type_info.lo tinfo.lo tinfo2.lo vec.lo \ - vmi_class_type_info.lo vterminate.lo + nested_exception.lo new_handler.lo new_op.lo new_opnt.lo \ + new_opv.lo new_opvnt.lo pbase_type_info.lo pmem_type_info.lo \ + pointer_type_info.lo pure.lo si_class_type_info.lo tinfo.lo \ + tinfo2.lo vec.lo vmi_class_type_info.lo vterminate.lo @GLIBCXX_HOSTED_TRUE@am__objects_2 = cp-demangle.lo am_libsupc___la_OBJECTS = $(am__objects_1) $(am__objects_2) libsupc___la_OBJECTS = $(am_libsupc___la_OBJECTS) @@ -383,6 +383,7 @@ sources = \ guard.cc \ guard_error.cc \ hash_bytes.cc \ + nested_exception.cc \ new_handler.cc \ new_op.cc \ new_opnt.cc \ @@ -766,6 +767,11 @@ cp-demangle.lo: cp-demangle.c cp-demangle.o: cp-demangle.c $(C_COMPILE) -DIN_GLIBCPP_V3 -Wno-error -c $< +nested_exception.lo: nested_exception.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +nested_exception.o: nested_exception.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + install-stdHEADERS: $(std_HEADERS) @$(NORMAL_INSTALL) $(mkinstalldirs) $(DESTDIR)$(stddir) diff --git a/libstdc++-v3/libsupc++/nested_exception.cc b/libstdc++-v3/libsupc++/nested_exception.cc new file mode 100644 index 00000000000..876e8e00aa1 --- /dev/null +++ b/libstdc++-v3/libsupc++/nested_exception.cc @@ -0,0 +1,29 @@ +// Copyright (C) 2011 Free Software Foundation +// +// This file is part of GCC. +// +// GCC 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. + +// GCC 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 +// . + +#include + +namespace std +{ + nested_exception::~nested_exception() = default; +} // namespace std diff --git a/libstdc++-v3/libsupc++/nested_exception.h b/libstdc++-v3/libsupc++/nested_exception.h index 799bd1979d7..6a4f04e2e07 100644 --- a/libstdc++-v3/libsupc++/nested_exception.h +++ b/libstdc++-v3/libsupc++/nested_exception.h @@ -63,7 +63,7 @@ namespace std nested_exception& operator=(const nested_exception&) = default; - inline virtual ~nested_exception(); + virtual ~nested_exception(); void rethrow_nested() const __attribute__ ((__noreturn__)) @@ -74,8 +74,6 @@ namespace std { return _M_ptr; } }; - inline nested_exception::~nested_exception() = default; - template struct _Nested_exception : public _Except, public nested_exception { diff --git a/libstdc++-v3/src/Makefile.am b/libstdc++-v3/src/Makefile.am index f52993b54cb..9a356855138 100644 --- a/libstdc++-v3/src/Makefile.am +++ b/libstdc++-v3/src/Makefile.am @@ -201,6 +201,7 @@ sources = \ ctype.cc \ debug.cc \ functexcept.cc \ + functional.cc \ globals_io.cc \ hash_c++0x.cc \ hash_tr1.cc \ @@ -225,6 +226,7 @@ sources = \ istream.cc \ placeholders.cc \ regex.cc \ + shared_ptr.cc \ streambuf.cc \ mutex.cc \ condition_variable.cc \ @@ -292,6 +294,11 @@ functexcept.lo: functexcept.cc functexcept.o: functexcept.cc $(CXXCOMPILE) -std=gnu++0x -c $< +shared_ptr.lo: shared_ptr.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +shared_ptr.o: shared_ptr.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + system_error.lo: system_error.cc $(LTCXXCOMPILE) -std=gnu++0x -c $< system_error.o: system_error.cc @@ -312,6 +319,11 @@ compatibility-c++0x.lo: compatibility-c++0x.cc compatibility-c++0x.o: compatibility-c++0x.cc $(CXXCOMPILE) -std=gnu++0x -c $< +functional.lo: functional.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +functional.o: functional.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + hash_c++0x.lo: hash_c++0x.cc $(LTCXXCOMPILE) -std=gnu++0x -c $< hash_c++0x.o: hash_c++0x.cc diff --git a/libstdc++-v3/src/Makefile.in b/libstdc++-v3/src/Makefile.in index 67c125f0c78..b454f66dc8b 100644 --- a/libstdc++-v3/src/Makefile.in +++ b/libstdc++-v3/src/Makefile.in @@ -110,13 +110,13 @@ am__objects_6 = atomic.lo bitmap_allocator.lo pool_allocator.lo \ compatibility-c++0x.lo compatibility-debug_list.lo \ compatibility-debug_list-2.lo compatibility-list.lo \ compatibility-list-2.lo complex_io.lo ctype.lo debug.lo \ - functexcept.lo globals_io.lo hash_c++0x.lo hash_tr1.lo \ - hashtable_c++0x.lo hashtable_tr1.lo ios.lo ios_failure.lo \ - ios_init.lo ios_locale.lo limits.lo list.lo locale.lo \ - locale_init.lo locale_facets.lo localename.lo \ + functexcept.lo functional.lo globals_io.lo hash_c++0x.lo \ + hash_tr1.lo hashtable_c++0x.lo hashtable_tr1.lo ios.lo \ + ios_failure.lo ios_init.lo ios_locale.lo limits.lo list.lo \ + locale.lo locale_init.lo locale_facets.lo localename.lo \ math_stubs_float.lo math_stubs_long_double.lo stdexcept.lo \ strstream.lo system_error.lo tree.lo istream.lo \ - placeholders.lo regex.lo streambuf.lo mutex.lo \ + placeholders.lo regex.lo shared_ptr.lo streambuf.lo mutex.lo \ condition_variable.lo chrono.lo thread.lo future.lo \ valarray.lo $(am__objects_1) $(am__objects_5) am_libstdc___la_OBJECTS = $(am__objects_6) @@ -420,6 +420,7 @@ sources = \ ctype.cc \ debug.cc \ functexcept.cc \ + functional.cc \ globals_io.cc \ hash_c++0x.cc \ hash_tr1.cc \ @@ -444,6 +445,7 @@ sources = \ istream.cc \ placeholders.cc \ regex.cc \ + shared_ptr.cc \ streambuf.cc \ mutex.cc \ condition_variable.cc \ @@ -885,6 +887,11 @@ functexcept.lo: functexcept.cc functexcept.o: functexcept.cc $(CXXCOMPILE) -std=gnu++0x -c $< +shared_ptr.lo: shared_ptr.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +shared_ptr.o: shared_ptr.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + system_error.lo: system_error.cc $(LTCXXCOMPILE) -std=gnu++0x -c $< system_error.o: system_error.cc @@ -905,6 +912,11 @@ compatibility-c++0x.lo: compatibility-c++0x.cc compatibility-c++0x.o: compatibility-c++0x.cc $(CXXCOMPILE) -std=gnu++0x -c $< +functional.lo: functional.cc + $(LTCXXCOMPILE) -std=gnu++0x -c $< +functional.o: functional.cc + $(CXXCOMPILE) -std=gnu++0x -c $< + hash_c++0x.lo: hash_c++0x.cc $(LTCXXCOMPILE) -std=gnu++0x -c $< hash_c++0x.o: hash_c++0x.cc diff --git a/libstdc++-v3/src/functional.cc b/libstdc++-v3/src/functional.cc new file mode 100644 index 00000000000..2ab34051432 --- /dev/null +++ b/libstdc++-v3/src/functional.cc @@ -0,0 +1,35 @@ +// Support for -*- C++ -*- + +// Copyright (C) 2011 +// 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 +// . + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + bad_function_call::~bad_function_call() throw() = default; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace diff --git a/libstdc++-v3/src/future.cc b/libstdc++-v3/src/future.cc index d5afcf21c8c..d2bc3237019 100644 --- a/libstdc++-v3/src/future.cc +++ b/libstdc++-v3/src/future.cc @@ -79,8 +79,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const char* future_error::what() const throw() { return _M_code.message().c_str(); } + __future_base::_Result_base::_Result_base() = default; + + __future_base::_Result_base::~_Result_base() = default; + + __future_base::_State_base::~_State_base() = default; + _GLIBCXX_END_NAMESPACE_VERSION -} // namespace +} // namespace std // XXX GLIBCXX_ABI Deprecated // gcc-4.6.0 diff --git a/libstdc++-v3/src/shared_ptr.cc b/libstdc++-v3/src/shared_ptr.cc new file mode 100644 index 00000000000..670b7ca7ff0 --- /dev/null +++ b/libstdc++-v3/src/shared_ptr.cc @@ -0,0 +1,39 @@ +// Support for pointer abstractions -*- C++ -*- + +// Copyright (C) 2011 +// 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 +// . + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + bad_weak_ptr::~bad_weak_ptr() throw() = default; + + char const* + bad_weak_ptr::what() const throw() + { return "std::bad_weak_ptr"; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace diff --git a/libstdc++-v3/src/stdexcept.cc b/libstdc++-v3/src/stdexcept.cc index 0b78f9a9b2e..b693da23f4f 100644 --- a/libstdc++-v3/src/stdexcept.cc +++ b/libstdc++-v3/src/stdexcept.cc @@ -1,6 +1,6 @@ // Methods for Exception Support for -*- C++ -*- -// Copyright (C) 1997, 1999, 2001, 2002, 2005, 2009 +// Copyright (C) 1997, 1999, 2001, 2002, 2005, 2009, 2011 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -34,7 +34,7 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION - logic_error::logic_error(const string& __arg) + logic_error::logic_error(const string& __arg) : exception(), _M_msg(__arg) { } logic_error::~logic_error() throw() { } @@ -46,16 +46,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION domain_error::domain_error(const string& __arg) : logic_error(__arg) { } + domain_error::~domain_error() throw() { } + invalid_argument::invalid_argument(const string& __arg) : logic_error(__arg) { } + invalid_argument::~invalid_argument() throw() { } + length_error::length_error(const string& __arg) : logic_error(__arg) { } + length_error::~length_error() throw() { } + out_of_range::out_of_range(const string& __arg) : logic_error(__arg) { } - runtime_error::runtime_error(const string& __arg) + out_of_range::~out_of_range() throw() { } + + runtime_error::runtime_error(const string& __arg) : exception(), _M_msg(__arg) { } runtime_error::~runtime_error() throw() { } @@ -67,12 +75,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION range_error::range_error(const string& __arg) : runtime_error(__arg) { } + range_error::~range_error() throw() { } + overflow_error::overflow_error(const string& __arg) : runtime_error(__arg) { } + overflow_error::~overflow_error() throw() { } + underflow_error::underflow_error(const string& __arg) : runtime_error(__arg) { } + underflow_error::~underflow_error() throw() { } + _GLIBCXX_END_NAMESPACE_VERSION } // namespace - diff --git a/libstdc++-v3/src/system_error.cc b/libstdc++-v3/src/system_error.cc index 156f8fcf7a0..5d9c6f5e26b 100644 --- a/libstdc++-v3/src/system_error.cc +++ b/libstdc++-v3/src/system_error.cc @@ -1,6 +1,6 @@ // implementation file -// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. +// Copyright (C) 2007, 2008, 2009, 2010, 2011 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 @@ -74,13 +74,17 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION + error_category::error_category() = default; + + error_category::~error_category() = default; + const error_category& system_category() throw() { return system_category_instance; } const error_category& generic_category() throw() { return generic_category_instance; } - system_error::~system_error() throw() { } + system_error::~system_error() throw() = default; error_condition error_category::default_error_condition(int __i) const diff --git a/libstdc++-v3/src/thread.cc b/libstdc++-v3/src/thread.cc index c164e8a0161..7c923a26610 100644 --- a/libstdc++-v3/src/thread.cc +++ b/libstdc++-v3/src/thread.cc @@ -54,6 +54,8 @@ namespace std _GLIBCXX_VISIBILITY(default) _GLIBCXX_BEGIN_NAMESPACE_VERSION + thread::_Impl_base::~_Impl_base() = default; + void thread::join() { diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc index c594461a4b9..36cf7f9c29d 100644 --- a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc @@ -32,9 +32,9 @@ void test01() { X* px = 0; std::shared_ptr p1(px); // { dg-error "here" } - // { dg-error "incomplete" "" { target *-*-* } 765 } + // { dg-error "incomplete" "" { target *-*-* } 766 } std::shared_ptr p9(ap()); // { dg-error "here" } - // { dg-error "incomplete" "" { target *-*-* } 857 } + // { dg-error "incomplete" "" { target *-*-* } 858 } } diff --git a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc index 098dbfd89df..28c8797b9ca 100644 --- a/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc +++ b/libstdc++-v3/testsuite/20_util/weak_ptr/comparison/cmp_neg.cc @@ -43,7 +43,7 @@ main() } // { dg-warning "note" "" { target *-*-* } 354 } -// { dg-warning "note" "" { target *-*-* } 1085 } +// { dg-warning "note" "" { target *-*-* } 1086 } // { dg-warning "note" "" { target *-*-* } 467 } // { dg-warning "note" "" { target *-*-* } 587 } // { dg-warning "note" "" { target *-*-* } 1050 }