From patchwork Tue Mar 15 02:59:40 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Benjamin Kosnik X-Patchwork-Id: 86843 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 3D22FB6FB1 for ; Tue, 15 Mar 2011 14:00:55 +1100 (EST) Received: (qmail 16429 invoked by alias); 15 Mar 2011 03:00:44 -0000 Received: (qmail 16175 invoked by uid 22791); 15 Mar 2011 03:00:06 -0000 X-SWARE-Spam-Status: No, hits=-5.8 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_HI, SPF_HELO_PASS, T_FILL_THIS_FORM_SHORT, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 15 Mar 2011 02:59:44 +0000 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id p2F2xhcf022023 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Mon, 14 Mar 2011 22:59:43 -0400 Received: from shotwell (ovpn-113-58.phx2.redhat.com [10.3.113.58]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id p2F2xeni025771 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES128-SHA bits=128 verify=NO); Mon, 14 Mar 2011 22:59:41 -0400 Date: Mon, 14 Mar 2011 19:59:40 -0700 From: Benjamin Kosnik To: Benjamin Kosnik Cc: gcc-patches@gcc.gnu.org, libstdc++@gcc.gnu.org Subject: Re: [v3] typeinfo tuning Message-ID: <20110314195940.02ee5099@shotwell> In-Reply-To: <20110314102944.565db3c8@shotwell> References: <20110314102944.565db3c8@shotwell> Mime-Version: 1.0 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org > Here are the clear wins that are ABI-compatible, or in C++0x code. > There are other issues, like the locale base classes, that are not as > easy to fix. There are a couple other issues in C++0x code that I am > working out, will post later today. Here is the complete set. > I'm holding off on this patch until branching is clear. But I thought > I'd post it so that this effort is public. It's set up for 4.6.0 but > may be moved to 4.7.0. This is versioned for 4.6.0, but I'll wait a day or two to see how it goes before I plead with the RMs. tested x86_64/linux -benjamin 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. Index: src/shared_ptr.cc =================================================================== --- src/shared_ptr.cc (revision 0) +++ src/shared_ptr.cc (revision 0) @@ -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 Index: src/system_error.cc =================================================================== --- src/system_error.cc (revision 170967) +++ src/system_error.cc (working copy) @@ -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 @@ { _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 Index: src/functional.cc =================================================================== --- src/functional.cc (revision 0) +++ src/functional.cc (revision 0) @@ -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 Index: src/stdexcept.cc =================================================================== --- src/stdexcept.cc (revision 170967) +++ src/stdexcept.cc (working copy) @@ -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 @@ { _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 @@ 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 @@ 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 - Index: src/future.cc =================================================================== --- src/future.cc (revision 170967) +++ src/future.cc (working copy) @@ -79,8 +79,14 @@ 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 Index: src/thread.cc =================================================================== --- src/thread.cc (revision 170967) +++ src/thread.cc (working copy) @@ -54,6 +54,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION + thread::_Impl_base::~_Impl_base() = default; + void thread::join() { Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 170967) +++ src/Makefile.am (working copy) @@ -201,6 +201,7 @@ ctype.cc \ debug.cc \ functexcept.cc \ + functional.cc \ globals_io.cc \ hash_c++0x.cc \ hash_tr1.cc \ @@ -225,6 +226,7 @@ istream.cc \ placeholders.cc \ regex.cc \ + shared_ptr.cc \ streambuf.cc \ mutex.cc \ condition_variable.cc \ @@ -292,6 +294,11 @@ 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.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 Index: include/std/system_error =================================================================== --- include/std/system_error (revision 170967) +++ include/std/system_error (working copy) @@ -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 @@ 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 @@ { 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(); Index: include/std/stdexcept =================================================================== --- include/std/stdexcept (revision 170967) +++ include/std/stdexcept (working copy) @@ -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 @@ 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 @@ { public: explicit domain_error(const string& __arg); + virtual ~domain_error() throw(); }; /** Thrown to report invalid arguments to functions. */ @@ -84,6 +84,7 @@ { 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 @@ { 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 @@ { 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 @@ 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 @@ { public: explicit range_error(const string& __arg); + virtual ~range_error() throw(); }; /** Thrown to indicate arithmetic overflow. */ @@ -137,6 +140,7 @@ { public: explicit overflow_error(const string& __arg); + virtual ~overflow_error() throw(); }; /** Thrown to indicate arithmetic underflow. */ @@ -144,6 +148,7 @@ { public: explicit underflow_error(const string& __arg); + virtual ~underflow_error() throw(); }; // @} group exceptions Index: include/std/thread =================================================================== --- include/std/thread (revision 170967) +++ include/std/thread (working copy) @@ -100,7 +100,7 @@ { __shared_base_type _M_this_ptr; - inline virtual ~_Impl_base(); + virtual ~_Impl_base(); virtual void _M_run() = 0; }; @@ -195,8 +195,6 @@ } }; - inline thread::_Impl_base::~_Impl_base() = default; - inline void swap(thread& __x, thread& __y) { __x.swap(__y); } Index: include/std/future =================================================================== --- include/std/future (revision 170967) +++ include/std/future (working copy) @@ -160,7 +160,6 @@ { exception_ptr _M_error; - _Result_base() = default; _Result_base(const _Result_base&) = delete; _Result_base& operator=(const _Result_base&) = delete; @@ -173,7 +172,8 @@ }; protected: - ~_Result_base(); + _Result_base(); + virtual ~_Result_base(); }; /// Result. @@ -273,8 +273,9 @@ } - /// 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,18 +286,18 @@ once_flag _M_once; public: - _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { } + _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(); - _State(const _State&) = delete; - _State& operator=(const _State&) = delete; - _Result_base& wait() { _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 @@ 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 @@ 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 @@ 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 @@ 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 @@ { 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 @@ { 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 @@ 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 @@ 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 @@ void wait() const { - _State::_S_check(_M_state); + _State_base::_S_check(_M_state); _M_state->wait(); } @@ -520,7 +519,7 @@ 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 @@ 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 @@ __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 @@ 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 @@ 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 @@ 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 @@ 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 @@ // 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 @@ }; 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 @@ 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 @@ 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 @@ }; 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 @@ 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; Index: include/std/functional =================================================================== --- include/std/functional (revision 170967) +++ include/std/functional (working copy) @@ -83,90 +83,90 @@ { }; /// 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 @@ { 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 @@ { 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 @@ 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 @@ 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 @@ // 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 @@ 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 @@ { 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 @@ * 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 @@ 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 @@ // 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 @@ /// 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 @@ // 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 @@ /// 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 @@ // 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 @@ /// 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 @@ 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 @@ // 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 @@ // 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 @@ * 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 @@ : public integral_constant { }; - /** + /** * Used by _Safe_tuple_element to indicate that there is no tuple * element at this position. */ @@ -926,8 +926,8 @@ */ 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 @@ * 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 @@ * 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 @@ { 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 @@ 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 @@ 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 @@ }; 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 @@ 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 @@ 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 @@ { 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 @@ // 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 @@ 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 @@ // 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 @@ 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 @@ 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 @@ 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 @@ * 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 @@ { 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 @@ { __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 @@ 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 @@ 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 @@ { 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 @@ __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 @@ }; _Function_base() : _M_manager(0) { } - + ~_Function_base() { if (_M_manager) @@ -1728,7 +1732,7 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ */ 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 @@ * 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 @@ function& operator=(const function& __x) { - function(__x).swap(*this); - return *this; + function(__x).swap(*this); + return *this; } /** @@ -1965,8 +1969,8 @@ function& operator=(function&& __x) { - function(std::move(__x)).swap(*this); - return *this; + function(std::move(__x)).swap(*this); + return *this; } /** @@ -1979,13 +1983,13 @@ 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 @@ * 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 @@ /// @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 @@ } // [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 @@ // 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 @@ * This function will not throw an %exception. */ const type_info& target_type() const; - + /** * @brief Access the stored target function object. * @@ -2096,7 +2100,7 @@ * This function will not throw an %exception. */ template _Functor* target(); - + /// @overload template const _Functor* target() const; #endif @@ -2125,7 +2129,7 @@ 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 @@ 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 @@ 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); } Index: include/bits/regex_compiler.h =================================================================== --- include/bits/regex_compiler.h (revision 170967) +++ include/bits/regex_compiler.h (working copy) @@ -30,10 +30,10 @@ namespace std _GLIBCXX_VISIBILITY(default) { +namespace __regex +{ _GLIBCXX_BEGIN_NAMESPACE_VERSION -namespace __regex -{ struct _Scanner_base { typedef unsigned int _StateT; @@ -41,6 +41,8 @@ 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 @@ { return _AutomatonPtr(new _Nfa(_Compiler<_InIter, _TraitsT>(__b, __e, __t, __f)._M_nfa())); } +_GLIBCXX_END_NAMESPACE_VERSION } // namespace __regex +} // namespace std -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace - /* vim: set ts=8 sw=2 sts=2: */ Index: include/bits/regex_grep_matcher.tcc =================================================================== --- include/bits/regex_grep_matcher.tcc (revision 170967) +++ include/bits/regex_grep_matcher.tcc (working copy) @@ -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 __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + inline _Grep_matcher:: _Grep_matcher(_PatternCursor& __p, _Results& __r, const _AutomatonPtr& __nfa, @@ -175,7 +174,6 @@ return __e; } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace Index: include/bits/regex_grep_matcher.h =================================================================== --- include/bits/regex_grep_matcher.h (revision 170967) +++ include/bits/regex_grep_matcher.h (working copy) @@ -30,7 +30,6 @@ namespace std _GLIBCXX_VISIBILITY(default) { -_GLIBCXX_BEGIN_NAMESPACE_VERSION template class sub_match; @@ -40,6 +39,8 @@ namespace __regex { +_GLIBCXX_BEGIN_NAMESPACE_VERSION + // A _Results facade specialized for wrapping a templated match_results. template class _SpecializedResults @@ -121,9 +122,8 @@ _Results& _M_results; }; +_GLIBCXX_END_NAMESPACE_VERSION } // namespace __regex - -_GLIBCXX_END_NAMESPACE_VERSION } // namespace #include Index: include/bits/regex_cursor.h =================================================================== --- include/bits/regex_cursor.h (revision 170967) +++ include/bits/regex_cursor.h (working copy) @@ -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 @@ __cursor(const _FwdIterT& __b, const _FwdIterT __e) { return _SpecializedCursor<_FwdIterT>(__b, __e); } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace Index: include/bits/regex_nfa.tcc =================================================================== --- include/bits/regex_nfa.tcc (revision 170967) +++ include/bits/regex_nfa.tcc (working copy) @@ -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 @@ _M_clone() { return 0; } -} // namespace __regex - _GLIBCXX_END_NAMESPACE_VERSION +} // namespace __regex } // namespace Index: include/bits/shared_ptr_base.h =================================================================== --- include/bits/shared_ptr_base.h (revision 170967) +++ include/bits/shared_ptr_base.h (working copy) @@ -61,8 +61,9 @@ { 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. Index: include/bits/regex_nfa.h =================================================================== --- include/bits/regex_nfa.h (revision 170967) +++ include/bits/regex_nfa.h (working copy) @@ -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 @@ public: virtual - ~_Automaton() - { } + ~_Automaton() { } virtual _SizeT _M_sub_count() const = 0; @@ -394,10 +392,9 @@ }; +_GLIBCXX_END_NAMESPACE_VERSION } // namespace __regex +} // namespace std -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace - #include Index: libsupc++/nested_exception.cc =================================================================== --- libsupc++/nested_exception.cc (revision 0) +++ libsupc++/nested_exception.cc (revision 0) @@ -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 Index: libsupc++/nested_exception.h =================================================================== --- libsupc++/nested_exception.h (revision 170967) +++ libsupc++/nested_exception.h (working copy) @@ -63,7 +63,7 @@ nested_exception& operator=(const nested_exception&) = default; - inline virtual ~nested_exception(); + virtual ~nested_exception(); void rethrow_nested() const __attribute__ ((__noreturn__)) @@ -74,8 +74,6 @@ { return _M_ptr; } }; - inline nested_exception::~nested_exception() = default; - template struct _Nested_exception : public _Except, public nested_exception { Index: libsupc++/Makefile.am =================================================================== --- libsupc++/Makefile.am (revision 170967) +++ libsupc++/Makefile.am (working copy) @@ -77,6 +77,7 @@ guard.cc \ guard_error.cc \ hash_bytes.cc \ + nested_exception.cc \ new_handler.cc \ new_op.cc \ new_opnt.cc \ @@ -134,6 +135,11 @@ $(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 Index: testsuite/20_util/shared_ptr/cons/43820_neg.cc =================================================================== --- testsuite/20_util/shared_ptr/cons/43820_neg.cc (revision 170967) +++ testsuite/20_util/shared_ptr/cons/43820_neg.cc (working copy) @@ -32,9 +32,9 @@ { 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 } } Index: testsuite/20_util/weak_ptr/comparison/cmp_neg.cc =================================================================== --- testsuite/20_util/weak_ptr/comparison/cmp_neg.cc (revision 170967) +++ testsuite/20_util/weak_ptr/comparison/cmp_neg.cc (working copy) @@ -43,7 +43,7 @@ } // { 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 } Index: config/abi/pre/gnu.ver =================================================================== --- config/abi/pre/gnu.ver (revision 170967) +++ config/abi/pre/gnu.ver (working copy) @@ -124,7 +124,7 @@ 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 @@ _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 @@ _ZTSSt17bad_function_call; _ZTVSt17bad_function_call; + # std::nested_exception + _ZNSt16nested_exceptionD*; + _ZTISt16nested_exception; + _ZTSSt16nested_exception; + _ZTVSt16nested_exception; + } CXXABI_1.3.4;