Changeset 2a301ff for src/Parser/StatementNode.cc

Timestamp:

Aug 31, 2023, 11:31:15 PM (13 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Resolve conflict

File:

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

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Author           : Rodolfo G. Esteves
 // 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 By : Peter A. Buhr
+// Last Modified On : Fri Aug 11 11:44:15 2023
+// Update Count     : 429
 //
 
@@ -361 +361 @@
 
 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::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::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 * 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::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;
 }