source: src/ControlStruct/ExceptTranslateNew.cpp @ eb211bf

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// ExceptTranslateNew.cpp -- Conversion of exception control flow structures.
//
// Author           : Andrew Beach
// Created On       : Mon Nov  8 11:53:00 2021
// Last Modified By : Peter A. Buhr
// Last Modified On : Mon Jan 31 18:49:58 2022
// Update Count     : 1
//

#include "ExceptTranslate.h"

#include "AST/Expr.hpp"
#include "AST/Pass.hpp"
#include "AST/Stmt.hpp"
#include "AST/TranslationUnit.hpp"
#include "AST/DeclReplacer.hpp"

namespace ControlStruct {

namespace {

        typedef std::list<ast::CatchStmt*> CatchList;

        void split( CatchList& allHandlers, CatchList& terHandlers,
                                CatchList& resHandlers ) {
                while ( !allHandlers.empty() ) {
                        ast::CatchStmt * stmt = allHandlers.front();
                        allHandlers.pop_front();
                        if (stmt->kind == ast::ExceptionKind::Terminate) {
                                terHandlers.push_back(stmt);
                        } else {
                                resHandlers.push_back(stmt);
                        }
                }
        }

        void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
                block->push_back(new ast::DeclStmt(block->location, item));
        }

class TranslateThrowsCore : public ast::WithGuards {
        const ast::ObjectDecl * terminateHandlerExcept;
        enum Context { NoHandler, TerHandler, ResHandler } currentContext;

        const ast::Stmt * createEitherThrow(
                const ast::ThrowStmt * throwStmt, const char * funcName );
        const ast::Stmt * createTerminateRethrow( const ast::ThrowStmt * );

public:
        TranslateThrowsCore() :
                terminateHandlerExcept( nullptr ), currentContext( NoHandler )
        {}

        void previsit( const ast::CatchStmt * stmt );
        const ast::Stmt * postvisit( const ast::ThrowStmt * stmt );
};

const ast::Stmt * TranslateThrowsCore::createEitherThrow(
                const ast::ThrowStmt * throwStmt, const char * funcName ) {
        // `throwFunc`( `throwStmt->name` );
        ast::UntypedExpr * call = new ast::UntypedExpr( throwStmt->location,
                new ast::NameExpr( throwStmt->location, funcName )
        );
        call->args.push_back( throwStmt->expr );
        return new ast::ExprStmt( throwStmt->location, call );
}

ast::VariableExpr * varOf( const ast::DeclWithType * decl ) {
        return new ast::VariableExpr( decl->location, decl );
}

const ast::Stmt * TranslateThrowsCore::createTerminateRethrow(
                const ast::ThrowStmt * stmt ) {
        // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
        assert( nullptr == stmt->expr );
        assert( terminateHandlerExcept );

        ast::CompoundStmt * result = new ast::CompoundStmt(
                stmt->location, {}, std::vector<ast::Label>( stmt->labels ) );
        result->push_back( new ast::ExprStmt( stmt->location,
                ast::UntypedExpr::createAssign(
                        stmt->location,
                        varOf( terminateHandlerExcept ),
                        ast::ConstantExpr::null(
                                stmt->location,
                                terminateHandlerExcept->type
                        )
                )
        ) );
        result->push_back( new ast::ExprStmt( stmt->location, new ast::UntypedExpr(
                stmt->location,
                new ast::NameExpr( stmt->location, "__cfaehm_rethrow_terminate" )
        ) ) );
        return result;
}

void TranslateThrowsCore::previsit( const ast::CatchStmt * stmt ) {
        // Validate the statement's form.
        const ast::ObjectDecl * decl = stmt->decl.as<ast::ObjectDecl>();
        // Also checking the type would be nice.
        if ( !decl || !decl->type.as<ast::PointerType>() ) {
                std::string kind = (ast::Terminate == stmt->kind) ? "catch" : "catchResume";
                SemanticError( stmt->location, kind + " must have pointer to an exception type" );
        }

        // Track the handler context.
        if ( ast::Terminate == stmt->kind ) {
                GuardValue( currentContext ) = TerHandler;
                GuardValue( terminateHandlerExcept ) = decl;
        } else {
                GuardValue( currentContext ) = ResHandler;
        }
}

const ast::Stmt * TranslateThrowsCore::postvisit(
                const ast::ThrowStmt * stmt ) {
        // Ignoring ThrowStmt::target for now.
        // Handle Termination (Raise, Reraise, Error):
        if ( ast::Terminate == stmt->kind ) {
                if ( stmt->expr ) {
                        return createEitherThrow( stmt, "$throw" );
                } else if ( TerHandler == currentContext ) {
                        return createTerminateRethrow( stmt );
                } else {
                        abort( "Invalid throw in %s at %i\n",
                                stmt->location.filename.c_str(),
                                stmt->location.first_line);
                }
        // Handle Resumption (Raise, Reraise, Error):
        } else {
                if ( stmt->expr ) {
                        return createEitherThrow( stmt, "$throwResume" );
                } else if ( ResHandler == currentContext ) {
                        // This has to be handled later.
                        return stmt;
                } else {
                        abort( "Invalid throwResume in %s at %i\n",
                                stmt->location.filename.c_str(),
                                stmt->location.first_line);
                }
        }
}


class TryMutatorCore {
        // The built in types used in translation.
        const ast::StructDecl * except_decl;
        const ast::StructDecl * node_decl;
        const ast::StructDecl * hook_decl;

        // The many helper functions for code/syntree generation.
        ast::CompoundStmt * take_try_block( ast::TryStmt * tryStmt );
        ast::FunctionDecl * create_try_wrapper( const ast::CompoundStmt * body );
        ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
        ast::CompoundStmt * create_single_matcher(
                const ast::DeclWithType * except_obj, ast::CatchStmt * 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::FunctionDecl * create_resume_handler( CatchList &handlers );
        ast::CompoundStmt * create_resume_wrapper(
                const ast::Stmt * wraps, const ast::FunctionDecl * resume_handler );
        ast::FunctionDecl * create_finally_wrapper( ast::TryStmt * tryStmt );
        ast::ObjectDecl * create_finally_hook( ast::FunctionDecl * finally_wrapper );
        ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );

        // Types used in translation, make sure to use clone.
        // void (*function)();
        ast::FunctionDecl * try_func_t;
        // void (*function)(int, exception);
        ast::FunctionDecl * catch_func_t;
        // int (*function)(exception);
        ast::FunctionDecl * match_func_t;
        // bool (*function)(exception);
        ast::FunctionDecl * handle_func_t;
        // void (*function)(__attribute__((unused)) void *);
        ast::FunctionDecl * finally_func_t;

        ast::StructInstType * create_except_type() {
                assert( except_decl );
                return new ast::StructInstType( except_decl );
        }
        void init_func_types();

public:
        TryMutatorCore() :
                except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr )
        {}

        void previsit( const ast::StructDecl *structDecl );
        ast::Stmt * postvisit( const ast::TryStmt *tryStmt );
        ast::Stmt * postvisit( const ast::ThrowStmt *throwStmt );
};

void TryMutatorCore::init_func_types() {
        assert( except_decl );

        ast::ObjectDecl index_obj(
                {},
                "__handler_index",
                new ast::BasicType(ast::BasicType::SignedInt)
                );
        ast::ObjectDecl exception_obj(
                {},
                "__exception_inst",
                new ast::PointerType(
                        new ast::StructInstType( except_decl )
                        ),
                NULL
                );
        ast::ObjectDecl bool_obj(
                {},
                "__ret_bool",
                new ast::BasicType( ast::BasicType::Bool ),
                nullptr, //init
                ast::Storage::Classes{},
                ast::Linkage::Cforall,
                nullptr, //width
                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                );
        ast::ObjectDecl voidptr_obj(
                {},
                "__hook",
                new ast::PointerType(
                        new ast::VoidType()
                ),
                nullptr, //init
                ast::Storage::Classes{},
                ast::Linkage::Cforall,
                nullptr, //width
                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                );

        ast::ObjectDecl unused_index_obj(
                {},
                "__handler_index",
                new ast::BasicType(ast::BasicType::SignedInt),
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall,
                nullptr, //width
                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
        );
        //unused_index_obj->attributes.push_back( new Attribute( "unused" ) );

        try_func_t = new ast::FunctionDecl(
                {},
                "try",
                {}, //forall
                {}, //no param
                {}, //no return
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall
        );

        catch_func_t = new ast::FunctionDecl(
                {},
                "catch",
                {}, //forall
                {ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
                {}, //return void
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall
        );

        match_func_t = new ast::FunctionDecl(
                {},
                "match",
                {}, //forall
                {ast::deepCopy(&exception_obj)},
                {ast::deepCopy(&unused_index_obj)},
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall
        );

        handle_func_t = new ast::FunctionDecl(
                {},
                "handle",
                {}, //forall
                {ast::deepCopy(&exception_obj)},
                {ast::deepCopy(&bool_obj)},
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall
        );

        finally_func_t = new ast::FunctionDecl(
                {},
                "finally",
                {}, //forall
                {ast::deepCopy(&voidptr_obj)},
                {}, //return void
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall
        );

        //catch_func_t.get_parameters().push_back( index_obj.clone() );
        //catch_func_t.get_parameters().push_back( exception_obj.clone() );
        //match_func_t.get_returnVals().push_back( unused_index_obj );
        //match_func_t.get_parameters().push_back( exception_obj.clone() );
        //handle_func_t.get_returnVals().push_back( bool_obj.clone() );
        //handle_func_t.get_parameters().push_back( exception_obj.clone() );
        //finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
}

// TryStmt Mutation Helpers

/*
ast::CompoundStmt * TryMutatorCore::take_try_block( ast::TryStmt *tryStmt ) {
        ast::CompoundStmt * block = tryStmt->body;
        tryStmt->body = nullptr;
        return block;
}
*/

ast::FunctionDecl * TryMutatorCore::create_try_wrapper(
                const ast::CompoundStmt *body ) {

        ast::FunctionDecl * ret = ast::deepCopy(try_func_t);
        ret->stmts = body;
        return ret;
}

ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
                CatchList &handlers ) {
        std::vector<ast::ptr<ast::Stmt>> handler_wrappers;

        assert (!handlers.empty());
        const CodeLocation loc = handlers.front()->location;

        ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
        const ast::DeclWithType * index_obj = func_t->params.front();
        const ast::DeclWithType * except_obj = func_t->params.back();

        // Index 1..{number of handlers}
        int index = 0;
        CatchList::iterator it = handlers.begin();
        for ( ; it != handlers.end() ; ++it ) {
                ++index;
                ast::CatchStmt * handler = *it;
                const CodeLocation loc = handler->location;

                // case `index`:
                // {
                //     `handler.decl` = { (virtual `decl.type`)`except` };
                //     `handler.body`;
                // }
                // return;
                ast::CompoundStmt * block = new ast::CompoundStmt(loc);

                // Just copy the exception value. (Post Validation)
                const ast::ObjectDecl * handler_decl =
                        handler->decl.strict_as<ast::ObjectDecl>();
                ast::ObjectDecl * local_except = ast::deepCopy(handler_decl);
                ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
                        new ast::VariableExpr( loc, except_obj ),
                        local_except->get_type()
                        );
                vcex->location = handler->location;
                local_except->init = new ast::ListInit(loc, { new ast::SingleInit( loc, vcex ) });
                block->push_back( new ast::DeclStmt( loc, local_except ) );

                // Add the cleanup attribute.
                local_except->attributes.push_back( new ast::Attribute(
                        "cleanup",
                        { new ast::NameExpr( loc, "__cfaehm_cleanup_terminate" ) }
                        ) );

                ast::DeclReplacer::DeclMap mapping;
                mapping[handler_decl] = local_except;
                const ast::Stmt * mutBody = strict_dynamic_cast<const ast::Stmt *>(
                        ast::DeclReplacer::replace(handler->body, mapping));


                block->push_back( mutBody );
                // handler->body = nullptr;

                handler_wrappers.push_back( new ast::CaseStmt(loc, 
                        ast::ConstantExpr::from_int(loc, index) ,
                        { block, new ast::ReturnStmt( loc, nullptr ) }
                        ));
        }
        // TODO: Some sort of meaningful error on default perhaps?

        /*
        std::list<Statement*> stmt_handlers;
        while ( !handler_wrappers.empty() ) {
                stmt_handlers.push_back( handler_wrappers.front() );
                handler_wrappers.pop_front();
        }
        */

        ast::SwitchStmt * handler_lookup = new ast::SwitchStmt(loc, 
                new ast::VariableExpr( loc, index_obj ),
                std::move(handler_wrappers)
                );
        ast::CompoundStmt * body = new ast::CompoundStmt(loc, 
                {handler_lookup});

        func_t->stmts = body;
        return func_t;
}

// Create a single check from a moddified handler.
// except_obj is referenced, modded_handler will be freed.
ast::CompoundStmt * TryMutatorCore::create_single_matcher(
                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
        // {
        //     `modded_handler.decl`
        //     if ( `decl.name = (virtual `decl.type`)`except`
        //             [&& `modded_handler.cond`] ) {
        //         `modded_handler.body`
        //     }
        // }

        const CodeLocation loc = modded_handler->location;
        ast::CompoundStmt * block = new ast::CompoundStmt(loc);

        // Local Declaration
        const ast::ObjectDecl * local_except =
                modded_handler->decl.strict_as<ast::ObjectDecl>();
        block->push_back( new ast::DeclStmt( loc,  local_except ) );

        // Check for type match.
        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc, 
                new ast::VariableExpr(loc, except_obj ),
                local_except->get_type()
                );
        ast::Expr * cond = ast::UntypedExpr::createAssign(loc,
                new ast::VariableExpr(loc, local_except ), vcex );

        // Add the check on the conditional if it is provided.
        if ( modded_handler->cond ) {
                cond = new ast::LogicalExpr( loc, cond, modded_handler->cond, ast::LogicalFlag::AndExpr );
        }
        // Construct the match condition.
        block->push_back( new ast::IfStmt(loc, 
                cond, modded_handler->body, nullptr ) );

        // xxx - how does this work in new ast
        //modded_handler->set_decl( nullptr );
        //modded_handler->set_cond( nullptr );
        //modded_handler->set_body( nullptr );
        //delete modded_handler;
        return block;
}

ast::FunctionDecl * TryMutatorCore::create_terminate_match(
                CatchList &handlers ) {
        // int match(exception * except) {
        //     HANDLER WRAPPERS { return `index`; }
        // }

        assert (!handlers.empty());
        const CodeLocation loc = handlers.front()->location;

        ast::CompoundStmt * body = new ast::CompoundStmt(loc);

        ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
        const ast::DeclWithType * except_obj = func_t->params.back();

        // Index 1..{number of handlers}
        int index = 0;
        CatchList::iterator it;
        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
                ++index;
                ast::CatchStmt * 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::ConstantExpr::from_int( handler->location, index ) );

                // Create the handler.
                body->push_back( create_single_matcher( except_obj, handler ) );
                *it = nullptr;
        }

        body->push_back( new ast::ReturnStmt(loc, 
                ast::ConstantExpr::from_int( loc, 0 ) ));

        func_t->stmts = body;

        return func_t;
}

ast::CompoundStmt * TryMutatorCore::create_terminate_caller(
                CodeLocation loc,
                ast::FunctionDecl * try_wrapper,
                ast::FunctionDecl * terminate_catch,
                ast::FunctionDecl * terminate_match ) {
        // { __cfaehm_try_terminate(`try`, `catch`, `match`); }

        ast::UntypedExpr * caller = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
                "__cfaehm_try_terminate" ) );
        caller->args.push_back( new ast::VariableExpr(loc, try_wrapper ) );
        caller->args.push_back( new ast::VariableExpr(loc, terminate_catch ) );
        caller->args.push_back( new ast::VariableExpr(loc, terminate_match ) );

        ast::CompoundStmt * callStmt = new ast::CompoundStmt(loc);
        callStmt->push_back( new ast::ExprStmt( loc, caller ) );
        return callStmt;
}

ast::FunctionDecl * TryMutatorCore::create_resume_handler(
                CatchList &handlers ) {
        // bool handle(exception * except) {
        //     HANDLER WRAPPERS { `hander->body`; return true; }
        // }
        assert (!handlers.empty());
        const CodeLocation loc = handlers.front()->location;
        ast::CompoundStmt * body = new ast::CompoundStmt(loc);

        ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
        const ast::DeclWithType * except_obj = func_t->params.back();

        CatchList::iterator it;
        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
                ast::CatchStmt * handler = *it;
                const CodeLocation loc = handler->location;
                // Modifiy body.
                ast::CompoundStmt * handling_code;
                if (handler->body.as<ast::CompoundStmt>()) {
                        handling_code = 
                        strict_dynamic_cast<ast::CompoundStmt*>( handler->body.get_and_mutate() );
                } else {
                        handling_code = new ast::CompoundStmt(loc);
                        handling_code->push_back( handler->body );
                }
                handling_code->push_back( new ast::ReturnStmt(loc,
                        ast::ConstantExpr::from_bool(loc, true ) ) );
                handler->body = handling_code;

                // Create the handler.
                body->push_back( create_single_matcher( except_obj, handler ) );
                *it = nullptr;
        }

        body->push_back( new ast::ReturnStmt(loc,
                ast::ConstantExpr::from_bool(loc, false ) ) );
        func_t->stmts = body;

        return func_t;
}

ast::CompoundStmt * TryMutatorCore::create_resume_wrapper(
                const ast::Stmt * wraps,
                const ast::FunctionDecl * resume_handler ) {
        const CodeLocation loc = wraps->location;
        ast::CompoundStmt * body = new ast::CompoundStmt(loc);

        // struct __try_resume_node __resume_node
        //      __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
        // ** unwinding of the stack here could cause problems **
        // ** however I don't think that can happen currently **
        // __cfaehm_try_resume_setup( &__resume_node, resume_handler );

        ast::ObjectDecl * obj = new ast::ObjectDecl(
                loc,
                "__resume_node",
                new ast::StructInstType(
                        node_decl
                        ),
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall,
                nullptr,
                {new ast::Attribute("cleanup", {new ast::NameExpr(loc, "__cfaehm_try_resume_cleanup")})}
                );
        appendDeclStmt( body, obj );

        ast::UntypedExpr *setup = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
                "__cfaehm_try_resume_setup" ) );
        setup->args.push_back( new ast::AddressExpr( loc, new ast::VariableExpr(loc, obj ) ) );
        setup->args.push_back( new ast::VariableExpr( loc, resume_handler ) );

        body->push_back( new ast::ExprStmt(loc, setup ) );

        body->push_back( wraps );
        return body;
}

ast::FunctionDecl * TryMutatorCore::create_finally_wrapper(
                ast::TryStmt * tryStmt ) {
        // void finally() { `finally->block` }
        const ast::FinallyStmt * finally = tryStmt->finally;
        const ast::CompoundStmt * body = finally->body;

        ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
        func_t->stmts = body;

        // finally->set_block( nullptr );
        // delete finally;
        tryStmt->finally = nullptr;


        return func_t;
}

ast::ObjectDecl * TryMutatorCore::create_finally_hook(
                ast::FunctionDecl * finally_wrapper ) {
        // struct __cfaehm_cleanup_hook __finally_hook
        //      __attribute__((cleanup( `finally_wrapper` )));

        const CodeLocation loc = finally_wrapper->location;
        // Make Cleanup Attribute.
        /*
        std::list< ast::Attribute * > attributes;
        {
                std::list<  > attr_params;
                attr_params.push_back( nameOf( finally_wrapper ) );
                attributes.push_back( new Attribute( "cleanup", attr_params ) );
        }
        */

        return new ast::ObjectDecl(
                loc,
                "__finally_hook",
                new ast::StructInstType(
                        hook_decl
                        ),
                nullptr,
                ast::Storage::Classes{},
                ast::Linkage::Cforall,
                nullptr,
                {new ast::Attribute("cleanup", {new ast::VariableExpr{loc, finally_wrapper}})}
                );
}

ast::Stmt * TryMutatorCore::create_resume_rethrow( const ast::ThrowStmt *throwStmt ) {
        // return false;
        const CodeLocation loc = throwStmt->location;
        ast::Stmt * result = new ast::ReturnStmt(loc, 
                ast::ConstantExpr::from_bool( loc, false )
                );
        result->labels = throwStmt->labels;
        // delete throwStmt; done by postvisit
        return result;
}

// Visiting/Mutating Functions
void TryMutatorCore::previsit( const ast::StructDecl *structDecl ) {
        if ( !structDecl->body ) {
                // Skip children?
                return;
        } else if ( structDecl->name == "__cfaehm_base_exception_t" ) {
                assert( nullptr == except_decl );
                except_decl = structDecl;
                init_func_types();
        } else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
                assert( nullptr == node_decl );
                node_decl = structDecl;
        } else if ( structDecl->name == "__cfaehm_cleanup_hook" ) {
                assert( nullptr == hook_decl );
                hook_decl = structDecl;
        }
}

ast::Stmt * TryMutatorCore::postvisit( const ast::TryStmt *tryStmt ) {
        assert( except_decl );
        assert( node_decl );
        assert( hook_decl );

        const CodeLocation loc = tryStmt->location;
        ast::TryStmt * mutStmt = mutate(tryStmt);
        // Generate a prefix for the function names?

        ast::CompoundStmt * block = new ast::CompoundStmt( loc );
        // ast::CompoundStmt * inner = take_try_block( mutStmt );
        // this is never mutated so let node deletion do its job?
        const ast::CompoundStmt * inner = mutStmt->body;

        if ( mutStmt->finally ) {
                // Define the helper function.
                ast::FunctionDecl * finally_block =
                        create_finally_wrapper( mutStmt );
                appendDeclStmt( block, finally_block );
                // Create and add the finally cleanup hook.
                appendDeclStmt( block, create_finally_hook( finally_block ) );
        }

        CatchList termination_handlers;
        CatchList resumption_handlers;

        for (auto & handler: mutStmt->handlers) {
                // xxx - should always be unique? mutate as safe const-cast
                assert(handler->unique());
                if (handler->kind == ast::ExceptionKind::Resume) {
                        resumption_handlers.push_back(handler.get_and_mutate());
                }
                else {
                        termination_handlers.push_back(handler.get_and_mutate());
                }
        }
        // split( mutStmt->handlers,
        //              termination_handlers, resumption_handlers );

        if ( resumption_handlers.size() ) {
                // Define the helper function.
                ast::FunctionDecl * resume_handler =
                        create_resume_handler( resumption_handlers );
                appendDeclStmt( block, resume_handler );
                // Prepare hooks
                inner = create_resume_wrapper( inner, resume_handler );
        }

        if ( termination_handlers.size() ) {
                // Define the three 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 );
                appendDeclStmt( block, terminate_match );
                // Build the call to the try wrapper.
                inner = create_terminate_caller(inner->location,
                        try_wrapper, terminate_catch, terminate_match );
        }

        // Embed the try block.
        block->push_back( inner );

        return block;
}

ast::Stmt * TryMutatorCore::postvisit( const ast::ThrowStmt *throwStmt ) {
        // Only valid `throwResume;` statements should remain. (2/3 checks)
        assert( ast::ExceptionKind::Resume == throwStmt->kind && ! throwStmt->expr );
        return create_resume_rethrow( throwStmt );
}

} // namespace

void translateThrows( ast::TranslationUnit & transUnit ) {
        ast::Pass<TranslateThrowsCore>::run( transUnit );
}

void translateTries( ast::TranslationUnit & transUnit ) {
        ast::Pass<TryMutatorCore>::run(transUnit);
}

} // namespace ControlStruct

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //