Changeset 3982384 for src/AST/Stmt.hpp

Timestamp:

May 17, 2023, 1:35:09 AM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, master

Children:

f11010e

Parents:

6e4c44d (diff), 8db4708 (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:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/AST/Stmt.hpp (modified) (3 diffs)

src/AST/Stmt.hpp

@@ -378 +378 @@
 };
 
-// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
-class WaitForStmt final : public Stmt {
-  public:
-        std::vector<ptr<WaitForClause>> clauses;
-        ptr<Expr> timeout_time;
+// Base class of WaitFor/WaitUntil statements
+// form: KEYWORD(...) ... timeout(...) ... else ...
+class WaitStmt : public Stmt { 
+  public:
+    ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
@@ -388 +388 @@
         ptr<Expr> else_cond;
 
+    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)) {}
+
+  private:
+    WaitStmt * clone() const override = 0;
+        MUTATE_FRIEND
+};
+
+// Base class for WaitFor/WaitUntil clauses
+// form: when( when_cond ) KEYWORD( target ) stmt
+class WhenClause : public StmtClause {
+  public:
+        ptr<Expr> target;
+        ptr<Stmt> stmt;
+        ptr<Expr> when_cond;
+
+        WhenClause( const CodeLocation & loc )
+                : StmtClause( loc ) {}
+
+        const WhenClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WhenClause * clone() const override { return new WhenClause{ *this }; }
+        MUTATE_FRIEND
+};
+
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
+class WaitForStmt final : public WaitStmt {
+  public:
+        std::vector<ptr<WaitForClause>> clauses;
+
         WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)) {}
+                : WaitStmt(loc, std::move(labels)) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -398 +428 @@
 
 // Clause in a waitfor statement: waitfor (..., ...) ...
-class WaitForClause final : public StmtClause {
-  public:
-        ptr<Expr> target_func;
+class WaitForClause final : public WhenClause {
+  public:
         std::vector<ptr<Expr>> target_args;
-        ptr<Stmt> stmt;
-        ptr<Expr> cond;
 
         WaitForClause( const CodeLocation & loc )
-                : StmtClause( loc ) {}
+                : WhenClause( loc ) {}
 
         const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
   private:
         WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+        MUTATE_FRIEND
+};
+
+// waituntil statement: when (...) waituntil (...) ... timeout(...) ... else ...
+class WaitUntilStmt final : public WaitStmt {
+  public:
+    // Non-ast node used during compilation to store data needed to generate predicates
+    //    and set initial status values for clauses
+    // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+    struct ClauseNode { 
+        enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+        // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+
+        ClauseNode * left;
+        ClauseNode * right;
+        WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+
+        bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+        bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+        bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+
+        ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+            : op(op), left(left), right(right), leaf(nullptr), 
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( Op op, WhenClause * leaf )
+            : op(op), left(nullptr), right(nullptr), leaf(leaf),
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+        
+        ~ClauseNode() {
+            if ( left ) delete left;
+            if ( right ) delete right;
+        }
+    };
+
+        std::vector<ptr<WhenClause>> clauses;
+    ClauseNode * predicateTree;
+
+        WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : WaitStmt(loc, std::move(labels)) {}
+
+    ~WaitUntilStmt() { delete predicateTree; }
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WaitUntilStmt * clone() const override { return new WaitUntilStmt{ *this }; }
         MUTATE_FRIEND
 };