Changeset 0a6d2045

Timestamp:

Dec 20, 2023, 12:04:33 PM (11 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

523e300

Parents:

9fba8e6

Message:

You can how use local control flow out of 'catch' clauses. Added a test to show that it works.

Files:

• src/ControlStruct/ExceptTranslate.cpp (modified) (8 diffs)
• src/ControlStruct/MultiLevelExit.cpp (modified) (5 diffs)
• tests/exceptions/.expect/try-ctrl-flow.txt (modified) (1 diff)
• tests/exceptions/.expect/try-leave-catch.txt (added)
• tests/exceptions/try-ctrl-flow.cfa (modified) (1 diff)
• tests/exceptions/try-leave-catch.cfa (added)

src/ControlStruct/ExceptTranslate.cpp

@@ -151 +151 @@
                 const ast::DeclWithType * except_obj, ast::CatchClause * modded_handler );
         ast::FunctionDecl * create_terminate_match( CatchList &handlers );
-        ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
-                ast::FunctionDecl * terminate_catch, ast::FunctionDecl * terminate_match );
+        ast::CompoundStmt * create_terminate_caller( const CodeLocation & location,
+                ast::FunctionDecl * try_wrapper, ast::FunctionDecl * terminate_match,
+                CatchList & terminate_handlers );
         ast::FunctionDecl * create_resume_handler( CatchList &handlers );
         ast::CompoundStmt * create_resume_wrapper(
@@ -264 +265 @@
         //     `handler.body`;
         // }
-        // return;
+        // break;
         const CodeLocation & location = clause->location;
 
@@ -295 +296 @@
                                 body,
                         } ),
-                        new ast::ReturnStmt( location, nullptr ),
+                        new ast::BranchStmt( location, ast::BranchStmt::Break,
+                                ast::Label( location ) ),
                 }
         );
@@ -391 +393 @@
         // Index 1..{number of handlers}
         int index = 0;
-        CatchList::iterator it;
-        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
+        for ( ast::CatchClause * handler : handlers ) {
                 ++index;
-                ast::CatchClause * handler = *it;
-
-                // Body should have been taken by create_terminate_catch.
-                // xxx - just ignore it?
-                // assert( nullptr == handler->get_body() );
-
-                // Create new body.
-                handler->body = new ast::ReturnStmt( handler->location,
+
+                ast::ptr<ast::Stmt> other_body = new ast::ReturnStmt( handler->location,
                         ast::ConstantExpr::from_int( handler->location, index ) );
-
-                // Create the handler.
+                handler->body.swap( other_body );
+
                 body->push_back( create_single_matcher( except_obj, handler ) );
-                *it = nullptr;
+
+                handler->body.swap( other_body );
         }
 
@@ -425 +421 @@
 
 ast::CompoundStmt * TryMutatorCore::create_terminate_caller(
-                CodeLocation loc,
+                const CodeLocation & loc,
                 ast::FunctionDecl * try_wrapper,
-                ast::FunctionDecl * terminate_catch,
-                ast::FunctionDecl * terminate_match ) {
+                ast::FunctionDecl * terminate_match,
+                CatchList & terminate_handlers ) {
         // {
         //     int __handler_index = __cfaehm_try_terminate(`try`, `match`);
@@ -447 +443 @@
         );
 
+        ast::ObjectDecl * except = make_exception_object( loc );
+        except->init = new ast::SingleInit( loc,
+                new ast::UntypedExpr( loc,
+                        new ast::NameExpr( loc, "__cfaehm_get_current_termination" )
+                )
+        );
+
+        std::vector<ast::ptr<ast::CaseClause>> cases;
+        for ( auto const & [index, handler] : enumerate( terminate_handlers ) ) {
+                cases.emplace_back(
+                        create_terminate_catch_case( except, index + 1, handler ) );
+        }
+        auto switch_stmt = new ast::SwitchStmt( loc,
+                new ast::VariableExpr( loc, index ), std::move( cases ) );
+
         return new ast::CompoundStmt( loc, {
                 new ast::DeclStmt( loc, index ),
                 new ast::IfStmt( loc,
                         new ast::VariableExpr( loc, index ),
-                        new ast::ExprStmt( loc,
-                                new ast::UntypedExpr( loc,
-                                        new ast::VariableExpr( loc, terminate_catch ),
-                                        {
-                                                new ast::VariableExpr( loc, index ),
-                                                new ast::UntypedExpr( loc,
-                                                        new ast::NameExpr( loc, "__cfaehm_get_current_termination" )
-                                                ),
-                                        }
-                                )
-                        )
+                        new ast::CompoundStmt( loc, {
+                                new ast::DeclStmt( loc, except ),
+                                switch_stmt,
+                        } )
                 ),
         } );
@@ -663 +667 @@
 
         if ( termination_handlers.size() ) {
-                // Define the three helper functions.
+                // Define the two helper functions.
                 ast::FunctionDecl * try_wrapper = create_try_wrapper( inner );
                 appendDeclStmt( block, try_wrapper );
-                ast::FunctionDecl * terminate_catch =
-                        create_terminate_catch( termination_handlers );
-                appendDeclStmt( block, terminate_catch );
                 ast::FunctionDecl * terminate_match =
                         create_terminate_match( termination_handlers );
@@ -674 +675 @@
                 // Build the call to the try wrapper.
                 inner = create_terminate_caller(inner->location,
-                        try_wrapper, terminate_catch, terminate_match );
+                        try_wrapper, terminate_match, termination_handlers );
         }
 

src/ControlStruct/MultiLevelExit.cpp

@@ -35 +35 @@
         InTryWithHandler,
         InResumeHandler,
-        InTerminateHandler,
         InFinally,
 };
@@ -512 +511 @@
                 context = "catchResume clause";
                 break;
-        case ReturnContext::InTerminateHandler:
-                context = "catch clause";
-                break;
         case ReturnContext::InFinally:
                 context = "finally clause";
@@ -524 +520 @@
 }
 
+bool hasTerminate( const TryStmt * stmt ) {
+        for ( auto clause : stmt->handlers ) {
+                if ( ast::Terminate == clause->kind ) return true;
+        }
+        return false;
+}
+
 void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
+        visit_children = false;
+
         bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
@@ -533 +538 @@
 
         // Try statements/try blocks are only sealed with a termination handler.
-        for ( auto clause : stmt->handlers ) {
-                if ( ast::Terminate == clause->kind ) {
-                        return enterSealedContext( ReturnContext::InTryWithHandler );
-                }
-        }
+        if ( hasTerminate( stmt ) ) {
+                // This is just enterSealedContext except scoped to the block.
+                // And that is because the state must change for a single field.
+                ValueGuard< ReturnContext > guard0( ret_context );
+                ret_context = ReturnContext::InTryWithHandler;
+                auto guard = makeFuncGuard( [](){}, [this, old = std::move(enclosing_control_structures)](){ enclosing_control_structures = std::move(old); });
+                enclosing_control_structures = vector<Entry>();
+                visitor->maybe_accept( stmt, &TryStmt::body );
+        } else {
+                visitor->maybe_accept( stmt, &TryStmt::body );
+        }
+
+        visitor->maybe_accept( stmt, &TryStmt::handlers );
+        visitor->maybe_accept( stmt, &TryStmt::finally );
 }
 
@@ -551 +565 @@
 
 void MultiLevelExitCore::previsit( const CatchClause * clause ) {
-        ReturnContext context = ( ast::Terminate == clause->kind )
-                ? ReturnContext::InTerminateHandler : ReturnContext::InResumeHandler;
-        enterSealedContext( context );
+        if ( ast::Resume == clause->kind ) {
+                enterSealedContext( ReturnContext::InResumeHandler );
+        }
 }
 

tests/exceptions/.expect/try-ctrl-flow.txt

@@ -15 +15 @@
 exceptions/try-ctrl-flow.cfa:148:1 error: "break" outside a loop, "switch", or labelled block
 exceptions/try-ctrl-flow.cfa:159:1 error: "return" may not appear in a try statement with a catch clause
-exceptions/try-ctrl-flow.cfa:187:1 error: "return" may not appear in a catch clause
-exceptions/try-ctrl-flow.cfa:195:1 error: "return" may not appear in a catchResume clause
+exceptions/try-ctrl-flow.cfa:187:1 error: "return" may not appear in a catchResume clause

tests/exceptions/try-ctrl-flow.cfa

@@ -181 +181 @@
 }
 
-void return_in_catch() {
-        try {
-                ;
-        } catch (nil_exception *) {
-                return;
-        }
-}
-
 void return_in_catchResume() {
         try {