Changeset 99fea48


Ignore:
Timestamp:
May 21, 2020, 5:06:35 PM (17 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
0e4df2e, 7119daa
Parents:
6f121b8 (diff), 66ba544 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/exception.c

    r6f121b8 r99fea48  
    1010// Created On       : Mon Jun 26 15:13:00 2017
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Apr 14 12:01:00 2020
    13 // Update Count     : 18
     12// Last Modified On : Thr May 21 12:18:00 2020
     13// Update Count     : 20
    1414//
    1515
     
    8080}
    8181
    82 void __cfaehm_throw_resume(exception_t * except) {
     82void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
    8383        struct exception_context_t * context = this_exception_context();
    8484
     
    9696        }
    9797
     98        // No handler found, fall back to the default operation.
    9899        __cfadbg_print_safe(exception, "Unhandled exception\n");
    99 
    100         // Fall back to termination:
    101         __cfaehm_throw_terminate(except);
    102         // TODO: Default handler for resumption.
     100        defaultHandler(except);
    103101}
    104102
     
    239237}
    240238
     239static void __cfaehm_cleanup_default( exception_t ** except ) {
     240        __cfaehm_delete_exception( *except );
     241        *except = NULL;
     242}
     243
    241244// The exception that is being thrown must already be stored.
    242 static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
    243         if ( ! this_exception_context()->current_exception ) {
     245static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) {
     246        struct exception_context_t * context = this_exception_context();
     247        struct _Unwind_Exception * storage = &this_exception_storage;
     248        if ( NULL == context->current_exception ) {
    244249                printf("UNWIND ERROR missing exception in begin unwind\n");
    245250                abort();
     
    247252
    248253        // Call stdlibc to raise the exception
    249         _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
     254        __cfadbg_print_safe(exception, "Begin unwinding (storage &p, context %p)\n", storage, context);
     255        _Unwind_Reason_Code ret = _Unwind_RaiseException( storage );
    250256
    251257        // If we reach here it means something happened. For resumption to work we need to find a way
     
    256262        // the whole stack.
    257263
     264        // We did not simply reach the end of the stack without finding a handler. This is an error.
     265        if ( ret != _URC_END_OF_STACK ) {
     266                printf("UNWIND ERROR %d after raise exception\n", ret);
     267                abort();
     268        }
     269
    258270        // No handler found, go to the default operation.
    259         // Currently this will always be a cancellation.
    260         if ( ret == _URC_END_OF_STACK ) {
    261                 __cfadbg_print_safe(exception, "Uncaught exception %p\n", &this_exception_storage);
    262 
    263                 __cfaehm_cancel_stack(this_exception_context()->current_exception);
    264         }
    265 
    266         // We did not simply reach the end of the stack without finding a handler. This is an error.
    267         printf("UNWIND ERROR %d after raise exception\n", ret);
     271        __cfadbg_print_safe(exception, "Uncaught exception %p\n", storage);
     272
     273        __attribute__((cleanup(__cfaehm_cleanup_default)))
     274        exception_t * exception = context->current_exception;
     275        defaultHandler( exception );
     276}
     277
     278void __cfaehm_throw_terminate( exception_t * val, void (*defaultHandler)(exception_t *) ) {
     279        __cfadbg_print_safe(exception, "Throwing termination exception\n");
     280
     281        __cfaehm_allocate_exception( val );
     282        __cfaehm_begin_unwind( defaultHandler );
     283}
     284
     285static __attribute__((noreturn)) void __cfaehm_rethrow_adapter( exception_t * except ) {
     286        // TODO: Print some error message.
     287        (void)except;
    268288        abort();
    269 }
    270 
    271 void __cfaehm_throw_terminate( exception_t * val ) {
    272         __cfadbg_print_safe(exception, "Throwing termination exception\n");
    273 
    274         __cfaehm_allocate_exception( val );
    275         __cfaehm_begin_unwind();
    276289}
    277290
     
    279292        __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
    280293
    281         __cfaehm_begin_unwind();
     294        __cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
     295        abort();
    282296}
    283297
  • libcfa/src/exception.h

    r6f121b8 r99fea48  
    1010// Created On       : Mon Jun 26 15:11:00 2017
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Mar 27 10:16:00 2020
    13 // Update Count     : 9
     12// Last Modified On : Tue May 19 14:17:00 2020
     13// Update Count     : 10
    1414//
    1515
     
    4141
    4242// Used in throw statement translation.
    43 void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
     43void __cfaehm_throw_terminate(exception_t * except, void (*)(exception_t *));
    4444void __cfaehm_rethrow_terminate() __attribute__((noreturn));
    45 void __cfaehm_throw_resume(exception_t * except);
     45void __cfaehm_throw_resume(exception_t * except, void (*)(exception_t *));
    4646
    4747// Function catches termination exceptions.
     
    7272#ifdef __cforall
    7373}
     74
     75// Not all the built-ins can be expressed in C. These can't be
     76// implemented in the .c file either so they all have to be inline.
     77
     78trait is_exception(dtype T) {
     79        /* The first field must be a pointer to a virtual table.
     80         * That virtual table must be a decendent of the base exception virtual tab$
     81         */
     82        void mark_exception(T *);
     83        // This is never used and should be a no-op.
     84};
     85
     86trait is_termination_exception(dtype T | is_exception(T)) {
     87        void defaultTerminationHandler(T &);
     88};
     89
     90trait is_resumption_exception(dtype T | is_exception(T)) {
     91        void defaultResumptionHandler(T &);
     92};
     93
     94forall(dtype T | is_termination_exception(T))
     95static inline void $throw(T & except) {
     96        __cfaehm_throw_terminate(
     97                (exception_t *)&except,
     98                (void(*)(exception_t *))defaultTerminationHandler
     99        );
     100}
     101
     102forall(dtype T | is_resumption_exception(T))
     103static inline void $throwResume(T & except) {
     104        __cfaehm_throw_resume(
     105                (exception_t *)&except,
     106                (void(*)(exception_t *))defaultResumptionHandler
     107        );
     108}
     109
     110forall(dtype T | is_exception(T))
     111static inline void cancel_stack(T & except) __attribute__((noreturn)) {
     112        __cfaehm_cancel_stack( (exception_t *)&except );
     113}
     114
     115forall(dtype T | is_exception(T))
     116static inline void defaultTerminationHandler(T & except) {
     117        return cancel_stack( except );
     118}
     119
     120forall(dtype T | is_exception(T))
     121static inline void defaultResumptionHandler(T & except) {
     122        throw except;
     123}
     124
    74125#endif
  • libcfa/src/exception.hfa

    r6f121b8 r99fea48  
    1010// Created On       : Thu Apr  7 10:25:00 2020
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Apr 13 15:42:00 2020
    13 // Update Count     : 1
     12// Last Modified On : Tue May 19 14:17:00 2020
     13// Update Count     : 2
    1414//
    15 
    16 trait is_exception(dtype T) {
    17         // The trait system can't describe the actual constrants.
    18         // Unused, should always be a no-op.
    19         void mark_exception(T *);
    20 };
    21 
    22 forall(dtype T | is_exception(T))
    23 inline void cancel_stack(T & except) __attribute__((noreturn)) {
    24         __cfaehm_cancel_stack( (exception_t *)&except );
    25 }
    2615
    2716// Everything below this line should be considered a patch while the exception
  • src/ControlStruct/ExceptTranslate.cc

    r6f121b8 r99fea48  
    1010// Created On       : Wed Jun 14 16:49:00 2017
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Mar 27 11:58:00 2020
    13 // Update Count     : 13
     12// Last Modified On : Thr May 21 13:18:00 2020
     13// Update Count     : 15
    1414//
    1515
     
    6464        }
    6565
    66         class ExceptionMutatorCore : public WithGuards {
    67                 enum Context { NoHandler, TerHandler, ResHandler };
    68 
    69                 // Also need to handle goto, break & continue.
    70                 // They need to be cut off in a ResHandler, until we enter another
    71                 // loop, switch or the goto stays within the function.
    72 
    73                 Context cur_context;
    74 
    75                 // The current (innermost) termination handler exception declaration.
    76                 ObjectDecl * handler_except_decl;
    77 
     66        class ThrowMutatorCore : public WithGuards {
     67                ObjectDecl * terminate_handler_except;
     68                enum Context { NoHandler, TerHandler, ResHandler } cur_context;
     69
     70                // The helper functions for code/syntree generation.
     71                Statement * create_either_throw(
     72                        ThrowStmt * throwStmt, const char * throwFunc );
     73                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
     74                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
     75
     76        public:
     77                ThrowMutatorCore() :
     78                        terminate_handler_except( nullptr ),
     79                        cur_context( NoHandler )
     80                {}
     81
     82                void premutate( CatchStmt *catchStmt );
     83                Statement * postmutate( ThrowStmt *throwStmt );
     84        };
     85
     86        // ThrowStmt Mutation Helpers
     87
     88        Statement * ThrowMutatorCore::create_either_throw(
     89                        ThrowStmt * throwStmt, const char * throwFunc ) {
     90                // `throwFunc`( `throwStmt->get_name()` );
     91                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
     92                call->get_args().push_back( throwStmt->get_expr() );
     93                throwStmt->set_expr( nullptr );
     94                delete throwStmt;
     95                return new ExprStmt( call );
     96        }
     97
     98        Statement * ThrowMutatorCore::create_terminate_rethrow(
     99                        ThrowStmt *throwStmt ) {
     100                // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
     101                assert( nullptr == throwStmt->get_expr() );
     102                assert( terminate_handler_except );
     103
     104                CompoundStmt * result = new CompoundStmt();
     105                result->labels =  throwStmt->labels;
     106                result->push_back( new ExprStmt( UntypedExpr::createAssign(
     107                        nameOf( terminate_handler_except ),
     108                        new ConstantExpr( Constant::null(
     109                                //new PointerType(
     110                                //      noQualifiers,
     111                                        terminate_handler_except->get_type()->clone()
     112                                //      )
     113                                ) )
     114                        ) ) );
     115                result->push_back( new ExprStmt(
     116                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
     117                        ) );
     118                delete throwStmt;
     119                return result;
     120        }
     121
     122        Statement * ThrowMutatorCore::create_resume_rethrow(
     123                        ThrowStmt *throwStmt ) {
     124                // return false;
     125                Statement * result = new ReturnStmt(
     126                        new ConstantExpr( Constant::from_bool( false ) )
     127                        );
     128                result->labels = throwStmt->labels;
     129                delete throwStmt;
     130                return result;
     131        }
     132
     133        // Visiting/Mutating Functions
     134
     135        void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
     136                // Validate the statement's form.
     137                ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
     138                // Also checking the type would be nice.
     139                if ( decl ) {
     140                        // Pass.
     141                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
     142                        SemanticError(catchStmt->location, "catch must have exception type");
     143                } else {
     144                        SemanticError(catchStmt->location, "catchResume must have exception type");
     145                }
     146
     147                // Track the handler context.
     148                GuardValue( cur_context );
     149                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
     150                        cur_context = TerHandler;
     151
     152                        GuardValue( terminate_handler_except );
     153                        terminate_handler_except = decl;
     154                } else {
     155                        cur_context = ResHandler;
     156                }
     157        }
     158
     159        Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
     160                // Ignoring throwStmt->get_target() for now.
     161                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
     162                        if ( throwStmt->get_expr() ) {
     163                                return create_either_throw( throwStmt, "$throw" );
     164                        } else if ( TerHandler == cur_context ) {
     165                                return create_terminate_rethrow( throwStmt );
     166                        } else {
     167                                abort("Invalid throw in %s at %i\n",
     168                                        throwStmt->location.filename.c_str(),
     169                                        throwStmt->location.first_line);
     170                        }
     171                } else {
     172                        if ( throwStmt->get_expr() ) {
     173                                return create_either_throw( throwStmt, "$throwResume" );
     174                        } else if ( ResHandler == cur_context ) {
     175                                return create_resume_rethrow( throwStmt );
     176                        } else {
     177                                abort("Invalid throwResume in %s at %i\n",
     178                                        throwStmt->location.filename.c_str(),
     179                                        throwStmt->location.first_line);
     180                        }
     181                }
     182        }
     183
     184        class TryMutatorCore {
    78185                // The built in types used in translation.
    79186                StructDecl * except_decl;
     
    82189
    83190                // The many helper functions for code/syntree generation.
    84                 Statement * create_given_throw(
    85                         const char * throwFunc, ThrowStmt * throwStmt );
    86                 Statement * create_terminate_throw( ThrowStmt * throwStmt );
    87                 Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
    88                 Statement * create_resume_throw( ThrowStmt * throwStmt );
    89                 Statement * create_resume_rethrow( ThrowStmt * throwStmt );
    90191                CompoundStmt * take_try_block( TryStmt * tryStmt );
    91192                FunctionDecl * create_try_wrapper( CompoundStmt * body );
     
    121222
    122223        public:
    123                 ExceptionMutatorCore() :
    124                         cur_context( NoHandler ),
    125                         handler_except_decl( nullptr ),
     224                TryMutatorCore() :
    126225                        except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
    127226                        try_func_t( noQualifiers, false ),
     
    132231                {}
    133232
    134                 void premutate( CatchStmt *catchStmt );
    135233                void premutate( StructDecl *structDecl );
    136234                Statement * postmutate( ThrowStmt *throwStmt );
     
    138236        };
    139237
    140         void ExceptionMutatorCore::init_func_types() {
     238        void TryMutatorCore::init_func_types() {
    141239                assert( except_decl );
    142240
     
    196294        }
    197295
    198         // ThrowStmt Mutation Helpers
    199 
    200         Statement * ExceptionMutatorCore::create_given_throw(
    201                         const char * throwFunc, ThrowStmt * throwStmt ) {
    202                 // `throwFunc`( `throwStmt->get_name` );
    203                 UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
    204                 call->get_args().push_back( throwStmt->get_expr() );
    205                 throwStmt->set_expr( nullptr );
    206                 delete throwStmt;
    207                 return new ExprStmt( call );
    208         }
    209 
    210         Statement * ExceptionMutatorCore::create_terminate_throw(
    211                         ThrowStmt *throwStmt ) {
    212                 // __throw_terminate( `throwStmt->get_name()` ); }
    213                 return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
    214         }
    215 
    216         Statement * ExceptionMutatorCore::create_terminate_rethrow(
    217                         ThrowStmt *throwStmt ) {
    218                 // { `handler_except_decl` = NULL; __rethrow_terminate(); }
    219                 assert( nullptr == throwStmt->get_expr() );
    220                 assert( handler_except_decl );
    221 
    222                 CompoundStmt * result = new CompoundStmt();
    223                 result->labels =  throwStmt->labels;
    224                 result->push_back( new ExprStmt( UntypedExpr::createAssign(
    225                         nameOf( handler_except_decl ),
    226                         new ConstantExpr( Constant::null(
    227                                 new PointerType(
    228                                         noQualifiers,
    229                                         handler_except_decl->get_type()->clone()
    230                                         )
    231                                 ) )
    232                         ) ) );
    233                 result->push_back( new ExprStmt(
    234                         new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
    235                         ) );
    236                 delete throwStmt;
    237                 return result;
    238         }
    239 
    240         Statement * ExceptionMutatorCore::create_resume_throw(
    241                         ThrowStmt *throwStmt ) {
    242                 // __throw_resume( `throwStmt->get_name` );
    243                 return create_given_throw( "__cfaehm_throw_resume", throwStmt );
    244         }
    245 
    246         Statement * ExceptionMutatorCore::create_resume_rethrow(
    247                         ThrowStmt *throwStmt ) {
    248                 // return false;
    249                 Statement * result = new ReturnStmt(
    250                         new ConstantExpr( Constant::from_bool( false ) )
    251                         );
    252                 result->labels = throwStmt->labels;
    253                 delete throwStmt;
    254                 return result;
    255         }
    256 
    257296        // TryStmt Mutation Helpers
    258297
    259         CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
     298        CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
    260299                CompoundStmt * block = tryStmt->get_block();
    261300                tryStmt->set_block( nullptr );
     
    263302        }
    264303
    265         FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
     304        FunctionDecl * TryMutatorCore::create_try_wrapper(
    266305                        CompoundStmt *body ) {
    267306
     
    270309        }
    271310
    272         FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
     311        FunctionDecl * TryMutatorCore::create_terminate_catch(
    273312                        CatchList &handlers ) {
    274313                std::list<CaseStmt *> handler_wrappers;
     
    350389        // Create a single check from a moddified handler.
    351390        // except_obj is referenced, modded_handler will be freed.
    352         CompoundStmt * ExceptionMutatorCore::create_single_matcher(
     391        CompoundStmt * TryMutatorCore::create_single_matcher(
    353392                        DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
    354393                // {
     
    388427        }
    389428
    390         FunctionDecl * ExceptionMutatorCore::create_terminate_match(
     429        FunctionDecl * TryMutatorCore::create_terminate_match(
    391430                        CatchList &handlers ) {
    392431                // int match(exception * except) {
     
    425464        }
    426465
    427         CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
     466        CompoundStmt * TryMutatorCore::create_terminate_caller(
    428467                        FunctionDecl * try_wrapper,
    429468                        FunctionDecl * terminate_catch,
     
    443482        }
    444483
    445         FunctionDecl * ExceptionMutatorCore::create_resume_handler(
     484        FunctionDecl * TryMutatorCore::create_resume_handler(
    446485                        CatchList &handlers ) {
    447486                // bool handle(exception * except) {
     
    480519        }
    481520
    482         CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
     521        CompoundStmt * TryMutatorCore::create_resume_wrapper(
    483522                        Statement * wraps,
    484523                        FunctionDecl * resume_handler ) {
     
    524563        }
    525564
    526         FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
     565        FunctionDecl * TryMutatorCore::create_finally_wrapper(
    527566                        TryStmt * tryStmt ) {
    528                 // void finally() { <finally code> }
     567                // void finally() { `finally->block` }
    529568                FinallyStmt * finally = tryStmt->get_finally();
    530569                CompoundStmt * body = finally->get_block();
     
    537576        }
    538577
    539         ObjectDecl * ExceptionMutatorCore::create_finally_hook(
     578        ObjectDecl * TryMutatorCore::create_finally_hook(
    540579                        FunctionDecl * finally_wrapper ) {
    541580                // struct __cfaehm_cleanup_hook __finally_hook
    542                 //      __attribute__((cleanup( finally_wrapper )));
     581                //      __attribute__((cleanup( `finally_wrapper` )));
    543582
    544583                // Make Cleanup Attribute.
     
    565604
    566605        // Visiting/Mutating Functions
    567         void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
    568                 // Validate the Statement's form.
    569                 ObjectDecl * decl =
    570                         dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
    571                 if ( decl && true /* check decl->get_type() */ ) {
    572                         // Pass.
    573                 } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
    574                         SemanticError(catchStmt->location, "catch must have exception type");
    575                 } else {
    576                         SemanticError(catchStmt->location, "catchResume must have exception type");
    577                 }
    578 
    579                 // Track the handler context.
    580                 GuardValue( cur_context );
    581                 if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
    582                         cur_context = TerHandler;
    583 
    584                         GuardValue( handler_except_decl );
    585                         handler_except_decl = decl;
    586                 } else {
    587                         cur_context = ResHandler;
    588                 }
    589         }
    590 
    591         void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
     606        void TryMutatorCore::premutate( StructDecl *structDecl ) {
    592607                if ( !structDecl->has_body() ) {
    593608                        // Skip children?
     
    604619                        hook_decl = structDecl;
    605620                }
    606                 // Later we might get the exception type as well.
    607         }
    608 
    609         Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
    610                 assert( except_decl );
    611 
    612                 // Ignoring throwStmt->get_target() for now.
    613                 if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
    614                         if ( throwStmt->get_expr() ) {
    615                                 return create_terminate_throw( throwStmt );
    616                         } else if ( TerHandler == cur_context ) {
    617                                 return create_terminate_rethrow( throwStmt );
    618                         } else {
    619                                 abort("Invalid throw in %s at %i\n",
    620                                         throwStmt->location.filename.c_str(),
    621                                         throwStmt->location.first_line);
    622                         }
    623                 } else {
    624                         if ( throwStmt->get_expr() ) {
    625                                 return create_resume_throw( throwStmt );
    626                         } else if ( ResHandler == cur_context ) {
    627                                 return create_resume_rethrow( throwStmt );
    628                         } else {
    629                                 abort("Invalid throwResume in %s at %i\n",
    630                                         throwStmt->location.filename.c_str(),
    631                                         throwStmt->location.first_line);
    632                         }
    633                 }
    634         }
    635 
    636         Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
     621        }
     622
     623        Statement * TryMutatorCore::postmutate( ThrowStmt * ) {
     624                // All throws should be removed by this point.
     625                assert( false );
     626        }
     627
     628        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
    637629                assert( except_decl );
    638630                assert( node_decl );
     
    688680        }
    689681
    690         void translateEHM( std::list< Declaration *> & translationUnit ) {
    691                 PassVisitor<ExceptionMutatorCore> translator;
     682        void translateThrows( std::list< Declaration *> & translationUnit ) {
     683                PassVisitor<ThrowMutatorCore> translator;
    692684                mutateAll( translationUnit, translator );
    693685        }
     686
     687        void translateTries( std::list< Declaration *> & translationUnit ) {
     688                PassVisitor<TryMutatorCore> translator;
     689                mutateAll( translationUnit, translator );
     690        }
    694691}
  • src/ControlStruct/ExceptTranslate.h

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

    r6f121b8 r99fea48  
    99// Author           : Peter Buhr and Rob Schluntz
    1010// Created On       : Fri May 15 23:12:02 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb  8 08:33:50 2020
    13 // Update Count     : 633
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tue May 19 12:03:00 2020
     13// Update Count     : 634
    1414//
    1515
     
    312312                } // if
    313313
     314                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
    314315                PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
    315316                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
     
    354355                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
    355356
    356                 PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
     357                PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
    357358
    358359                PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
  • tests/errors/.expect/completeType.txt

    r6f121b8 r99fea48  
    132132?=?: pointer to function
    133133        ... with parameters
    134           reference to instance of type _104_0_T (not function type)
    135           instance of type _104_0_T (not function type)
     134          reference to instance of type _108_0_T (not function type)
     135          instance of type _108_0_T (not function type)
    136136        ... returning
    137           _retval__operator_assign: instance of type _104_0_T (not function type)
     137          _retval__operator_assign: instance of type _108_0_T (not function type)
    138138          ... with attributes:
    139139            Attribute with name: unused
  • tests/exceptions/conditional.cfa

    r6f121b8 r99fea48  
    5656
    5757        try {
    58                 throw &exc;
     58                throw exc;
    5959        } catch (num_error * error ; 3 == error->virtual_table->code( error )) {
    6060                caught_num_error(3, error);
     
    6464
    6565        try {
    66                 throwResume &exc;
     66                throwResume exc;
    6767        } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
    6868                caught_num_error(3, error);
  • tests/exceptions/data-except.cfa

    r6f121b8 r99fea48  
    2828
    2929        try {
    30                 throw &except;
     30                throw except;
    3131        } catch (paired * exc) {
    3232                printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
     
    3737
    3838        try {
    39                 throwResume &except;
     39                throwResume except;
    4040        } catchResume (paired * exc) {
    4141                printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
  • tests/exceptions/finally.cfa

    r6f121b8 r99fea48  
    1212                try {
    1313                        printf("termination throw\n");
    14                         throw &exc;
     14                        throw exc;
    1515                } finally {
    1616                        loud_exit a = "termination inner finally";
     
    2828                try {
    2929                        printf("resumption throw\n");
    30                         throwResume &exc;
     30                        throwResume exc;
    3131                } finally {
    3232                        loud_exit a = "resumption inner finally";
  • tests/exceptions/interact.cfa

    r6f121b8 r99fea48  
    1010        // Resume falls back to terminate.
    1111        try {
    12                 throwResume &(star){};
     12                throwResume (star){};
    1313        } catch (star *) {
    1414                printf("caught as termination\n");
     
    1717        try {
    1818                loud_region a = "try block with resume throw";
    19                 throwResume &(star){};
     19                throwResume (star){};
    2020        } catch (star *) {
    2121                printf("caught as termination\n");
     
    2929        try {
    3030                try {
    31                         throw &(star){};
     31                        throw (star){};
    3232                } catchResume (star *) {
    3333                        printf("resume catch on terminate\n");
     
    4343        try {
    4444                try {
    45                         throwResume &(star){};
     45                        throwResume (star){};
    4646                } catch (star *) {
    4747                        printf("terminate catch on resume\n");
     
    5858                try {
    5959                        try {
    60                                 throw &(star){};
     60                                throw (star){};
    6161                        } catchResume (star *) {
    6262                                printf("inner resume catch (error)\n");
     
    6464                } catch (star * error) {
    6565                        printf("termination catch, will resume\n");
    66                         throwResume error;
     66                        throwResume *error;
    6767                }
    6868        } catchResume (star *) {
     
    7575                try {
    7676                        try {
    77                                 throwResume &(star){};
     77                                throwResume (star){};
    7878                        } catch (star *) {
    7979                                printf("inner termination catch\n");
     
    8181                } catchResume (star * error) {
    8282                        printf("resumption catch, will terminate\n");
    83                         throw error;
     83                        throw *error;
    8484                }
    8585        } catch (star *) {
     
    9494                                try {
    9595                                        printf("throwing resume moon\n");
    96                                         throwResume &(moon){};
     96                                        throwResume (moon){};
    9797                                } catch (star *) {
    9898                                        printf("termination catch\n");
    9999                                }
    100100                                printf("throwing resume star\n");
    101                                 throwResume &(star){};
     101                                throwResume (star){};
    102102                        } catchResume (star *) {
    103103                                printf("resumption star catch\n");
     
    105105                } catchResume (moon *) {
    106106                        printf("resumption moon catch, will terminate\n");
    107                         throw &(star){};
     107                        throw (star){};
    108108                }
    109109        } catchResume (star *) {
  • tests/exceptions/resume.cfa

    r6f121b8 r99fea48  
    1414                loud_exit a = "simple try clause";
    1515                printf("simple throw\n");
    16                 throwResume &(zen){};
     16                throwResume (zen){};
    1717                printf("end of try clause\n");
    1818        } catchResume (zen * error) {
     
    2424        // Throw catch-all test.
    2525        try {
    26                 throwResume &(zen){};
     26                throwResume (zen){};
    2727        } catchResume (exception_t * error) {
    2828                printf("catch-all\n");
     
    3333        try {
    3434                printf("throwing child exception\n");
    35                 throwResume &(moment_of){};
     35                throwResume (moment_of){};
    3636        } catchResume (zen *) {
    3737                printf("inner parent match\n");
     
    4444        try {
    4545                try {
    46                         throwResume &(yin){};
     46                        throwResume (yin){};
    4747                } catchResume (zen *) {
    4848                        printf("caught yin as zen\n");
     
    6060                        loud_exit a = "rethrow inner try";
    6161                        printf("rethrow inner try\n");
    62                         throwResume &(zen){};
     62                        throwResume (zen){};
    6363                } catchResume (zen *) {
    6464                        loud_exit a = "rethrowing catch clause";
     
    7575        try {
    7676                try {
    77                         throwResume &(yin){};
     77                        throwResume (yin){};
    7878                } catchResume (yin *) {
    7979                        printf("caught yin, will throw yang\n");
    80                         throwResume &(yang){};
     80                        throwResume (yang){};
    8181                } catchResume (yang *) {
    8282                        printf("caught exception from same try\n");
     
    9191                try {
    9292                        printf("throwing first exception\n");
    93                         throwResume &(yin){};
     93                        throwResume (yin){};
    9494                } catchResume (yin *) {
    9595                        printf("caught first exception\n");
    9696                        try {
    9797                                printf("throwing second exception\n");
    98                                 throwResume &(yang){};
     98                                throwResume (yang){};
    9999                        } catchResume (yang *) {
    100100                                printf("caught second exception\n");
     
    112112        try {
    113113                try {
    114                         throwResume &(zen){};
    115                         throwResume &(zen){};
     114                        throwResume (zen){};
     115                        throwResume (zen){};
    116116                } catchResume (zen *) {
    117117                        printf("inner catch\n");
    118118                }
    119                 throwResume &(zen){};
     119                throwResume (zen){};
    120120        } catchResume (zen *) {
    121121                printf("outer catch\n");
  • tests/exceptions/terminate.cfa

    r6f121b8 r99fea48  
    1414                loud_exit a = "simple try clause";
    1515                printf("simple throw\n");
    16                 throw &(zen){};
     16                throw (zen){};
    1717                printf("end of try clause\n");
    1818        } catch (zen * error) {
     
    2424        // Throw catch-all test.
    2525        try {
    26                 throw &(zen){};
     26                throw (zen){};
    2727        } catch (exception_t * error) {
    2828                printf("catch-all\n");
     
    3333        try {
    3434                printf("throwing child exception\n");
    35                 throw &(moment_of){};
     35                throw (moment_of){};
    3636        } catch (zen *) {
    3737                printf("inner parent match\n");
     
    4444        try {
    4545                try {
    46                         throw &(yin){};
     46                        throw (yin){};
    4747                } catch (zen *) {
    4848                        printf("caught yin as zen\n");
     
    6060                        loud_exit a = "rethrow inner try";
    6161                        printf("rethrow inner try\n");
    62                         throw &(zen){};
     62                        throw (zen){};
    6363                } catch (zen *) {
    6464                        loud_exit a = "rethrowing catch clause";
     
    7575        try {
    7676                try {
    77                         throw &(yin){};
     77                        throw (yin){};
    7878                } catch (yin *) {
    7979                        printf("caught yin, will throw yang\n");
    80                         throw &(yang){};
     80                        throw (yang){};
    8181                } catch (yang *) {
    8282                        printf("caught exception from same try\n");
     
    9191                try {
    9292                        printf("throwing first exception\n");
    93                         throw &(yin){};
     93                        throw (yin){};
    9494                } catch (yin *) {
    9595                        printf("caught first exception\n");
    9696                        try {
    9797                                printf("throwing second exception\n");
    98                                 throw &(yang){};
     98                                throw (yang){};
    9999                        } catch (yang *) {
    100100                                printf("caught second exception\n");
     
    112112        try {
    113113                try {
    114                         throw &(zen){};
    115                         throw &(zen){};
     114                        throw (zen){};
     115                        throw (zen){};
    116116                } catch (zen *) {
    117117                        printf("inner catch\n");
    118118                }
    119                 throw &(zen){};
     119                throw (zen){};
    120120        } catch (zen *) {
    121121                printf("outer catch\n");
Note: See TracChangeset for help on using the changeset viewer.