Changes in src/Parser/StatementNode.cc [ac71a86:e82aa9df]

File:

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

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 20:47:11 2016
-// Update Count     : 322
+// Last Modified On : Mon Aug 15 14:40:05 2016
+// Update Count     : 317
 //
 
@@ -32 +32 @@
                 if ( agg ) {
                         StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
-                        set_next( nextStmt );
+                        next = nextStmt;
                         if ( decl->get_next() ) {
-                                get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) );
+                                next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
                                 decl->set_next( 0 );
                         } // if
                 } else {
                         if ( decl->get_next() ) {
-                                set_next(new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) );
+                                next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
                                 decl->set_next( 0 );
                         } // if
                         agg = decl;
                 } // if
-                stmt.reset( new DeclStmt( noLabels, maybeBuild< Declaration >(agg) ) );
+                stmt = new DeclStmt( noLabels, maybeBuild<Declaration>(agg) );
         } else {
                 assert( false );
@@ -54 +54 @@
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
-                StatementNode *node = dynamic_cast< StatementNode * >(curr);
+                StatementNode *node = dynamic_cast<StatementNode *>(curr);
                 assert( node );
-                assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
+                assert( dynamic_cast<CaseStmt *>(node->stmt) );
                 prev = curr;
         } // for
         // convert from StatementNode list to Statement list
-        StatementNode *node = dynamic_cast< StatementNode * >(prev);
-        std::list< Statement * > stmts;
-        buildMoveList( stmt, stmts );
+        StatementNode *node = dynamic_cast<StatementNode *>(prev);
+        std::list<Statement *> stmts;
+        buildList( stmt, stmts );
         // splice any new Statements to end of current Statements
-        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt.get());
+        CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
@@ -70 +70 @@
 
 Statement *build_expr( ExpressionNode *ctl ) {
-        Expression *e = maybeMoveBuild< Expression >( ctl );
+        Expression *e = maybeBuild< Expression >( ctl );
 
         if ( e )
@@ -80 +80 @@
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
         Statement *thenb, *elseb = 0;
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( then_stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( then_stmt, branches );
         assert( branches.size() == 1 );
         thenb = branches.front();
 
         if ( else_stmt ) {
-                std::list< Statement * > branches;
-                buildMoveList< Statement, StatementNode >( else_stmt, branches );
+                std::list<Statement *> branches;
+                buildList<Statement, StatementNode>( else_stmt, branches );
                 assert( branches.size() == 1 );
                 elseb = branches.front();
         } // if
-        return new IfStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), thenb, elseb );
+        return new IfStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), thenb, elseb );
 }
 
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
         assert( branches.size() >= 0 );                                         // size == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+        return new SwitchStmt( noLabels, maybeBuild<Expression>(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
-        std::list< Statement * > branches;
-        return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+        std::list<Statement *> branches;
+        return new CaseStmt( noLabels, maybeBuild<Expression>(ctl), branches );
 }
 Statement *build_default() {
-        std::list< Statement * > branches;
+        std::list<Statement *> branches;
         return new CaseStmt( noLabels, nullptr, branches, true );
 }
 
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
+        return new WhileStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), branches.front(), kind );
 }
 
 Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
         assert( branches.size() == 1 );
 
-        std::list< Statement * > init;
+        std::list<Statement *> init;
         if ( forctl->init != 0 ) {
-                buildMoveList( forctl->init, init );
+                buildList( forctl->init, init );
         } // if
 
         Expression *cond = 0;
         if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
+                cond = notZeroExpr( maybeBuild<Expression>(forctl->condition) );
 
         Expression *incr = 0;
         if ( forctl->change != 0 )
-                incr = maybeMoveBuild< Expression >(forctl->change);
+                incr = maybeBuild<Expression>(forctl->change);
 
         delete forctl;
@@ -142 +142 @@
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-        return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( noLabels, maybeBuild<Expression>(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
-        std::list< Expression * > exps;
-        buildMoveList( ctl, exps );
+        std::list<Expression *> exps;
+        buildList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 Statement *build_throw( ExpressionNode *ctl ) {
-        std::list< Expression * > exps;
-        buildMoveList( ctl, exps );
-        assertf( exps.size() < 2, "This means we are leaking memory");
-        return new ReturnStmt( noLabels, !exps.empty() ? exps.back() : nullptr, true );
+        std::list<Expression *> exps;
+        buildList( ctl, exps );
+        return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
 }
 
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( catch_stmt, branches );
-        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( catch_stmt, branches );
+        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>(maybeBuild<Statement>(try_stmt));
         assert( tryBlock );
-        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
+        FinallyStmt *finallyBlock = dynamic_cast<FinallyStmt *>(maybeBuild<Statement>(finally_stmt) );
         return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( noLabels, maybeMoveBuild< Declaration >(decl), branches.front(), catchAny );
+        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
         assert( branches.size() == 1 );
-        return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
+        return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
 }
 
 Statement *build_compound( StatementNode *first ) {
         CompoundStmt *cs = new CompoundStmt( noLabels );
-        buildMoveList( first, cs->get_kids() );
+        buildList( first, cs->get_kids() );
         return cs;
 }
@@ -188 +187 @@
         std::list< ConstantExpr * > clob;
 
-        buildMoveList( output, out );
-        buildMoveList( input, in );
-        buildMoveList( clobber, clob );
+        buildList( output, out );
+        buildList( input, in );
+        buildList( clobber, clob );
         return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }