feat(wasm): hacks to make work in a fno-exceptions wasm environment (#1)

ludamad · ludamad · commit 24733e6c07a6 · 2026-01-09T10:44:00.000-05:00
* feat(wasm): hacks to make work in a fno-exceptions wasm environment

* feat(wasm): properly mark operator as noreturn
diff --git a/erb/v1/cpp03_zone.hpp.erb b/erb/v1/cpp03_zone.hpp.erb
@@ -321,14 +321,14 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>)
         m_finalizer_array.push(&zone::object_destruct<T>, x);
     } catch (...) {
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
     try {
         return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>);
     } catch (...) {
         --m_finalizer_array.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 <%}%>
diff --git a/include/msgpack/assert.hpp b/include/msgpack/assert.hpp
@@ -23,4 +23,19 @@
 
 #endif // defined(MSGPACK_NO_BOOST)
 
+#ifdef __wasm__
+struct AbortStream {
+    void operator<< [[noreturn]] (const auto& error) {
+        info(error.what());
+        std::abort();
+    }
+};
+#define throw AbortStream() <<
+#define try if (true)
+#define catch(...) if (false)
+#define RETHROW  
+#else
+#define RETHROW throw 
+#endif
+
 #endif // MSGPACK_ASSERT_HPP
diff --git a/include/msgpack/sysdep.hpp b/include/msgpack/sysdep.hpp
@@ -183,11 +183,11 @@
     } while (0);
 
 #define _msgpack_store16(to, num) \
-    do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
+    do { uint16_t val = (uint16_t)_msgpack_be16(num); memcpy(to, &val, 2); } while(0)
 #define _msgpack_store32(to, num) \
-    do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
+    do { uint32_t val = (uint32_t)_msgpack_be32(num); memcpy(to, &val, 4); } while(0)
 #define _msgpack_store64(to, num) \
-    do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
+    do { uint64_t val = (uint64_t)_msgpack_be64(num); memcpy(to, &val, 8); } while(0)
 
 /*
 #define _msgpack_load16(cast, from) \
diff --git a/include/msgpack/v1/detail/cpp03_zone.hpp b/include/msgpack/v1/detail/cpp03_zone.hpp
@@ -366,14 +366,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -385,14 +385,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -404,14 +404,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -423,14 +423,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -442,14 +442,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -461,14 +461,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -480,14 +480,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -499,14 +499,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -518,14 +518,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -537,14 +537,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -556,14 +556,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -575,14 +575,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -594,14 +594,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -613,14 +613,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -632,14 +632,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
@@ -651,14 +651,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
diff --git a/include/msgpack/v1/detail/cpp11_zone.hpp b/include/msgpack/v1/detail/cpp11_zone.hpp
@@ -343,14 +343,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.m_tail;
         undo_allocate(sizeof(T));
-        throw;
+        RETHROW;
     }
 }
 
diff --git a/include/msgpack/v1/object.hpp b/include/msgpack/v1/object.hpp
@@ -1040,11 +1040,13 @@ inline bool operator==(const msgpack::object& x, const msgpack::object& y)
 
 template <typename T>
 inline bool operator==(const msgpack::object& x, const T& y)
+{
 try {
     return x == msgpack::object(y);
 } catch (msgpack::type_error&) {
     return false;
 }
+}
 
 inline bool operator!=(const msgpack::object& x, const msgpack::object& y)
 { return !(x == y); }
diff --git a/include/msgpack/v1/unpack.hpp b/include/msgpack/v1/unpack.hpp
diff --git a/include/msgpack/v1/unpack_decl.hpp b/include/msgpack/v1/unpack_decl.hpp
diff --git a/include/msgpack/v2/parse.hpp b/include/msgpack/v2/parse.hpp

Original file line number	Diff line number	Diff line change
`@@ -321,14 +321,14 @@ T* zone::allocate(<%=(1..i).map{\|j\|"A#{j} a#{j}"}.join(', ')%>)`
`321`	`321`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`322`	`322`	`} catch (...) {`
`323`	`323`	`undo_allocate(sizeof(T));`
`324`		`- throw;`
	`324`	`+ RETHROW;`
`325`	`325`	`}`
`326`	`326`	`try {`
`327`	`327`	`return new (x) T(<%=(1..i).map{\|j\|"a#{j}"}.join(', ')%>);`
`328`	`328`	`} catch (...) {`
`329`	`329`	`--m_finalizer_array.m_tail;`
`330`	`330`	`undo_allocate(sizeof(T));`
`331`		`- throw;`
	`331`	`+ RETHROW;`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`	`<%}%>`
Original file line number	Diff line number	Diff line change
`@@ -366,14 +366,14 @@ T* zone::allocate()`
`366`	`366`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`367`	`367`	`} catch (...) {`
`368`	`368`	`undo_allocate(sizeof(T));`
`369`		`- throw;`
	`369`	`+ RETHROW;`
`370`	`370`	`}`
`371`	`371`	`try {`
`372`	`372`	`return new (x) T();`
`373`	`373`	`} catch (...) {`
`374`	`374`	`--m_finalizer_array.m_tail;`
`375`	`375`	`undo_allocate(sizeof(T));`
`376`		`- throw;`
	`376`	`+ RETHROW;`
`377`	`377`	`}`
`378`	`378`	`}`
`379`	`379`
`@@ -385,14 +385,14 @@ T* zone::allocate(A1 a1)`
`385`	`385`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`386`	`386`	`} catch (...) {`
`387`	`387`	`undo_allocate(sizeof(T));`
`388`		`- throw;`
	`388`	`+ RETHROW;`
`389`	`389`	`}`
`390`	`390`	`try {`
`391`	`391`	`return new (x) T(a1);`
`392`	`392`	`} catch (...) {`
`393`	`393`	`--m_finalizer_array.m_tail;`
`394`	`394`	`undo_allocate(sizeof(T));`
`395`		`- throw;`
	`395`	`+ RETHROW;`
`396`	`396`	`}`
`397`	`397`	`}`
`398`	`398`
`@@ -404,14 +404,14 @@ T* zone::allocate(A1 a1, A2 a2)`
`404`	`404`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`405`	`405`	`} catch (...) {`
`406`	`406`	`undo_allocate(sizeof(T));`
`407`		`- throw;`
	`407`	`+ RETHROW;`
`408`	`408`	`}`
`409`	`409`	`try {`
`410`	`410`	`return new (x) T(a1, a2);`
`411`	`411`	`} catch (...) {`
`412`	`412`	`--m_finalizer_array.m_tail;`
`413`	`413`	`undo_allocate(sizeof(T));`
`414`		`- throw;`
	`414`	`+ RETHROW;`
`415`	`415`	`}`
`416`	`416`	`}`
`417`	`417`
`@@ -423,14 +423,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3)`
`423`	`423`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`424`	`424`	`} catch (...) {`
`425`	`425`	`undo_allocate(sizeof(T));`
`426`		`- throw;`
	`426`	`+ RETHROW;`
`427`	`427`	`}`
`428`	`428`	`try {`
`429`	`429`	`return new (x) T(a1, a2, a3);`
`430`	`430`	`} catch (...) {`
`431`	`431`	`--m_finalizer_array.m_tail;`
`432`	`432`	`undo_allocate(sizeof(T));`
`433`		`- throw;`
	`433`	`+ RETHROW;`
`434`	`434`	`}`
`435`	`435`	`}`
`436`	`436`
`@@ -442,14 +442,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4)`
`442`	`442`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`443`	`443`	`} catch (...) {`
`444`	`444`	`undo_allocate(sizeof(T));`
`445`		`- throw;`
	`445`	`+ RETHROW;`
`446`	`446`	`}`
`447`	`447`	`try {`
`448`	`448`	`return new (x) T(a1, a2, a3, a4);`
`449`	`449`	`} catch (...) {`
`450`	`450`	`--m_finalizer_array.m_tail;`
`451`	`451`	`undo_allocate(sizeof(T));`
`452`		`- throw;`
	`452`	`+ RETHROW;`
`453`	`453`	`}`
`454`	`454`	`}`
`455`	`455`
`@@ -461,14 +461,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)`
`461`	`461`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`462`	`462`	`} catch (...) {`
`463`	`463`	`undo_allocate(sizeof(T));`
`464`		`- throw;`
	`464`	`+ RETHROW;`
`465`	`465`	`}`
`466`	`466`	`try {`
`467`	`467`	`return new (x) T(a1, a2, a3, a4, a5);`
`468`	`468`	`} catch (...) {`
`469`	`469`	`--m_finalizer_array.m_tail;`
`470`	`470`	`undo_allocate(sizeof(T));`
`471`		`- throw;`
	`471`	`+ RETHROW;`
`472`	`472`	`}`
`473`	`473`	`}`
`474`	`474`
`@@ -480,14 +480,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)`
`480`	`480`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`481`	`481`	`} catch (...) {`
`482`	`482`	`undo_allocate(sizeof(T));`
`483`		`- throw;`
	`483`	`+ RETHROW;`
`484`	`484`	`}`
`485`	`485`	`try {`
`486`	`486`	`return new (x) T(a1, a2, a3, a4, a5, a6);`
`487`	`487`	`} catch (...) {`
`488`	`488`	`--m_finalizer_array.m_tail;`
`489`	`489`	`undo_allocate(sizeof(T));`
`490`		`- throw;`
	`490`	`+ RETHROW;`
`491`	`491`	`}`
`492`	`492`	`}`
`493`	`493`
`@@ -499,14 +499,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)`
`499`	`499`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`500`	`500`	`} catch (...) {`
`501`	`501`	`undo_allocate(sizeof(T));`
`502`		`- throw;`
	`502`	`+ RETHROW;`
`503`	`503`	`}`
`504`	`504`	`try {`
`505`	`505`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7);`
`506`	`506`	`} catch (...) {`
`507`	`507`	`--m_finalizer_array.m_tail;`
`508`	`508`	`undo_allocate(sizeof(T));`
`509`		`- throw;`
	`509`	`+ RETHROW;`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`
`@@ -518,14 +518,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)`
`518`	`518`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`519`	`519`	`} catch (...) {`
`520`	`520`	`undo_allocate(sizeof(T));`
`521`		`- throw;`
	`521`	`+ RETHROW;`
`522`	`522`	`}`
`523`	`523`	`try {`
`524`	`524`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8);`
`525`	`525`	`} catch (...) {`
`526`	`526`	`--m_finalizer_array.m_tail;`
`527`	`527`	`undo_allocate(sizeof(T));`
`528`		`- throw;`
	`528`	`+ RETHROW;`
`529`	`529`	`}`
`530`	`530`	`}`
`531`	`531`
`@@ -537,14 +537,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)`
`537`	`537`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`538`	`538`	`} catch (...) {`
`539`	`539`	`undo_allocate(sizeof(T));`
`540`		`- throw;`
	`540`	`+ RETHROW;`
`541`	`541`	`}`
`542`	`542`	`try {`
`543`	`543`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9);`
`544`	`544`	`} catch (...) {`
`545`	`545`	`--m_finalizer_array.m_tail;`
`546`	`546`	`undo_allocate(sizeof(T));`
`547`		`- throw;`
	`547`	`+ RETHROW;`
`548`	`548`	`}`
`549`	`549`	`}`
`550`	`550`
`@@ -556,14 +556,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`556`	`556`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`557`	`557`	`} catch (...) {`
`558`	`558`	`undo_allocate(sizeof(T));`
`559`		`- throw;`
	`559`	`+ RETHROW;`
`560`	`560`	`}`
`561`	`561`	`try {`
`562`	`562`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);`
`563`	`563`	`} catch (...) {`
`564`	`564`	`--m_finalizer_array.m_tail;`
`565`	`565`	`undo_allocate(sizeof(T));`
`566`		`- throw;`
	`566`	`+ RETHROW;`
`567`	`567`	`}`
`568`	`568`	`}`
`569`	`569`
`@@ -575,14 +575,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`575`	`575`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`576`	`576`	`} catch (...) {`
`577`	`577`	`undo_allocate(sizeof(T));`
`578`		`- throw;`
	`578`	`+ RETHROW;`
`579`	`579`	`}`
`580`	`580`	`try {`
`581`	`581`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);`
`582`	`582`	`} catch (...) {`
`583`	`583`	`--m_finalizer_array.m_tail;`
`584`	`584`	`undo_allocate(sizeof(T));`
`585`		`- throw;`
	`585`	`+ RETHROW;`
`586`	`586`	`}`
`587`	`587`	`}`
`588`	`588`
`@@ -594,14 +594,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`594`	`594`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`595`	`595`	`} catch (...) {`
`596`	`596`	`undo_allocate(sizeof(T));`
`597`		`- throw;`
	`597`	`+ RETHROW;`
`598`	`598`	`}`
`599`	`599`	`try {`
`600`	`600`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);`
`601`	`601`	`} catch (...) {`
`602`	`602`	`--m_finalizer_array.m_tail;`
`603`	`603`	`undo_allocate(sizeof(T));`
`604`		`- throw;`
	`604`	`+ RETHROW;`
`605`	`605`	`}`
`606`	`606`	`}`
`607`	`607`
`@@ -613,14 +613,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`613`	`613`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`614`	`614`	`} catch (...) {`
`615`	`615`	`undo_allocate(sizeof(T));`
`616`		`- throw;`
	`616`	`+ RETHROW;`
`617`	`617`	`}`
`618`	`618`	`try {`
`619`	`619`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);`
`620`	`620`	`} catch (...) {`
`621`	`621`	`--m_finalizer_array.m_tail;`
`622`	`622`	`undo_allocate(sizeof(T));`
`623`		`- throw;`
	`623`	`+ RETHROW;`
`624`	`624`	`}`
`625`	`625`	`}`
`626`	`626`
`@@ -632,14 +632,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`632`	`632`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`633`	`633`	`} catch (...) {`
`634`	`634`	`undo_allocate(sizeof(T));`
`635`		`- throw;`
	`635`	`+ RETHROW;`
`636`	`636`	`}`
`637`	`637`	`try {`
`638`	`638`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);`
`639`	`639`	`} catch (...) {`
`640`	`640`	`--m_finalizer_array.m_tail;`
`641`	`641`	`undo_allocate(sizeof(T));`
`642`		`- throw;`
	`642`	`+ RETHROW;`
`643`	`643`	`}`
`644`	`644`	`}`
`645`	`645`
`@@ -651,14 +651,14 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9,`
`651`	`651`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`652`	`652`	`} catch (...) {`
`653`	`653`	`undo_allocate(sizeof(T));`
`654`		`- throw;`
	`654`	`+ RETHROW;`
`655`	`655`	`}`
`656`	`656`	`try {`
`657`	`657`	`return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);`
`658`	`658`	`} catch (...) {`
`659`	`659`	`--m_finalizer_array.m_tail;`
`660`	`660`	`undo_allocate(sizeof(T));`
`661`		`- throw;`
	`661`	`+ RETHROW;`
`662`	`662`	`}`
`663`	`663`	`}`
`664`	`664`
Original file line number	Diff line number	Diff line change
`@@ -343,14 +343,14 @@ T* zone::allocate(Args... args)`
`343`	`343`	`m_finalizer_array.push(&zone::object_destruct<T>, x);`
`344`	`344`	`} catch (...) {`
`345`	`345`	`undo_allocate(sizeof(T));`
`346`		`- throw;`
	`346`	`+ RETHROW;`
`347`	`347`	`}`
`348`	`348`	`try {`
`349`	`349`	`return new (x) T(args...);`
`350`	`350`	`} catch (...) {`
`351`	`351`	`--m_finalizer_array.m_tail;`
`352`	`352`	`undo_allocate(sizeof(T));`
`353`		`- throw;`
	`353`	`+ RETHROW;`
`354`	`354`	`}`
`355`	`355`	`}`
`356`	`356`