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

File:

• src/Parser/StatementNode.cc (modified) (5 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 : Sun Aug 14 13:10:54 2016
+// Update Count     : 288
 //
 
@@ -26 +26 @@
 using namespace std;
 
-
-StatementNode::StatementNode( DeclarationNode *decl ) {
+const char *StatementNode::StType[] = {
+        "Exp",   "If",       "Switch", "Case",    "Default",  "Choose",   "Fallthru",
+        "While", "Do",       "For",
+        "Goto",  "Continue", "Break",  "Return",  "Throw",
+        "Try",   "Catch",    "Finally", "Asm",
+        "Decl"
+};
+
+StatementNode::StatementNode() : ParseNode(), labels( 0 ), decl( 0 ) {}
+
+StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), labels( 0 ) {
+        assert( false );
         if ( decl ) {
-                DeclarationNode *agg = decl->extractAggregate();
-                if ( agg ) {
-                        StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
+                if ( DeclarationNode *agg = decl->extractAggregate() ) {
+                        this->decl = agg;
+                        StatementNode *nextStmt = new StatementNode;
+                        nextStmt->type = Decl;
+                        nextStmt->decl = decl;
                         next = nextStmt;
                         if ( decl->get_next() ) {
-                                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
@@ -42 +54 @@
                                 decl->set_next( 0 );
                         } // if
+                        this->decl = decl;
+                } // if
+        } // if
+}
+
+StatementNode2::StatementNode2( DeclarationNode *decl ) {
+        if ( decl ) {
+                DeclarationNode *agg = decl->extractAggregate();
+                if ( agg ) {
+                        StatementNode *nextStmt = new StatementNode;
+                        nextStmt->type = Decl;
+                        nextStmt->decl = decl;
+                        next = nextStmt;
+                        if ( decl->get_next() ) {
+                                next->set_next( new StatementNode2( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
+                                decl->set_next( 0 );
+                        } // if
+                } else {
+                        if ( decl->get_next() ) {
+                                next = new StatementNode2( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
+                                decl->set_next( 0 );
+                        } // if
                         agg = decl;
                 } // if
@@ -50 +84 @@
 }
 
+StatementNode::~StatementNode() {
+        delete decl;
+}
+
+StatementNode * StatementNode::clone() const {
+        assert( false );
+        return 0;
+}
+
+StatementNode *StatementNode::add_label( const std::string *l ) {
+        if ( l != 0 ) {
+                labels.push_front( *l );
+                delete l;
+        } // if
+        return this;
+}
+
 StatementNode *StatementNode::append_last_case( StatementNode *stmt ) {
+        assert( false );
+        return this;
+}
+
+StatementNode *StatementNode2::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 = dynamic_cast<StatementNode *>(curr);
+                StatementNode2 *node = dynamic_cast<StatementNode2 *>(curr);
                 assert( node );
                 assert( dynamic_cast<CaseStmt *>(node->stmt) );
                 prev = curr;
         } // for
-        // convert from StatementNode list to Statement list
-        StatementNode *node = dynamic_cast<StatementNode *>(prev);
+        // conver from StatementNode list to Statement list
+        StatementNode2 *node = dynamic_cast<StatementNode2 *>(prev);
         std::list<Statement *> stmts;
         buildList( stmt, stmts );
-        // splice any new Statements to end of current Statements
+        // splice any new Statements to end of currents Statements
         CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
+}
+
+Statement *StatementNode::build() const {
+        switch ( type ) {
+          case Decl:
+                return new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) );
+                assert( false );
+          case Exp:
+          case If:
+          case Switch:
+          case Case:
+          case Default:
+          case While:
+          case Do:
+          case For:
+          case Goto:
+          case Break:
+          case Continue:
+          case Return:
+          case Throw :
+          case Try:
+          case Catch:
+          case Finally:
+          case Asm:
+          default:
+                assert( false );
+                return 0;
+        } // switch
 }
 
@@ -177 +261 @@
 }
 
-Statement *build_compound( StatementNode *first ) {
-        CompoundStmt *cs = new CompoundStmt( noLabels );
+
+CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
+
+CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ) : first( stmt ) {
+        if ( first ) {
+                last = ( StatementNode *)( stmt->get_last());
+        } else {
+                last = 0;
+        } // if
+}
+
+CompoundStmtNode::~CompoundStmtNode() {
+        delete first;
+}
+
+void CompoundStmtNode::add_statement( StatementNode *stmt ) {
+        if ( stmt != 0 ) {
+                last->set_last( stmt );
+                last = ( StatementNode *)( stmt->get_next());
+        } // if
+}
+
+void CompoundStmtNode::print( ostream &os, int indent ) const {
+        if ( first ) {
+                first->printList( os, indent+2 );
+        } // if
+}
+
+Statement *CompoundStmtNode::build() const {
+        std::list<Label> labs;
+        const std::list<std::string> &labels = get_labels();
+
+        if ( ! labels.empty() ) {
+                std::back_insert_iterator< std::list<Label> > lab_it( labs );
+                copy( labels.begin(), labels.end(), lab_it );
+        } // if
+
+        CompoundStmt *cs = new CompoundStmt( labs );
         buildList( first, cs->get_kids() );
         return cs;
 }
 
-Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) {
+
+AsmStmtNode::AsmStmtNode( bool voltile, ConstantExpr *instruction, ExpressionNode *output, ExpressionNode *input, ExpressionNode *clobber, LabelNode *gotolabels ) :
+        voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ) {
+        type = Asm;
+        if ( gotolabels ) {
+                this->gotolabels = gotolabels->get_labels();
+                delete gotolabels;
+        } // if
+}
+
+AsmStmtNode::~AsmStmtNode() {
+        delete output; delete input; delete clobber;
+}
+
+Statement *AsmStmtNode::build() const {
+        std::list<Label> labs;
+
+        if ( ! get_labels().empty() ) {
+                std::back_insert_iterator< std::list<Label> > lab_it( labs );
+                copy( get_labels().begin(), get_labels().end(), lab_it );
+        } // if
+
         std::list< Expression * > out, in;
         std::list< ConstantExpr * > clob;
-
         buildList( output, out );
         buildList( input, in );
         buildList( clobber, clob );
-        return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
-}
+        std::list< Label > gotolabs = gotolabels;
+        return new AsmStmt( labs, voltile, instruction, out, in, clob, gotolabs );
+}
+
+// Statement *build_asm( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 ) {
+//      std::list<Label> labs;
+
+//      if ( ! get_labels().empty() ) {
+//              std::back_insert_iterator< std::list<Label> > lab_it( labs );
+//              copy( get_labels().begin(), get_labels().end(), lab_it );
+//      } // if
+
+//      std::list< Expression * > out, in;
+//      std::list< ConstantExpr * > clob;
+//      buildList( output, out );
+//      buildList( input, in );
+//      buildList( clobber, clob );
+//      std::list< Label > gotolabs = gotolabels;
+//      return new AsmStmt( labs, voltile, instruction, out, in, clob, gotolabs );
+// }
 
 // Local Variables: //