fix(wasm): Throw => THROW

ludamad · ludamad · commit 5699c833f3a0 · 2026-01-09T10:45:59.000-05:00
diff --git a/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp b/include/msgpack/v1/adaptor/boost/msgpack_variant.hpp
@@ -196,7 +196,7 @@ struct basic_variant :
         if (is_uint64_t()) {
             return static_cast<double>(boost::get<uint64_t>(*this));
         }
-        throw msgpack::type_error();
+        THROW msgpack::type_error();
     }
     std::string const& as_string() const {
         return boost::get<std::string>(*this);
diff --git a/include/msgpack/v1/adaptor/cpp11/chrono.hpp b/include/msgpack/v1/adaptor/cpp11/chrono.hpp
@@ -120,12 +120,12 @@ template <
 >
 Target integral_cast(Source source) {
     if (would_underflow<Target, Source>(source).value) {
-        throw std::underflow_error{
+        THROW std::underflow_error{
             "casting from Source to Target causes an underflow error"
         };
     }
     if(would_overflow<Target, Source>(source).value) {
-        throw std::overflow_error{
+        THROW std::overflow_error{
             "casting from Source to Target causes an overflow error"
         };
     }
diff --git a/include/msgpack/v1/adaptor/cpp17/variant.hpp b/include/msgpack/v1/adaptor/cpp17/variant.hpp
@@ -76,7 +76,7 @@ struct as<std::variant<Ts...>, typename std::enable_if<(msgpack::has_as<Ts>::val
            || o.via.array.size != 2
            || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
            || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
-            throw msgpack::type_error{};
+            THROW msgpack::type_error{};
         }
 
         return detail::construct_variant<std::variant<Ts...>, Ts...>(
@@ -94,7 +94,7 @@ struct convert<std::variant<Ts...>> {
            || o.via.array.size != 2
            || o.via.array.ptr[0].type != msgpack::type::POSITIVE_INTEGER
            || o.via.array.ptr[0].via.u64 >= sizeof...(Ts)) {
-            throw msgpack::type_error{};
+            THROW msgpack::type_error{};
         }
 
         v =  detail::construct_variant<std::variant<Ts...>, Ts...>(
diff --git a/include/msgpack/v1/detail/cpp03_zone.hpp b/include/msgpack/v1/detail/cpp03_zone.hpp
@@ -135,7 +135,7 @@ class zone {
 
     static void* operator new(std::size_t size) {
         void* p = ::malloc(size);
-        if (!p) throw std::bad_alloc();
+        if (!p) THROW std::bad_alloc();
         return p;
     }
 
@@ -243,7 +243,7 @@ inline zone::chunk_list& zone::get_chank_lst() {
     if (!m_chunk_list) {
         void* ptr = ::malloc(sizeof(chunk_list) + m_chunk_size);
         if (!ptr)
-            throw std::bad_alloc();
+            THROW std::bad_alloc();
         m_chunk_list = new (ptr) chunk_list(m_chunk_size, reinterpret_cast<char*>(ptr) + sizeof(chunk_list));
     }
     return *m_chunk_list;
@@ -290,7 +290,7 @@ inline char* zone::allocate_expand(size_t size) {
     }
 
     chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
-    if (!c) throw std::bad_alloc();
+    if (!c) THROW std::bad_alloc();
 
     char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
 
@@ -355,14 +355,14 @@ T* zone::allocate()
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T();
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -374,14 +374,14 @@ T* zone::allocate(A1 a1)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -393,14 +393,14 @@ T* zone::allocate(A1 a1, A2 a2)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -412,14 +412,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -431,14 +431,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -450,14 +450,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -469,14 +469,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -488,14 +488,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -507,14 +507,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -526,14 +526,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -545,14 +545,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -564,14 +564,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -583,14 +583,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -602,14 +602,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -621,14 +621,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -640,14 +640,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
diff --git a/include/msgpack/v1/detail/cpp11_zone.hpp b/include/msgpack/v1/detail/cpp11_zone.hpp
@@ -147,7 +147,7 @@ class zone {
 
     static void* operator new(std::size_t size) {
         void* p = ::malloc(size);
-        if (!p) throw std::bad_alloc();
+        if (!p) THROW std::bad_alloc();
         return p;
     }
 
@@ -208,7 +208,7 @@ inline zone::chunk_list& zone::get_chank_lst() {
     if (!m_chunk_list) {
         auto ptr = ::malloc(sizeof(chunk_list) + m_chunk_size);
         if (!ptr)
-            throw std::bad_alloc();
+            THROW std::bad_alloc();
         m_chunk_list = new (ptr) chunk_list(m_chunk_size, reinterpret_cast<char*>(ptr) + sizeof(chunk_list));
     }
     return *m_chunk_list;
@@ -255,7 +255,7 @@ inline char* zone::allocate_expand(size_t size) {
     }
 
     chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
-    if (!c) throw std::bad_alloc();
+    if (!c) THROW std::bad_alloc();
 
     char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
 
@@ -314,14 +314,14 @@ T* zone::allocate(Args... args) {
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(args...);
     } catch (...) {
         m_finalizer_array.pop();
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ struct basic_variant :`
`196`	`196`	`if (is_uint64_t()) {`
`197`	`197`	`return static_cast<double>(boost::get<uint64_t>(*this));`
`198`	`198`	`}`
`199`		`- throw msgpack::type_error();`
	`199`	`+ THROW msgpack::type_error();`
`200`	`200`	`}`
`201`	`201`	`std::string const& as_string() const {`
`202`	`202`	`return boost::get<std::string>(*this);`
Original file line number	Diff line number	Diff line change
`@@ -120,12 +120,12 @@ template <`
`120`	`120`	`>`
`121`	`121`	`Target integral_cast(Source source) {`
`122`	`122`	`if (would_underflow<Target, Source>(source).value) {`
`123`		`- throw std::underflow_error{`
	`123`	`+ THROW std::underflow_error{`
`124`	`124`	`"casting from Source to Target causes an underflow error"`
`125`	`125`	`};`
`126`	`126`	`}`
`127`	`127`	`if(would_overflow<Target, Source>(source).value) {`
`128`		`- throw std::overflow_error{`
	`128`	`+ THROW std::overflow_error{`
`129`	`129`	`"casting from Source to Target causes an overflow error"`
`130`	`130`	`};`
`131`	`131`	`}`