Issue #49

Prefer using std::current_exception when available

include/boost/exception/detail/exception_ptr.hpp

@@ -64,8 +64,7 @@ boost
         inline
         wrap_exception_ptr( std::exception_ptr const & e )
             {
-            exception_detail::clone_base const & base =
-                boost::enable_current_exception(std_exception_ptr_wrapper(std::current_exception()));
+            exception_detail::clone_base const & base = boost::enable_current_exception(std_exception_ptr_wrapper(e));
             return shared_ptr<exception_detail::clone_base const>(base.clone());
             }
 #endif
@@ -112,14 +111,24 @@ boost
             }
         };
 
+    namespace
+    exception_detail
+        {
+        template <class E>
+        inline
+        exception_ptr
+        copy_exception_impl( E const & e )
+            {
+            return exception_ptr(boost::make_shared<E>(e));
+            }
+        }
+
     template <class E>
     inline
     exception_ptr
     copy_exception( E const & e )
         {
-        E cp = e;
-        exception_detail::copy_boost_exception(&cp, &e);
-        return exception_ptr(boost::make_shared<wrapexcept<E> >(cp));
+        return exception_detail::copy_exception_impl(boost::enable_current_exception(e));
         }
 
     template <class T>
@@ -385,6 +394,9 @@ boost
                         {
                         return exception_ptr(shared_ptr<exception_detail::clone_base const>(e.clone()));
                         }
+
+#ifdef BOOST_NO_CXX11_HDR_EXCEPTION
+
                     catch(
                     std::domain_error & e )
                         {
@@ -457,19 +469,19 @@ boost
                         {
                         return exception_detail::current_exception_std_exception(e);
                         }
-#ifdef BOOST_NO_CXX11_HDR_EXCEPTION
-                    // this case can be handled losslesly with std::current_exception() (see below)
                     catch(
                     std::exception & e )
                         {
                         return exception_detail::current_exception_unknown_std_exception(e);
                         }
-#endif
                     catch(
                     boost::exception & e )
                         {
                         return exception_detail::current_exception_unknown_boost_exception(e);
                         }
+
+#endif // #ifdef BOOST_NO_CXX11_HDR_EXCEPTION
+
                     catch(
                     ... )
                         {

include/boost/exception/diagnostic_information.hpp

@@ -9,7 +9,7 @@
 #include <boost/config.hpp>
 #include <boost/exception/get_error_info.hpp>
 #include <boost/exception/info.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #ifndef BOOST_NO_RTTI
 #include <boost/core/demangle.hpp>
 #endif
@@ -149,11 +149,11 @@ boost
                     if( f )
                         {
                         tmp << *f;
-                        if( int const * l=get_error_info<throw_line>(*be) )
+                        if( l )
                             tmp << '(' << *l << "): ";
                         }
                     tmp << "Throw in function ";
-                    if( char const * const * fn=get_error_info<throw_function>(*be) )
+                    if( fn )
                         tmp << *fn;
                     else
                         tmp << "(unknown)";

include/boost/exception/to_string.hpp

@@ -6,7 +6,7 @@
 #ifndef BOOST_EXCEPTION_7E48761AD92811DC9011477D56D89593
 #define BOOST_EXCEPTION_7E48761AD92811DC9011477D56D89593
 
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/exception/detail/is_output_streamable.hpp>
 #include <sstream>
 

meta/libraries.json

@@ -7,6 +7,7 @@
     "description": "The Boost Exception library supports transporting of arbitrary data in exception objects, and transporting of exceptions between threads.",
     "documentation": "doc/boost-exception.html",
     "category": [
+        "Error-handling",
         "Emulation"
     ],
     "maintainers": [

test/Jamfile.v2

@@ -41,6 +41,7 @@ run no_exceptions_test.cpp : : : <exception-handling>off ;
 run errinfos_test.cpp : : : <exception-handling>on ;
 run exception_ptr_test.cpp/<define>BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR ../../thread/src/tss_null.cpp /boost/exception /boost//thread : : : <threading>multi <exception-handling>on : non_intrusive_exception_ptr_test ;
 run exception_ptr_test.cpp ../../thread/src/tss_null.cpp /boost//thread : : : <threading>multi <exception-handling>on ;
+run exception_ptr_test2.cpp ;
 
 lib visibility_test_lib : visibility_test_lib.cpp : <visibility>hidden <exception-handling>on ;
 run visibility_test.cpp visibility_test_lib/<link>shared : : : <visibility>hidden <exception-handling>on ;

test/exception_ptr_test2.cpp

@@ -0,0 +1,114 @@
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_EXCEPTIONS)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_EXCEPTIONS is defined" )
+
+int main() {}
+
+#elif defined(BOOST_NO_CXX11_HDR_EXCEPTION)
+
+#include <boost/config/pragma_message.hpp>
+BOOST_PRAGMA_MESSAGE( "Skipping test because BOOST_NO_CXX11_HDR_EXCEPTION is defined" )
+
+int main() {}
+
+#else
+
+#include <boost/exception_ptr.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <exception>
+#include <new>
+#include <stdexcept>
+
+class my_exception
+{
+};
+
+class my_exception2: public std::exception
+{
+};
+
+class my_exception3: public std::bad_alloc
+{
+};
+
+class my_exception4: public std::exception, public boost::exception
+{
+};
+
+class my_exception5: public std::logic_error, public virtual boost::exception
+{
+public:
+
+    my_exception5(): std::logic_error( "" ) {}
+};
+
+int main()
+{
+    try
+    {
+        throw my_exception();
+    }
+    catch( ... )
+    {
+        boost::exception_ptr p = boost::current_exception();
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), my_exception );
+    }
+
+    try
+    {
+        throw my_exception2();
+    }
+    catch( ... )
+    {
+        boost::exception_ptr p = boost::current_exception();
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), my_exception2 );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), std::exception );
+    }
+
+    try
+    {
+        throw my_exception3();
+    }
+    catch( ... )
+    {
+        boost::exception_ptr p = boost::current_exception();
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), my_exception3 );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), std::bad_alloc );
+    }
+
+    try
+    {
+        throw my_exception4();
+    }
+    catch( ... )
+    {
+        boost::exception_ptr p = boost::current_exception();
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), my_exception4 );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), std::exception );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), boost::exception );
+    }
+
+    try
+    {
+        throw my_exception5();
+    }
+    catch( ... )
+    {
+        boost::exception_ptr p = boost::current_exception();
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), my_exception5 );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), std::logic_error );
+        BOOST_TEST_THROWS( boost::rethrow_exception( p ), boost::exception );
+    }
+
+    return boost::report_errors();
+}
+
+#endif