Windows various bug fixes for SEH

Author: TheTechsTech

include/exception.h

@@ -201,6 +201,11 @@ enum {
     const char *const err_file = ((void)err_file, ex_err.file); \
     const int err_line = ((void)err_line, ex_err.line)
 
+#define EX_MAKE_IF()                                              \
+    const char *const err = ((void)err, !is_empty((void *)ex_err.panic) ? ex_err.panic : ex_err.ex);             \
+    const char *const err_file = ((void)err_file, ex_err.file); \
+    const int err_line = ((void)err_line, ex_err.line)
+
 /* macros
  */
 #define EX_EXCEPTION(E) \
@@ -236,12 +241,13 @@ throws an exception of given message. */
 
 #ifdef _WIN32
 #define throw(E) raii_panic(EX_STR(E))
-
-#define rethrow()                   \
-    if (ex_err.caught > -1)         \
-        ex_err.state = ex_throw_st; \
-    else                            \
-        ex_throw(ex_err.ex, ex_err.file, ex_err.line, ex_err.function, ex_err.panic)
+#define rethrow()                                       \
+        if (ex_err.caught > -1 || ex_err.is_rethrown) { \
+            ex_err.is_rethrown = false;                         \
+            ex_longjmp(ex_err.buf, ex_err.state | ex_throw_st); \
+        } else {                                                \
+            ex_throw(ex_err.ex, ex_err.file, ex_err.line, ex_err.function, ex_err.panic); \
+        }
 
 #define ex_signal_block(ctrl)               \
     CRITICAL_SECTION ctrl##__FUNCTION__;    \
@@ -264,60 +270,58 @@ throws an exception of given message. */
     ex_err.stack = 0;                       \
     ex_err.ex = 0;                          \
     ex_err.unstack = 0;                     \
+    ex_err.is_rethrown = false;             \
     /* global context updated */            \
     ex_context = &ex_err;                   \
     /* save jump location */                \
     ex_err.state = ex_setjmp(ex_err.buf);   \
-    __try                                   \
-    {                                       \
-        if (ex_err.state == ex_try_st)  {
-
-#define ex_catch(E)                         \
-        }                                   \
-    } __except(catch_seh(EX_STR(E), GetExceptionCode(), GetExceptionInformation())) {   \
-        if (ex_err.state == ex_throw_st) {  \
-            EX_MAKE();                      \
-            ex_err.state = ex_catch_st;
-
-#define ex_catch_any                    \
-        }                               \
-    } __except(catch_filter_seh(GetExceptionCode(), GetExceptionInformation())) {   \
-        if (ex_err.state == ex_throw_st) {  \
-            EX_MAKE();                  \
-            ex_err.state = ex_catch_st;
-
-#define ex_catch_if                     \
-        }                               \
-    } __except(catch_filter_seh(GetExceptionCode(), GetExceptionInformation())) {   \
-        if (ex_err.state == ex_throw_st) {  \
-            EX_MAKE();
-
-#define ex_finally                      \
-    }                                   \
+    if (ex_err.state == ex_try_st) {		\
+		__try {
+
+#define ex_catch(E)                             \
+		} __except(catch_seh(EX_STR(E), GetExceptionCode(), GetExceptionInformation())) {   \
+			if (ex_err.state == ex_throw_st) {  \
+				EX_MAKE_IF();                   \
+				ex_err.state = ex_catch_st;
+
+#define ex_finally						\
+			}							\
+		}                               \
     }                                   \
         {                               \
-            EX_MAKE();                  \
+            EX_MAKE_IF();               \
             /* global context updated */\
             ex_context = ex_err.next;
 
-#define ex_finality                      \
-        }                               \
-    } __finally  {                      \
-        EX_MAKE();                      \
-        /* global context updated */    \
-        ex_context = ex_err.next;
-
 #define ex_end_try                          \
-        }                                   \
+    }										\
     if (ex_context == &ex_err)              \
         /* global context updated */        \
         ex_context = ex_err.next;           \
     ex_err.caught = -1;                     \
+    ex_err.is_rethrown = false;             \
     if ((ex_err.state & ex_throw_st) != 0)  \
         rethrow();                          \
-    }
+}
+
+#define ex_catch_any                    	    \
+        } __except(catch_filter_seh(GetExceptionCode(), GetExceptionInformation())) {   \
+            if (ex_err.state == ex_throw_st) {  \
+                EX_MAKE_IF();                   \
+                ex_err.state = ex_catch_st;
+
+#define ex_catch_if                             \
+        } __except(catch_filter_seh(GetExceptionCode(), GetExceptionInformation())) {   \
+            if (ex_err.state == ex_throw_st) {  \
+                EX_MAKE_IF();
+
+#define ex_finality							\
+        } __finally {						\
+			EX_MAKE_IF();					\
+			/* global context updated */	\
+			ex_context = ex_err.next;
 
-#define ex_end_trying   ex_end_try }
+#define ex_end_trying	 ex_finally ex_end_try
 
 #else
 #define ex_signal_block(ctrl)                  \
@@ -410,6 +414,8 @@ struct ex_context_s {
     void *data;
     void *prev;
     bool is_unwind;
+    bool is_rethrown;
+    bool is_guarded;
     int volatile caught;
 
     /* The handler in the stack (which is a FILO container). */

include/raii.h

@@ -235,6 +235,7 @@ C_API void *malloc_arena(size_t size);
 C_API void *calloc_arena(int count, size_t size);
 
 C_API values_type *raii_value(void *);
+C_API void raii_setup(void);
 C_API raii_type type_of(void *);
 C_API bool is_type(void *, raii_type);
 C_API bool is_instance_of(void *, void *);
@@ -273,9 +274,9 @@ execution begins when current `guard` scope exits or panic/throw. */
 #define _recover(err)   raii_is_caught(raii_init()->arena, err)
 
 /* Compare `err` to scoped error condition, will mark exception handled, if `true`. */
-#define _is_caught(err)   raii_is_caught(raii_init()->arena, err)
+#define _is_caught(err)   raii_is_caught(raii_init()->arena, EX_STR(err))
 
-/* Compare `err` to scoped error condition, will mark exception handled, if `true`. */
+/* Get scoped error condition string. */
 #define _get_message()  raii_message_by(raii_init()->arena)
 #define _panic          raii_panic
 
@@ -323,8 +324,6 @@ return given `result` when done, use `NONE` for no return. */
     } ex_catch_if {                                                 \
         if ((is_type(&(_$##__FUNCTION__)->defer, RAII_DEF_ARR)))    \
             raii_deferred_free(_$##__FUNCTION__);                   \
-        if ((_$##__FUNCTION__)->is_recovered)                      \
-            ex_err.state = ex_catch_st;                             \
     } ex_finally {                                                  \
         guard_reset(s##__FUNCTION__, sf##__FUNCTION__, uf##__FUNCTION__);   \
         guard_delete(_$##__FUNCTION__);                             \
@@ -342,8 +341,6 @@ On exit will begin executing deferred functions.
     } ex_catch_if {                                                \
         if ((is_type(&(_$##__FUNCTION__)->defer, RAII_DEF_ARR)))    \
             raii_deferred_free(_$##__FUNCTION__);                   \
-        if ((_$##__FUNCTION__)->is_recovered)                      \
-            ex_err.state = ex_catch_st;                             \
     } ex_finally {                                                  \
         guard_reset(s##__FUNCTION__, sf##__FUNCTION__, uf##__FUNCTION__);   \
         guard_delete(_$##__FUNCTION__);                             \
@@ -367,6 +364,7 @@ On exit will begin executing deferred functions.
 #define catch(e) ex_catch(e)
 #define end_try ex_end_try
 #define finally ex_finally
+#define caught(err) raii_caught(EX_STR(err))
 
 #ifdef _WIN32
     #define finality ex_finality

src/exception.c

@@ -162,7 +162,7 @@ static void ex_print(ex_context_t *exception, const char *message) {
     fprintf(stderr, "\n%s: %s\n", message, (exception->panic != NULL ? exception->panic : exception->ex));
     if (exception->file != NULL) {
         if (exception->function != NULL) {
-            fprintf(stderr, "    thrown at %s (%s:%d)\n\n", exception->function, exception->file, exception->line);
+            fprintf(stderr, "    thrown in %s at (%s:%d)\n\n", exception->function, exception->file, exception->line);
         } else {
             fprintf(stderr, "    thrown at %s:%d\n\n", exception->file, exception->line);
         }
@@ -204,6 +204,8 @@ ex_context_t *ex_init(void) {
     ex_signal_block(all);
     ex_context = &ex_context_buffer;
     ex_context->is_unwind = false;
+    ex_context->is_rethrown = false;
+    ex_context->is_guarded = false;
     ex_context->caught = -1;
     ex_context->type = ex_context_st;
     ex_signal_unblock(all);
@@ -260,7 +262,7 @@ void ex_throw(const char *exception, const char *file, int line, const char *fun
         ex_terminate();
 
 #ifdef _WIN32
-    RaiseException(EXCEPTION_PANIC, 0, 0, 0);
+    RaiseException(EXCEPTION_PANIC, 0, 0, NULL);
 #endif
     ex_longjmp(ctx->buf, ctx->state | ex_throw_st);
 }
@@ -271,19 +273,25 @@ int catch_seh(const char *exception, DWORD code, struct _EXCEPTION_POINTERS *ep)
     const char *ex = 0;
     int i;
 
+    if (!is_str_eq(ctx->panic, exception))
+        return EXCEPTION_EXECUTE_HANDLER;
+
     for (i = 0; i < max_ex_sig; i++) {
-        if (is_str_eq(ex_sig[i].ex, exception)
+        if (ex_sig[i].seh == code
+            || ctx->caught == ex_sig[i].seh
             || is_str_eq(ctx->panic, exception)
-            || ex_sig[i].seh == code
-            || ctx->caught == ex_sig[i].seh) {
+            ) {
             ctx->state = ex_throw_st;
-            ctx->ex = ex_sig[i].ex;
-            ctx->file = "unknown";
-            ctx->line = 0;
-            ctx->function = NULL;
+            ctx->is_rethrown = true;
+            if (got_signal) {
+                ctx->ex = ex_sig[i].ex;
+                ctx->file = "unknown";
+                ctx->line = 0;
+                ctx->function = NULL;
+            }
 
             if (exception_setup_func)
-                exception_setup_func(ctx, ctx->ex, NULL);
+                exception_setup_func(ctx, ctx->ex, ctx->panic);
             return EXCEPTION_EXECUTE_HANDLER;
         }
     }
@@ -304,13 +312,18 @@ int catch_filter_seh(DWORD code, struct _EXCEPTION_POINTERS *ep) {
     for (i = 0; i < max_ex_sig; i++) {
         if (ex_sig[i].seh == code || ctx->caught == ex_sig[i].seh) {
             ctx->state = ex_throw_st;
+            ctx->is_rethrown = true;
             ctx->ex = ex_sig[i].ex;
+            ctx->panic = NULL;
             ctx->file = "unknown";
             ctx->line = 0;
             ctx->function = NULL;
 
             if (exception_setup_func)
-                exception_setup_func(ctx, ctx->ex, NULL);
+                exception_setup_func(ctx, ctx->ex, ctx->panic);
+
+            if (!ctx->is_guarded)
+                ex_unwind_stack(ctx);
             return EXCEPTION_EXECUTE_HANDLER;
         }
     }

src/raii.c

@@ -417,12 +417,18 @@ RAII_INLINE void raii_recover_by(memory_t *scope, func_t func, void *data) {
 bool raii_caught(const char *err) {
     memory_t *scope = raii_init();
     const char *exception = (const char *)(!is_empty((void *)scope->panic) ? scope->panic : scope->err);
-    return scope->is_recovered = is_str_eq(err, exception);
+    if (scope->is_recovered = is_str_eq(err, exception))
+        ex_init()->state = ex_catch_st;
+
+    return scope->is_recovered;
 }
 
 bool raii_is_caught(unique_t *scope, const char *err) {
     const char *exception = (const char *)(!is_empty((void *)scope->panic) ? scope->panic : scope->err);
-    return scope->is_recovered = is_str_eq(err, exception);
+    if (scope->is_recovered = is_str_eq(err, exception))
+        ex_init()->state = ex_catch_st;
+
+    return scope->is_recovered;
 }
 
 const char *raii_message(void) {
@@ -446,13 +452,15 @@ void guard_set(ex_context_t *ctx, const char *ex, const char *message) {
     memory_t *scope = raii_init()->arena;
     scope->err = (void *)ex;
     scope->panic = message;
+    ctx->is_guarded = true;
     ex_swap_set(ctx, (void *)scope);
     ex_unwind_set(ctx, scope->is_protected);
 }
 
 void guard_reset(void *scope, ex_setup_func set, ex_unwind_func unwind) {
     raii_init()->arena = scope;
     ex_swap_reset(ex_init());
+    ex_init()->is_guarded = false;
     exception_setup_func = set;
     exception_unwind_func = unwind;
 }
@@ -470,7 +478,21 @@ values_type *raii_value(void *data) {
         return ((raii_values_t *)data)->value;
 
     RAII_LOG("attempt to get value on null");
-    return ((raii_values_t *)0)->value;
+    return;
+}
+
+static void raii_unwind_set(ex_context_t *ctx, const char *ex, const char *message) {
+    memory_t *scope = raii_init();
+    scope->err = (void *)ex;
+    scope->panic = message;
+    ex_swap_set(ctx, (void *)scope);
+    ex_unwind_set(ctx, scope->is_protected);
+}
+
+void raii_setup(void) {
+    exception_unwind_func = (ex_unwind_func)raii_deferred_free;
+    exception_setup_func = raii_unwind_set;
+    ex_signal_setup();
 }
 
 int strpos(const char *text, char *pattern) {