Changeset 1d4580a for src/Parser/StatementNode.cc

Timestamp:

Aug 14, 2016, 8:36:29 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:

777bfcf

Parents:

46b4259

Message:

more refactoring of parser code

File:

• src/Parser/StatementNode.cc (modified) (18 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 : Thu Aug 11 16:19:45 2016
-// Update Count     : 210
+// Last Modified On : Sun Aug 14 08:09:31 2016
+// Update Count     : 271
 //
 
@@ -34 +34 @@
 };
 
-StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
-
-StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
-
-StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) {
+StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) {}
+
+StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) { assert( false ); }
+
+StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), catchAny( false ) {
+        assert( false );
         if ( decl ) {
                 if ( DeclarationNode *agg = decl->extractAggregate() ) {
@@ -46 +47 @@
                         nextStmt->decl = decl;
                         next = nextStmt;
-                        if ( decl->get_link() ) {
-                                next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) );
+                        if ( decl->get_next() ) {
+                                next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) ) );
                                 decl->set_next( 0 );
                         } // if
                 } else {
-                        if ( decl->get_link() ) {
-                                next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) );
+                        if ( decl->get_next() ) {
+                                next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
                                 decl->set_next( 0 );
                         } // if
@@ -60 +61 @@
 }
 
-StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {
+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
+                stmt = new DeclStmt( noLabels, maybeBuild<Declaration>(agg) );
+        } else {
+                assert( false );
+        } // if
+}
+
+StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) {
         this->control = ( t == Default ) ? 0 : control;
 }
 
-StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), isCatchRest ( false ) {}
+StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), catchAny( false ) {}
 
 StatementNode::~StatementNode() {
@@ -73 +99 @@
 }
 
-StatementNode * StatementNode::newCatchStmt( DeclarationNode *d, StatementNode *s, bool catchRestP ) {
-        StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s );
-        ret->addDeclaration( d );
-        ret->setCatchRest( catchRestP );
-
-        return ret;
-}
-
-std::string StatementNode::get_target() const{
-        if ( target )
-                return *target;
-
-        return string("");
-}
-
 StatementNode * StatementNode::clone() const {
+        assert( false );
         StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) );
         if ( target ) {
@@ -112 +124 @@
                         block = stmt;
                 else
-                        block->set_link( stmt );
+                        block->set_last( stmt );
         } // if
         return this;
@@ -120 +132 @@
         assert( false );
         if ( stmt != 0 ) {
-                StatementNode *next = ( StatementNode *)get_link();
+                StatementNode *next = ( StatementNode *)get_next();
                 if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default ) )
                         next->append_last_case( stmt );
@@ -127 +139 @@
                                 block = stmt;
                         else
-                                block->set_link( stmt );
+                                block->set_last( stmt );
         } // if
         return this;
@@ -134 +146 @@
 StatementNode *StatementNode2::append_last_case( StatementNode *stmt ) {
         StatementNode *prev = this;
-        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_link() ) {
+        // find end of list and maintain previous pointer
+        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
                 StatementNode2 *node = dynamic_cast<StatementNode2 *>(curr);
                 assert( node );
@@ -140 +153 @@
                 prev = curr;
         } // for
+        // conver from StatementNode list to Statement list
         StatementNode2 *node = dynamic_cast<StatementNode2 *>(prev);
         std::list<Statement *> stmts;
         buildList( stmt, stmts );
-        CaseStmt * caseStmt;
-        caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
+        // 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;
@@ -177 +191 @@
                                 os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
                                 decl->print( os, indent + 2 * ParseNode::indent_by );
-                        } else if ( isCatchRest ) {
+                        } else if ( catchAny ) {
                                 os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
                         } else {
@@ -191 +205 @@
                         block->printList( os, indent + 2 * ParseNode::indent_by );
                 } // if
-                if ( target ) {
-                        os << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl;
-                } // if
                 break;
         } // switch
@@ -208 +219 @@
         } // if
 
-        // try {
         buildList<Statement, StatementNode>( get_block(), branches );
 
@@ -214 +224 @@
           case Decl:
                 return new DeclStmt( labs, maybeBuild< Declaration >( decl ) );
+                assert( false );
           case Exp:
-                {
-                        Expression *e = maybeBuild< Expression >( get_control() );
-
-                        if ( e )
-                                return new ExprStmt( labs, e );
-                        else
-                                return new NullStmt( labs );
-                }
+                // {
+                //      Expression *e = maybeBuild< Expression >( get_control() );
+
+                //      if ( e )
+                //              return new ExprStmt( labs, e );
+                //      else
+                //              return new NullStmt( labs );
+                // }
                 assert( false );
           case If:
@@ -279 +290 @@
                 assert( false );
           case Goto:
-                // {
-                //      if ( get_target() == "" ) {                                     // computed goto
-                //              assert( get_control() != 0 );
-                //              return new BranchStmt( labs, maybeBuild<Expression>(get_control()), BranchStmt::Goto );
-                //      } // if
-
-                //      return new BranchStmt( labs, get_target(), BranchStmt::Goto );
-                // }
                 assert( false );
           case Break:
-                // return new BranchStmt( labs, get_target(), BranchStmt::Break );
                 assert( false );
           case Continue:
-                // return new BranchStmt( labs, get_target(), BranchStmt::Continue );
                 assert( false );
           case Return:
@@ -303 +304 @@
                 assert( false );
           case Try:
-                {
-                        assert( branches.size() >= 0 );
-                        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front());
-                        branches.pop_front();
-                        FinallyStmt *finallyBlock = 0;
-                        if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
-                                branches.pop_back();
-                        } // if
-                        return new TryStmt( labs, tryBlock, branches, finallyBlock );
-                }
+                // {
+                //      assert( branches.size() >= 0 );
+                //      CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front());
+                //      branches.pop_front();
+                //      FinallyStmt *finallyBlock = 0;
+                //      if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
+                //              branches.pop_back();
+                //      } // if
+                //      return new TryStmt( labs, tryBlock, branches, finallyBlock );
+                // }
+                assert( false );
           case Catch:
-                {
-                        assert( branches.size() == 1 );
-
-                        return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), isCatchRest );
-                }
+                // {
+                //      assert( branches.size() == 1 );
+
+                //      return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), catchAny );
+                // }
+                assert( false );
           case Finally:
-                {
-                        assert( branches.size() == 1 );
-                        CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() );
-                        assert( block != 0 );
-
-                        return new FinallyStmt( labs, block );
-                }
+                // {
+                //      assert( branches.size() == 1 );
+                //      CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() );
+                //      assert( block != 0 );
+
+                //      return new FinallyStmt( labs, block );
+                // }
+                assert( false );
           case Asm:
                 assert( false );
           default:
-                // shouldn't be here
+                assert( false );
                 return 0;
         } // switch
@@ -422 +426 @@
 }
 
+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));
+        assert( tryBlock );
+        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 );
+        assert( branches.size() == 1 );
+        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
+}
+Statement *build_finally( StatementNode *stmt ) {
+        std::list<Statement *> branches;
+        buildList<Statement, StatementNode>( stmt, branches );
+        assert( branches.size() == 1 );
+        return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
+}
+
 
 CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
-
-CompoundStmtNode::CompoundStmtNode( const string *name_ ) : StatementNode( name_ ), first( 0 ), last( 0 ) {}
 
 CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ) : first( stmt ) {
@@ -441 +464 @@
 void CompoundStmtNode::add_statement( StatementNode *stmt ) {
         if ( stmt != 0 ) {
-                last->set_link( stmt );
-                last = ( StatementNode *)( stmt->get_link());
+                last->set_last( stmt );
+                last = ( StatementNode *)( stmt->get_next());
         } // if
 }