Changeset 3740656 in mainline

Timestamp:

2018-07-05T21:41:17Z (6 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

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

Children:

c2c1966

Parents:

a1aecb1

git-author:

Jaroslav Jindrak <dzejrou@…> (2017-10-09 16:33:43)

git-committer:

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

Message:

cpp: added the rest of the C++11 memory allocation/deallocation operators.

Location:

uspace/lib/cpp

Files:

• include/exception (modified) (1 diff)
• include/new (modified) (1 diff)
• src/exception.cpp (modified) (1 diff)
• src/new.cpp (modified) (2 diffs)

uspace/lib/cpp/include/exception

@@ -39 +39 @@
                 exception(const exception&) = default;
                 exception& operator=(const exception&) noexcept;
-                virtual const char *what() const;
+                virtual const char* what() const;
                 virtual ~exception() = default;
 };

uspace/lib/cpp/include/new

@@ -41 +41 @@
                 bad_alloc(const bad_alloc&);
                 bad_alloc& operator=(const bad_alloc&) = default;
-                virtual const char *what() const override;
+                virtual const char* what() const override;
                 virtual ~bad_alloc() = default;
 };
-
-using new_handler = void (*)();
 
 struct nothrow_t {};
 extern const nothrow_t nothrow;
 
+using new_handler = void (*)();
+
+new_handler set_new_handler(new_handler);
+new_handler get_new_handler() noexcept;
+
 }
 
-void *operator new(std::size_t);
+void* operator new(std::size_t);
+void* operator new(std::size_t, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t);
+void* operator new[](std::size_t, const std::nothrow_t&) noexcept;
 
-void operator delete(void *);
+void operator delete(void* );
+void operator delete[](void* );
 
 #endif

uspace/lib/cpp/src/exception.cpp

@@ -30 +30 @@
 namespace std
 {
-    const char *exception::what() const
+    const char* exception::what() const
     {
         return "std::exception";

uspace/lib/cpp/src/new.cpp

@@ -31 +31 @@
 namespace std
 {
-    const char *bad_alloc::what() const
+    const char* bad_alloc::what() const
     {
         return "std::bad_alloc";
@@ -37 +37 @@
 
     const nothrow_t nothrow{};
+
+    static new_handler handler = nullptr;
+
+    new_handler set_new_handler(new_handler h)
+    {
+        auto old = handler;
+        handler = h;
+
+        return old;
+    }
+
+    new_handler get_new_handler() noexcept
+    {
+        return handler;
+    }
 }
 
-void *operator new(std::size_t size)
+void* operator new(std::size_t size)
 {
-    // TODO: Implement usage of std::new_handler.
     if (size == 0)
         size = 1;
 
     void *ptr = std::malloc(size);
-    // TODO: For this we need stack unwinding support.
-    /* if (!ptr) */
-    /*     throw std::bad_alloc{}; */
+
+    while (!ptr)
+    {
+        auto h = std::get_new_handler();
+        if (h)
+            h();
+        else
+        {
+            // TODO: For this we need stack unwinding support.
+            /*     throw std::bad_alloc{}; */
+        }
+    }
 
     return ptr;
 }
 
-void operator delete(void *ptr)
+void* operator new(std::size_t size, const std::nothrow_t& nt) noexcept
+{
+    void* ptr{nullptr};
+
+    try
+    {
+        ptr = ::operator new(size);
+    }
+    catch(...)
+    { /* DUMMY BODY */ }
+
+    return ptr;
+}
+
+void* operator new[](std::size_t size)
+{
+    return ::operator new(size);
+}
+
+void* operator new[](std::size_t size, const std::nothrow_t& nt) noexcept
+{
+    return ::operator new(size, nt);
+}
+
+void operator delete(void* ptr)
 {
     if (ptr)
         std::free(ptr);
 }
+
+void operator delete[](void* ptr)
+{
+    ::operator delete(ptr);
+}