Changes in src/AST/Stmt.hpp [c86b08d:94c98f0e]

File:

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

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 20 14:34:00 2022
-// Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 
@@ -205 +205 @@
 };
 
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
+
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
@@ -212 +215 @@
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
-        bool isDoWhile;
+        WhileDoKind isDoWhile;
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
@@ -364 +367 @@
   public:
         ptr<CompoundStmt> then;
-        enum Type { None, Coroutine, Generator } type = None;
-
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        enum Kind { None, Coroutine, Generator } kind = None;
+
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -375 +378 @@
 };
 
-// Base class of WaitFor/WaitUntil statements
-// form: KEYWORD(...) ... timeout(...) ... else ...
-class WaitStmt : public Stmt { 
-  public:
-    ptr<Expr> timeout_time;
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
+class WaitForStmt final : public Stmt {
+  public:
+        std::vector<ptr<WaitForClause>> clauses;
+        ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
@@ -385 +388 @@
         ptr<Expr> else_cond;
 
-    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+        WaitForStmt( 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;
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
+// Clause in a waitfor statement: waitfor (..., ...) ...
+class WaitForClause final : public StmtClause {
+  public:
+        ptr<Expr> target_func;
+        std::vector<ptr<Expr>> target_args;
         ptr<Stmt> stmt;
-        ptr<Expr> when_cond;
-
-        WhenClause( const CodeLocation & loc )
+        ptr<Expr> cond;
+
+        WaitForClause( 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 = {} )
-                : WaitStmt(loc, std::move(labels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
-        MUTATE_FRIEND
-};
-
-class WaitForClause final : public WhenClause {
-  public:
-        std::vector<ptr<Expr>> target_args;
-
-        WaitForClause( const CodeLocation & 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
 };
@@ -527 +458 @@
         MUTATE_FRIEND
 };
+
 } // namespace ast