Changeset 3982384 for src

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

Location:

src

Files:

• AST/Convert.cpp (modified) (4 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (7 diffs)
• AST/Pass.proto.hpp (modified) (6 diffs)
• AST/Print.cpp (modified) (4 diffs)
• AST/Stmt.hpp (modified) (3 diffs)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Concurrency/WaitforNew.cpp (modified) (2 diffs)
• Concurrency/Waituntil.cpp (added)
• Concurrency/Waituntil.hpp (added)
• Concurrency/module.mk (modified) (1 diff)
• Parser/StatementNode.cc (modified) (2 diffs)
• Parser/StatementNode.h (modified) (1 diff)
• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• main.cc (modified) (2 diffs)

src/AST/Convert.cpp

@@ -567 +567 @@
         }
 
+    const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                // There is no old-AST WhenClause, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
+
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 if ( inCache( node ) ) return nullptr;
@@ -573 +579 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().accept1( clause->target ),
                                         get<Expression>().acceptL( clause->target_args ),
                                 },
                                 get<Statement>().accept1( clause->stmt ),
-                                get<Expression>().accept1( clause->cond ),
+                                get<Expression>().accept1( clause->when_cond ),
                         });
                 }
@@ -594 +600 @@
         const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 // There is no old-AST WaitForClause, so this should never be called.
+                assert( !node );
+                return nullptr;
+        }
+
+    const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+        // There is no old-AST WaitUntilStmt, so this should never be called.
                 assert( !node );
                 return nullptr;
@@ -2158 +2170 @@
                         auto clause = new ast::WaitForClause( old->location );
 
-                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target = GET_ACCEPT_1(clauses[i].target.function, Expr);
                         clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
                         clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
-                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+                        clause->when_cond = GET_ACCEPT_1(clauses[i].condition, Expr);
 
                         stmt->clauses.push_back( clause );

src/AST/Fwd.hpp

@@ -58 +58 @@
 class FinallyClause;
 class SuspendStmt;
+class WhenClause;
 class WaitForStmt;
 class WaitForClause;
+class WaitUntilStmt;
 class WithStmt;
 class DeclStmt;

src/AST/Node.cpp

@@ -174 +174 @@
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WhenClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WaitUntilStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -162 +162 @@
         const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
         const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
+    const ast::WhenClause *       visit( const ast::WhenClause           * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
+    const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
         const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -22 +22 @@
 #include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
-#include "Common/Iterate.hpp"
 
 #define VISIT_START( node ) \
@@ -127 +126 @@
         }
 
-        template< typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::result1< node_t >::apply( object_t * object, field_t super_t::* field ) {
-                object->*field = value;
-        }
-
         template< typename core_t >
         template< typename node_t >
@@ -234 +227 @@
 
                 return {true, compound};
-        }
-
-        template< template <class...> class container_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() <= values.size() );
-
-                auto cit = enumerate(container).begin();
-
-                container_t<ptr<Stmt>> nvals;
-                for (delta & d : values) {
-                        if ( d.is_old ) {
-                                __pedantic_pass_assert( cit.idx <= d.old_idx );
-                                std::advance( cit, d.old_idx - cit.idx );
-                                nvals.push_back( std::move( (*cit).val) );
-                        } else {
-                                nvals.push_back( std::move(d.new_val) );
-                        }
-                }
-
-                container = std::move(nvals);
-        }
-
-        template< template <class...> class container_t >
-        template< template <class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Stmt>> * stmts ) {
-                if (!stmts || stmts->empty()) return;
-
-                std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
-                                return delta( stmt.release(), -1, false );
-                        });
-                stmts->clear();
-                differs = true;
-        }
-
-        template< template<class...> class container_t >
-        template< template<class...> class incontainer_t >
-        void __pass::resultNstmt< container_t >::take_all( incontainer_t<ptr<Decl>> * decls ) {
-                if (!decls || decls->empty()) return;
-
-                std::transform(decls->begin(), decls->end(), std::back_inserter( values ),
-                        [](ast::ptr<ast::Decl>& decl) -> delta {
-                                auto loc = decl->location;
-                                auto stmt = new DeclStmt( loc, decl.release() );
-                                return delta( stmt, -1, false );
-                        });
-                decls->clear();
-                differs = true;
         }
 
@@ -353 +296 @@
 
                 return new_kids;
-        }
-
-        template< template <class...> class container_t, typename node_t >
-        template< typename object_t, typename super_t, typename field_t >
-        void __pass::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
-                auto & container = object->*field;
-                __pedantic_pass_assert( container.size() == values.size() );
-
-                for(size_t i = 0; i < container.size(); i++) {
-                        // Take all the elements that are different in 'values'
-                        // and swap them into 'container'
-                        if( values[i] != nullptr ) swap(container[i], values[i]);
-                }
-
-                // Now the original containers should still have the unchanged values
-                // but also contain the new values
         }
 
@@ -1066 +993 @@
 
 //--------------------------------------------------------------------------
+// WhenClause
+template< typename core_t >
+const ast::WhenClause * ast::Pass< core_t >::visit( const ast::WhenClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WhenClause::target );
+                maybe_accept( node, &WhenClause::stmt );
+                maybe_accept( node, &WhenClause::when_cond );
+        }
+
+        VISIT_END( WhenClause, node );
+}
+
+//--------------------------------------------------------------------------
 // WaitForStmt
 template< typename core_t >
@@ -1090 +1032 @@
 
         if ( __visit_children() ) {
-                maybe_accept( node, &WaitForClause::target_func );
+                maybe_accept( node, &WaitForClause::target );
                 maybe_accept( node, &WaitForClause::target_args );
                 maybe_accept( node, &WaitForClause::stmt );
-                maybe_accept( node, &WaitForClause::cond );
+                maybe_accept( node, &WaitForClause::when_cond );
         }
 
         VISIT_END( WaitForClause, node );
+}
+
+//--------------------------------------------------------------------------
+// WaitUntilStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitUntilStmt * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WaitUntilStmt::clauses );
+                maybe_accept( node, &WaitUntilStmt::timeout_time );
+                maybe_accept( node, &WaitUntilStmt::timeout_stmt );
+                maybe_accept( node, &WaitUntilStmt::timeout_cond );
+                maybe_accept( node, &WaitUntilStmt::else_stmt );
+                maybe_accept( node, &WaitUntilStmt::else_cond );
+        }
+
+        VISIT_END( Stmt, node );
 }
 
@@ -2203 +2163 @@
 }
 
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert
 #undef VISIT_START
 #undef VISIT_END

src/AST/Pass.proto.hpp

@@ -17 +17 @@
 // IWYU pragma: private, include "Pass.hpp"
 
+#include "Common/Iterate.hpp"
 #include "Common/Stats/Heap.h"
 namespace ast {
@@ -24 +25 @@
         template<typename node_t> node_t * deepCopy( const node_t * );
 }
+
+#ifdef PEDANTIC_PASS_ASSERT
+#define __pedantic_pass_assert(...) assert (__VA_ARGS__)
+#define __pedantic_pass_assertf(...) assertf(__VA_ARGS__)
+#else
+#define __pedantic_pass_assert(...)
+#define __pedantic_pass_assertf(...)
+#endif
 
 namespace ast::__pass {
@@ -130 +139 @@
 
         template< typename object_t, typename super_t, typename field_t >
-        void apply( object_t *, field_t super_t::* field );
+        void apply( object_t * object, field_t super_t::* field ) {
+                object->*field = value;
+        }
 };
 
@@ -150 +161 @@
 
         template< typename object_t, typename super_t, typename field_t >
-        void apply( object_t *, field_t super_t::* field );
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & container = object->*field;
+                __pedantic_pass_assert( container.size() <= values.size() );
+
+                auto cit = enumerate(container).begin();
+
+                container_t<ptr<Stmt>> nvals;
+                for ( delta & d : values ) {
+                        if ( d.is_old ) {
+                                __pedantic_pass_assert( cit.idx <= d.old_idx );
+                                std::advance( cit, d.old_idx - cit.idx );
+                                nvals.push_back( std::move( (*cit).val ) );
+                        } else {
+                                nvals.push_back( std::move( d.new_val ) );
+                        }
+                }
+
+                container = std::move(nvals);
+        }
 
         template< template<class...> class incontainer_t >
-        void take_all( incontainer_t<ptr<Stmt>> * stmts );
+        void take_all( incontainer_t<ptr<Stmt>> * stmts ) {
+                if ( !stmts || stmts->empty() ) return;
+
+                std::transform( stmts->begin(), stmts->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Stmt>& stmt) -> delta {
+                                return delta( stmt.release(), -1, false );
+                        });
+                stmts->clear();
+                differs = true;
+        }
 
         template< template<class...> class incontainer_t >
-        void take_all( incontainer_t<ptr<Decl>> * decls );
+        void take_all( incontainer_t<ptr<Decl>> * decls ) {
+                if ( !decls || decls->empty() ) return;
+
+                std::transform( decls->begin(), decls->end(), std::back_inserter( values ),
+                        [](ast::ptr<ast::Decl>& decl) -> delta {
+                                ast::Decl const * d = decl.release();
+                                return delta( new DeclStmt( d->location, d ), -1, false );
+                        });
+                decls->clear();
+                differs = true;
+        }
 };
 
@@ -166 +214 @@
 
         template< typename object_t, typename super_t, typename field_t >
-        void apply( object_t *, field_t super_t::* field );
+        void apply( object_t * object, field_t super_t::* field ) {
+                field_t & container = object->*field;
+                __pedantic_pass_assert( container.size() == values.size() );
+
+                for ( size_t i = 0; i < container.size(); ++i ) {
+                        // Take all the elements that are different in 'values'
+                        // and swap them into 'container'
+                        if ( values[i] != nullptr ) swap(container[i], values[i]);
+                }
+                // Now the original containers should still have the unchanged values
+                // but also contain the new values.
+        }
 };
 
@@ -517 +576 @@
 
 } // namespace ast::__pass
+
+#undef __pedantic_pass_assertf
+#undef __pedantic_pass_assert

src/AST/Print.cpp

@@ -208 +208 @@
         }
 
+    void print( const ast::WaitStmt * node ) {
+                if ( node->timeout_time ) {
+                        os << indent-1 << "timeout of:" << endl;
+                        node->timeout_time->accept( *this );
+
+                        if ( node->timeout_stmt ) {
+                                os << indent-1 << "... with statment:" << endl;
+                                node->timeout_stmt->accept( *this );
+                        }
+
+                        if ( node->timeout_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->timeout_cond->accept( *this );
+                        }
+                }
+
+                if ( node->else_stmt ) {
+                        os << indent-1 << "else:" << endl;
+                        node->else_stmt->accept( *this );
+
+                        if ( node->else_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->else_cond->accept( *this );
+                        }
+                }
+        }
+
         void preprint( const ast::NamedTypeDecl * node ) {
                 if ( ! node->name.empty() ) {
@@ -756 +783 @@
         }
 
+        virtual const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
+                os << indent-1 << "target: ";
+                safe_print( node->target );
+
+                if ( node->stmt ) {
+                        os << indent-1 << "... with statment:" << endl;
+                        node->stmt->accept( *this );
+                }
+
+                if ( node->when_cond ) {
+                        os << indent-1 << "... with when condition:" << endl;
+                        node->when_cond->accept( *this );
+                }
+
+                return node;
+        }
+
         virtual const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 os << "Waitfor Statement" << endl;
@@ -793 +837 @@
         virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 os << indent-1 << "target function: ";
-                safe_print( node->target_func );
+                safe_print( node->target );
 
                 if ( !node->target_args.empty() ) {
@@ -807 +851 @@
                 }
 
-                if ( node->cond ) {
+                if ( node->when_cond ) {
                         os << indent-1 << "... with condition:" << endl;
-                        node->cond->accept( *this );
-                }
-
+                        node->when_cond->accept( *this );
+                }
+
+                return node;
+        }
+
+    virtual const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
+                os << "Waituntil Statement" << endl;
+                indent += 2;
+                for( const auto & clause : node->clauses ) {
+                        clause->accept( *this );
+                }
+        print(node);    // calls print( const ast::WaitStmt * node )
                 return node;
         }

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
 };

src/AST/Visitor.hpp

@@ -50 +50 @@
     virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
+    virtual const ast::WhenClause *       visit( const ast::WhenClause           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::WaitUntilStmt        * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
     virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;

src/Common/CodeLocationTools.cpp

@@ -128 +128 @@
     macro(FinallyClause, FinallyClause) \
     macro(SuspendStmt, Stmt) \
+    macro(WhenClause, WhenClause) \
     macro(WaitForStmt, Stmt) \
     macro(WaitForClause, WaitForClause) \
+    macro(WaitUntilStmt, Stmt) \
     macro(WithStmt, Decl) \
     macro(NullStmt, NullStmt) \

src/Concurrency/WaitforNew.cpp

@@ -305 +305 @@
 
         const ast::VariableExpr * variableExpr =
-                clause->target_func.as<ast::VariableExpr>();
+                clause->target.as<ast::VariableExpr>();
         ast::Expr * castExpr = new ast::CastExpr(
                 location,
                 new ast::CastExpr(
                         location,
-                        clause->target_func,
+                        clause->target,
                         ast::deepCopy( variableExpr->result.get() ),
                         ast::GeneratedCast ),
@@ -325 +325 @@
 
         ResolveContext context{ symtab, transUnit().global };
-        out->push_back( maybeCond( location, clause->cond.get(), {
+        out->push_back( maybeCond( location, clause->when_cond.get(), {
                 makeAccStmt( location, acceptables, index, "is_dtor",
-                        detectIsDtor( location, clause->target_func ), context ),
+                        detectIsDtor( location, clause->target ), context ),
                 makeAccStmt( location, acceptables, index, "func",
                         funcExpr, context ),

src/Concurrency/module.mk

@@ -23 +23 @@
         Concurrency/WaitforNew.cpp \
         Concurrency/Waitfor.cc \
-        Concurrency/Waitfor.h 
+        Concurrency/Waitfor.h \
+        Concurrency/Waituntil.cpp \
+        Concurrency/Waituntil.hpp

src/Parser/StatementNode.cc

@@ -328 +328 @@
 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 +359 @@
         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 ) {

src/Parser/StatementNode.h

@@ -100 +100 @@
 ast::WaitForStmt * build_waitfor_else( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt );
 ast::WaitForStmt * build_waitfor_timeout( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
+ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt );
+ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt );
+ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
+ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root );
 ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );
 ast::Stmt * build_mutex( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sat Mar 25 08:09:03 2023
- * Update Count     : 768
+ * Last Modified On : Tue May  2 08:45:21 2023
+ * Update Count     : 769
  */
 
@@ -258 +258 @@
 enable                  { KEYWORD_RETURN(ENABLE); }                             // CFA
 enum                    { KEYWORD_RETURN(ENUM); }
+exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 __extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
-exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
 extern                  { KEYWORD_RETURN(EXTERN); }
 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA

src/Parser/parser.yy

@@ -307 +307 @@
         ClauseNode * clause;
         ast::WaitForStmt * wfs;
+    ast::WaitUntilStmt::ClauseNode * wucn;
         CondCtl * ifctl;
         ForCtrl * forctl;
@@ -427 +428 @@
 %type<expr> when_clause                                 when_clause_opt                         waitfor         waituntil               timeout
 %type<stmt> waitfor_statement                           waituntil_statement
-%type<wfs> wor_waitfor_clause                   waituntil_clause                        wand_waituntil_clause   wor_waituntil_clause
+%type<wfs> wor_waitfor_clause
+%type<wucn> waituntil_clause                    wand_waituntil_clause       wor_waituntil_clause
 
 // declarations
@@ -1685 +1687 @@
 waituntil_clause:
         when_clause_opt waituntil statement
-                { printf( "waituntil_clause 1\n" ); $$ = nullptr; }
+                { $$ = build_waituntil_clause( yylloc, $1, $2, maybe_build_compound( yylloc, $3 ) ); }
         | '(' wor_waituntil_clause ')'
-                { printf( "waituntil_clause 2\n" ); $$ = nullptr; }
+                { $$ = $2; }
         ;
 
 wand_waituntil_clause:
         waituntil_clause                                                                        %prec THEN
-                { printf( "wand_waituntil_clause 1\n" ); $$ = nullptr; }
+                { $$ = $1; }
         | waituntil_clause wand wand_waituntil_clause
-                { printf( "wand_waituntil_clause 2\n" ); $$ = nullptr; }
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::AND, $1, $3 ); }
         ;
 
 wor_waituntil_clause:
         wand_waituntil_clause
-                { printf( "wor_waituntil_clause 1\n" ); $$ = nullptr; }
+                { $$ = $1; }
         | wor_waituntil_clause wor wand_waituntil_clause
-                { printf( "wor_waituntil_clause 2\n" ); $$ = nullptr; }
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, $1, $3 ); }
         | wor_waituntil_clause wor when_clause_opt ELSE statement
-                { printf( "wor_waituntil_clause 3\n" ); $$ = nullptr; }
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_else( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
         | wor_waituntil_clause wor when_clause_opt timeout statement    %prec THEN
-                { printf( "wor_waituntil_clause 4\n" ); $$ = nullptr; }
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1, build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ) ); }
         // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | wor_waituntil_clause wor when_clause_opt timeout statement wor ELSE statement // syntax error
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | wor_waituntil_clause wor when_clause_opt timeout statement wor when_clause ELSE statement
-                { printf( "wor_waituntil_clause 6\n" ); $$ = nullptr; }
+                { $$ = new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::LEFT_OR, $1,
+                new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::OR, 
+                    build_waituntil_timeout( yylloc, $3, $4, maybe_build_compound( yylloc, $5 ) ), 
+                    build_waituntil_else( yylloc, $7, maybe_build_compound( yylloc, $9 ) ) ) ); }
         ;
 
@@ -1716 +1721 @@
         wor_waituntil_clause                                                            %prec THEN
                 // SKULLDUGGERY: create an empty compound statement to test parsing of waituntil statement.
-                { $$ = new StatementNode( build_compound( yylloc, nullptr ) ); }
+                {
+            $$ = new StatementNode( build_waituntil_stmt( yylloc, $1 ) );
+            // $$ = new StatementNode( build_compound( yylloc, nullptr ) );
+        }
         ;
 

src/ResolvExpr/Resolver.cc

@@ -1730 +1730 @@
 
                         // Find all candidates for a function in canonical form
-                        funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
+                        funcFinder.find( clause.target, ResolvMode::withAdjustment() );
 
                         if ( funcFinder.candidates.empty() ) {
                                 stringstream ss;
                                 ss << "Use of undeclared indentifier '";
-                                ss << clause.target_func.strict_as< ast::NameExpr >()->name;
+                                ss << clause.target.strict_as< ast::NameExpr >()->name;
                                 ss << "' in call to waitfor";
                                 SemanticError( stmt->location, ss.str() );
@@ -1922 +1922 @@
                         auto clause2 = new ast::WaitForClause( clause.location );
 
-                        clause2->target_func = funcCandidates.front()->expr;
+                        clause2->target = funcCandidates.front()->expr;
 
                         clause2->target_args.reserve( clause.target_args.size() );
@@ -1945 +1945 @@
 
                         // Resolve the conditions as if it were an IfStmt, statements normally
-                        clause2->cond = findSingleExpression( clause.cond, context );
+                        clause2->when_cond = findSingleExpression( clause.when_cond, context );
                         clause2->stmt = clause.stmt->accept( *visitor );
 

src/main.cc

@@ -48 +48 @@
 #include "Concurrency/Keywords.h"           // for implementMutex, implement...
 #include "Concurrency/Waitfor.h"            // for generateWaitfor
+#include "Concurrency/Waituntil.hpp"        // for generateWaitUntil
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
 #include "ControlStruct/ExceptTranslate.h"  // for translateThrows, translat...
@@ -340 +341 @@
                 PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords, transUnit );
                 PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );
+        PASS( "Implement Waituntil", Concurrency::generateWaitUntil, transUnit  );
                 PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls, transUnit );