Changeset ba915fb5


Ignore:
Timestamp:
Jun 22, 2017, 4:32:47 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
d24d4e1
Parents:
5dd0704 (diff), 653f2c7 (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:/u/cforall/software/cfa/cfa-cc

Location:
src
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed
  • src/Common/PassVisitor.h

    r5dd0704 rba915fb5  
    2525// | WithStmtsToAdd       - provides the ability to insert statements before or after the current statement by adding new statements into
    2626//                          stmtsToAddBefore or stmtsToAddAfter respectively.
    27 // | WithShortCircuiting  - provides the ability to skip visiting child nodes; set skip_children to true if pre{visit,mutate} to skip visiting children
     27// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children to false in pre{visit,mutate} to skip visiting children
    2828// | WithScopes           - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable
    2929//                          will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates.
     
    3737        PassVisitor(Args &&... args)
    3838                : pass( std::forward<Args>( args )... )
    39         {}
     39        {
     40                typedef PassVisitor<pass_type> this_t;
     41                this_t * const * visitor = visitor_impl(pass, 0);
     42                if(visitor) {
     43                        *const_cast<this_t **>( visitor ) = this;
     44                }
     45        }
    4046
    4147        virtual ~PassVisitor() = default;
     
    214220
    215221private:
     222        template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
     223        template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
     224
    216225        template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
    217226        template<typename node_type> void call_postvisit( node_type * node ) { postvisit_impl( pass, node, 0 ); }
     
    225234        void set_env( TypeSubstitution * env ) { set_env_impl( pass, env, 0); }
    226235
    227         void visitStatementList( std::list< Statement* > &statements );
     236        template< typename func_t >
     237        void handleStatementList( std::list< Statement * > & statements, func_t func );
     238        void visitStatementList ( std::list< Statement* > &statements );
    228239        void mutateStatementList( std::list< Statement* > &statements );
    229240
    230         Statement * visitStatement( Statement * stmt );
     241        template< typename func_t >
     242        Statement * handleStatement( Statement * stmt, func_t func );
     243        Statement * visitStatement ( Statement * stmt );
    231244        Statement * mutateStatement( Statement * stmt );
    232245
    233         void visitExpression( Expression * expr );
     246        template< typename func_t >
     247        Expression * handleExpression( Expression * expr, func_t func );
     248        Expression * visitExpression ( Expression * expr );
    234249        Expression * mutateExpression( Expression * expr );
    235250
     
    238253        std::list< Statement* > *       get_beforeStmts() { return stmtsToAddBefore_impl( pass, 0); }
    239254        std::list< Statement* > *       get_afterStmts () { return stmtsToAddAfter_impl ( pass, 0); }
    240         bool visit_children() { bool* skip = skip_children_impl(pass, 0); return ! (skip && *skip); }
    241         void reset_visit() { bool* skip = skip_children_impl(pass, 0); if(skip) *skip = false; }
     255        std::list< Declaration* > *     get_beforeDecls() { return declsToAddBefore_impl( pass, 0); }
     256        std::list< Declaration* > *     get_afterDecls () { return declsToAddAfter_impl ( pass, 0); }
     257
     258        void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
    242259
    243260        guard_value_impl init_guard() {
     
    278295        std::list< Statement* > stmtsToAddAfter;
    279296};
    280 
    281297class WithShortCircuiting {
    282298protected:
     
    285301
    286302public:
    287         bool skip_children;
     303        bool_ref visit_children;
    288304};
    289305
     
    309325};
    310326
     327template<typename pass_type>
     328class WithVisitorRef {
     329protected:
     330        WithVisitorRef() = default;
     331        ~WithVisitorRef() = default;
     332
     333public:
     334        PassVisitor<pass_type> * const visitor;
     335};
    311336
    312337#include "PassVisitor.impl.h"
  • src/Common/PassVisitor.impl.h

    r5dd0704 rba915fb5  
    44        __attribute__((unused))                   \
    55        const auto & guard = init_guard();        \
     6        bool visit_children = true;               \
     7        set_visit_children( visit_children );   \
    68        call_previsit( node );                    \
    7         if( visit_children() ) {                  \
     9        if( visit_children ) {                    \
    810
    911#define VISIT_END( node )                       \
    1012        }                                         \
    11         reset_visit();                            \
    1213        call_postvisit( node );                   \
    1314
     
    1516        __attribute__((unused))                   \
    1617        const auto & guard = init_guard();        \
     18        bool visit_children = true;               \
     19        set_visit_children( visit_children );   \
    1720        call_premutate( node );                   \
    18         if( visit_children() ) {                  \
     21        if( visit_children ) {                    \
    1922
    2023#define MUTATE_END( type, node )                \
    2124        }                                         \
    22         reset_visit();                            \
    2325        return call_postmutate< type * >( node ); \
    2426
     
    4244}
    4345
    44 typedef std::list< Statement * > StmtList_t;
    45 
    46 template< typename pass_type >
    47 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
     46typedef std::list< Statement   * > StmtList_t;
     47typedef std::list< Declaration * > DeclList_t;
     48
     49template<typename iterator_t>
     50static inline void splice( iterator_t it, DeclList_t * decls ) {
     51        std::transform(
     52                decls->begin(),
     53                decls->end(),
     54                it,
     55                [](Declaration * decl) -> auto {
     56                        return new DeclStmt( noLabels, decl );
     57                }
     58        );
     59        decls->clear();
     60}
     61
     62template< typename pass_type >
     63static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
     64
     65        DeclList_t* beforeDecls = visitor.get_beforeDecls();
     66        DeclList_t* afterDecls  = visitor.get_afterDecls();
     67
     68        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     69                // splice in new declarations after previous decl
     70                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
     71
     72                if ( i == decls.end() ) break;
     73
     74                // run mutator on declaration
     75                maybeAccept( *i, visitor );
     76
     77                // splice in new declarations before current decl
     78                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
     79        }
     80}
     81
     82template< typename pass_type >
     83static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
     84
     85        DeclList_t* beforeDecls = mutator.get_beforeDecls();
     86        DeclList_t* afterDecls  = mutator.get_afterDecls();
     87
     88        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     89                // splice in new declarations after previous decl
     90                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
     91
     92                if ( i == decls.end() ) break;
     93
     94                // run mutator on declaration
     95                *i = maybeMutate( *i, mutator );
     96
     97                // splice in new declarations before current decl
     98                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
     99        }
     100}
     101
     102template< typename pass_type >
     103template< typename func_t >
     104void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
    48105        SemanticError errors;
    49106
    50107        StmtList_t* beforeStmts = get_beforeStmts();
    51108        StmtList_t* afterStmts  = get_afterStmts();
     109        DeclList_t* beforeDecls = get_beforeDecls();
     110        DeclList_t* afterDecls  = get_afterDecls();
    52111
    53112        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
     113
     114                if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
    54115                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
     116
    55117                try {
    56                         (*i)->accept( *this );
     118                        func( *i );
     119                        assert(( empty( beforeStmts ) && empty( afterStmts ))
     120                            || ( empty( beforeDecls ) && empty( afterDecls )) );
     121
    57122                } catch ( SemanticError &e ) {
    58123                        errors.append( e );
    59124                }
     125
     126                if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
    60127                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
    61128        }
    62129
     130        if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
    63131        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
    64132        if ( !errors.isEmpty() ) { throw errors; }
     
    66134
    67135template< typename pass_type >
     136void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
     137        handleStatementList( statements, [this]( Statement * stmt) {
     138                stmt->accept( *this );
     139        });
     140}
     141
     142template< typename pass_type >
    68143void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
    69         SemanticError errors;
     144        handleStatementList( statements, [this]( Statement *& stmt) {
     145                stmt = stmt->acceptMutator( *this );
     146        });
     147}
     148
     149
     150template< typename pass_type >
     151template< typename func_t >
     152Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
     153        // don't want statements from outer CompoundStmts to be added to this CompoundStmt
     154        ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
     155        ValueGuardPtr< DeclList_t >          oldBeforeDecls( get_beforeDecls() );
     156        ValueGuardPtr< DeclList_t >          oldAfterDecls ( get_afterDecls () );
     157        ValueGuardPtr< StmtList_t >          oldBeforeStmts( get_beforeStmts() );
     158        ValueGuardPtr< StmtList_t >          oldAfterStmts ( get_afterStmts () );
     159
     160        Statement *newStmt = func( stmt );
    70161
    71162        StmtList_t* beforeStmts = get_beforeStmts();
    72163        StmtList_t* afterStmts  = get_afterStmts();
    73 
    74         for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
    75                 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
    76                 try {
    77                         *i = (*i)->acceptMutator( *this );
    78                 } catch ( SemanticError &e ) {
    79                         errors.append( e );
    80                 }
    81                 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
    82         }
    83 
    84         if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
    85         if ( !errors.isEmpty() ) { throw errors; }
    86 }
    87 
    88 template< typename pass_type >
    89 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
    90         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
    91         ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
    92         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
    93         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    94 
    95         maybeAccept( stmt, *this );
    96 
    97         StmtList_t* beforeStmts = get_beforeStmts();
    98         StmtList_t* afterStmts  = get_afterStmts();
    99 
    100         if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; }
     164        DeclList_t* beforeDecls = get_beforeDecls();
     165        DeclList_t* afterDecls  = get_afterDecls();
     166
     167        if( empty(beforeStmts) && empty(afterStmts) && empty(beforeDecls) && empty(afterDecls) ) { return newStmt; }
     168        assert(( empty( beforeStmts ) && empty( afterStmts ))
     169            || ( empty( beforeDecls ) && empty( afterDecls )) );
    101170
    102171        CompoundStmt *compound = new CompoundStmt( noLabels );
     172        if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
    103173        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    104         compound->get_kids().push_back( stmt );
     174        compound->get_kids().push_back( newStmt );
     175        if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
    105176        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    106177        return compound;
     
    108179
    109180template< typename pass_type >
     181Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
     182        return handleStatement( stmt, [this]( Statement * stmt ) {
     183                maybeAccept( stmt, *this );
     184                return stmt;
     185        });
     186}
     187
     188template< typename pass_type >
    110189Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
    111         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
    112         ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
    113         ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() );
    114         ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () );
    115 
    116         Statement *newStmt = maybeMutate( stmt, *this );
    117 
    118         StmtList_t* beforeStmts = get_beforeStmts();
    119         StmtList_t* afterStmts  = get_afterStmts();
    120 
    121         if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }
    122 
    123         CompoundStmt *compound = new CompoundStmt( noLabels );
    124         if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    125         compound->get_kids().push_back( newStmt );
    126         if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    127         return compound;
    128 }
    129 
    130 
    131 
    132 template< typename pass_type >
    133 void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
    134         if( !expr ) return;
     190        return handleStatement( stmt, [this]( Statement * stmt ) {
     191                return maybeMutate( stmt, *this );
     192        });
     193}
     194
     195template< typename pass_type >
     196template< typename func_t >
     197Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
     198        if( !expr ) return nullptr;
    135199
    136200        auto env_ptr = get_env_ptr();
     
    138202                *env_ptr = expr->get_env();
    139203        }
    140         // xxx - should env be cloned (or moved) onto the result of the mutate?
    141         expr->accept( *this );
     204
     205        // should env be cloned (or moved) onto the result of the mutate?
     206        return func( expr );
     207}
     208
     209template< typename pass_type >
     210Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
     211        return handleExpression(expr, [this]( Expression * expr ) {
     212                expr->accept( *this );
     213                return expr;
     214        });             
    142215}
    143216
    144217template< typename pass_type >
    145218Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
    146         if( !expr ) return nullptr;
    147 
    148         auto env_ptr = get_env_ptr();
    149         if ( env_ptr && expr->get_env() ) {
    150                 *env_ptr = expr->get_env();
    151         }
    152         // xxx - should env be cloned (or moved) onto the result of the mutate?
    153         return expr->acceptMutator( *this );
    154 }
    155 
     219        return handleExpression(expr, [this]( Expression * expr ) {
     220                return expr->acceptMutator( *this );
     221        });
     222}
    156223
    157224//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     
    231298void PassVisitor< pass_type >::visit( ExprStmt * node ) {
    232299        VISIT_START( node );
    233         call_beginScope();
    234300
    235301        visitExpression( node->get_expr() );
    236302
    237         call_endScope();
    238303        VISIT_END( node );
    239304}
     
    248313}
    249314
     315//--------------------------------------------------------------------------
     316// AsmStmt
    250317template< typename pass_type >
    251318void PassVisitor< pass_type >::visit( AsmStmt * node ) {
    252319        VISIT_BODY( node );
     320}
     321
     322template< typename pass_type >
     323Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
     324        MUTATE_BODY( Statement, node );
    253325}
    254326
     
    300372
    301373//--------------------------------------------------------------------------
    302 // WhileStmt
     374// ForStmt
    303375template< typename pass_type >
    304376void PassVisitor< pass_type >::visit( ForStmt * node ) {
     
    348420
    349421//--------------------------------------------------------------------------
    350 // SwitchStmt
     422// CaseStmt
    351423template< typename pass_type >
    352424void PassVisitor< pass_type >::visit( CaseStmt * node ) {
     
    369441}
    370442
     443//--------------------------------------------------------------------------
     444// BranchStmt
    371445template< typename pass_type >
    372446void PassVisitor< pass_type >::visit( BranchStmt * node ) {
    373447        VISIT_BODY( node );
     448}
     449
     450template< typename pass_type >
     451Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
     452        MUTATE_BODY( Statement, node );
    374453}
    375454
     
    415494        maybeAccept( node->get_block(), *this );
    416495        acceptAll( node->get_catchers(), *this );
     496        maybeAccept( node->get_finally(), *this );
    417497
    418498        VISIT_END( node );
     
    425505        node->set_block(  maybeMutate( node->get_block(), *this ) );
    426506        mutateAll( node->get_catchers(), *this );
     507        node->set_finally( maybeMutate( node->get_finally(), *this ) );
    427508
    428509        MUTATE_END( Statement, node );
     
    435516        VISIT_START( node );
    436517
     518        maybeAccept( node->get_decl(), *this );
     519        node->set_cond( visitExpression( node->get_cond() ) );
    437520        node->set_body( visitStatement( node->get_body() ) );
    438         maybeAccept( node->get_decl(), *this );
    439521
    440522        VISIT_END( node );
     
    445527        MUTATE_START( node );
    446528
    447         node->set_body(  mutateStatement( node->get_body() ) );
    448         node->set_decl(  maybeMutate( node->get_decl(), *this ) );
     529        node->set_decl( maybeMutate( node->get_decl(), *this ) );
     530        node->set_cond( mutateExpression( node->get_cond() ) );
     531        node->set_body( mutateStatement( node->get_body() ) );
    449532
    450533        MUTATE_END( Statement, node );
     
    838921
    839922template< typename pass_type >
    840 Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
    841         MUTATE_BODY( Statement, node );
    842 }
    843 
    844 template< typename pass_type >
    845 Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
    846         MUTATE_BODY( Statement, node );
    847 }
    848 
    849 template< typename pass_type >
    850923Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
    851924        MUTATE_BODY( Statement, node );
  • src/Common/PassVisitor.proto.h

    r5dd0704 rba915fb5  
    11#pragma once
     2
     3template<typename pass_type>
     4class PassVisitor;
    25
    36typedef std::function<void( void * )> cleanup_func_t;
     
    3134
    3235typedef std::function< void( cleanup_func_t, void * ) > at_cleanup_t;
     36
     37class bool_ref {
     38public:
     39        bool_ref() = default;
     40        ~bool_ref() = default;
     41
     42        operator bool() { return *m_ref; }
     43        bool operator=( bool val ) { return *m_ref = val; }
     44
     45private:
     46
     47        template<typename pass>
     48        friend class PassVisitor;
     49
     50        void set( bool & val ) { m_ref = &val; };
     51
     52        bool * m_ref;
     53};
    3354
    3455//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     
    112133FIELD_PTR( std::list< Statement* >, stmtsToAddBefore )
    113134FIELD_PTR( std::list< Statement* >, stmtsToAddAfter  )
    114 FIELD_PTR( bool, skip_children )
     135FIELD_PTR( std::list< Declaration* >, declsToAddBefore )
     136FIELD_PTR( std::list< Declaration* >, declsToAddAfter  )
     137FIELD_PTR( bool_ref, visit_children )
    115138FIELD_PTR( at_cleanup_t, at_cleanup )
     139FIELD_PTR( PassVisitor<pass_type> * const, visitor )
  • src/GenPoly/DeclMutator.cc

    r5dd0704 rba915fb5  
    99// Author           : Aaron B. Moss
    1010// Created On       : Fri Nov 27 14:44:00 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 11:16:43 2016
    13 // Update Count     : 3
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Jun 22 13:49:00 2017
     13// Update Count     : 4
    1414//
    1515
     
    178178        Statement* DeclMutator::mutate(CatchStmt *catchStmt) {
    179179                catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
     180                catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
    180181                catchStmt->set_body( mutateStatement( catchStmt->get_body() ) );
    181182                return catchStmt;
  • src/GenPoly/PolyMutator.cc

    r5dd0704 rba915fb5  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 11:26:22 2016
    13 // Update Count     : 16
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thu Jun 22 13:47:00 2017
     13// Update Count     : 17
    1414//
    1515
     
    123123
    124124        Statement * PolyMutator::mutate(TryStmt *tryStmt) {
    125                 tryStmt->set_block(  maybeMutate( tryStmt->get_block(), *this ) );
     125                tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
    126126                mutateAll( tryStmt->get_catchers(), *this );
     127                tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
    127128                return tryStmt;
    128129        }
    129130
    130131        Statement * PolyMutator::mutate(CatchStmt *cathStmt) {
    131                 cathStmt->set_body(  mutateStatement( cathStmt->get_body() ) );
    132                 cathStmt->set_decl(  maybeMutate( cathStmt->get_decl(), *this ) );
     132                cathStmt->set_body( mutateStatement( cathStmt->get_body() ) );
     133                cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) );
     134                cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) );
    133135                return cathStmt;
    134136        }
  • src/InitTweak/InitTweak.cc

    r5dd0704 rba915fb5  
    474474        public:
    475475                ConstExprChecker() : isConstExpr( true ) {}
     476
     477                using Visitor::visit;
    476478
    477479                virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }
  • src/Parser/StatementNode.cc

    r5dd0704 rba915fb5  
    168168
    169169Statement *build_resume_at( ExpressionNode *ctl, ExpressionNode *target ) {
    170         std::list< Expression * > exps;
    171         buildMoveList( ctl, exps );
    172         assertf( exps.size() < 2, "This means we are leaking memory");
    173         return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
     170        (void)ctl;
     171        (void)target;
     172        assertf( false, "resume at (non-local throw) is not yet supported," );
    174173}
    175174
  • src/SynTree/Mutator.cc

    r5dd0704 rba915fb5  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Mar  8 16:36:00 2017
    13 // Update Count     : 23
     12// Last Modified On : Thu Jun 22 13:43:00 2017
     13// Update Count     : 24
    1414//
    1515
     
    162162        tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
    163163        mutateAll( tryStmt->get_catchers(), *this );
     164        tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
    164165        return tryStmt;
    165166}
     
    167168Statement *Mutator::mutate( CatchStmt *catchStmt ) {
    168169        catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
     170        catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
    169171        catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
    170172        return catchStmt;
  • src/SynTree/Visitor.cc

    r5dd0704 rba915fb5  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thu Jun  8 16:31:00 2017
    13 // Update Count     : 25
     12// Last Modified On : Thu Jun 22 13:41:00 2017
     13// Update Count     : 26
    1414//
    1515
     
    137137        maybeAccept( tryStmt->get_block(), *this );
    138138        acceptAll( tryStmt->get_catchers(), *this );
     139        maybeAccept( tryStmt->get_finally(), *this );
    139140}
    140141
    141142void Visitor::visit( CatchStmt *catchStmt ) {
    142143        maybeAccept( catchStmt->get_decl(), *this );
     144        maybeAccept( catchStmt->get_cond(), *this );
    143145        maybeAccept( catchStmt->get_body(), *this );
    144146}
Note: See TracChangeset for help on using the changeset viewer.