throw leaf::exception(....) becomes leaf::throw_exception(....)

Author: zajo

.vscode/launch.json

@@ -8,7 +8,7 @@
             "name": "(lldb) Launch",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/bld/debug/lua_callback_eh",
+            "program": "${workspaceFolder}/bld/debug/capture_exception_async_test",
             "args": [ ],
             "cwd": "${workspaceFolder}",
             "stopAtEntry": false,

doc/LEAF-2.png

@@ -376,7 +376,7 @@ leaf::result<std::string> execute_command(std::string_view line) {
         if (i2 == 0) {
             // In some cases this command execution function might throw, not
             // just return an error.
-            throw leaf::exception(std::runtime_error{"division by zero"});
+            leaf::throw_exception(std::runtime_error{"division by zero"});
         }
         response = std::to_string(i1 % i2);
     } else {

doc/leaf.adoc

@@ -33,7 +33,7 @@ task_result task()
     if( succeed )
         return { };
     else
-        throw leaf::exception(
+        leaf::throw_exception(
             e_thread_id{std::this_thread::get_id()},
             e_failure_info1{"info"},
             e_failure_info2{42} );

example/asio_beast_leaf_rpc.cpp

@@ -75,7 +75,7 @@ int do_work( lua_State * L )
     }
     else
     {
-        throw leaf::exception(ec1);
+        leaf::throw_exception(ec1);
     }
 }
 
@@ -127,7 +127,7 @@ int call_lua( lua_State * L )
                 // cur_err.assigned_error_id() will return a new leaf::error_id,
                 // otherwise we'll be working with the original error reported
                 // by a C++ exception out of do_work.
-                throw leaf::exception( cur_err.assigned_error_id().load( e_lua_pcall_error{err}, e_lua_error_message{std::move(msg)} ) );
+                leaf::throw_exception( cur_err.assigned_error_id().load( e_lua_pcall_error{err}, e_lua_error_message{std::move(msg)} ) );
             }
             else
             {

example/capture_in_exception.cpp

@@ -67,7 +67,7 @@ int main( int argc, char const * argv[] )
             std::cout << buffer;
             std::cout.flush();
             if( std::cout.fail() )
-                throw leaf::exception(output_error, leaf::e_errno{errno});
+                leaf::throw_exception(output_error, leaf::e_errno{errno});
 
             return 0;
         },
@@ -152,7 +152,7 @@ char const * parse_command_line( int argc, char const * argv[] )
     if( argc==2 )
         return argv[1];
     else
-        throw leaf::exception(bad_command_line);
+        leaf::throw_exception(bad_command_line);
 }
 
 
@@ -162,7 +162,7 @@ std::shared_ptr<FILE> file_open( char const * file_name )
     if( FILE * f = fopen(file_name, "rb") )
         return std::shared_ptr<FILE>(f, &fclose);
     else
-        throw leaf::exception(open_error, leaf::e_errno{errno});
+        leaf::throw_exception(open_error, leaf::e_errno{errno});
 }
 
 
@@ -172,14 +172,14 @@ int file_size( FILE & f )
     auto load = leaf::on_error([] { return leaf::e_errno{errno}; });
 
     if( fseek(&f, 0, SEEK_END) )
-        throw leaf::exception(size_error);
+        leaf::throw_exception(size_error);
 
     int s = ftell(&f);
     if( s==-1L )
-        throw leaf::exception(size_error);
+        leaf::throw_exception(size_error);
 
     if( fseek(&f,0,SEEK_SET) )
-        throw leaf::exception(size_error);
+        leaf::throw_exception(size_error);
 
     return s;
 }
@@ -191,8 +191,8 @@ void file_read( FILE & f, void * buf, int size )
     int n = fread(buf, 1, size, &f);
 
     if( ferror(&f) )
-        throw leaf::exception(read_error, leaf::e_errno{errno});
+        leaf::throw_exception(read_error, leaf::e_errno{errno});
 
     if( n!=size )
-        throw leaf::exception(eof_error);
+        leaf::throw_exception(eof_error);
 }

example/lua_callback_eh.cpp

@@ -132,12 +132,12 @@ namespace leaf_detail
         catch( exception_base const & e )
         {
             ctx->captured_id_ = e.get_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::move(ctx)) );
         }
         catch(...)
         {
             ctx->captured_id_ = cur_err.assigned_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::move(ctx)) );
         }
     }
 
@@ -165,12 +165,12 @@ namespace leaf_detail
         catch( exception_base const & e )
         {
             ctx->captured_id_ = e.get_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::move(ctx)) );
         }
         catch(...)
         {
             ctx->captured_id_ = cur_err.assigned_error_id();
-            throw_exception( capturing_exception(std::current_exception(), std::move(ctx)) );
+            leaf_detail::throw_exception_impl( capturing_exception(std::current_exception(), std::move(ctx)) );
         }
     }
 

example/print_file/print_file_eh.cpp

@@ -99,39 +99,6 @@ namespace leaf_detail
 
 ////////////////////////////////////////
 
-#ifdef BOOST_LEAF_NO_EXCEPTIONS
-
-namespace boost
-{
-[[noreturn]] void throw_exception( std::exception const & ); // user defined
-}
-
-namespace boost { namespace leaf {
-
-template <class T>
-[[noreturn]] void throw_exception( T const & e )
-{
-    ::boost::throw_exception(e);
-}
-
-} }
-
-#else
-
-namespace boost { namespace leaf {
-
-template <class T>
-[[noreturn]] void throw_exception( T const & e )
-{
-    throw e;
-}
-
-} }
-
-#endif
-
-////////////////////////////////////////
-
 namespace boost { namespace leaf {
 
 #if BOOST_LEAF_CFG_DIAGNOSTICS

include/boost/leaf/capture.hpp

@@ -8,48 +8,58 @@
 
 #include <boost/leaf/config.hpp>
 #include <boost/leaf/error.hpp>
-
-#ifndef BOOST_LEAF_NO_EXCEPTIONS
-
 #include <exception>
 
-#define BOOST_LEAF_EXCEPTION ::boost::leaf::leaf_detail::inject_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::exception
-#define BOOST_LEAF_THROW_EXCEPTION ::boost::leaf::leaf_detail::throw_with_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::exception
+#ifdef BOOST_LEAF_NO_EXCEPTIONS
 
-////////////////////////////////////////
+namespace boost
+{
+    [[noreturn]] void throw_exception( std::exception const & ); // user defined
+}
 
 namespace boost { namespace leaf {
 
 namespace leaf_detail
 {
-    struct throw_with_loc
+    template <class T>
+    [[noreturn]] void throw_exception_impl( T && e )
     {
-        char const * const file;
-        int const line;
-        char const * const fn;
+        ::boost::throw_exception(std::move(e));
+    }
 
-        template <class Ex>
-        [[noreturn]] friend void operator+( throw_with_loc loc, Ex const & ex )
-        {
-            ex.load_source_location_(loc.file, loc.line, loc.fn);
-            ::boost::leaf::throw_exception(ex);
-        }
+    class BOOST_LEAF_SYMBOL_VISIBLE exception_base
+    {
+    public:
+
+        virtual error_id get_error_id() const noexcept = 0;
+
+    protected:
+
+        exception_base() noexcept { }
+        ~exception_base() noexcept { }
     };
 }
 
 } }
 
-////////////////////////////////////////
+#else
+
+#include <memory>
 
 namespace boost { namespace leaf {
 
 namespace leaf_detail
 {
-    inline void enforce_std_exception( std::exception const & ) noexcept { }
+    template <class T>
+    [[noreturn]] void throw_exception_impl( T && e )
+    {
+        throw std::move(e);
+    }
 
     class BOOST_LEAF_SYMBOL_VISIBLE exception_base
     {
         std::shared_ptr<void const> auto_id_bump_;
+
     public:
 
         virtual error_id get_error_id() const noexcept = 0;
@@ -63,6 +73,44 @@ namespace leaf_detail
 
         ~exception_base() noexcept { }
     };
+}
+
+} }
+
+#endif
+
+////////////////////////////////////////
+
+#define BOOST_LEAF_THROW_EXCEPTION ::boost::leaf::leaf_detail::throw_with_loc{__FILE__,__LINE__,__FUNCTION__}+::boost::leaf::leaf_detail::make_exception
+
+namespace boost { namespace leaf {
+
+namespace leaf_detail
+{
+    struct throw_with_loc
+    {
+        char const * const file;
+        int const line;
+        char const * const fn;
+
+        template <class Ex>
+        [[noreturn]] friend void operator+( throw_with_loc loc, Ex && ex )
+        {
+            ex.load_source_location_(loc.file, loc.line, loc.fn);
+            ::boost::leaf::leaf_detail::throw_exception_impl(std::move(ex));
+        }
+    };
+}
+
+} }
+
+////////////////////////////////////////
+
+namespace boost { namespace leaf {
+
+namespace leaf_detail
+{
+    inline void enforce_std_exception( std::exception const & ) noexcept { }
 
     template <class Ex>
     class BOOST_LEAF_SYMBOL_VISIBLE exception:
@@ -112,52 +160,62 @@ namespace leaf_detail
     {
         constexpr static const bool value = std::is_base_of<std::exception,typename std::remove_reference<T>::type>::value || at_least_one_derives_from_std_exception<Rest...>::value;
     };
-}
 
-template <class Ex, class... E>
-inline
-typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, leaf_detail::exception<typename std::remove_reference<Ex>::type>>::type
-exception( error_id err, Ex && ex, E && ... e ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<typename std::remove_reference<Ex>::type>( err.load(std::forward<E>(e)...), std::forward<Ex>(ex) );
-}
+    template <class Ex, class... E>
+    inline
+    typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, exception<typename std::remove_reference<Ex>::type>>::type
+    make_exception( error_id err, Ex && ex, E && ... e ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<typename std::remove_reference<Ex>::type>( err.load(std::forward<E>(e)...), std::forward<Ex>(ex) );
+    }
 
-template <class E1, class... E>
-inline
-typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, leaf_detail::exception<std::exception>>::type
-exception( error_id err, E1 && car, E && ... cdr ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<std::exception>( err.load(std::forward<E1>(car), std::forward<E>(cdr)...) );
-}
+    template <class E1, class... E>
+    inline
+    typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, exception<std::exception>>::type
+    make_exception( error_id err, E1 && car, E && ... cdr ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<std::exception>( err.load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    }
 
-inline leaf_detail::exception<std::exception> exception( error_id err ) noexcept
-{
-    return leaf_detail::exception<std::exception>(err);
-}
+    inline exception<std::exception> make_exception( error_id err ) noexcept
+    {
+        return exception<std::exception>(err);
+    }
 
-template <class Ex, class... E>
-inline
-typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, leaf_detail::exception<typename std::remove_reference<Ex>::type>>::type
-exception( Ex && ex, E && ... e ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<typename std::remove_reference<Ex>::type>( new_error().load(std::forward<E>(e)...), std::forward<Ex>(ex) );
-}
+    template <class Ex, class... E>
+    inline
+    typename std::enable_if<std::is_base_of<std::exception,typename std::remove_reference<Ex>::type>::value, exception<typename std::remove_reference<Ex>::type>>::type
+    make_exception( Ex && ex, E && ... e ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<typename std::remove_reference<Ex>::type>( new_error().load(std::forward<E>(e)...), std::forward<Ex>(ex) );
+    }
 
-template <class E1, class... E>
-inline
-typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, leaf_detail::exception<std::exception>>::type
-exception( E1 && car, E && ... cdr ) noexcept
-{
-    static_assert(!leaf_detail::at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
-    return leaf_detail::exception<std::exception>( new_error().load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    template <class E1, class... E>
+    inline
+    typename std::enable_if<!std::is_base_of<std::exception,typename std::remove_reference<E1>::type>::value, exception<std::exception>>::type
+    make_exception( E1 && car, E && ... cdr ) noexcept
+    {
+        static_assert(!at_least_one_derives_from_std_exception<E...>::value, "Error objects passed to leaf::exception may not derive from std::exception");
+        return exception<std::exception>( new_error().load(std::forward<E1>(car), std::forward<E>(cdr)...) );
+    }
+
+    inline exception<std::exception> make_exception() noexcept
+    {
+        return exception<std::exception>(leaf::new_error());
+    }
 }
 
-inline leaf_detail::exception<std::exception> exception() noexcept
+template <class... E>
+[[noreturn]] void throw_exception( E && ... e )
 {
-    return leaf_detail::exception<std::exception>(leaf::new_error());
+    // Warning: setting a breakpoint here will not intercept exceptions thrown
+    // via BOOST_LEAF_THROW_EXCEPTION or originating in the few other throw
+    // points elsewhere in LEAF. To intercept all of those exceptions as well,
+    // set a breakpoint inside boost::leaf::leaf_detail::throw_exception_impl.
+    leaf_detail::throw_exception_impl(leaf_detail::make_exception(std::forward<E>(e)...));
 }
 
 ////////////////////////////////////////
@@ -223,5 +281,3 @@ exception_to_result( F && f ) noexcept
 } }
 
 #endif
-
-#endif