Changes in / [99fea48:6f121b8]

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 (deleted)
• tests/exceptions/conditional.cfa (modified) (2 diffs)
• tests/exceptions/data-except.cfa (modified) (2 diffs)
• tests/exceptions/defaults.cfa (deleted)
• 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 : Thr May 21 12:18:00 2020
-// Update Count     : 20
+// Last Modified On : Tue Apr 14 12:01:00 2020
+// Update Count     : 18
 //
 
@@ -80 +80 @@
 }
 
-void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
+void __cfaehm_throw_resume(exception_t * except) {
         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");
-        defaultHandler(except);
+
+        // Fall back to termination:
+        __cfaehm_throw_terminate(except);
+        // TODO: Default handler for resumption.
 }
 
@@ -237 +239 @@
 }
 
-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 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 ) {
+static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
+        if ( ! this_exception_context()->current_exception ) {
                 printf("UNWIND ERROR missing exception in begin unwind\n");
                 abort();
@@ -252 +247 @@
 
         // Call stdlibc to raise the exception
-        __cfadbg_print_safe(exception, "Begin unwinding (storage &p, context %p)\n", storage, context);
-        _Unwind_Reason_Code ret = _Unwind_RaiseException( storage );
+        _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
 
         // If we reach here it means something happened. For resumption to work we need to find a way
@@ -262 +256 @@
         // the whole stack.
 
+        // 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.
-        if ( ret != _URC_END_OF_STACK ) {
-                printf("UNWIND ERROR %d after raise exception\n", ret);
-                abort();
-        }
-
-        // No handler found, go to the default operation.
-        __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 *) ) {
+        printf("UNWIND ERROR %d after raise exception\n", ret);
+        abort();
+}
+
+void __cfaehm_throw_terminate( exception_t * val ) {
         __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();
+        __cfaehm_begin_unwind();
 }
 
@@ -292 +279 @@
         __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
 
-        __cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
-        abort();
+        __cfaehm_begin_unwind();
 }
 

libcfa/src/exception.h

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue May 19 14:17:00 2020
-// Update Count     : 10
+// Last Modified On : Fri Mar 27 10:16:00 2020
+// Update Count     : 9
 //
 
@@ -41 +41 @@
 
 // Used in throw statement translation.
-void __cfaehm_throw_terminate(exception_t * except, void (*)(exception_t *));
+void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
 void __cfaehm_rethrow_terminate() __attribute__((noreturn));
-void __cfaehm_throw_resume(exception_t * except, void (*)(exception_t *));
+void __cfaehm_throw_resume(exception_t * except);
 
 // 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 : Tue May 19 14:17:00 2020
-// Update Count     : 2
+// Last Modified On : Wed Apr 13 15:42:00 2020
+// Update Count     : 1
 //
+
+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 : Thr May 21 13:18:00 2020
-// Update Count     : 15
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 13
 //
 
@@ -64 +64 @@
         }
 
-        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 {
+        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;
+
                 // The built in types used in translation.
                 StructDecl * except_decl;
@@ -189 +82 @@
 
                 // 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 );
@@ -222 +121 @@
 
         public:
-                TryMutatorCore() :
+                ExceptionMutatorCore() :
+                        cur_context( NoHandler ),
+                        handler_except_decl( nullptr ),
                         except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
                         try_func_t( noQualifiers, false ),
@@ -231 +132 @@
                 {}
 
+                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
                 Statement * postmutate( ThrowStmt *throwStmt );
@@ -236 +138 @@
         };
 
-        void TryMutatorCore::init_func_types() {
+        void ExceptionMutatorCore::init_func_types() {
                 assert( except_decl );
 
@@ -294 +196 @@
         }
 
+        // 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 * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
@@ -302 +263 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_try_wrapper(
+        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 
@@ -309 +270 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_terminate_catch(
+        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
@@ -389 +350 @@
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
-        CompoundStmt * TryMutatorCore::create_single_matcher(
+        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
                 // {
@@ -427 +388 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_terminate_match(
+        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
@@ -464 +425 @@
         }
 
-        CompoundStmt * TryMutatorCore::create_terminate_caller(
+        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
@@ -482 +443 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_resume_handler(
+        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
@@ -519 +480 @@
         }
 
-        CompoundStmt * TryMutatorCore::create_resume_wrapper(
+        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -563 +524 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_finally_wrapper(
+        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
                         TryStmt * tryStmt ) {
-                // void finally() { `finally->block` }
+                // void finally() { <finally code> }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
@@ -576 +537 @@
         }
 
-        ObjectDecl * TryMutatorCore::create_finally_hook(
+        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm_cleanup_hook __finally_hook
-                //      __attribute__((cleanup( `finally_wrapper` )));
+                //      __attribute__((cleanup( finally_wrapper )));
 
                 // Make Cleanup Attribute.
@@ -604 +565 @@
 
         // Visiting/Mutating Functions
-        void TryMutatorCore::premutate( StructDecl *structDecl ) {
+        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 ) {
                 if ( !structDecl->has_body() ) {
                         // Skip children?
@@ -619 +604 @@
                         hook_decl = structDecl;
                 }
-        }
-
-        Statement * TryMutatorCore::postmutate( ThrowStmt * ) {
-                // All throws should be removed by this point.
-                assert( false );
-        }
-
-        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
+                // 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 ) {
                 assert( except_decl );
                 assert( node_decl );
@@ -680 +688 @@
         }
 
-        void translateThrows( std::list< Declaration *> & translationUnit ) {
-                PassVisitor<ThrowMutatorCore> translator;
+        void translateEHM( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ExceptionMutatorCore> 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 : Andrew Beach
-// Last Modified On : Tus May 19 11:47:00 2020
-// Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 09:19:23 2017
+// Update Count     : 4
 //
 
@@ -21 +21 @@
 
 namespace ControlStruct {
-        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.
-         */
+        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.
 }
 

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue May 19 12:03:00 2020
-// Update Count     : 634
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Feb  8 08:33:50 2020
+// Update Count     : 633
 //
 
@@ -312 +312 @@
                 } // if
 
-                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
@@ -355 +354 @@
                 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 Tries" , ControlStruct::translateTries( translationUnit ) );
+                PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
 
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );

tests/errors/.expect/completeType.txt

@@ -132 +132 @@
 ?=?: pointer to function
         ... with parameters
-          reference to instance of type _108_0_T (not function type)
-          instance of type _108_0_T (not function type)
+          reference to instance of type _104_0_T (not function type)
+          instance of type _104_0_T (not function type)
         ... returning
-          _retval__operator_assign: instance of type _108_0_T (not function type)
+          _retval__operator_assign: instance of type _104_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");