Changes in src/Parser/StatementNode.cc [8d7bef2:cc32d83]

File:

• src/Parser/StatementNode.cc (modified) (15 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 : Fri Sep  1 23:25:23 2017
-// Update Count     : 346
+// Last Modified On : Mon Apr 30 09:21:16 2018
+// Update Count     : 354
 //
 
 #include <cassert>                 // for assert, strict_dynamic_cast, assertf
 #include <list>                    // for list
+#include <memory>                  // for unique_ptr
 #include <string>                  // for string
 
@@ -32 +33 @@
 
 
-StatementNode::StatementNode( DeclarationNode *decl ) {
+StatementNode::StatementNode( DeclarationNode * decl ) {
         assert( decl );
-        DeclarationNode *agg = decl->extractAggregate();
+        DeclarationNode * agg = decl->extractAggregate();
         if ( agg ) {
-                StatementNode *nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
@@ -49 +50 @@
                 agg = decl;
         } // if
-        stmt = new DeclStmt{ maybeMoveBuild< Declaration >(agg) };
+        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
 } // StatementNode::StatementNode
 
-StatementNode *StatementNode::append_last_case( StatementNode *stmt ) {
-        StatementNode *prev = this;
+StatementNode * StatementNode::append_last_case( StatementNode * stmt ) {
+        StatementNode * prev = this;
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
-                StatementNode *node = strict_dynamic_cast< StatementNode * >(curr);
-                assert( dynamic_cast< CaseStmt * >(node->stmt) );
+                StatementNode * node = strict_dynamic_cast< StatementNode * >(curr);
+                assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
                 prev = curr;
         } // for
         // convert from StatementNode list to Statement list
-        StatementNode *node = dynamic_cast< StatementNode * >(prev);
+        StatementNode * node = dynamic_cast< StatementNode * >(prev);
         std::list< Statement * > stmts;
         buildMoveList( 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.get());
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
 }
 
-Statement *build_expr( ExpressionNode *ctl ) {
-        Expression *e = maybeMoveBuild< Expression >( ctl );
+Statement * build_expr( ExpressionNode * ctl ) {
+        Expression * e = maybeMoveBuild< Expression >( ctl );
 
         if ( e )
@@ -79 +80 @@
 }
 
-Statement *build_if( IfCtl * ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
-        Statement *thenb, *elseb = 0;
+Statement * build_if( IfCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
+        Statement * thenb, * elseb = 0;
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( then_stmt, branches );
@@ -115 +116 @@
 }
 
-Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
+Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );
+        if ( ! isSwitch ) {                                                                             // choose statement
+                for ( Statement * stmt : branches ) {
+                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
+                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
+                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
+                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
+                        } // if
+                } // for
+        } // if
         // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
         return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
-Statement *build_case( ExpressionNode *ctl ) {
+Statement * build_case( ExpressionNode * ctl ) {
         std::list< Statement * > branches;
         return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
-Statement *build_default() {
+Statement * build_default() {
         std::list< Statement * > branches;
         return new CaseStmt( nullptr, branches, true );
 }
 
-Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
+Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );
@@ -137 +147 @@
 }
 
-Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
+Statement * build_for( ForCtl * forctl, StatementNode * stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );
@@ -147 +157 @@
         } // if
 
-        Expression *cond = 0;
+        Expression * cond = 0;
         if ( forctl->condition != 0 )
                 cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
 
-        Expression *incr = 0;
+        Expression * incr = 0;
         if ( forctl->change != 0 )
                 incr = maybeMoveBuild< Expression >(forctl->change);
@@ -159 +169 @@
 }
 
-Statement *build_branch( BranchStmt::Type kind ) {
+Statement * build_branch( BranchStmt::Type kind ) {
         Statement * ret = new BranchStmt( "", kind );
         return ret;
 }
-Statement *build_branch( std::string *identifier, BranchStmt::Type kind ) {
-        Statement * ret = new BranchStmt( *identifier, kind );
+Statement * build_branch( std::string * identifier, BranchStmt::Type kind ) {
+        Statement * ret = new BranchStmt( * identifier, kind );
         delete identifier;                                                                      // allocated by lexer
         return ret;
 }
-Statement *build_computedgoto( ExpressionNode *ctl ) {
+Statement * build_computedgoto( ExpressionNode * ctl ) {
         return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
-Statement *build_return( ExpressionNode *ctl ) {
+Statement * build_return( ExpressionNode * ctl ) {
         std::list< Expression * > exps;
         buildMoveList( ctl, exps );
@@ -178 +188 @@
 }
 
-Statement *build_throw( ExpressionNode *ctl ) {
+Statement * build_throw( ExpressionNode * ctl ) {
         std::list< Expression * > exps;
         buildMoveList( ctl, exps );
@@ -185 +195 @@
 }
 
-Statement *build_resume( ExpressionNode *ctl ) {
+Statement * build_resume( ExpressionNode * ctl ) {
         std::list< Expression * > exps;
         buildMoveList( ctl, exps );
@@ -192 +202 @@
 }
 
-Statement *build_resume_at( ExpressionNode *ctl, ExpressionNode *target ) {
+Statement * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) {
         (void)ctl;
         (void)target;
@@ -198 +208 @@
 }
 
-Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
+Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt ) {
         std::list< CatchStmt * > branches;
         buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
-        CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
-        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
         return new TryStmt( tryBlock, branches, finallyBlock );
 }
-Statement *build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body ) {
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( body, branches );
@@ -211 +221 @@
         return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
 }
-Statement *build_finally( StatementNode *stmt ) {
+Statement * build_finally( StatementNode * stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );
@@ -294 +304 @@
 }
 
-Statement *build_compound( StatementNode *first ) {
-        CompoundStmt *cs = new CompoundStmt();
+Statement * build_compound( StatementNode * first ) {
+        CompoundStmt * cs = new CompoundStmt();
         buildMoveList( first, cs->get_kids() );
         return cs;
 }
 
-Statement *build_asmstmt( bool voltile, Expression *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) {
+Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         std::list< Expression * > out, in;
         std::list< ConstantExpr * > clob;
@@ -308 +318 @@
         buildMoveList( clobber, clob );
         return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+}
+
+Statement * build_directive( string * directive ) {
+        return new DirectiveStmt( *directive );
 }