Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Convert.cpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -10,6 +10,6 @@ // Created On : Thu May 09 15::37::05 2019 // Last Modified By : Andrew Beach -// Last Modified On : Wed Mar 16 15:01:00 2022 -// Update Count : 42 +// Last Modified On : Wed Apr 20 13:58:00 2022 +// Update Count : 43 // @@ -562,21 +562,27 @@ for ( auto clause : node->clauses ) { stmt->clauses.push_back({{ - get().accept1( clause.target.func ), - get().acceptL( clause.target.args ), + get().accept1( clause->target_func ), + get().acceptL( clause->target_args ), }, - get().accept1( clause.stmt ), - get().accept1( clause.cond ), + get().accept1( clause->stmt ), + get().accept1( clause->cond ), }); } stmt->timeout = { - get().accept1( node->timeout.time ), - get().accept1( node->timeout.stmt ), - get().accept1( node->timeout.cond ), + get().accept1( node->timeout_time ), + get().accept1( node->timeout_stmt ), + get().accept1( node->timeout_cond ), }; stmt->orelse = { - get().accept1( node->orElse.stmt ), - get().accept1( node->orElse.cond ), + get().accept1( node->else_stmt ), + get().accept1( node->else_cond ), }; return stmtPostamble( stmt, node ); + } + + const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final { + // There is no old-AST WaitForClause, so this should never be called. + assert( !node ); + return nullptr; } @@ -2096,22 +2102,18 @@ stmt->clauses.reserve( old->clauses.size() ); for (size_t i = 0 ; i < old->clauses.size() ; ++i) { - stmt->clauses.push_back({ - ast::WaitForStmt::Target{ - GET_ACCEPT_1(clauses[i].target.function, Expr), - GET_ACCEPT_V(clauses[i].target.arguments, Expr) - }, - GET_ACCEPT_1(clauses[i].statement, Stmt), - GET_ACCEPT_1(clauses[i].condition, Expr) - }); - } - stmt->timeout = { - GET_ACCEPT_1(timeout.time, Expr), - GET_ACCEPT_1(timeout.statement, Stmt), - GET_ACCEPT_1(timeout.condition, Expr), - }; - stmt->orElse = { - GET_ACCEPT_1(orelse.statement, Stmt), - GET_ACCEPT_1(orelse.condition, Expr), - }; + auto clause = new ast::WaitForClause( old->location ); + + clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr); + clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr); + clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt); + clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr); + + stmt->clauses.push_back( clause ); + } + stmt->timeout_time = GET_ACCEPT_1(timeout.time, Expr); + stmt->timeout_stmt = GET_ACCEPT_1(timeout.statement, Stmt); + stmt->timeout_cond = GET_ACCEPT_1(timeout.condition, Expr); + stmt->else_stmt = GET_ACCEPT_1(orelse.statement, Stmt); + stmt->else_cond = GET_ACCEPT_1(orelse.condition, Expr); this->node = stmt; Index: src/AST/Fwd.hpp =================================================================== --- src/AST/Fwd.hpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Fwd.hpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -56,4 +56,5 @@ class SuspendStmt; class WaitForStmt; +class WaitForClause; class WithStmt; class DeclStmt; Index: src/AST/Node.cpp =================================================================== --- src/AST/Node.cpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Node.cpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -176,4 +176,6 @@ template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >; template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >; +template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >; +template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >; template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >; template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >; Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Pass.hpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -158,4 +158,5 @@ const ast::Stmt * visit( const ast::SuspendStmt * ) override final; const ast::Stmt * visit( const ast::WaitForStmt * ) override final; + const ast::WaitForClause * visit( const ast::WaitForClause * ) override final; const ast::Decl * visit( const ast::WithStmt * ) override final; const ast::NullStmt * visit( const ast::NullStmt * ) override final; Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Pass.impl.hpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -1010,81 +1010,31 @@ const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) { VISIT_START( node ); - // for( auto & clause : node->clauses ) { - // maybeAccept_impl( clause.target.function, *this ); - // maybeAccept_impl( clause.target.arguments, *this ); - - // maybeAccept_impl( clause.statement, *this ); - // maybeAccept_impl( clause.condition, *this ); - // } - - if ( __visit_children() ) { - std::vector new_clauses; - new_clauses.reserve( node->clauses.size() ); - bool mutated = false; - for( const auto & clause : node->clauses ) { - - const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr; - if(func != clause.target.func) mutated = true; - else func = nullptr; - - std::vector> new_args; - new_args.reserve(clause.target.args.size()); - for( const auto & arg : clause.target.args ) { - auto a = arg->accept(*this); - if( a != arg ) { - mutated = true; - new_args.push_back( a ); - } else - new_args.push_back( nullptr ); - } - - const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr; - if(stmt != clause.stmt) mutated = true; - else stmt = nullptr; - - const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr; - if(cond != clause.cond) mutated = true; - else cond = nullptr; - - new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } ); - } - - if(mutated) { - auto n = __pass::mutate(node); - for(size_t i = 0; i < new_clauses.size(); i++) { - if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func); - - for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) { - if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j)); - } - - if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt); - if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond); - } - node = n; - } - } - - #define maybe_accept(field) \ - if(node->field) { \ - auto nval = call_accept( node->field ); \ - if(nval.differs ) { \ - auto nparent = __pass::mutate(node); \ - nparent->field = nval.value; \ - node = nparent; \ - } \ - } - - if ( __visit_children() ) { - maybe_accept( timeout.time ); - maybe_accept( timeout.stmt ); - maybe_accept( timeout.cond ); - maybe_accept( orElse.stmt ); - maybe_accept( orElse.cond ); - } - - #undef maybe_accept + + if ( __visit_children() ) { + maybe_accept( node, &WaitForStmt::clauses ); + maybe_accept( node, &WaitForStmt::timeout_time ); + maybe_accept( node, &WaitForStmt::timeout_stmt ); + maybe_accept( node, &WaitForStmt::timeout_cond ); + maybe_accept( node, &WaitForStmt::else_stmt ); + maybe_accept( node, &WaitForStmt::else_cond ); + } VISIT_END( Stmt, node ); +} + +//-------------------------------------------------------------------------- +// WaitForClause +template< typename core_t > +const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) { + VISIT_START( node ); + + if ( __visit_children() ) { + maybe_accept( node, &WaitForClause::target_func ); + maybe_accept( node, &WaitForClause::target_args ); + maybe_accept( node, &WaitForClause::stmt ); + maybe_accept( node, &WaitForClause::cond ); + } + + VISIT_END( WaitForClause, node ); } Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Print.cpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -760,50 +760,55 @@ indent += 2; for( const auto & clause : node->clauses ) { - os << indent-1 << "target function: "; - safe_print( clause.target.func ); - - if ( ! clause.target.args.empty() ) { - os << endl << indent-1 << "... with arguments:" << endl; - for( const ast::Expr * arg : clause.target.args ) { - arg->accept( *this ); - } + clause->accept( *this ); + } + + if ( node->timeout_time ) { + os << indent-1 << "timeout of:" << endl; + node->timeout_time->accept( *this ); + + if ( node->timeout_stmt ) { + os << indent-1 << "... with statment:" << endl; + node->timeout_stmt->accept( *this ); } - if ( clause.stmt ) { - os << indent-1 << "... with statment:" << endl; - clause.stmt->accept( *this ); + if ( node->timeout_cond ) { + os << indent-1 << "... with condition:" << endl; + node->timeout_cond->accept( *this ); } - - if ( clause.cond ) { + } + + if ( node->else_stmt ) { + os << indent-1 << "else:" << endl; + node->else_stmt->accept( *this ); + + if ( node->else_cond ) { os << indent-1 << "... with condition:" << endl; - clause.cond->accept( *this ); + node->else_cond->accept( *this ); } } - if ( node->timeout.time ) { - os << indent-1 << "timeout of:" << endl; - node->timeout.time->accept( *this ); - - if ( node->timeout.stmt ) { - os << indent-1 << "... with statment:" << endl; - node->timeout.stmt->accept( *this ); + return node; + } + + virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final { + os << indent-1 << "target function: "; + safe_print( node->target_func ); + + if ( !node->target_args.empty() ) { + os << endl << indent-1 << "... with arguments:" << endl; + for( const ast::Expr * arg : node->target_args ) { + arg->accept( *this ); } - - if ( node->timeout.cond ) { - os << indent-1 << "... with condition:" << endl; - node->timeout.cond->accept( *this ); - } - } - - if ( node->orElse.stmt ) { - os << indent-1 << "else:" << endl; - node->orElse.stmt->accept( *this ); - - if ( node->orElse.cond ) { - os << indent-1 << "... with condition:" << endl; - node->orElse.cond->accept( *this ); - } - } - indent -= 2; + } + + if ( node->stmt ) { + os << indent-1 << "... with statment:" << endl; + node->stmt->accept( *this ); + } + + if ( node->cond ) { + os << indent-1 << "... with condition:" << endl; + node->cond->accept( *this ); + } return node; Index: src/AST/Stmt.hpp =================================================================== --- src/AST/Stmt.hpp (revision 374cb11784dccbf21002ae7aee894790d8f79d65) +++ src/AST/Stmt.hpp (revision 94d91e1705d3b0e943c9e2eaf700a3dac5153ae1) @@ -10,6 +10,6 @@ // Created On : Wed May 8 13:00:00 2019 // Last Modified By : Andrew Beach -// Last Modified On : Mon Mar 28 9:50:00 2022 -// Update Count : 35 +// Last Modified On : Wed Apr 20 14:34:00 2022 +// Update Count : 36 // @@ -378,29 +378,10 @@ class WaitForStmt final : public Stmt { public: - struct Target { - ptr func; - std::vector> args; - }; - - struct Clause { - Target target; - ptr stmt; - ptr cond; - }; - - struct Timeout { - ptr time; - ptr stmt; - ptr cond; - }; - - struct OrElse { - ptr stmt; - ptr cond; - }; - - std::vector clauses; - Timeout timeout; - OrElse orElse; + std::vector> clauses; + ptr timeout_time; + ptr timeout_stmt; + ptr timeout_cond; + ptr else_stmt; + ptr else_cond; WaitForStmt( const CodeLocation & loc, const std::vector