Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Common/PassVisitor.impl.h

    r6ca154b r6e09f211  
    44        __attribute__((unused))                   \
    55        const auto & guard = init_guard();        \
    6         bool visit_children = true;               \
    7         set_visit_children( visit_children );   \
    86        call_previsit( node );                    \
    9         if( visit_children ) {                    \
     7        if( visit_children() ) {                  \
     8                reset_visit();                      \
    109
    1110#define VISIT_END( node )                       \
    … …  
    1615        __attribute__((unused))                   \
    1716        const auto & guard = init_guard();        \
    18         bool visit_children = true;               \
    19         set_visit_children( visit_children );   \
    2017        call_premutate( node );                   \
    21         if( visit_children ) {                    \
     18        if( visit_children() ) {                  \
     19                reset_visit();                      \
    2220
    2321#define MUTATE_END( type, node )                \
    … …  
    4442}
    4543
    46 typedef std::list< Statement   * > StmtList_t;
    47 typedef std::list< Declaration * > DeclList_t;
    48 
    49 template<typename iterator_t>
    50 static 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 
    62 template< typename pass_type >
    63 static 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 
    82 template< typename pass_type >
    83 static 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 
    102 template< typename pass_type >
    103 template< typename func_t >
    104 void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
     44typedef std::list< Statement * > StmtList_t;
     45
     46template< typename pass_type >
     47void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
    10548        SemanticError errors;
    10649
    10750        StmtList_t* beforeStmts = get_beforeStmts();
    10851        StmtList_t* afterStmts  = get_afterStmts();
    109         DeclList_t* beforeDecls = get_beforeDecls();
    110         DeclList_t* afterDecls  = get_afterDecls();
    11152
    11253        for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
    113 
    114                 if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); }
    11554                if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); }
    116 
    11755                try {
    118                         func( *i );
    119                         assert(( empty( beforeStmts ) && empty( afterStmts ))
    120                             || ( empty( beforeDecls ) && empty( afterDecls )) );
    121 
     56                        (*i)->accept( *this );
    12257                } catch ( SemanticError &e ) {
    12358                        errors.append( e );
    12459                }
    125 
    126                 if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); }
    12760                if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); }
    12861        }
    12962
    130         if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); }
    13163        if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); }
    13264        if ( !errors.isEmpty() ) { throw errors; }
    … …  
    13466
    13567template< typename pass_type >
    136 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
    137         handleStatementList( statements, [this]( Statement * stmt) {
    138                 stmt->accept( *this );
    139         });
    140 }
    141 
    142 template< typename pass_type >
    14368void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
    144         handleStatementList( statements, [this]( Statement *& stmt) {
    145                 stmt = stmt->acceptMutator( *this );
    146         });
    147 }
    148 
    149 
    150 template< typename pass_type >
    151 template< typename func_t >
    152 Statement * 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 );
     69        SemanticError errors;
    16170
    16271        StmtList_t* beforeStmts = get_beforeStmts();
    16372        StmtList_t* afterStmts  = get_afterStmts();
    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 )) );
     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
     88template< typename pass_type >
     89Statement * 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; }
    170101
    171102        CompoundStmt *compound = new CompoundStmt( noLabels );
    172         if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
     103        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
     104        compound->get_kids().push_back( stmt );
     105        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
     106        return compound;
     107}
     108
     109template< typename pass_type >
     110Statement * 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 );
    173124        if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
    174125        compound->get_kids().push_back( newStmt );
    175         if( !empty(afterDecls) ) { splice( std::back_inserter( compound->get_kids() ), afterDecls ); }
    176126        if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); }
    177127        return compound;
    178128}
    179129
    180 template< typename pass_type >
    181 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
    182         return handleStatement( stmt, [this]( Statement * stmt ) {
    183                 maybeAccept( stmt, *this );
    184                 return stmt;
    185         });
    186 }
    187 
    188 template< typename pass_type >
    189 Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
    190         return handleStatement( stmt, [this]( Statement * stmt ) {
    191                 return maybeMutate( stmt, *this );
    192         });
    193 }
    194 
    195 template< typename pass_type >
    196 template< typename func_t >
    197 Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
    198         if( !expr ) return nullptr;
     130
     131
     132template< typename pass_type >
     133void PassVisitor< pass_type >::visitExpression( Expression * expr ) {
     134        if( !expr ) return;
    199135
    200136        auto env_ptr = get_env_ptr();
    … …  
    202138                *env_ptr = expr->get_env();
    203139        }
    204 
    205         // should env be cloned (or moved) onto the result of the mutate?
    206         return func( expr );
    207 }
    208 
    209 template< typename pass_type >
    210 Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
    211         return handleExpression(expr, [this]( Expression * expr ) {
    212                 expr->accept( *this );
    213                 return expr;
    214         });             
     140        // xxx - should env be cloned (or moved) onto the result of the mutate?
     141        expr->accept( *this );
    215142}
    216143
    217144template< typename pass_type >
    218145Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
    219         return handleExpression(expr, [this]( Expression * expr ) {
    220                 return expr->acceptMutator( *this );
    221         });
    222 }
     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
    223156
    224157//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    … …  
    226159template< typename pass_type >
    227160void PassVisitor< pass_type >::visit( ObjectDecl * node ) {
    228         VISIT_BODY( node );
     161        VISIT_BODY( node ); 
    229162}
    230163
    231164template< typename pass_type >
    232165void PassVisitor< pass_type >::visit( FunctionDecl * node ) {
    233         VISIT_BODY( node );
     166        VISIT_BODY( node ); 
    234167}
    235168
    236169template< typename pass_type >
    237170void PassVisitor< pass_type >::visit( StructDecl * node ) {
    238         VISIT_BODY( node );
     171        VISIT_BODY( node ); 
    239172}
    240173
    241174template< typename pass_type >
    242175void PassVisitor< pass_type >::visit( UnionDecl * node ) {
    243         VISIT_BODY( node );
     176        VISIT_BODY( node ); 
    244177}
    245178
    246179template< typename pass_type >
    247180void PassVisitor< pass_type >::visit( EnumDecl * node ) {
    248         VISIT_BODY( node );
     181        VISIT_BODY( node ); 
    249182}
    250183
    251184template< typename pass_type >
    252185void PassVisitor< pass_type >::visit( TraitDecl * node ) {
    253         VISIT_BODY( node );
     186        VISIT_BODY( node ); 
    254187}
    255188
    256189template< typename pass_type >
    257190void PassVisitor< pass_type >::visit( TypeDecl * node ) {
    258         VISIT_BODY( node );
     191        VISIT_BODY( node ); 
    259192}
    260193
    261194template< typename pass_type >
    262195void PassVisitor< pass_type >::visit( TypedefDecl * node ) {
    263         VISIT_BODY( node );
     196        VISIT_BODY( node ); 
    264197}
    265198
    266199template< typename pass_type >
    267200void PassVisitor< pass_type >::visit( AsmDecl * node ) {
    268         VISIT_BODY( node );
     201        VISIT_BODY( node ); 
    269202}
    270203
    … …  
    298231void PassVisitor< pass_type >::visit( ExprStmt * node ) {
    299232        VISIT_START( node );
     233        call_beginScope();
    300234
    301235        visitExpression( node->get_expr() );
    302236
     237        call_endScope();
    303238        VISIT_END( node );
    304239}
    … …  
    313248}
    314249
    315 //--------------------------------------------------------------------------
    316 // AsmStmt
    317250template< typename pass_type >
    318251void PassVisitor< pass_type >::visit( AsmStmt * node ) {
    319         VISIT_BODY( node );
    320 }
    321 
    322 template< typename pass_type >
    323 Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
    324         MUTATE_BODY( Statement, node );
     252        VISIT_BODY( node );
    325253}
    326254
    … …  
    329257template< typename pass_type >
    330258void PassVisitor< pass_type >::visit( IfStmt * node ) {
    331         VISIT_START( node );
     259        VISIT_START( node ); 
    332260
    333261        visitExpression( node->get_condition() );
    … …  
    340268template< typename pass_type >
    341269Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
    342         MUTATE_START( node );
     270        MUTATE_START( node ); 
    343271
    344272        node->set_condition( mutateExpression( node->get_condition() ) );
    … …  
    353281template< typename pass_type >
    354282void PassVisitor< pass_type >::visit( WhileStmt * node ) {
    355         VISIT_START( node );
     283        VISIT_START( node ); 
    356284
    357285        visitExpression( node->get_condition() );
    … …  
    363291template< typename pass_type >
    364292Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
    365         MUTATE_START( node );
     293        MUTATE_START( node ); 
    366294
    367295        node->set_condition( mutateExpression( node->get_condition() ) );
    … …  
    372300
    373301//--------------------------------------------------------------------------
    374 // ForStmt
     302// WhileStmt
    375303template< typename pass_type >
    376304void PassVisitor< pass_type >::visit( ForStmt * node ) {
    377         VISIT_START( node );
     305        VISIT_START( node ); 
    378306
    379307        acceptAll( node->get_initialization(), *this );
    … …  
    387315template< typename pass_type >
    388316Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
    389         MUTATE_START( node );
     317        MUTATE_START( node ); 
    390318
    391319        mutateAll( node->get_initialization(), *this );
    … …  
    401329template< typename pass_type >
    402330void PassVisitor< pass_type >::visit( SwitchStmt * node ) {
    403         VISIT_START( node );
     331        VISIT_START( node ); 
    404332
    405333        visitExpression( node->get_condition() );
    … …  
    411339template< typename pass_type >
    412340Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
    413         MUTATE_START( node );
    414 
     341        MUTATE_START( node ); 
     342       
    415343        node->set_condition( mutateExpression( node->get_condition() ) );
    416344        mutateStatementList( node->get_statements() );
    417 
     345       
    418346        MUTATE_END( Statement, node );
    419347}
    420348
    421349//--------------------------------------------------------------------------
    422 // CaseStmt
     350// SwitchStmt
    423351template< typename pass_type >
    424352void PassVisitor< pass_type >::visit( CaseStmt * node ) {
    425         VISIT_START( node );
    426 
     353        VISIT_START( node ); 
     354       
    427355        visitExpression( node->get_condition() );
    428356        visitStatementList( node->get_statements() );
    429 
     357       
    430358        VISIT_END( node );
    431359}
    … …  
    433361template< typename pass_type >
    434362Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
    435         MUTATE_START( node );
    436 
     363        MUTATE_START( node ); 
     364       
    437365        node->set_condition(  mutateExpression( node->get_condition() ) );
    438366        mutateStatementList( node->get_statements() );
    439 
     367       
    440368        MUTATE_END( Statement, node );
    441369}
    442370
    443 //--------------------------------------------------------------------------
    444 // BranchStmt
    445371template< typename pass_type >
    446372void PassVisitor< pass_type >::visit( BranchStmt * node ) {
    447         VISIT_BODY( node );
    448 }
    449 
    450 template< typename pass_type >
    451 Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
    452         MUTATE_BODY( Statement, node );
     373        VISIT_BODY( node );
    453374}
    454375
    … …  
    494415        maybeAccept( node->get_block(), *this );
    495416        acceptAll( node->get_catchers(), *this );
    496         maybeAccept( node->get_finally(), *this );
    497417
    498418        VISIT_END( node );
    … …  
    505425        node->set_block(  maybeMutate( node->get_block(), *this ) );
    506426        mutateAll( node->get_catchers(), *this );
    507         node->set_finally( maybeMutate( node->get_finally(), *this ) );
    508 
     427       
    509428        MUTATE_END( Statement, node );
    510429}
    … …  
    516435        VISIT_START( node );
    517436
     437        node->set_body( visitStatement( node->get_body() ) );
    518438        maybeAccept( node->get_decl(), *this );
    519         node->set_cond( visitExpression( node->get_cond() ) );
    520         node->set_body( visitStatement( node->get_body() ) );
    521439
    522440        VISIT_END( node );
    … …  
    526444Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
    527445        MUTATE_START( node );
    528 
    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() ) );
    532 
     446       
     447        node->set_body(  mutateStatement( node->get_body() ) );
     448        node->set_decl(  maybeMutate( node->get_decl(), *this ) );
     449       
    533450        MUTATE_END( Statement, node );
    534451}
    … …  
    536453template< typename pass_type >
    537454void PassVisitor< pass_type >::visit( FinallyStmt * node ) {
    538         VISIT_BODY( node );
     455        VISIT_BODY( node ); 
    539456}
    540457
    541458template< typename pass_type >
    542459void PassVisitor< pass_type >::visit( NullStmt * node ) {
    543         VISIT_BODY( node );
     460        VISIT_BODY( node ); 
    544461}
    545462
    546463template< typename pass_type >
    547464void PassVisitor< pass_type >::visit( DeclStmt * node ) {
    548         VISIT_BODY( node );
     465        VISIT_BODY( node ); 
    549466}
    550467
    551468template< typename pass_type >
    552469void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
    553         VISIT_BODY( node );
     470        VISIT_BODY( node ); 
    554471}
    555472
    556473template< typename pass_type >
    557474void PassVisitor< pass_type >::visit( ApplicationExpr * node ) {
    558         VISIT_BODY( node );
     475        VISIT_BODY( node ); 
    559476}
    560477
    … …  
    585502template< typename pass_type >
    586503void PassVisitor< pass_type >::visit( NameExpr * node ) {
    587         VISIT_BODY( node );
     504        VISIT_BODY( node ); 
    588505}
    589506
    590507template< typename pass_type >
    591508void PassVisitor< pass_type >::visit( CastExpr * node ) {
    592         VISIT_BODY( node );
     509        VISIT_BODY( node ); 
    593510}
    594511
    595512template< typename pass_type >
    596513void PassVisitor< pass_type >::visit( AddressExpr * node ) {
    597         VISIT_BODY( node );
     514        VISIT_BODY( node ); 
    598515}
    599516
    600517template< typename pass_type >
    601518void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) {
    602         VISIT_BODY( node );
     519        VISIT_BODY( node ); 
    603520}
    604521
    605522template< typename pass_type >
    606523void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) {
    607         VISIT_BODY( node );
     524        VISIT_BODY( node ); 
    608525}
    609526
    610527template< typename pass_type >
    611528void PassVisitor< pass_type >::visit( MemberExpr * node ) {
    612         VISIT_BODY( node );
     529        VISIT_BODY( node ); 
    613530}
    614531
    615532template< typename pass_type >
    616533void PassVisitor< pass_type >::visit( VariableExpr * node ) {
    617         VISIT_BODY( node );
     534        VISIT_BODY( node ); 
    618535}
    619536
    620537template< typename pass_type >
    621538void PassVisitor< pass_type >::visit( ConstantExpr * node ) {
    622         VISIT_BODY( node );
     539        VISIT_BODY( node ); 
    623540}
    624541
    625542template< typename pass_type >
    626543void PassVisitor< pass_type >::visit( SizeofExpr * node ) {
    627         VISIT_BODY( node );
     544        VISIT_BODY( node ); 
    628545}
    629546
    630547template< typename pass_type >
    631548void PassVisitor< pass_type >::visit( AlignofExpr * node ) {
    632         VISIT_BODY( node );
     549        VISIT_BODY( node ); 
    633550}
    634551
    635552template< typename pass_type >
    636553void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) {
    637         VISIT_BODY( node );
     554        VISIT_BODY( node ); 
    638555}
    639556
    640557template< typename pass_type >
    641558void PassVisitor< pass_type >::visit( OffsetofExpr * node ) {
    642         VISIT_BODY( node );
     559        VISIT_BODY( node ); 
    643560}
    644561
    645562template< typename pass_type >
    646563void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) {
    647         VISIT_BODY( node );
     564        VISIT_BODY( node ); 
    648565}
    649566
    650567template< typename pass_type >
    651568void PassVisitor< pass_type >::visit( AttrExpr * node ) {
    652         VISIT_BODY( node );
     569        VISIT_BODY( node ); 
    653570}
    654571
    655572template< typename pass_type >
    656573void PassVisitor< pass_type >::visit( LogicalExpr * node ) {
    657         VISIT_BODY( node );
     574        VISIT_BODY( node ); 
    658575}
    659576
    660577template< typename pass_type >
    661578void PassVisitor< pass_type >::visit( ConditionalExpr * node ) {
    662         VISIT_BODY( node );
     579        VISIT_BODY( node ); 
    663580}
    664581
    665582template< typename pass_type >
    666583void PassVisitor< pass_type >::visit( CommaExpr * node ) {
    667         VISIT_BODY( node );
     584        VISIT_BODY( node ); 
    668585}
    669586
    670587template< typename pass_type >
    671588void PassVisitor< pass_type >::visit( TypeExpr * node ) {
    672         VISIT_BODY( node );
     589        VISIT_BODY( node ); 
    673590}
    674591
    675592template< typename pass_type >
    676593void PassVisitor< pass_type >::visit( AsmExpr * node ) {
    677         VISIT_BODY( node );
     594        VISIT_BODY( node ); 
    678595}
    679596
    680597template< typename pass_type >
    681598void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) {
    682         VISIT_BODY( node );
     599        VISIT_BODY( node ); 
    683600}
    684601
    685602template< typename pass_type >
    686603void PassVisitor< pass_type >::visit( ConstructorExpr * node ) {
    687         VISIT_BODY( node );
     604        VISIT_BODY( node ); 
    688605}
    689606
    690607template< typename pass_type >
    691608void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) {
    692         VISIT_BODY( node );
     609        VISIT_BODY( node );
     610}
     611
     612template< typename pass_type >
     613void PassVisitor< pass_type >::visit( UntypedValofExpr * node ) {
     614        VISIT_BODY( node );
    693615}
    694616
    695617template< typename pass_type >
    696618void PassVisitor< pass_type >::visit( RangeExpr * node ) {
    697         VISIT_BODY( node );
     619        VISIT_BODY( node ); 
    698620}
    699621
    700622template< typename pass_type >
    701623void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) {
    702         VISIT_BODY( node );
     624        VISIT_BODY( node ); 
    703625}
    704626
    705627template< typename pass_type >
    706628void PassVisitor< pass_type >::visit( TupleExpr * node ) {
    707         VISIT_BODY( node );
     629        VISIT_BODY( node ); 
    708630}
    709631
    710632template< typename pass_type >
    711633void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) {
    712         VISIT_BODY( node );
     634        VISIT_BODY( node ); 
    713635}
    714636
    715637template< typename pass_type >
    716638void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) {
    717         VISIT_BODY( node );
     639        VISIT_BODY( node ); 
    718640}
    719641
    … …  
    737659Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
    738660        MUTATE_START( node );
    739 
     661       
    740662        // don't want statements from outer CompoundStmts to be added to this StmtExpr
    741663        ValueGuardPtr< TypeSubstitution * >      oldEnv        ( get_env_ptr() );
    … …  
    750672template< typename pass_type >
    751673void PassVisitor< pass_type >::visit( UniqueExpr * node ) {
    752         VISIT_BODY( node );
     674        VISIT_BODY( node ); 
    753675}
    754676
    755677template< typename pass_type >
    756678void PassVisitor< pass_type >::visit( VoidType * node ) {
    757         VISIT_BODY( node );
     679        VISIT_BODY( node ); 
    758680}
    759681
    760682template< typename pass_type >
    761683void PassVisitor< pass_type >::visit( BasicType * node ) {
    762         VISIT_BODY( node );
     684        VISIT_BODY( node ); 
    763685}
    764686
    765687template< typename pass_type >
    766688void PassVisitor< pass_type >::visit( PointerType * node ) {
    767         VISIT_BODY( node );
     689        VISIT_BODY( node ); 
    768690}
    769691
    770692template< typename pass_type >
    771693void PassVisitor< pass_type >::visit( ArrayType * node ) {
    772         VISIT_BODY( node );
     694        VISIT_BODY( node ); 
    773695}
    774696
    775697template< typename pass_type >
    776698void PassVisitor< pass_type >::visit( FunctionType * node ) {
    777         VISIT_BODY( node );
     699        VISIT_BODY( node ); 
    778700}
    779701
    780702template< typename pass_type >
    781703void PassVisitor< pass_type >::visit( StructInstType * node ) {
    782         VISIT_BODY( node );
     704        VISIT_BODY( node ); 
    783705}
    784706
    785707template< typename pass_type >
    786708void PassVisitor< pass_type >::visit( UnionInstType * node ) {
    787         VISIT_BODY( node );
     709        VISIT_BODY( node ); 
    788710}
    789711
    790712template< typename pass_type >
    791713void PassVisitor< pass_type >::visit( EnumInstType * node ) {
    792         VISIT_BODY( node );
     714        VISIT_BODY( node ); 
    793715}
    794716
    795717template< typename pass_type >
    796718void PassVisitor< pass_type >::visit( TraitInstType * node ) {
    797         VISIT_BODY( node );
     719        VISIT_BODY( node ); 
    798720}
    799721
    800722template< typename pass_type >
    801723void PassVisitor< pass_type >::visit( TypeInstType * node ) {
    802         VISIT_BODY( node );
     724        VISIT_BODY( node ); 
    803725}
    804726
    805727template< typename pass_type >
    806728void PassVisitor< pass_type >::visit( TupleType * node ) {
    807         VISIT_BODY( node );
     729        VISIT_BODY( node ); 
    808730}
    809731
    810732template< typename pass_type >
    811733void PassVisitor< pass_type >::visit( TypeofType * node ) {
    812         VISIT_BODY( node );
     734        VISIT_BODY( node ); 
    813735}
    814736
    815737template< typename pass_type >
    816738void PassVisitor< pass_type >::visit( AttrType * node ) {
    817         VISIT_BODY( node );
     739        VISIT_BODY( node ); 
    818740}
    819741
    820742template< typename pass_type >
    821743void PassVisitor< pass_type >::visit( VarArgsType * node ) {
    822         VISIT_BODY( node );
     744        VISIT_BODY( node ); 
    823745}
    824746
    825747template< typename pass_type >
    826748void PassVisitor< pass_type >::visit( ZeroType * node ) {
    827         VISIT_BODY( node );
     749        VISIT_BODY( node ); 
    828750}
    829751
    830752template< typename pass_type >
    831753void PassVisitor< pass_type >::visit( OneType * node ) {
    832         VISIT_BODY( node );
     754        VISIT_BODY( node ); 
    833755}
    834756
    … …  
    855777template< typename pass_type >
    856778void PassVisitor< pass_type >::visit( ListInit * node ) {
    857         VISIT_BODY( node );
     779        VISIT_BODY( node ); 
    858780}
    859781
    860782template< typename pass_type >
    861783void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
    862         VISIT_BODY( node );
     784        VISIT_BODY( node ); 
    863785}
    864786
    865787template< typename pass_type >
    866788void PassVisitor< pass_type >::visit( Subrange * node ) {
    867         VISIT_BODY( node );
     789        VISIT_BODY( node ); 
    868790}
    869791
    870792template< typename pass_type >
    871793void PassVisitor< pass_type >::visit( Constant * node ) {
    872         VISIT_BODY( node );
     794        VISIT_BODY( node ); 
    873795}
    874796
    … …  
    921843
    922844template< typename pass_type >
     845Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
     846        MUTATE_BODY( Statement, node );
     847}
     848
     849template< typename pass_type >
     850Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
     851        MUTATE_BODY( Statement, node );
     852}
     853
     854template< typename pass_type >
    923855Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
    924856        MUTATE_BODY( Statement, node );
    … …  
    1056988
    1057989template< typename pass_type >
     990Expression * PassVisitor< pass_type >::mutate( UntypedValofExpr * node ) {
     991        MUTATE_BODY( Expression, node );
     992}
     993
     994template< typename pass_type >
    1058995Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
    1059996        MUTATE_BODY( Expression, node );
Note: See TracChangeset for help on using the changeset viewer.