Changes in src/AST/Stmt.hpp [a1da039:eb779d5]

File:

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

src/AST/Stmt.hpp

@@ -28 +28 @@
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
 #define MUTATE_FRIEND                                                                                                   \
-        template<typename node_t> friend node_t * mutate(const node_t * node); \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
@@ -340 +340 @@
 
         CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                        const Stmt * body )
+                           const Stmt * body )
                 : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
 
@@ -380 +380 @@
 // Base class of WaitFor/WaitUntil statements
 // form: KEYWORD(...) ... timeout(...) ... else ...
-class WaitStmt : public Stmt {
-  public:
-        ptr<Expr> timeout_time;
+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 = {} )
+    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
   private:
-        WaitStmt * clone() const override = 0;
+    WaitStmt * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -444 +444 @@
 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;
-                }
-        };
+    // 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;
+    ClauseNode * predicateTree;
 
         WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : WaitStmt(loc, std::move(labels)) {}
 
-        ~WaitUntilStmt() { delete predicateTree; }
+    ~WaitUntilStmt() { delete predicateTree; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -522 +522 @@
         std::vector<ptr<Expr>> mutexObjs;
 
-        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
+        MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
                            const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}