Changes in src/Parser/StatementNode.cc [f135b50:702e826]

File:

• src/Parser/StatementNode.cc (modified) (18 diffs)

src/Parser/StatementNode.cc

@@ -38 +38 @@
         DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
-                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
@@ -51 +51 @@
                 agg = decl;
         } // if
-        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        stmt.reset( new DeclStmt( maybeMoveBuild( agg ) ) );
 } // StatementNode::StatementNode
 
@@ -73 +73 @@
 
 Statement * build_expr( ExpressionNode * ctl ) {
-        Expression * e = maybeMoveBuild< Expression >( ctl );
+        Expression * e = maybeMoveBuild( ctl );
 
         if ( e ) return new ExprStmt( e );
@@ -87 +87 @@
         if ( ctl->condition ) {
                 // compare the provided condition against 0
-                cond = notZeroExpr( maybeMoveBuild< Expression >(ctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
         } else {
                 for ( Statement * stmt : init ) {
@@ -134 +134 @@
         } // if
         // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
+        return new SwitchStmt( maybeMoveBuild( ctl ), aststmt );
 } // build_switch
 
 Statement * build_case( ExpressionNode * ctl ) {
-        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
+        return new CaseStmt( maybeMoveBuild( ctl ), {} ); // stmt starts empty and then added to
 } // build_case
 
@@ -168 +168 @@
 
         // do-while cannot have declarations in the contitional, so init is always empty
-        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
+        return new WhileDoStmt( notZeroExpr( maybeMoveBuild( ctl ) ), aststmt.front(), astelse.front(), {}, true );
 } // build_do_while
 
@@ -176 +176 @@
 
         Expression * astcond = nullptr;                                         // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
 
         Expression * astincr = nullptr;                                         // maybe empty
-        astincr = maybeMoveBuild< Expression >(forctl->change);
+        astincr = maybeMoveBuild( forctl->change );
         delete forctl;
 
@@ -199 +199 @@
 Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
         Statement * ret = new BranchStmt( * identifier, kind );
-        delete identifier;                                                                      // allocated by lexer
+        delete identifier;                                                                      // allocated by lexer
         return ret;
 } // build_branch
 
 Statement * build_computedgoto( ExpressionNode * ctl ) {
-        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( maybeMoveBuild( ctl ), BranchStmt::Goto );
 } // build_computedgoto
 
@@ -236 +236 @@
         list< CatchStmt * > aststmt;
         buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
-        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
-        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >( maybeMoveBuild( try_ ) );
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >( maybeMoveBuild( finally_ ) );
         return new TryStmt( tryBlock, aststmt, finallyBlock );
 } // build_try
@@ -245 +245 @@
         buildMoveList< Statement, StatementNode >( body, aststmt );
         assert( aststmt.size() == 1 );
-        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
+        return new CatchStmt( kind, maybeMoveBuild( decl ), maybeMoveBuild( cond ), aststmt.front() );
 } // build_catch
 
@@ -274 +274 @@
 
         WaitForStmt::Target target;
-        target.function = maybeBuild<Expression>( targetExpr );
+        target.function = maybeBuild( targetExpr );
 
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
@@ -284 +284 @@
         node->clauses.push_back( WaitForStmt::Clause{
                 target,
-                maybeMoveBuild<Statement >( stmt ),
-                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+                maybeMoveBuild( stmt ),
+                notZeroExpr( maybeMoveBuild( when ) )
         });
 
@@ -293 +293 @@
 WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
         WaitForStmt::Target target;
-        target.function = maybeBuild<Expression>( targetExpr );
+        target.function = maybeBuild( targetExpr );
 
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
@@ -303 +303 @@
         node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
-                maybeMoveBuild<Statement >( stmt ),
-                notZeroExpr( maybeMoveBuild<Expression>( when ) )
+                maybeMoveBuild( stmt ),
+                notZeroExpr( maybeMoveBuild( when ) )
         });
 
@@ -314 +314 @@
 
         if( timeout ) {
-                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+                node->timeout.time      = maybeMoveBuild( timeout );
+                node->timeout.statement = maybeMoveBuild( stmt    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) );
         } else {
-                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
-                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+                node->orelse.statement  = maybeMoveBuild( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild( when ) );
         } // if
 
@@ -328 +328 @@
         auto node = new WaitForStmt();
 
-        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
-
-        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
-        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
+        node->timeout.time      = maybeMoveBuild( timeout );
+        node->timeout.statement = maybeMoveBuild( stmt    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) );
+
+        node->orelse.statement  = maybeMoveBuild( else_ );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild( else_when ) );
 
         return node;
@@ -341 +341 @@
         list< Expression * > e;
         buildMoveList( exprs, e );
-        Statement * s = maybeMoveBuild<Statement>( stmt );
+        Statement * s = maybeMoveBuild( stmt );
         return new DeclStmt( new WithStmt( e, s ) );
 } // build_with
@@ -384 +384 @@
         list< Expression * > expList;
         buildMoveList( exprs, expList );
-        Statement * body = maybeMoveBuild<Statement>( stmt );
+        Statement * body = maybeMoveBuild( stmt );
         return new MutexStmt( body, expList );
 } // build_mutex