Changeset 7880579 for src/Parser/StatementNode.cc

Timestamp:

Aug 16, 2016, 8:59:49 AM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

0da3e2c, 13e3b50, 7527e63

Parents:

b1848a0

Message:

more refactoring of parser code

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 14:40:05 2016
-// Update Count     : 317
+// Last Modified On : Mon Aug 15 20:47:11 2016
+// Update Count     : 322
 //
 
@@ -32 +32 @@
                 if ( agg ) {
                         StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
-                        next = nextStmt;
+                        set_next( nextStmt );
                         if ( decl->get_next() ) {
-                                next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
+                                get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) );
                                 decl->set_next( 0 );
                         } // if
                 } else {
                         if ( decl->get_next() ) {
-                                next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
+                                set_next(new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) );
                                 decl->set_next( 0 );
                         } // if
                         agg = decl;
                 } // if
-                stmt = 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) );
+                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;
+        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);
+        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt);
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
@@ -80 +80 @@
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
         Statement *thenb, *elseb = 0;
-        std::list<Statement *> branches;
-        buildList<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;
-                buildList<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( maybeBuild<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;
-        buildList<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, maybeBuild<Expression>(ctl), branches );
+        return new SwitchStmt( noLabels, maybeBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
-        std::list<Statement *> branches;
-        return new CaseStmt( noLabels, maybeBuild<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;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( noLabels, notZeroExpr( maybeBuild<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;
-        buildList<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 ) {
                 buildList( forctl->init, init );
@@ -128 +128 @@
         Expression *cond = 0;
         if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeBuild<Expression>(forctl->condition) );
+                cond = notZeroExpr( maybeBuild< Expression >(forctl->condition) );
 
         Expression *incr = 0;
         if ( forctl->change != 0 )
-                incr = maybeBuild<Expression>(forctl->change);
+                incr = maybeBuild< 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, maybeBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
-        std::list<Expression *> 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;
+        std::list< Expression * > exps;
         buildList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
@@ -157 +157 @@
 
 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));
+        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 *>(maybeBuild<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;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
+        return new CatchStmt( noLabels, maybeBuild< Declaration >(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
-        std::list<Statement *> branches;
-        buildList<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() ) );
 }