Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Pass.impl.hpp

    rc86b08d r2d0f918  
    2222#include "AST/TranslationUnit.hpp"
    2323#include "AST/TypeSubstitution.hpp"
    24 #include "Common/Iterate.hpp"
    2524
    2625#define VISIT_START( node ) \
     
    127126        }
    128127
    129         template< typename node_t >
    130         template< typename object_t, typename super_t, typename field_t >
    131         void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
    132                 object->*field = value;
    133         }
    134 
    135128        template< typename core_t >
    136129        template< typename node_t >
     
    234227
    235228                return {true, compound};
    236         }
    237 
    238         template< template <class...> class container_t >
    239         template< typename object_t, typename super_t, typename field_t >
    240         void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
    241                 auto & container = object->*field;
    242                 __pedantic_pass_assert( container.size() <= values.size() );
    243 
    244                 auto cit = enumerate(container).begin();
    245 
    246                 container_t<ptr<Stmt>> nvals;
    247                 for (delta & d : values) {
    248                         if ( d.is_old ) {
    249                                 __pedantic_pass_assert( cit.idx <= d.old_idx );
    250                                 std::advance( cit, d.old_idx - cit.idx );
    251                                 nvals.push_back( std::move( (*cit).val) );
    252                         } else {
    253                                 nvals.push_back( std::move(d.new_val) );
    254                         }
    255                 }
    256 
    257                 container = std::move(nvals);
    258         }
    259 
    260         template< template <class...> class container_t >
    261         template< template <class...> class incontainer_t >
    262         void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
    263                 if (!stmts || stmts->empty()) return;
    264 
    265                 std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
    266                         [](ast::ptr<ast::Stmt>& stmt) -> delta {
    267                                 return delta( stmt.release(), -1, false );
    268                         });
    269                 stmts->clear();
    270                 differs = true;
    271         }
    272 
    273         template< template<class...> class container_t >
    274         template< template<class...> class incontainer_t >
    275         void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
    276                 if (!decls || decls->empty()) return;
    277 
    278                 std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
    279                         [](ast::ptr<ast::Decl>& decl) -> delta {
    280                                 auto loc = decl->location;
    281                                 auto stmt = new DeclStmt( loc, decl.release() );
    282                                 return delta( stmt, -1, false );
    283                         });
    284                 decls->clear();
    285                 differs = true;
    286229        }
    287230
     
    353296
    354297                return new_kids;
    355         }
    356 
    357         template< template <class...> class container_t, typename node_t >
    358         template< typename object_t, typename super_t, typename field_t >
    359         void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
    360                 auto & container = object->*field;
    361                 __pedantic_pass_assert( container.size() == values.size() );
    362 
    363                 for(size_t i = 0; i < container.size(); i++) {
    364                         // Take all the elements that are different in 'values'
    365                         // and swap them into 'container'
    366                         if( values[i] != nullptr ) swap(container[i], values[i]);
    367                 }
    368 
    369                 // Now the original containers should still have the unchanged values
    370                 // but also contain the new values
    371298        }
    372299
     
    20752002        if ( __visit_children() ) {
    20762003                maybe_accept( node, &TupleType::types );
    2077                 maybe_accept( node, &TupleType::members );
    20782004        }
    20792005
     
    22372163}
    22382164
     2165#undef __pedantic_pass_assertf
     2166#undef __pedantic_pass_assert
    22392167#undef VISIT_START
    22402168#undef VISIT_END
Note: See TracChangeset for help on using the changeset viewer.