Changeset 3eb5a478

Timestamp:

Apr 2, 2020, 3:00:55 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

0f3d844

Parents:

6d43cdde

Message:

Fixed the disabled exceptions/resume test. Added more tests in exceptions/interact, one of which is disabled.

Files:

• libcfa/src/exception.c (modified) (4 diffs)
• tests/exceptions/.expect/interact.txt (modified) (1 diff)
• tests/exceptions/.expect/resume.txt (modified) (1 diff)
• tests/exceptions/interact.cfa (modified) (2 diffs)
• tests/exceptions/resume.cfa (modified) (2 diffs)

libcfa/src/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 10:19:00 2020
-// Update Count     : 12
+// Last Modified On : Thr Apr 02 14:47:00 2020
+// Update Count     : 13
 //
 
@@ -53 +53 @@
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
-    struct __cfaehm_try_resume_node * top_resume;
-    struct __cfaehm_try_resume_node * current_resume;
-
-    exception_t * current_exception;
-    int current_handler_index;
-} static shared_stack = {NULL, NULL, NULL, 0};
+        struct __cfaehm_try_resume_node * top_resume;
+
+        exception_t * current_exception;
+        int current_handler_index;
+} static shared_stack = {NULL, NULL, 0};
 
 // Get the current exception context.
@@ -75 +74 @@
         __cfaabi_dbg_print_safe("Throwing resumption exception\n");
 
-        struct __cfaehm_try_resume_node * original_head = context->current_resume;
-        struct __cfaehm_try_resume_node * current =
-                (original_head) ? original_head->next : context->top_resume;
+        struct __cfaehm_try_resume_node * original_head = context->top_resume;
+        struct __cfaehm_try_resume_node * current = context->top_resume;
 
         for ( ; current ; current = current->next) {
-                context->current_resume = current;
+                context->top_resume = current->next;
                 if (current->handler(except)) {
-                        context->current_resume = original_head;
+                        context->top_resume = original_head;
                         return;
                 }
@@ -88 +86 @@
 
         __cfaabi_dbg_print_safe("Unhandled exception\n");
-        context->current_resume = original_head;
+        context->top_resume = original_head;
 
         // Fall back to termination:

tests/exceptions/.expect/interact.txt

@@ -8 +8 @@
 
 resume catch on resume
+
+termination catch, will resume
+outer resume catch
+
+resumption catch, will terminate
+inner termination catch

tests/exceptions/.expect/resume.txt

@@ -19 +19 @@
 caught yin, will throw yang
 caught yang
+
+throwing first exception
+caught first exception
+throwing second exception
+caught second exception
+recaught first exception

tests/exceptions/interact.cfa

@@ -5 +5 @@
 
 TRIVIAL_EXCEPTION(star);
+TRIVIAL_EXCEPTION(moon);
 
 int main(int argc, char * argv[]) {
@@ -51 +52 @@
                 printf("resume catch on resume\n");
         }
+        printf("\n");
+
+        // Resume a termination exception.
+        try {
+                try {
+                        try {
+                                THROW(&(star){});
+                        } catchResume (star *) {
+                                printf("inner resume catch (error)\n");
+                        }
+                } catch (star * error) {
+                        printf("termination catch, will resume\n");
+                        THROW_RESUME(error);
+                }
+        } catchResume (star *) {
+                printf("outer resume catch\n");
+        }
+        printf("\n");
+
+        // Terminate a resumption exception.
+        try {
+                try {
+                        try {
+                                THROW_RESUME(&(star){});
+                        } catch (star *) {
+                                printf("inner termination catch\n");
+                        }
+                } catchResume (star * error) {
+                        printf("resumption catch, will terminate\n");
+                        THROW(error);
+                }
+        } catch (star *) {
+                printf("outer terminate catch (error)\n");
+        }
+#if 0
+        printf("\n");
+
+        // Unwinding a resumption catch does not break the system.
+        try {
+                try {
+                        try {
+                                try {
+                                        printf("throwing resume moon\n");
+                                        THROW_RESUME(&(moon){});
+                                } catch (star *) {
+                                        printf("termination catch\n");
+                                }
+                                printf("throwing resume star\n");
+                                THROW_RESUME(&(star){});
+                        } catchResume (star *) {
+                                printf("resumption star catch\n");
+                        }
+                } catchResume (moon *) {
+                        printf("resumption moon catch, will terminate\n");
+                        THROW(&(star){});
+                }
+        } catchResume (star *) {
+                printf("outermost catch (error)\n");
+        }
+#endif
 }

tests/exceptions/resume.cfa

@@ -77 +77 @@
                 printf("caught yang\n");
         }
-#ifdef FAILING
         printf("\n");
 
@@ -100 +99 @@
                 printf("caught second exception (bad location)\n");
         }
-#endif
 }