Changes in src/Parser/StatementNode.cc [7880579:7ecbb7e]

File:

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

src/Parser/StatementNode.cc

@@ -62 +62 @@
         StatementNode *node = dynamic_cast< StatementNode * >(prev);
         std::list< Statement * > stmts;
-        buildList( stmt, stmts );
+        buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
         CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt);
@@ -70 +70 @@
 
 Statement *build_expr( ExpressionNode *ctl ) {
-        Expression *e = maybeBuild< Expression >( ctl );
+        Expression *e = maybeMoveBuild< Expression >( ctl );
 
         if ( e )
@@ -81 +81 @@
         Statement *thenb, *elseb = 0;
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( then_stmt, branches );
+        buildMoveList< Statement, StatementNode >( then_stmt, branches );
         assert( branches.size() == 1 );
         thenb = branches.front();
@@ -87 +87 @@
         if ( else_stmt ) {
                 std::list< Statement * > branches;
-                buildList< Statement, StatementNode >( else_stmt, branches );
+                buildMoveList< Statement, StatementNode >( else_stmt, branches );
                 assert( branches.size() == 1 );
                 elseb = branches.front();
         } // if
-        return new IfStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), thenb, elseb );
+        return new IfStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), thenb, elseb );
 }
 
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() >= 0 );                                         // size == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( noLabels, maybeBuild< Expression >(ctl), branches );
+        return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
         std::list< Statement * > branches;
-        return new CaseStmt( noLabels, maybeBuild< Expression >(ctl), branches );
+        return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
@@ -111 +111 @@
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), branches.front(), kind );
+        return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
 Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
 
         std::list< Statement * > init;
         if ( forctl->init != 0 ) {
-                buildList( forctl->init, init );
+                buildMoveList( forctl->init, init );
         } // if
 
         Expression *cond = 0;
         if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeBuild< Expression >(forctl->condition) );
+                cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
 
         Expression *incr = 0;
         if ( forctl->change != 0 )
-                incr = maybeBuild< Expression >(forctl->change);
+                incr = maybeMoveBuild< Expression >(forctl->change);
 
         delete forctl;
@@ -142 +142 @@
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-        return new BranchStmt( noLabels, maybeBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
         std::list< Expression * > exps;
-        buildList( ctl, exps );
+        buildMoveList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 Statement *build_throw( ExpressionNode *ctl ) {
         std::list< Expression * > exps;
-        buildList( ctl, exps );
+        buildMoveList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
 }
@@ -158 +158 @@
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( catch_stmt, branches );
-        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeBuild< Statement >(try_stmt));
+        buildMoveList< Statement, StatementNode >( catch_stmt, branches );
+        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
         assert( tryBlock );
-        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeBuild< Statement >(finally_stmt) );
+        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
         return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( noLabels, maybeBuild< Declaration >(decl), branches.front(), catchAny );
+        return new CatchStmt( noLabels, maybeMoveBuild< Declaration >(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
         std::list< Statement * > branches;
-        buildList< Statement, StatementNode >( stmt, branches );
+        buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
         return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
@@ -179 +179 @@
 Statement *build_compound( StatementNode *first ) {
         CompoundStmt *cs = new CompoundStmt( noLabels );
-        buildList( first, cs->get_kids() );
+        buildMoveList( first, cs->get_kids() );
         return cs;
 }
@@ -187 +187 @@
         std::list< ConstantExpr * > clob;
 
-        buildList( output, out );
-        buildList( input, in );
-        buildList( clobber, clob );
+        buildMoveList( output, out );
+        buildMoveList( input, in );
+        buildMoveList( clobber, clob );
         return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }