Changeset ba915fb5 for src/Common/PassVisitor.impl.h
- Timestamp:
- Jun 22, 2017, 4:32:47 PM (7 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, 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. - File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
src/Common/PassVisitor.impl.h
r5dd0704 rba915fb5 4 4 __attribute__((unused)) \ 5 5 const auto & guard = init_guard(); \ 6 bool visit_children = true; \ 7 set_visit_children( visit_children ); \ 6 8 call_previsit( node ); \ 7 if( visit_children () ) {\9 if( visit_children ) { \ 8 10 9 11 #define VISIT_END( node ) \ 10 12 } \ 11 reset_visit(); \12 13 call_postvisit( node ); \ 13 14 … … 15 16 __attribute__((unused)) \ 16 17 const auto & guard = init_guard(); \ 18 bool visit_children = true; \ 19 set_visit_children( visit_children ); \ 17 20 call_premutate( node ); \ 18 if( visit_children () ) {\21 if( visit_children ) { \ 19 22 20 23 #define MUTATE_END( type, node ) \ 21 24 } \ 22 reset_visit(); \23 25 return call_postmutate< type * >( node ); \ 24 26 … … 42 44 } 43 45 44 typedef std::list< Statement * > StmtList_t; 45 46 template< typename pass_type > 47 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) { 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 ) { 48 105 SemanticError errors; 49 106 50 107 StmtList_t* beforeStmts = get_beforeStmts(); 51 108 StmtList_t* afterStmts = get_afterStmts(); 109 DeclList_t* beforeDecls = get_beforeDecls(); 110 DeclList_t* afterDecls = get_afterDecls(); 52 111 53 112 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { 113 114 if ( !empty( afterDecls ) ) { splice( std::inserter( statements, i ), afterDecls ); } 54 115 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } 116 55 117 try { 56 (*i)->accept( *this ); 118 func( *i ); 119 assert(( empty( beforeStmts ) && empty( afterStmts )) 120 || ( empty( beforeDecls ) && empty( afterDecls )) ); 121 57 122 } catch ( SemanticError &e ) { 58 123 errors.append( e ); 59 124 } 125 126 if ( !empty( beforeDecls ) ) { splice( std::inserter( statements, i ), beforeDecls ); } 60 127 if ( !empty( beforeStmts ) ) { statements.splice( i, *beforeStmts ); } 61 128 } 62 129 130 if ( !empty( afterDecls ) ) { splice( std::back_inserter( statements ), afterDecls); } 63 131 if ( !empty( afterStmts ) ) { statements.splice( statements.end(), *afterStmts ); } 64 132 if ( !errors.isEmpty() ) { throw errors; } … … 66 134 67 135 template< 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 > 68 143 void 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 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 ); 70 161 71 162 StmtList_t* beforeStmts = get_beforeStmts(); 72 163 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 )) ); 101 170 102 171 CompoundStmt *compound = new CompoundStmt( noLabels ); 172 if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); } 103 173 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 ); } 105 176 if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } 106 177 return compound; … … 108 179 109 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 > 110 189 Statement * 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 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; 135 199 136 200 auto env_ptr = get_env_ptr(); … … 138 202 *env_ptr = expr->get_env(); 139 203 } 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 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 }); 142 215 } 143 216 144 217 template< typename pass_type > 145 218 Expression * 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 } 156 223 157 224 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ … … 231 298 void PassVisitor< pass_type >::visit( ExprStmt * node ) { 232 299 VISIT_START( node ); 233 call_beginScope();234 300 235 301 visitExpression( node->get_expr() ); 236 302 237 call_endScope();238 303 VISIT_END( node ); 239 304 } … … 248 313 } 249 314 315 //-------------------------------------------------------------------------- 316 // AsmStmt 250 317 template< typename pass_type > 251 318 void PassVisitor< pass_type >::visit( AsmStmt * node ) { 252 319 VISIT_BODY( node ); 320 } 321 322 template< typename pass_type > 323 Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) { 324 MUTATE_BODY( Statement, node ); 253 325 } 254 326 … … 300 372 301 373 //-------------------------------------------------------------------------- 302 // WhileStmt374 // ForStmt 303 375 template< typename pass_type > 304 376 void PassVisitor< pass_type >::visit( ForStmt * node ) { … … 348 420 349 421 //-------------------------------------------------------------------------- 350 // SwitchStmt422 // CaseStmt 351 423 template< typename pass_type > 352 424 void PassVisitor< pass_type >::visit( CaseStmt * node ) { … … 369 441 } 370 442 443 //-------------------------------------------------------------------------- 444 // BranchStmt 371 445 template< typename pass_type > 372 446 void PassVisitor< pass_type >::visit( BranchStmt * node ) { 373 447 VISIT_BODY( node ); 448 } 449 450 template< typename pass_type > 451 Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) { 452 MUTATE_BODY( Statement, node ); 374 453 } 375 454 … … 415 494 maybeAccept( node->get_block(), *this ); 416 495 acceptAll( node->get_catchers(), *this ); 496 maybeAccept( node->get_finally(), *this ); 417 497 418 498 VISIT_END( node ); … … 425 505 node->set_block( maybeMutate( node->get_block(), *this ) ); 426 506 mutateAll( node->get_catchers(), *this ); 507 node->set_finally( maybeMutate( node->get_finally(), *this ) ); 427 508 428 509 MUTATE_END( Statement, node ); … … 435 516 VISIT_START( node ); 436 517 518 maybeAccept( node->get_decl(), *this ); 519 node->set_cond( visitExpression( node->get_cond() ) ); 437 520 node->set_body( visitStatement( node->get_body() ) ); 438 maybeAccept( node->get_decl(), *this );439 521 440 522 VISIT_END( node ); … … 445 527 MUTATE_START( node ); 446 528 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() ) ); 449 532 450 533 MUTATE_END( Statement, node ); … … 838 921 839 922 template< 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 >850 923 Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) { 851 924 MUTATE_BODY( Statement, node );
Note: See TracChangeset
for help on using the changeset viewer.