Changes in src/Parser/StatementNode.cc [32d6fdc:c86b08d]

File:

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

src/Parser/StatementNode.cc

@@ -11 +11 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 11 10:16:00 2023
-// Update Count     : 428
+// Last Modified On : Tue Apr  4 11:40:00 2023
+// Update Count     : 427
 //
-
-#include "StatementNode.h"
 
 #include <cassert>                 // for assert, strict_dynamic_cast, assertf
@@ -25 +23 @@
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for maybeMoveBuild, maybeBuild
-#include "DeclarationNode.h"       // for DeclarationNode
-#include "ExpressionNode.h"        // for ExpressionNode
+#include "ParseNode.h"             // for StatementNode, ExpressionNode, bui...
 #include "parserutility.h"         // for notZeroExpr
 
@@ -32 +29 @@
 
 using namespace std;
-
-// Some helpers for cases that really want a single node but check for lists.
-static const ast::Stmt * buildMoveSingle( StatementNode * node ) {
-        std::vector<ast::ptr<ast::Stmt>> list;
-        buildMoveList( node, list );
-        assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" );
-        return list.front().release();
-}
-
-static const ast::Stmt * buildMoveOptional( StatementNode * node ) {
-        std::vector<ast::ptr<ast::Stmt>> list;
-        buildMoveList( node, list );
-        assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" );
-        return list.empty() ? nullptr : list.front().release();
-}
 
 StatementNode::StatementNode( DeclarationNode * decl ) {
@@ -71 +53 @@
 } // StatementNode::StatementNode
 
-StatementNode * StatementNode::add_label(
-                const CodeLocation & location,
-                const std::string * name,
-                DeclarationNode * attr ) {
-        stmt->labels.emplace_back( location,
-                *name,
-                attr ? std::move( attr->attributes )
-                        : std::vector<ast::ptr<ast::Attribute>>{} );
-        delete attr;
-        delete name;
-        return this;
-}
-
-ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) {
-        ClauseNode * prev = this;
+StatementNode * StatementNode::append_last_case( StatementNode * stmt ) {
+        StatementNode * prev = this;
         // find end of list and maintain previous pointer
-        for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) {
-                ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr);
+        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
+                StatementNode * node = strict_dynamic_cast< StatementNode * >(curr);
+                assert( nullptr == node->stmt.get() );
                 assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) );
                 prev = curr;
         } // for
-        ClauseNode * node = dynamic_cast< ClauseNode * >(prev);
         // convert from StatementNode list to Statement list
+        StatementNode * node = dynamic_cast< StatementNode * >(prev);
         std::vector<ast::ptr<ast::Stmt>> stmts;
         buildMoveList( stmt, stmts );
@@ -103 +73 @@
         stmts.clear();
         return this;
-} // ClauseNode::append_last_case
+} // StatementNode::append_last_case
 
 ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) {
@@ -127 +97 @@
                 for ( ast::ptr<ast::Stmt> & stmt : inits ) {
                         // build the && of all of the declared variables compared against 0
+                        //auto declStmt = strict_dynamic_cast<ast::DeclStmt *>( stmt );
                         auto declStmt = stmt.strict_as<ast::DeclStmt>();
+                        //ast::DeclWithType * dwt = strict_dynamic_cast<ast::DeclWithType *>( declStmt->decl );
                         auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
                         ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
@@ -141 +113 @@
         ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
 
-        ast::Stmt const * astthen = buildMoveSingle( then );
-        ast::Stmt const * astelse = buildMoveOptional( else_ );
+        std::vector<ast::ptr<ast::Stmt>> aststmt;
+        buildMoveList( then, aststmt );
+        assert( aststmt.size() == 1 );
+        ast::Stmt const * astthen = aststmt.front().release();
+
+        ast::Stmt const * astelse = nullptr;
+        if ( else_ ) {
+                std::vector<ast::ptr<ast::Stmt>> aststmt;
+                buildMoveList( else_, aststmt );
+                assert( aststmt.size() == 1 );
+                astelse = aststmt.front().release();
+        } // if
 
         return new ast::IfStmt( location, astcond, astthen, astelse,
@@ -149 +131 @@
 } // build_if
 
-ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) {
+// Temporary work around. Split StmtClause off from StatementNode.
+template<typename clause_t>
+static void buildMoveClauseList( StatementNode * firstNode,
+                std::vector<ast::ptr<clause_t>> & output ) {
+        SemanticErrorException errors;
+        std::back_insert_iterator<std::vector<ast::ptr<clause_t>>>
+                out( output );
+        StatementNode * cur = firstNode;
+
+        while ( cur ) {
+                try {
+                        auto clause = cur->clause.release();
+                        if ( auto result = dynamic_cast<clause_t *>( clause ) ) {
+                                *out++ = result;
+                        } else {
+                                assertf(false, __PRETTY_FUNCTION__ );
+                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
+                        } // if
+                } catch( SemanticErrorException & e ) {
+                        errors.append( e );
+                } // try
+                ParseNode * temp = cur->get_next();
+                // Should not return nullptr, then it is non-homogeneous:
+                cur = dynamic_cast<StatementNode *>( temp );
+                if ( !cur && temp ) {
+                        SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
+                } // if
+        } // while
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        } // if
+        // Usually in the wrapper.
+        delete firstNode;
+}
+
+ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
         std::vector<ast::ptr<ast::CaseClause>> aststmt;
-        buildMoveList( stmt, aststmt );
+        buildMoveClauseList( stmt, aststmt );
         // If it is not a switch it is a choose statement.
         if ( ! isSwitch ) {
@@ -173 +190 @@
 } // build_switch
 
-ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) {
+ast::CaseClause * build_case( ExpressionNode * ctl ) {
         // stmt starts empty and then added to
         auto expr = maybeMoveBuild( ctl );
-        return new ast::CaseClause( location, expr, {} );
+        return new ast::CaseClause( expr->location, expr, {} );
 } // build_case
 
@@ -188 +205 @@
         ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
 
+        std::vector<ast::ptr<ast::Stmt>> aststmt;                                               // loop body, compound created if empty
+        buildMoveList( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+
+        std::vector<ast::ptr<ast::Stmt>> astelse;                                               // else clause, maybe empty
+        buildMoveList( else_, astelse );
+        assert( astelse.size() <= 1 );
+
         return new ast::WhileDoStmt( location,
                 astcond,
-                buildMoveSingle( stmt ),
-                buildMoveOptional( else_ ),
+                aststmt.front(),
+                astelse.empty() ? nullptr : astelse.front().release(),
                 std::move( astinit ),
-                ast::While
+                false
         );
 } // build_while
 
 ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        std::vector<ast::ptr<ast::Stmt>> aststmt;                                               // loop body, compound created if empty
+        buildMoveList( stmt, aststmt );
+        assert( aststmt.size() == 1 );                                          // compound created if empty
+
+        std::vector<ast::ptr<ast::Stmt>> astelse;                                               // else clause, maybe empty
+        buildMoveList( else_, astelse );
+        assert( astelse.size() <= 1 );
+
         // do-while cannot have declarations in the contitional, so init is always empty
         return new ast::WhileDoStmt( location,
                 notZeroExpr( maybeMoveBuild( ctl ) ),
-                buildMoveSingle( stmt ),
-                buildMoveOptional( else_ ),
+                aststmt.front(),
+                astelse.empty() ? nullptr : astelse.front().release(),
                 {},
-                ast::DoWhile
+                true
         );
 } // build_do_while
@@ -218 +251 @@
         astincr = maybeMoveBuild( forctl->change );
         delete forctl;
+
+        std::vector<ast::ptr<ast::Stmt>> aststmt;                                               // loop body, compound created if empty
+        buildMoveList( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+
+        std::vector<ast::ptr<ast::Stmt>> astelse;                                               // else clause, maybe empty
+        buildMoveList( else_, astelse );
+        assert( astelse.size() <= 1 );
 
         return new ast::ForStmt( location,
@@ -223 +264 @@
                 astcond,
                 astincr,
-                buildMoveSingle( stmt ),
-                buildMoveOptional( else_ )
+                aststmt.front(),
+                astelse.empty() ? nullptr : astelse.front().release()
         );
 } // build_for
@@ -285 +326 @@
 } // build_resume_at
 
-ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) {
+ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
         std::vector<ast::ptr<ast::CatchClause>> aststmt;
-        buildMoveList( catch_, aststmt );
+        buildMoveClauseList( catch_, aststmt );
         ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) );
         ast::FinallyClause * finallyBlock = nullptr;
@@ -301 +342 @@
 
 ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
+        std::vector<ast::ptr<ast::Stmt>> aststmt;
+        buildMoveList( body, aststmt );
+        assert( aststmt.size() == 1 );
         return new ast::CatchClause( location,
                 kind,
                 maybeMoveBuild( decl ),
                 maybeMoveBuild( cond ),
-                buildMoveSingle( body )
+                aststmt.front().release()
         );
 } // build_catch
 
 ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Stmt>> aststmt;
+        buildMoveList( stmt, aststmt );
+        assert( aststmt.size() == 1 );
         return new ast::FinallyClause( location,
-                strict_dynamic_cast<const ast::CompoundStmt *>(
-                        buildMoveSingle( stmt )
-                )
+                aststmt.front().strict_as<ast::CompoundStmt>()
         );
 } // build_finally
 
-ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) {
-        return new ast::SuspendStmt( location,
-                strict_dynamic_cast<const ast::CompoundStmt *, nullptr>(
-                        buildMoveOptional( then )
-                ),
-                kind
-        );
+ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Type type ) {
+        std::vector<ast::ptr<ast::Stmt>> stmts;
+        buildMoveList( then, stmts );
+        ast::CompoundStmt const * then2 = nullptr;
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                then2 = stmts.front().strict_as<ast::CompoundStmt>();
+        }
+        auto node = new ast::SuspendStmt( location, then2, ast::SuspendStmt::None );
+        node->type = type;
+        return node;
 } // build_suspend
 
 ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
         auto clause = new ast::WaitForClause( location );
-        clause->target_func = maybeBuild( targetExpr );
+        clause->target = maybeBuild( targetExpr );
         clause->stmt = maybeMoveBuild( stmt );
-        clause->cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
 
         ExpressionNode * next = dynamic_cast<ExpressionNode *>( targetExpr->get_next() );
@@ -359 +408 @@
         return existing;
 } // build_waitfor_timeout
+
+ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( targetExpr );
+    return new ast::WaitUntilStmt::ClauseNode( clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
+}
+ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) {
+    ast::WhenClause * clause = new ast::WhenClause( loc );
+    clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+    clause->stmt = maybeMoveBuild( stmt );
+    clause->target = maybeMoveBuild( timeout );
+    return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::TIMEOUT, clause );
+}
+
+ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) {
+    ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc );
+    retStmt->predicateTree = root;
+    
+    // iterative tree traversal
+    std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal
+    ast::WaitUntilStmt::ClauseNode * currNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr;
+    ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout
+    nodeStack.push_back(root);
+
+    do {
+        currNode = nodeStack.back();
+        nodeStack.pop_back(); // remove node since it will be processed
+
+        switch (currNode->op) {
+            case ast::WaitUntilStmt::ClauseNode::LEAF:
+                retStmt->clauses.push_back(currNode->leaf);
+                break;
+            case ast::WaitUntilStmt::ClauseNode::ELSE:
+                retStmt->else_stmt = currNode->leaf->stmt 
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                
+                retStmt->else_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+
+                delete currNode->leaf;
+                break;
+            case ast::WaitUntilStmt::ClauseNode::TIMEOUT:
+                retStmt->timeout_time = currNode->leaf->target 
+                    ? ast::deepCopy( currNode->leaf->target )
+                    : nullptr;
+                retStmt->timeout_stmt = currNode->leaf->stmt
+                    ? ast::deepCopy( currNode->leaf->stmt )
+                    : nullptr;
+                retStmt->timeout_cond = currNode->leaf->when_cond
+                    ? ast::deepCopy( currNode->leaf->when_cond )
+                    : nullptr;
+
+                delete currNode->leaf;
+                break;
+            default:
+                nodeStack.push_back( currNode->right ); // process right after left
+                nodeStack.push_back( currNode->left );
+
+                // Cut else/timeout out of the tree
+                if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) {
+                    if ( lastInternalNode )
+                        lastInternalNode->right = currNode->left;
+                    else    // if not set then root is LEFT_OR 
+                        retStmt->predicateTree = currNode->left;
+    
+                    currNode->left = nullptr;
+                    cleanup = currNode;
+                }
+                
+                lastInternalNode = currNode;
+                break;
+        }
+    } while ( !nodeStack.empty() );
+
+    if ( cleanup ) delete cleanup;
+
+    return retStmt;
+}
 
 ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) {
@@ -387 +525 @@
 
 // Question
-ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
+ast::Stmt * build_asm( const CodeLocation & location, bool voltile, ast::Expr * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         std::vector<ast::ptr<ast::Expr>> out, in;
         std::vector<ast::ptr<ast::ConstantExpr>> clob;
@@ -395 +533 @@
         buildMoveList( clobber, clob );
         return new ast::AsmStmt( location,
-                is_volatile,
-                maybeMoveBuild( instruction ),
+                voltile,
+                instruction,
                 std::move( out ),
                 std::move( in ),