Changeset 6a48cc9 for doc

Timestamp:

Jun 14, 2017, 2:46:27 PM (7 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

78372fd, 838ef08

Parents:

e4e9173

Message:

More tests for the exception library.

Location:

doc/working/exception

Files:

• impl/exception.c (modified) (1 diff)
• impl/test-main.c (modified) (5 diffs)
• translate.c (modified) (1 diff)

doc/working/exception/impl/exception.c

@@ -222 +222 @@
                                                 ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
                                         shared_stack.current_handler_index = index;
-
 
                                         // Based on the return value, check if we matched the exception

doc/working/exception/impl/test-main.c

@@ -9 +9 @@
 #define CLEANUP(function) \
         struct __cleanup_hook __hidden_hook __attribute__((cleanup(function)))
+
+#define SET_UP_RESUME_NODE(handler_function) \
+        struct __try_resume_node node \
+                __attribute__((cleanup(__try_resume_node_delete))); \
+        __try_resume_node_new(&node, handler_function)
 
 void __try_resume_node_new(struct __try_resume_node * node,
@@ -153 +158 @@
                         printf("See you next time\n");
                 }
-                CLEANUP(farewell_finally1);
-                {
-                        printf("jump out of farewell\n");
+                struct __cleanup_hook __hidden_hook
+                        __attribute__((cleanup(farewell_finally1)));
+                {
+                        printf("walk out of farewell\n");
                 }
         }
@@ -162 +168 @@
 // Resume-to-Terminate Test:
 void fallback() {
-        //raii_t a = {"fallback function\n"};
         {
                 void fallback_try1() {
@@ -186 +191 @@
         }
 }
+
+// Terminate Throw New Exception:
+void terminate_swap() {
+        raii_t a = {"terminate_swap"};
+        {
+                void fn_try1() {
+                        terminate(2);
+                }
+                void fn_catch1(int index, exception except) {
+                        switch (index) {
+                        case 1:
+                                terminate(1);
+                                break;
+                        default:
+                                printf("INVALID INDEX in terminate_swap: %d (%d)\n",
+                                        index, except);
+                        }
+                }
+                int fn_match1(exception except) {
+                        if (2 == except) {
+                                return 1;
+                        } else {
+                                return 0;
+                        }
+                }
+                __try_terminate(fn_try1, fn_catch1, fn_match1);
+        }
+}
+
+void terminate_swapped() {
+        raii_t a = {"terminate_swapped"};
+        {
+                void fn_try1() {
+                        terminate_swap();
+                }
+                void fn_catch1(int index, exception except) {
+                        switch (index) {
+                        case 1:
+                                printf("terminate_swapped caught exception 1\n");
+                                break;
+                        default:
+                                printf("INVALID INDEX in terminate_swapped: %d (%d)\n",
+                                        index, except);
+                        }
+                }
+                int fn_match1(exception except) {
+                        if (1 == except) {
+                                return 1;
+                        } else {
+                                return 0;
+                        }
+                }
+                __try_terminate(fn_try1, fn_catch1, fn_match1);
+        }
+}
+
+// Resume Throw New Exception:
+void resume_swap() {
+        raii_t a = {"terminate_swap"};
+        {
+                bool fn_handle1(exception except) {
+                        if (2 == except) {
+                                resume(1);
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __try_resume_node node
+                        __attribute__((cleanup(__try_resume_node_delete)));
+                __try_resume_node_new(&node, fn_handle1);
+                {
+                        resume(2);
+                }
+        }
+}
+
+void resume_swapped() {
+        {
+                bool fn_handle1(exception except) {
+                        if (1 == except) {
+                                printf("resume_swapped caught exception 1\n");
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __try_resume_node node
+                        __attribute__((cleanup(__try_resume_node_delete)));
+                __try_resume_node_new(&node, fn_handle1);
+                {
+                        resume_swap();
+                }
+        }
+}
+
+// Terminate Rethrow:
+// I don't have an implementation for this.
+
+// Resume Rethrow:
+void reresume() {
+        {
+                bool reresume_handle1(exception except) {
+                        if (1 == except) {
+                                printf("reresume 1 caught exception 1\n");
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __try_resume_node node
+                        __attribute__((cleanup(__try_resume_node_delete)));
+                __try_resume_node_new(&node, reresume_handle1);
+                {
+                        bool reresume_handle2(exception except) {
+                                if (1 == except) {
+                                        printf("reresume 2 caught and rethrows exception 1\n");
+                                        return false;
+                                } else {
+                                        return false;
+                                }
+                        }
+                        struct __try_resume_node node
+                                __attribute__((cleanup(__try_resume_node_delete)));
+                        __try_resume_node_new(&node, reresume_handle2);
+                        {
+                                resume(1);
+                        }
+                }
+        }
+}
+
+// Terminate-Resume interaction:
+void fum() {
+        // terminate block, call resume
+        {
+                void fum_try1() {
+                        resume(3);
+                }
+                void fum_catch1(int index, exception except) {
+                        switch (index) {
+                        case 1:
+                                printf("fum caught exception 3\n");
+                                break;
+                        default:
+                                printf("INVALID INDEX in fum: %d (%d)\n", index, except);
+                        }
+                }
+                int fum_match1(exception except) {
+                        if (3 == except) {
+                                return 1;
+                        } else {
+                                return 0;
+                        }
+                }
+                __try_terminate(fum_try1, fum_catch1, fum_match1);
+        }
+}
+
+void foe() {
+        // resume block, call terminate
+        {
+                bool foe_handle1(exception except) {
+                        if (3 == except) {
+                                printf("foe caught exception 3\n");
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __try_resume_node node
+                        __attribute__((cleanup(__try_resume_node_delete)));
+                __try_resume_node_new(&node, foe_handle1);
+                {
+                        terminate(3);
+                }
+        }
+}
+
+void fy() {
+        // terminate block calls fum, call foe
+        {
+                void fy_try1() {
+                        foe();
+                }
+                void fy_catch1(int index, exception except) {
+                        switch (index) {
+                        case 1:
+                                printf("fy caught exception 3\n");
+                                fum();
+                                break;
+                        default:
+                                printf("INVALID INDEX in fy: %d (%d)\n", index, except);
+                        }
+                }
+                int fy_match1(exception except) {
+                        if (3 == except) {
+                                return 1;
+                        } else {
+                                return 0;
+                        }
+                }
+                __try_terminate(fy_try1, fy_catch1, fy_match1);
+        }
+}
+
+void fee() {
+        // resume block, call fy
+        {
+                bool fee_handle1(exception except) {
+                        if (3 == except) {
+                                printf("fee caught exception 3\n");
+                                return true;
+                        } else {
+                                return false;
+                        }
+                }
+                struct __try_resume_node node
+                        __attribute__((cleanup(__try_resume_node_delete)));
+                __try_resume_node_new(&node, fee_handle1);
+                {
+                        fy();
+                }
+        }
+}
+
 
 // main: choose which tests to run
@@ -195 +426 @@
         farewell(); printf("\n");
         fallback(); printf("\n");
+        terminate_swapped(); printf("\n");
+        resume_swapped(); printf("\n");
+        reresume(); printf("\n");
+        fee(); printf("\n");
         // Uncaught termination test.
         terminate(7);

doc/working/exception/translate.c

@@ -237 +237 @@
                 }
                 void finally1() {
-                        // (Finally, because of timing, also work for resume.)
+                        // Finally, because of timing, also works for resume.
+                        // However this might not actually be better in any way.
                         __try_resume_cleanup();