Changeset 99fea48

Timestamp:

May 21, 2020, 5:06:35 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

0e4df2e, 7119daa

Parents:

6f121b8 (diff), 66ba544 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/exception.c (modified) (7 diffs)
• libcfa/src/exception.h (modified) (3 diffs)
• libcfa/src/exception.hfa (modified) (1 diff)
• src/ControlStruct/ExceptTranslate.cc (modified) (19 diffs)
• src/ControlStruct/ExceptTranslate.h (modified) (2 diffs)
• src/main.cc (modified) (3 diffs)
• tests/errors/.expect/completeType.txt (modified) (1 diff)
• tests/exceptions/.expect/defaults.txt (added)
• tests/exceptions/conditional.cfa (modified) (2 diffs)
• tests/exceptions/data-except.cfa (modified) (2 diffs)
• tests/exceptions/defaults.cfa (added)
• tests/exceptions/finally.cfa (modified) (2 diffs)
• tests/exceptions/interact.cfa (modified) (10 diffs)
• tests/exceptions/resume.cfa (modified) (8 diffs)
• tests/exceptions/terminate.cfa (modified) (8 diffs)

libcfa/src/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 14 12:01:00 2020
-// Update Count     : 18
+// Last Modified On : Thr May 21 12:18:00 2020
+// Update Count     : 20
 //
 
@@ -80 +80 @@
 }
 
-void __cfaehm_throw_resume(exception_t * except) {
+void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
         struct exception_context_t * context = this_exception_context();
 
@@ -96 +96 @@
         }
 
+        // No handler found, fall back to the default operation.
         __cfadbg_print_safe(exception, "Unhandled exception\n");
-
-        // Fall back to termination:
-        __cfaehm_throw_terminate(except);
-        // TODO: Default handler for resumption.
+        defaultHandler(except);
 }
 
@@ -239 +237 @@
 }
 
+static void __cfaehm_cleanup_default( exception_t ** except ) {
+        __cfaehm_delete_exception( *except );
+        *except = NULL;
+}
+
 // The exception that is being thrown must already be stored.
-static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
-        if ( ! this_exception_context()->current_exception ) {
+static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) {
+        struct exception_context_t * context = this_exception_context();
+        struct _Unwind_Exception * storage = &this_exception_storage;
+        if ( NULL == context->current_exception ) {
                 printf("UNWIND ERROR missing exception in begin unwind\n");
                 abort();
@@ -247 +252 @@
 
         // Call stdlibc to raise the exception
-        _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
+        __cfadbg_print_safe(exception, "Begin unwinding (storage &p, context %p)\n", storage, context);
+        _Unwind_Reason_Code ret = _Unwind_RaiseException( storage );
 
         // If we reach here it means something happened. For resumption to work we need to find a way
@@ -256 +262 @@
         // the whole stack.
 
+        // We did not simply reach the end of the stack without finding a handler. This is an error.
+        if ( ret != _URC_END_OF_STACK ) {
+                printf("UNWIND ERROR %d after raise exception\n", ret);
+                abort();
+        }
+
         // No handler found, go to the default operation.
-        // Currently this will always be a cancellation.
-        if ( ret == _URC_END_OF_STACK ) {
-                __cfadbg_print_safe(exception, "Uncaught exception %p\n", &this_exception_storage);
-
-                __cfaehm_cancel_stack(this_exception_context()->current_exception);
-        }
-
-        // We did not simply reach the end of the stack without finding a handler. This is an error.
-        printf("UNWIND ERROR %d after raise exception\n", ret);
+        __cfadbg_print_safe(exception, "Uncaught exception %p\n", storage);
+
+        __attribute__((cleanup(__cfaehm_cleanup_default)))
+        exception_t * exception = context->current_exception;
+        defaultHandler( exception );
+}
+
+void __cfaehm_throw_terminate( exception_t * val, void (*defaultHandler)(exception_t *) ) {
+        __cfadbg_print_safe(exception, "Throwing termination exception\n");
+
+        __cfaehm_allocate_exception( val );
+        __cfaehm_begin_unwind( defaultHandler );
+}
+
+static __attribute__((noreturn)) void __cfaehm_rethrow_adapter( exception_t * except ) {
+        // TODO: Print some error message.
+        (void)except;
         abort();
-}
-
-void __cfaehm_throw_terminate( exception_t * val ) {
-        __cfadbg_print_safe(exception, "Throwing termination exception\n");
-
-        __cfaehm_allocate_exception( val );
-        __cfaehm_begin_unwind();
 }
 
@@ -279 +292 @@
         __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
 
-        __cfaehm_begin_unwind();
+        __cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
+        abort();
 }
 

libcfa/src/exception.h

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 10:16:00 2020
-// Update Count     : 9
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 10
 //
 
@@ -41 +41 @@
 
 // Used in throw statement translation.
-void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
+void __cfaehm_throw_terminate(exception_t * except, void (*)(exception_t *));
 void __cfaehm_rethrow_terminate() __attribute__((noreturn));
-void __cfaehm_throw_resume(exception_t * except);
+void __cfaehm_throw_resume(exception_t * except, void (*)(exception_t *));
 
 // Function catches termination exceptions.
@@ -72 +72 @@
 #ifdef __cforall
 }
+
+// Not all the built-ins can be expressed in C. These can't be
+// implemented in the .c file either so they all have to be inline.
+
+trait is_exception(dtype T) {
+        /* The first field must be a pointer to a virtual table.
+         * That virtual table must be a decendent of the base exception virtual tab$
+         */
+        void mark_exception(T *);
+        // This is never used and should be a no-op.
+};
+
+trait is_termination_exception(dtype T | is_exception(T)) {
+        void defaultTerminationHandler(T &);
+};
+
+trait is_resumption_exception(dtype T | is_exception(T)) {
+        void defaultResumptionHandler(T &);
+};
+
+forall(dtype T | is_termination_exception(T))
+static inline void $throw(T & except) {
+        __cfaehm_throw_terminate(
+                (exception_t *)&except,
+                (void(*)(exception_t *))defaultTerminationHandler
+        );
+}
+
+forall(dtype T | is_resumption_exception(T))
+static inline void $throwResume(T & except) {
+        __cfaehm_throw_resume(
+                (exception_t *)&except,
+                (void(*)(exception_t *))defaultResumptionHandler
+        );
+}
+
+forall(dtype T | is_exception(T))
+static inline void cancel_stack(T & except) __attribute__((noreturn)) {
+        __cfaehm_cancel_stack( (exception_t *)&except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultTerminationHandler(T & except) {
+        return cancel_stack( except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultResumptionHandler(T & except) {
+        throw except;
+}
+
 #endif

libcfa/src/exception.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr  7 10:25:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 13 15:42:00 2020
-// Update Count     : 1
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 2
 //
-
-trait is_exception(dtype T) {
-        // The trait system can't describe the actual constrants.
-        // Unused, should always be a no-op.
-        void mark_exception(T *);
-};
-
-forall(dtype T | is_exception(T))
-inline void cancel_stack(T & except) __attribute__((noreturn)) {
-        __cfaehm_cancel_stack( (exception_t *)&except );
-}
 
 // Everything below this line should be considered a patch while the exception

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 11:58:00 2020
-// Update Count     : 13
+// Last Modified On : Thr May 21 13:18:00 2020
+// Update Count     : 15
 //
 
@@ -64 +64 @@
         }
 
-        class ExceptionMutatorCore : public WithGuards {
-                enum Context { NoHandler, TerHandler, ResHandler };
-
-                // Also need to handle goto, break & continue.
-                // They need to be cut off in a ResHandler, until we enter another
-                // loop, switch or the goto stays within the function.
-
-                Context cur_context;
-
-                // The current (innermost) termination handler exception declaration.
-                ObjectDecl * handler_except_decl;
-
+        class ThrowMutatorCore : public WithGuards {
+                ObjectDecl * terminate_handler_except;
+                enum Context { NoHandler, TerHandler, ResHandler } cur_context;
+
+                // The helper functions for code/syntree generation.
+                Statement * create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
+
+        public:
+                ThrowMutatorCore() :
+                        terminate_handler_except( nullptr ),
+                        cur_context( NoHandler )
+                {}
+
+                void premutate( CatchStmt *catchStmt );
+                Statement * postmutate( ThrowStmt *throwStmt );
+        };
+
+        // ThrowStmt Mutation Helpers
+
+        Statement * ThrowMutatorCore::create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc ) {
+                // `throwFunc`( `throwStmt->get_name()` );
+                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( throwStmt->get_expr() );
+                throwStmt->set_expr( nullptr );
+                delete throwStmt;
+                return new ExprStmt( call );
+        }
+
+        Statement * ThrowMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
+                assert( nullptr == throwStmt->get_expr() );
+                assert( terminate_handler_except );
+
+                CompoundStmt * result = new CompoundStmt();
+                result->labels =  throwStmt->labels;
+                result->push_back( new ExprStmt( UntypedExpr::createAssign(
+                        nameOf( terminate_handler_except ),
+                        new ConstantExpr( Constant::null(
+                                //new PointerType(
+                                //      noQualifiers,
+                                        terminate_handler_except->get_type()->clone()
+                                //      )
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
+                        ) );
+                delete throwStmt;
+                return result;
+        }
+
+        Statement * ThrowMutatorCore::create_resume_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // return false;
+                Statement * result = new ReturnStmt(
+                        new ConstantExpr( Constant::from_bool( false ) )
+                        );
+                result->labels = throwStmt->labels;
+                delete throwStmt;
+                return result;
+        }
+
+        // Visiting/Mutating Functions
+
+        void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the statement's form.
+                ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                // Also checking the type would be nice.
+                if ( decl ) {
+                        // Pass.
+                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        SemanticError(catchStmt->location, "catch must have exception type");
+                } else {
+                        SemanticError(catchStmt->location, "catchResume must have exception type");
+                }
+
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+
+                        GuardValue( terminate_handler_except );
+                        terminate_handler_except = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+
+        Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Ignoring throwStmt->get_target() for now.
+                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throw" );
+                        } else if ( TerHandler == cur_context ) {
+                                return create_terminate_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throw in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                } else {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throwResume" );
+                        } else if ( ResHandler == cur_context ) {
+                                return create_resume_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throwResume in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                }
+        }
+
+        class TryMutatorCore {
                 // The built in types used in translation.
                 StructDecl * except_decl;
@@ -82 +189 @@
 
                 // The many helper functions for code/syntree generation.
-                Statement * create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt );
-                Statement * create_terminate_throw( ThrowStmt * throwStmt );
-                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
-                Statement * create_resume_throw( ThrowStmt * throwStmt );
-                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
                 CompoundStmt * take_try_block( TryStmt * tryStmt );
                 FunctionDecl * create_try_wrapper( CompoundStmt * body );
@@ -121 +222 @@
 
         public:
-                ExceptionMutatorCore() :
-                        cur_context( NoHandler ),
-                        handler_except_decl( nullptr ),
+                TryMutatorCore() :
                         except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
                         try_func_t( noQualifiers, false ),
@@ -132 +231 @@
                 {}
 
-                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
                 Statement * postmutate( ThrowStmt *throwStmt );
@@ -138 +236 @@
         };
 
-        void ExceptionMutatorCore::init_func_types() {
+        void TryMutatorCore::init_func_types() {
                 assert( except_decl );
 
@@ -196 +294 @@
         }
 
-        // ThrowStmt Mutation Helpers
-
-        Statement * ExceptionMutatorCore::create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt ) {
-                // `throwFunc`( `throwStmt->get_name` );
-                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
-                call->get_args().push_back( throwStmt->get_expr() );
-                throwStmt->set_expr( nullptr );
-                delete throwStmt;
-                return new ExprStmt( call );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
-                assert( nullptr == throwStmt->get_expr() );
-                assert( handler_except_decl );
-
-                CompoundStmt * result = new CompoundStmt();
-                result->labels =  throwStmt->labels;
-                result->push_back( new ExprStmt( UntypedExpr::createAssign(
-                        nameOf( handler_except_decl ),
-                        new ConstantExpr( Constant::null(
-                                new PointerType(
-                                        noQualifiers,
-                                        handler_except_decl->get_type()->clone()
-                                        )
-                                ) )
-                        ) ) );
-                result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
-                        ) );
-                delete throwStmt;
-                return result;
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaehm_throw_resume", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // return false;
-                Statement * result = new ReturnStmt(
-                        new ConstantExpr( Constant::from_bool( false ) )
-                        );
-                result->labels = throwStmt->labels;
-                delete throwStmt;
-                return result;
-        }
-
         // TryStmt Mutation Helpers
 
-        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
@@ -263 +302 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+        FunctionDecl * TryMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 
@@ -270 +309 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+        FunctionDecl * TryMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
@@ -350 +389 @@
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
-        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+        CompoundStmt * TryMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
                 // {
@@ -388 +427 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+        FunctionDecl * TryMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
@@ -425 +464 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+        CompoundStmt * TryMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
@@ -443 +482 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+        FunctionDecl * TryMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
@@ -480 +519 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+        CompoundStmt * TryMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -524 +563 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+        FunctionDecl * TryMutatorCore::create_finally_wrapper(
                         TryStmt * tryStmt ) {
-                // void finally() { <finally code> }
+                // void finally() { `finally->block` }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
@@ -537 +576 @@
         }
 
-        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+        ObjectDecl * TryMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm_cleanup_hook __finally_hook
-                //      __attribute__((cleanup( finally_wrapper )));
+                //      __attribute__((cleanup( `finally_wrapper` )));
 
                 // Make Cleanup Attribute.
@@ -565 +604 @@
 
         // Visiting/Mutating Functions
-        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
-                // Validate the Statement's form.
-                ObjectDecl * decl =
-                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
-                if ( decl && true /* check decl->get_type() */ ) {
-                        // Pass.
-                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        SemanticError(catchStmt->location, "catch must have exception type");
-                } else {
-                        SemanticError(catchStmt->location, "catchResume must have exception type");
-                }
-
-                // Track the handler context.
-                GuardValue( cur_context );
-                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        cur_context = TerHandler;
-
-                        GuardValue( handler_except_decl );
-                        handler_except_decl = decl;
-                } else {
-                        cur_context = ResHandler;
-                }
-        }
-
-        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+        void TryMutatorCore::premutate( StructDecl *structDecl ) {
                 if ( !structDecl->has_body() ) {
                         // Skip children?
@@ -604 +619 @@
                         hook_decl = structDecl;
                 }
-                // Later we might get the exception type as well.
-        }
-
-        Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
-                assert( except_decl );
-
-                // Ignoring throwStmt->get_target() for now.
-                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
-                        if ( throwStmt->get_expr() ) {
-                                return create_terminate_throw( throwStmt );
-                        } else if ( TerHandler == cur_context ) {
-                                return create_terminate_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throw in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                } else {
-                        if ( throwStmt->get_expr() ) {
-                                return create_resume_throw( throwStmt );
-                        } else if ( ResHandler == cur_context ) {
-                                return create_resume_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throwResume in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                }
-        }
-
-        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+        }
+
+        Statement * TryMutatorCore::postmutate( ThrowStmt * ) {
+                // All throws should be removed by this point.
+                assert( false );
+        }
+
+        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
                 assert( except_decl );
                 assert( node_decl );
@@ -688 +680 @@
         }
 
-        void translateEHM( std::list< Declaration *> & translationUnit ) {
-                PassVisitor<ExceptionMutatorCore> translator;
+        void translateThrows( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ThrowMutatorCore> translator;
                 mutateAll( translationUnit, translator );
         }
+
+        void translateTries( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<TryMutatorCore> translator;
+                mutateAll( translationUnit, translator );
+        }
 }

src/ControlStruct/ExceptTranslate.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:19:23 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus May 19 11:47:00 2020
+// Update Count     : 5
 //
 
@@ -21 +21 @@
 
 namespace ControlStruct {
-        void translateEHM( std::list< Declaration *> & translationUnit );
-        // Converts exception handling structures into their underlying C code.  Translation does use the exception
-        // handling header, make sure it is visible wherever translation occurs.
+        void translateThrows( std::list< Declaration *> & translationUnit );
+        /* Replaces all throw & throwResume statements with function calls.
+         * These still need to be resolved, so call this before the reslover.
+         */
+
+        void translateTries( std::list< Declaration *> & translationUnit );
+        /* Replaces all try blocks (and their many clauses) with function definitions and calls.
+         * This uses the exception built-ins to produce typed output and should take place after
+         * the resolver.
+         */
 }
 

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:33:50 2020
-// Update Count     : 633
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 19 12:03:00 2020
+// Update Count     : 634
 //
 
@@ -312 +312 @@
                 } // if
 
+                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
@@ -354 +355 @@
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
-                PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );

tests/errors/.expect/completeType.txt

@@ -132 +132 @@
 ?=?: pointer to function
         ... with parameters
-          reference to instance of type _104_0_T (not function type)
-          instance of type _104_0_T (not function type)
+          reference to instance of type _108_0_T (not function type)
+          instance of type _108_0_T (not function type)
         ... returning
-          _retval__operator_assign: instance of type _104_0_T (not function type)
+          _retval__operator_assign: instance of type _108_0_T (not function type)
           ... with attributes:
             Attribute with name: unused

tests/exceptions/conditional.cfa

@@ -56 +56 @@
 
         try {
-                throw &exc;
+                throw exc;
         } catch (num_error * error ; 3 == error->virtual_table->code( error )) {
                 caught_num_error(3, error);
@@ -64 +64 @@
 
         try {
-                throwResume &exc;
+                throwResume exc;
         } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
                 caught_num_error(3, error);

tests/exceptions/data-except.cfa

@@ -28 +28 @@
 
         try {
-                throw &except;
+                throw except;
         } catch (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
@@ -37 +37 @@
 
         try {
-                throwResume &except;
+                throwResume except;
         } catchResume (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);

tests/exceptions/finally.cfa

@@ -12 +12 @@
                 try {
                         printf("termination throw\n");
-                        throw &exc;
+                        throw exc;
                 } finally {
                         loud_exit a = "termination inner finally";
@@ -28 +28 @@
                 try {
                         printf("resumption throw\n");
-                        throwResume &exc;
+                        throwResume exc;
                 } finally {
                         loud_exit a = "resumption inner finally";

tests/exceptions/interact.cfa

@@ -10 +10 @@
         // Resume falls back to terminate.
         try {
-                throwResume &(star){};
+                throwResume (star){};
         } catch (star *) {
                 printf("caught as termination\n");
@@ -17 +17 @@
         try {
                 loud_region a = "try block with resume throw";
-                throwResume &(star){};
+                throwResume (star){};
         } catch (star *) {
                 printf("caught as termination\n");
@@ -29 +29 @@
         try {
                 try {
-                        throw &(star){};
+                        throw (star){};
                 } catchResume (star *) {
                         printf("resume catch on terminate\n");
@@ -43 +43 @@
         try {
                 try {
-                        throwResume &(star){};
+                        throwResume (star){};
                 } catch (star *) {
                         printf("terminate catch on resume\n");
@@ -58 +58 @@
                 try {
                         try {
-                                throw &(star){};
+                                throw (star){};
                         } catchResume (star *) {
                                 printf("inner resume catch (error)\n");
@@ -64 +64 @@
                 } catch (star * error) {
                         printf("termination catch, will resume\n");
-                        throwResume error;
+                        throwResume *error;
                 }
         } catchResume (star *) {
@@ -75 +75 @@
                 try {
                         try {
-                                throwResume &(star){};
+                                throwResume (star){};
                         } catch (star *) {
                                 printf("inner termination catch\n");
@@ -81 +81 @@
                 } catchResume (star * error) {
                         printf("resumption catch, will terminate\n");
-                        throw error;
+                        throw *error;
                 }
         } catch (star *) {
@@ -94 +94 @@
                                 try {
                                         printf("throwing resume moon\n");
-                                        throwResume &(moon){};
+                                        throwResume (moon){};
                                 } catch (star *) {
                                         printf("termination catch\n");
                                 }
                                 printf("throwing resume star\n");
-                                throwResume &(star){};
+                                throwResume (star){};
                         } catchResume (star *) {
                                 printf("resumption star catch\n");
@@ -105 +105 @@
                 } catchResume (moon *) {
                         printf("resumption moon catch, will terminate\n");
-                        throw &(star){};
+                        throw (star){};
                 }
         } catchResume (star *) {

tests/exceptions/resume.cfa

@@ -14 +14 @@
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
-                throwResume &(zen){};
+                throwResume (zen){};
                 printf("end of try clause\n");
         } catchResume (zen * error) {
@@ -24 +24 @@
         // Throw catch-all test.
         try {
-                throwResume &(zen){};
+                throwResume (zen){};
         } catchResume (exception_t * error) {
                 printf("catch-all\n");
@@ -33 +33 @@
         try {
                 printf("throwing child exception\n");
-                throwResume &(moment_of){};
+                throwResume (moment_of){};
         } catchResume (zen *) {
                 printf("inner parent match\n");
@@ -44 +44 @@
         try {
                 try {
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (zen *) {
                         printf("caught yin as zen\n");
@@ -60 +60 @@
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
-                        throwResume &(zen){};
+                        throwResume (zen){};
                 } catchResume (zen *) {
                         loud_exit a = "rethrowing catch clause";
@@ -75 +75 @@
         try {
                 try {
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (yin *) {
                         printf("caught yin, will throw yang\n");
-                        throwResume &(yang){};
+                        throwResume (yang){};
                 } catchResume (yang *) {
                         printf("caught exception from same try\n");
@@ -91 +91 @@
                 try {
                         printf("throwing first exception\n");
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
-                                throwResume &(yang){};
+                                throwResume (yang){};
                         } catchResume (yang *) {
                                 printf("caught second exception\n");
@@ -112 +112 @@
         try {
                 try {
-                        throwResume &(zen){};
-                        throwResume &(zen){};
+                        throwResume (zen){};
+                        throwResume (zen){};
                 } catchResume (zen *) {
                         printf("inner catch\n");
                 }
-                throwResume &(zen){};
+                throwResume (zen){};
         } catchResume (zen *) {
                 printf("outer catch\n");

tests/exceptions/terminate.cfa

@@ -14 +14 @@
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
-                throw &(zen){};
+                throw (zen){};
                 printf("end of try clause\n");
         } catch (zen * error) {
@@ -24 +24 @@
         // Throw catch-all test.
         try {
-                throw &(zen){};
+                throw (zen){};
         } catch (exception_t * error) {
                 printf("catch-all\n");
@@ -33 +33 @@
         try {
                 printf("throwing child exception\n");
-                throw &(moment_of){};
+                throw (moment_of){};
         } catch (zen *) {
                 printf("inner parent match\n");
@@ -44 +44 @@
         try {
                 try {
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (zen *) {
                         printf("caught yin as zen\n");
@@ -60 +60 @@
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
-                        throw &(zen){};
+                        throw (zen){};
                 } catch (zen *) {
                         loud_exit a = "rethrowing catch clause";
@@ -75 +75 @@
         try {
                 try {
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (yin *) {
                         printf("caught yin, will throw yang\n");
-                        throw &(yang){};
+                        throw (yang){};
                 } catch (yang *) {
                         printf("caught exception from same try\n");
@@ -91 +91 @@
                 try {
                         printf("throwing first exception\n");
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
-                                throw &(yang){};
+                                throw (yang){};
                         } catch (yang *) {
                                 printf("caught second exception\n");
@@ -112 +112 @@
         try {
                 try {
-                        throw &(zen){};
-                        throw &(zen){};
+                        throw (zen){};
+                        throw (zen){};
                 } catch (zen *) {
                         printf("inner catch\n");
                 }
-                throw &(zen){};
+                throw (zen){};
         } catch (zen *) {
                 printf("outer catch\n");