Changes in src/ControlStruct/ExceptTranslate.cc [7f9968ad:3090127]

File:

• src/ControlStruct/ExceptTranslate.cc (modified) (19 diffs)

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 24 11:18:00 2020
-// Update Count     : 17
+// 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 );
-
-        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(
-                                terminate_handler_except->get_type()->clone()
-                                ) )
-                        ) ) );
-                result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
-                        ) );
-                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 || !dynamic_cast<PointerType *>( decl->type ) ) {
-                        std::string kind = (CatchStmt::Terminate == catchStmt->kind) ? "catch" : "catchResume";
-                        SemanticError( catchStmt->location, kind + " must have pointer to an 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 ) {
-                                // This has to be handled later.
-                                return 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;
@@ -172 +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 );
@@ -185 +101 @@
                 FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
                 ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
-                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
 
                 // Types used in translation, make sure to use clone.
@@ -206 +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 ),
@@ -215 +132 @@
                 {}
 
+                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
+                Statement * postmutate( ThrowStmt *throwStmt );
                 Statement * postmutate( TryStmt *tryStmt );
-                Statement * postmutate( ThrowStmt *throwStmt );
         };
 
-        void TryMutatorCore::init_func_types() {
+        void ExceptionMutatorCore::init_func_types() {
                 assert( except_decl );
 
@@ -278 +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 );
@@ -286 +263 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_try_wrapper(
+        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 
@@ -293 +270 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_terminate_catch(
+        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
@@ -373 +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 ) {
                 // {
@@ -411 +388 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_terminate_match(
+        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
@@ -448 +425 @@
         }
 
-        CompoundStmt * TryMutatorCore::create_terminate_caller(
+        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
@@ -466 +443 @@
         }
 
-        FunctionDecl * TryMutatorCore::create_resume_handler(
+        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
@@ -503 +480 @@
         }
 
-        CompoundStmt * TryMutatorCore::create_resume_wrapper(
+        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -547 +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();
@@ -560 +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.
@@ -587 +564 @@
         }
 
-        Statement * TryMutatorCore::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 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?
@@ -613 +604 @@
                         hook_decl = structDecl;
                 }
-        }
-
-        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 );
@@ -669 +688 @@
         }
 
-        Statement * TryMutatorCore::postmutate( ThrowStmt *throwStmt ) {
-                // Only valid `throwResume;` statements should remain. (2/3 checks)
-                assert( ThrowStmt::Resume == throwStmt->kind && ! throwStmt->expr );
-                return create_resume_rethrow( throwStmt );
-        }
-
-        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 );
-        }
 }