Changeset 1610aa35 in mainline

Timestamp:

2018-07-05T21:41:23Z (7 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

17c41c3

Parents:

68cfab1

git-author:

Dzejrou <dzejrou@…> (2018-05-08 16:23:51)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:23)

Message:

cpp: added <exception>

Location:

uspace/lib/cpp

Files:

• include/impl/exception.hpp (modified) (1 diff)
• src/exception.cpp (modified) (1 diff)

uspace/lib/cpp/include/impl/exception.hpp

@@ -30 +30 @@
 #define LIBCPP_EXCEPTION
 
+#include <internal/trycatch.hpp>
+
 namespace std
 {
-    [[noreturn]] void terminate() noexcept;
+    /**
+     * 18.8.1, class exception:
+     */
 
     class exception
     {
         public:
-            exception() = default;
-            exception(const exception&) = default;
-            exception& operator=(const exception&) noexcept;
-            virtual const char* what() const;
+            exception() noexcept = default;
+            exception(const exception&) noexcept = default;
+            exception& operator=(const exception&) noexcept = default;
             virtual ~exception() = default;
+            virtual const char* what() const noexcept;
     };
+
+    /**
+     * 18.8.2, class bad_exception:
+     */
+
+    class bad_exception: public exception
+    {
+        public:
+            bad_exception() noexcept = default;
+            bad_exception(const bad_exception&) noexcept = default;
+            bad_exception& operator=(const bad_exception&) noexcept = default;
+
+            virtual const char* what() const noexcept;
+    };
+
+    /**
+     * 18.8.3, abnormal termination:
+     */
+
+    using terminate_handler = void (*)();
+
+    terminate_handler get_terminate() noexcept;
+    terminate_handler set_terminate(terminate_handler) noexcept;
+    [[noreturn]] void terminate() noexcept;
+
+    /**
+     * 18.8.4, uncaght_exceptions:
+     */
+
+    bool uncaught_exception() noexcept;
+    int uncaught_exceptions() noexcept;
+
+    using unexpected_handler = void (*)();
+
+    unexpected_handler get_unexpected() noexcept;
+    unexpected_handler set_unexpected(unexpected_handler) noexcept;
+    [[noreturn]] void unexpected();
+
+    /**
+     * 18.8.5, exception propagation:
+     */
+
+    namespace aux
+    {
+        class exception_ptr_t
+        { /* DUMMY BODY */ };
+    }
+
+    using exception_ptr = aux::exception_ptr_t;
+
+    exception_ptr current_exception() noexcept;
+    [[noreturn]] void rethrow_exception(exception_ptr);
+
+    template<class E>
+    exception_ptr make_exception_ptr(E e) noexcept
+    {
+        return exception_ptr{};
+    }
+
+    class nested_exception
+    {
+        public:
+            nested_exception() noexcept = default;
+            nested_exception(const nested_exception&) noexcept = default;
+            nested_exception& operator=(const nested_exception&) noexcept = default;
+            virtual ~nested_exception() = default;
+
+            [[noreturn]] void throw_nested() const;
+            exception_ptr nested_ptr() const noexcept;
+
+        private:
+            exception_ptr ptr_;
+    };
+
+    template<class E>
+    [[noreturn]] void throw_with_nested(E&& e)
+    {
+        terminate();
+    }
+
+    template<class E>
+    void rethrow_if_nested(const E& e)
+    {
+        auto casted = dynamic_cast<const nested_exception*>(&e);
+        if (casted)
+            casted->throw_nested();
+    }
 }
 

uspace/lib/cpp/src/exception.cpp

@@ -32 +32 @@
 namespace std
 {
+    const char* exception::what() const noexcept
+    {
+        return "std::exception";
+    }
+
+    const char* bad_exception::what() const noexcept
+    {
+        return "std::bad_exception";
+    }
+
+    namespace aux
+    {
+        terminate_handler term_handler{nullptr};
+        unexpected_handler unex_handler{nullptr};
+    }
+
+    terminate_handler get_terminate() noexcept
+    {
+        return aux::term_handler;
+    }
+
+    terminate_handler set_terminate(terminate_handler h) noexcept
+    {
+        auto res = aux::term_handler;
+        aux::term_handler = h;
+
+        return res;
+    }
+
     [[noreturn]] void terminate() noexcept
     {
+        if (aux::term_handler)
+            aux::term_handler();
+
         abort();
     }
 
-    const char* exception::what() const
+    bool uncaught_exception() noexcept
     {
-        return "std::exception";
+        /**
+         * Note: The implementation of these two
+         *       functions currently uses our mock
+         *       exception handling system.
+         */
+        return aux::exception_thrown;
+    }
+
+    int uncaught_exceptins() noexcept
+    {
+        return aux::exception_thrown ? 1 : 0;
+    }
+
+    unexpected_handler get_unexpected() noexcept
+    {
+        return aux::unex_handler;
+    }
+
+    unexpected_handler set_unexpected(unexpected_handler h) noexcept
+    {
+        auto res = aux::unex_handler;
+        aux::unex_handler = h;
+
+        return res;
+    }
+
+    [[noreturn]] void unexpected()
+    {
+        if (aux::unex_handler)
+            aux::unex_handler();
+
+        terminate();
+    }
+
+    exception_ptr current_exception() noexcept
+    {
+        return exception_ptr{};
+    }
+
+    [[noreturn]] void rethrow_exception(exception_ptr)
+    {
+        terminate();
+    }
+
+    [[noreturn]] void nested_exception::throw_nested() const
+    {
+        terminate();
+    }
+
+    exception_ptr nested_exception::nested_ptr() const noexcept
+    {
+        return ptr_;
     }
 }