Changeset b56ad5e for src

Timestamp:

Feb 4, 2022, 10:10:34 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

f8143a6

Parents:

5f3ba11 (diff), 67e86ae6 (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) (7 diffs)
• AST/Copy.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (2 diffs)
• AST/Node.cpp (modified) (2 diffs)
• AST/Node.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (118 diffs)
• AST/Print.cpp (modified) (2 diffs)
• AST/Stmt.cpp (modified) (2 diffs)
• AST/Stmt.hpp (modified) (9 diffs)
• AST/Visitor.hpp (modified) (2 diffs)
• CodeGen/CodeGenerator.cc (modified) (5 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• Common/CodeLocationTools.cpp (modified) (2 diffs)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (6 diffs)
• ControlStruct/ExceptTranslateNew.cpp (modified) (1 diff)
• ControlStruct/FixLabels.cpp (modified) (8 diffs)
• ControlStruct/FixLabels.hpp (modified) (2 diffs)
• ControlStruct/ForExprMutator.cc (modified) (2 diffs)
• ControlStruct/ForExprMutator.h (modified) (3 diffs)
• ControlStruct/HoistControlDecls.cpp (added)
• ControlStruct/HoistControlDecls.hpp (added)
• ControlStruct/LabelFixer.cc (modified) (2 diffs)
• ControlStruct/LabelFixer.h (modified) (2 diffs)
• ControlStruct/LabelGenerator.cc (modified) (3 diffs)
• ControlStruct/LabelGenerator.h (modified) (2 diffs)
• ControlStruct/LabelGeneratorNew.cpp (added)
• ControlStruct/LabelGeneratorNew.hpp (added)
• ControlStruct/MLEMutator.cc (modified) (6 diffs)
• ControlStruct/MLEMutator.h (modified) (3 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (22 diffs)
• ControlStruct/MultiLevelExit.hpp (modified) (2 diffs)
• ControlStruct/module.mk (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• Parser/ParseNode.h (modified) (4 diffs)
• Parser/StatementNode.cc (modified) (15 diffs)
• Parser/parser.yy (modified) (7 diffs)
• ResolvExpr/Resolver.cc (modified) (9 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SymTab/Validate.h (modified) (1 diff)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/Statement.cc (modified) (25 diffs)
• SynTree/Statement.h (modified) (10 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Visitor.h (modified) (2 diffs)
• Validate/Autogen.cpp (added)
• Validate/Autogen.hpp (added)
• Validate/module.mk (modified) (1 diff)
• main.cc (modified) (7 diffs)

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 14 16:15:00 2021
-// Update Count     : 37
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 13:19:22 2022
+// Update Count     : 41
 //
 
@@ -393 +393 @@
                 auto stmt = new IfStmt(
                         get<Expression>().accept1( node->cond ),
-                        get<Statement>().accept1( node->thenPart ),
-                        get<Statement>().accept1( node->elsePart ),
+                        get<Statement>().accept1( node->then ),
+                        get<Statement>().accept1( node->else_ ),
                         get<Statement>().acceptL( node->inits )
                 );
@@ -419 +419 @@
         }
 
-        const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
+        const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
                 if ( inCache( node ) ) return nullptr;
                 auto inits = get<Statement>().acceptL( node->inits );
-                auto stmt = new WhileStmt(
+                auto stmt = new WhileDoStmt(
                         get<Expression>().accept1( node->cond ),
                         get<Statement>().accept1( node->body ),
+                        get<Statement>().accept1( node->else_ ),
                         inits,
                         node->isDoWhile
@@ -437 +438 @@
                         get<Expression>().accept1( node->cond ),
                         get<Expression>().accept1( node->inc ),
-                        get<Statement>().accept1( node->body )
+                        get<Statement>().accept1( node->body ),
+                        get<Statement>().accept1( node->else_ )
                 );
                 return stmtPostamble( stmt, node );
@@ -1872 +1874 @@
                         old->location,
                         GET_ACCEPT_1(condition, Expr),
-                        GET_ACCEPT_1(thenPart, Stmt),
-                        GET_ACCEPT_1(elsePart, Stmt),
+                        GET_ACCEPT_1(then, Stmt),
+                        GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
                         GET_LABELS_V(old->labels)
@@ -1902 +1904 @@
         }
 
-        virtual void visit( const WhileStmt * old ) override final {
+        virtual void visit( const WhileDoStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                this->node = new ast::WhileStmt(
+                this->node = new ast::WhileDoStmt(
                         old->location,
                         GET_ACCEPT_1(condition, Expr),
                         GET_ACCEPT_1(body, Stmt),
+                        GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
                         old->isDoWhile,
@@ -1923 +1926 @@
                         GET_ACCEPT_1(increment, Expr),
                         GET_ACCEPT_1(body, Stmt),
+                        GET_ACCEPT_1(else_, Stmt),
                         GET_LABELS_V(old->labels)
                 );

src/AST/Copy.hpp

@@ -10 +10 @@
 // Created On       : Wed Jul 10 16:13:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:22:00 2021
-// Update Count     : 2
+// Last Modified On : Wed Dec 15 11:07:00 2021
+// Update Count     : 3
 //
 
@@ -52 +52 @@
 Node * deepCopy<Node>( const Node * localRoot );
 
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * shallowCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+        return shallowCopy( localRoot.get() );
+}
+
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * deepCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+        return deepCopy( localRoot.get() );
+}
+
 }
 

src/AST/Fwd.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 16:05:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:37:39 2021
-// Update Count     : 4
+// Last Modified On : Tue Feb  1 09:08:33 2022
+// Update Count     : 5
 //
 
@@ -44 +44 @@
 class DirectiveStmt;
 class IfStmt;
-class WhileStmt;
+class WhileDoStmt;
 class ForStmt;
 class SwitchStmt;

src/AST/Node.cpp

@@ -10 +10 @@
 // Created On       : Thu May 16 14:16:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:25:06 2021
-// Update Count     : 2
+// Last Modified On : Tue Feb  1 09:09:39 2022
+// Update Count     : 3
 //
 
@@ -146 +146 @@
 template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::strong >;

src/AST/Node.hpp

@@ -188 +188 @@
         }
 
+        ptr_base & operator=( const node_t * node ) {
+                assign( node );
+                return *this;
+        }
+
         template<typename o_node_t>
         ptr_base & operator=( const o_node_t * node ) {

src/AST/Pass.hpp

@@ -146 +146 @@
         const ast::Stmt *             visit( const ast::DirectiveStmt        * ) override final;
         const ast::Stmt *             visit( const ast::IfStmt               * ) override final;
-        const ast::Stmt *             visit( const ast::WhileStmt            * ) override final;
+        const ast::Stmt *             visit( const ast::WhileDoStmt          * ) override final;
         const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
         const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;

src/AST/Pass.impl.hpp

@@ -33 +33 @@
         /* call the implementation of the previsit of this pass */ \
         __pass::previsit( core, node, 0 );
-
-#define VISIT( code... ) \
-        /* if this node should visit its children */ \
-        if ( __visit_children() ) { \
-                /* visit the children */ \
-                code \
-        }
 
 #define VISIT_END( type, node ) \
@@ -452 +445 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -460 +453 @@
                 maybe_accept( node, &ObjectDecl::bitfieldWidth );
                 maybe_accept( node, &ObjectDecl::attributes    );
-        )
+        }
 
         __pass::symtab::addId( core, 0, node );
@@ -475 +468 @@
         __pass::symtab::addId( core, 0, node );
 
-        VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
+        if ( __visit_children() ) {
+                maybe_accept( node, &FunctionDecl::withExprs );
+        }
         {
                 // with clause introduces a level of scope (for the with expression members).
@@ -493 +488 @@
                         } };
                         __pass::symtab::addId( core, 0, func );
-                        VISIT(
+                        if ( __visit_children() ) {
                                 // parameter declarations
                                 maybe_accept( node, &FunctionDecl::params );
@@ -509 +504 @@
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
-                        )
+                        }
                 }
         }
@@ -526 +521 @@
         __pass::symtab::addStructFwd( core, 0, node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { * this };
                 maybe_accept( node, &StructDecl::params     );
                 maybe_accept( node, &StructDecl::members    );
                 maybe_accept( node, &StructDecl::attributes );
-        })
+        }
 
         // this addition replaces the forward declaration
@@ -548 +543 @@
         __pass::symtab::addUnionFwd( core, 0, node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { * this };
                 maybe_accept( node, &UnionDecl::params     );
                 maybe_accept( node, &UnionDecl::members    );
                 maybe_accept( node, &UnionDecl::attributes );
-        })
+        }
 
         __pass::symtab::addUnion( core, 0, node );
@@ -568 +563 @@
         __pass::symtab::addEnum( core, 0, node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 // unlike structs, traits, and unions, enums inject their members into the global scope
                 maybe_accept( node, &EnumDecl::params     );
                 maybe_accept( node, &EnumDecl::members    );
                 maybe_accept( node, &EnumDecl::attributes );
-        )
+        }
 
         VISIT_END( Decl, node );
@@ -584 +579 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TraitDecl::params     );
                 maybe_accept( node, &TraitDecl::members    );
                 maybe_accept( node, &TraitDecl::attributes );
-        })
+        }
 
         __pass::symtab::addTrait( core, 0, node );
@@ -602 +597 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TypeDecl::base   );
-        })
+        }
 
         // see A NOTE ON THE ORDER OF TRAVERSAL, above
@@ -612 +607 @@
         __pass::symtab::addType( core, 0, node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TypeDecl::assertions );
 
@@ -619 +614 @@
                         maybe_accept( node, &TypeDecl::init );
                 }
-        )
+        }
 
         VISIT_END( Decl, node );
@@ -630 +625 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TypedefDecl::base   );
-        })
+        }
 
         __pass::symtab::addType( core, 0, node );
 
-        VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
+        if ( __visit_children() ) {
+                maybe_accept( node, &TypedefDecl::assertions );
+        }
 
         VISIT_END( Decl, node );
@@ -648 +645 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &AsmDecl::stmt );
-        )
+        }
 
         VISIT_END( AsmDecl, node );
@@ -661 +658 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &DirectiveDecl::stmt );
-        )
+        }
 
         VISIT_END( DirectiveDecl, node );
@@ -674 +671 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &StaticAssertDecl::cond );
                 maybe_accept( node, &StaticAssertDecl::msg  );
-        )
+        }
 
         VISIT_END( StaticAssertDecl, node );
@@ -687 +684 @@
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
-        VISIT(
+
+        if ( __visit_children() ) {
                 // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
                 auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
@@ -704 +702 @@
                 guard_scope guard3 { *this };
                 maybe_accept( node, &CompoundStmt::kids );
-        )
+        }
+
         VISIT_END( CompoundStmt, node );
 }
@@ -714 +713 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ExprStmt::expr );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -727 +726 @@
         VISIT_START( node )
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &AsmStmt::instruction );
                 maybe_accept( node, &AsmStmt::output      );
                 maybe_accept( node, &AsmStmt::input       );
                 maybe_accept( node, &AsmStmt::clobber     );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -752 +751 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // if statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept_as_compound( node, &IfStmt::thenPart );
-                maybe_accept_as_compound( node, &IfStmt::elsePart );
-        })
+                maybe_accept_as_compound( node, &IfStmt::then );
+                maybe_accept_as_compound( node, &IfStmt::else_ );
+        }
 
         VISIT_END( Stmt, node );
@@ -765 +764 @@
 
 //--------------------------------------------------------------------------
-// WhileStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
-        VISIT_START( node );
-
-        VISIT({
+// WhileDoStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
                 // while statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
-                maybe_accept( node, &WhileStmt::inits );
-                maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept_as_compound( node, &WhileStmt::body  );
-        })
+                maybe_accept( node, &WhileDoStmt::inits );
+                maybe_accept( node, &WhileDoStmt::cond  );
+                maybe_accept_as_compound( node, &WhileDoStmt::body  );
+        }
 
         VISIT_END( Stmt, node );
@@ -787 +786 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
@@ -795 +794 @@
                 maybe_accept( node, &ForStmt::inc   );
                 maybe_accept_as_compound( node, &ForStmt::body  );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -806 +805 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SwitchStmt::cond  );
                 maybe_accept( node, &SwitchStmt::stmts );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -820 +819 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &CaseStmt::cond  );
                 maybe_accept( node, &CaseStmt::stmts );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -842 +841 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ReturnStmt::expr );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -855 +854 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ThrowStmt::expr   );
                 maybe_accept( node, &ThrowStmt::target );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -869 +868 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TryStmt::body     );
                 maybe_accept( node, &TryStmt::handlers );
                 maybe_accept( node, &TryStmt::finally  );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -884 +883 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // catch statements introduce a level of scope (for the caught exception)
                 guard_symtab guard { *this };
@@ -890 +889 @@
                 maybe_accept( node, &CatchStmt::cond );
                 maybe_accept_as_compound( node, &CatchStmt::body );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -901 +900 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &FinallyStmt::body );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -914 +913 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SuspendStmt::then   );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -934 +933 @@
                 // }
 
-        VISIT({
+        if ( __visit_children() ) {
                 std::vector<WaitForStmt::Clause> new_clauses;
                 new_clauses.reserve( node->clauses.size() );
@@ -965 +964 @@
                         node = n;
                 }
-        })
+        }
 
         #define maybe_accept(field) \
@@ -977 +976 @@
                 }
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( timeout.time );
                 maybe_accept( timeout.stmt );
@@ -983 +982 @@
                 maybe_accept( orElse.stmt  );
                 maybe_accept( orElse.cond  );
-        )
+        }
 
         #undef maybe_accept
@@ -996 +995 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &WithStmt::exprs );
                 {
@@ -1004 +1003 @@
                         maybe_accept( node, &WithStmt::stmt );
                 }
-        )
+        }
+
         VISIT_END( Stmt, node );
 }
@@ -1022 +1022 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &DeclStmt::decl );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -1037 +1037 @@
         // For now this isn't visited, it is unclear if this causes problem
         // if all tests are known to pass, remove this code
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -1050 +1050 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // mutex statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
                 maybe_accept( node, &MutexStmt::stmt );
                 maybe_accept( node, &MutexStmt::mutexObjs );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -1066 +1066 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -1073 +1073 @@
                 maybe_accept( node, &ApplicationExpr::func );
                 maybe_accept( node, &ApplicationExpr::args );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1084 +1084 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -1091 +1091 @@
 
                 maybe_accept( node, &UntypedExpr::args );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1102 +1102 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &NameExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1116 +1116 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CastExpr::result );
                 }
                 maybe_accept( node, &CastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1132 +1133 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &KeywordCastExpr::result );
                 }
                 maybe_accept( node, &KeywordCastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1148 +1150 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &VirtualCastExpr::result );
                 }
                 maybe_accept( node, &VirtualCastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1164 +1167 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AddressExpr::result );
                 }
                 maybe_accept( node, &AddressExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1180 +1184 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &LabelAddressExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1194 +1198 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedMemberExpr::result );
@@ -1200 +1205 @@
                 maybe_accept( node, &UntypedMemberExpr::aggregate );
                 maybe_accept( node, &UntypedMemberExpr::member    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1211 +1216 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &MemberExpr::result );
                 }
                 maybe_accept( node, &MemberExpr::aggregate );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1227 +1233 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &VariableExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1241 +1247 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &ConstantExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1255 +1261 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &SizeofExpr::result );
@@ -1264 +1271 @@
                         maybe_accept( node, &SizeofExpr::expr );
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1275 +1282 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AlignofExpr::result );
@@ -1284 +1292 @@
                         maybe_accept( node, &AlignofExpr::expr );
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1295 +1303 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedOffsetofExpr::result );
                 }
                 maybe_accept( node, &UntypedOffsetofExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1311 +1320 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &OffsetofExpr::result );
                 }
                 maybe_accept( node, &OffsetofExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1327 +1337 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &OffsetPackExpr::result );
                 }
                 maybe_accept( node, &OffsetPackExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1343 +1354 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &LogicalExpr::result );
@@ -1349 +1361 @@
                 maybe_accept( node, &LogicalExpr::arg1 );
                 maybe_accept( node, &LogicalExpr::arg2 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1360 +1372 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ConditionalExpr::result );
@@ -1367 +1380 @@
                 maybe_accept( node, &ConditionalExpr::arg2 );
                 maybe_accept( node, &ConditionalExpr::arg3 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1378 +1391 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CommaExpr::result );
@@ -1384 +1398 @@
                 maybe_accept( node, &CommaExpr::arg1 );
                 maybe_accept( node, &CommaExpr::arg2 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1395 +1409 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TypeExpr::result );
                 }
                 maybe_accept( node, &TypeExpr::type );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1411 +1426 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AsmExpr::result );
@@ -1417 +1433 @@
                 maybe_accept( node, &AsmExpr::constraint );
                 maybe_accept( node, &AsmExpr::operand    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1428 +1444 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ImplicitCopyCtorExpr::result );
                 }
                 maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1444 +1461 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ConstructorExpr::result );
                 }
                 maybe_accept( node, &ConstructorExpr::callExpr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1460 +1478 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CompoundLiteralExpr::result );
                 }
                 maybe_accept( node, &CompoundLiteralExpr::init );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1476 +1495 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &RangeExpr::result );
@@ -1482 +1502 @@
                 maybe_accept( node, &RangeExpr::low    );
                 maybe_accept( node, &RangeExpr::high   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1493 +1513 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedTupleExpr::result );
                 }
                 maybe_accept( node, &UntypedTupleExpr::exprs  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1509 +1530 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleExpr::result );
                 }
                 maybe_accept( node, &TupleExpr::exprs  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1525 +1547 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleIndexExpr::result );
                 }
                 maybe_accept( node, &TupleIndexExpr::tuple  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1541 +1564 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleAssignExpr::result );
                 }
                 maybe_accept( node, &TupleAssignExpr::stmtExpr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1557 +1581 @@
         VISIT_START( node );
 
-        VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
+        if ( __visit_children() ) {
+                // don't want statements from outer CompoundStmts to be added to this StmtExpr
                 // get the stmts that will need to be spliced in
                 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
@@ -1574 +1599 @@
                 maybe_accept( node, &StmtExpr::returnDecls );
                 maybe_accept( node, &StmtExpr::dtors       );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1585 +1610 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UniqueExpr::result );
                 }
                 maybe_accept( node, &UniqueExpr::expr   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1601 +1627 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedInitExpr::result );
@@ -1607 +1634 @@
                 maybe_accept( node, &UntypedInitExpr::expr   );
                 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1618 +1645 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &InitExpr::result );
@@ -1624 +1652 @@
                 maybe_accept( node, &InitExpr::expr   );
                 maybe_accept( node, &InitExpr::designation );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1635 +1663 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &DeletedExpr::result );
@@ -1641 +1670 @@
                 maybe_accept( node, &DeletedExpr::expr );
                 // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1652 +1681 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &DefaultArgExpr::result );
                 }
                 maybe_accept( node, &DefaultArgExpr::expr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1668 +1698 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &GenericExpr::result );
@@ -1697 +1728 @@
                         node = n;
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1726 +1757 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 // xxx - should PointerType visit/mutate dimension?
                 maybe_accept( node, &PointerType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1740 +1771 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ArrayType::dimension );
                 maybe_accept( node, &ArrayType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1754 +1785 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ReferenceType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1767 +1798 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &QualifiedType::parent );
                 maybe_accept( node, &QualifiedType::child );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1781 +1812 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // guard_forall_subs forall_guard { *this, node };
                 // mutate_forall( node );
@@ -1787 +1818 @@
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1800 +1831 @@
         __pass::symtab::addStruct( core, 0, node->name );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &StructInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1816 +1847 @@
         __pass::symtab::addUnion( core, 0, node->name );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &UnionInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1830 +1861 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 maybe_accept( node, &EnumInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1843 +1874 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 maybe_accept( node, &TraitInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1856 +1887 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         maybe_accept( node, &TypeInstType::params );
@@ -1862 +1893 @@
                 // ensure that base re-bound if doing substitution
                 __pass::forall::replace( core, 0, node );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1873 +1904 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
                 maybe_accept( node, &TupleType::members );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1887 +1918 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TypeofType::expr );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1900 +1931 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &VTableType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1950 +1981 @@
         VISIT_START( node );
 
-        VISIT( maybe_accept( node, &Designation::designators ); )
+        if ( __visit_children() ) {
+                maybe_accept( node, &Designation::designators );
+        }
 
         VISIT_END( Designation, node );
@@ -1961 +1994 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SingleInit::value );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -1974 +2007 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ListInit::designations );
                 maybe_accept( node, &ListInit::initializers );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -1988 +2021 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ConstructorInit::ctor );
                 maybe_accept( node, &ConstructorInit::dtor );
                 maybe_accept( node, &ConstructorInit::init );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -2003 +2036 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &Attribute::params );
-        )
+        }
 
         VISIT_END( Attribute, node );
@@ -2016 +2049 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         bool mutated = false;
@@ -2032 +2065 @@
                         }
                 }
-        )
+        }
 
         VISIT_END( TypeSubstitution, node );
@@ -2038 +2071 @@
 
 #undef VISIT_START
-#undef VISIT
 #undef VISIT_END

src/AST/Print.cpp

@@ -511 +511 @@
                 ++indent;
                 os << indent;
-                safe_print( node->thenPart );
-                --indent;
-
-                if ( node->elsePart != 0 ) {
+                safe_print( node->then );
+                --indent;
+
+                if ( node->else_ != 0 ) {
                         os << indent << "... else:" << endl;
                         ++indent;
                         os << indent;
-                        node->elsePart->accept( *this );
+                        node->else_->accept( *this );
                         --indent;
                 } // if
@@ -524 +524 @@
         }
 
-        virtual const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
+        virtual const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
                 if ( node->isDoWhile ) { os << "Do-"; }
                 os << "While on condition:" << endl;

src/AST/Stmt.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed May 15 15:53:00 2019
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 19:01:20 2022
+// Update Count     : 3
 //
 
@@ -56 +56 @@
 
 // --- BranchStmt
-BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, std::vector<Label>&& labels )
-: Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
+BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, const std::vector<Label>&& labels )
+                : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
         // Make sure a syntax error hasn't slipped through.
         assert( Goto != kind || !target.empty() );

src/AST/Stmt.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:45:00 2019
-// Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 20:06:41 2022
+// Update Count     : 34
 //
 
@@ -17 +17 @@
 
 #include <list>
-#include <utility>                // for move
+#include <utility>                                                                              // for move
 #include <vector>
 
 #include "Label.hpp"
-#include "Node.hpp"               // for node, ptr
+#include "Node.hpp"                                                                             // for node, ptr
 #include "ParseNode.hpp"
 #include "Visitor.hpp"
@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND \
+#define MUTATE_FRIEND                                                                                                   \
     template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
-
 class Expr;
 
-/// Base statement node
+// Base statement node
 class Stmt : public ParseNode {
-public:
+  public:
         std::vector<Label> labels;
 
-        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : ParseNode(loc), labels(std::move(labels)) {}
-
-        Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
+        Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : ParseNode(loc), labels(std::move(labels)) {}
+
+        Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}
 
         const Stmt * accept( Visitor & v ) const override = 0;
-private:
+  private:
         Stmt * clone() const override = 0;
         MUTATE_FRIEND
 };
 
-/// Compound statement `{ ... }`
+// Compound statement: { ... }
 class CompoundStmt final : public Stmt {
-public:
+  public:
         std::list<ptr<Stmt>> kids;
 
-        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
-                std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
-
-        CompoundStmt( const CompoundStmt& o );
-        CompoundStmt( CompoundStmt&& o ) = default;
+        CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
+
+        CompoundStmt( const CompoundStmt & o );
+        CompoundStmt( CompoundStmt && o ) = default;
 
         void push_back( const Stmt * s ) { kids.emplace_back( s ); }
@@ -67 +65 @@
 
         const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Empty statment `;`
+// Empty statment: ;
 class NullStmt final : public Stmt {
-public:
-        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
+  public:
+        NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)) {}
 
         const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         NullStmt * clone() const override { return new NullStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Expression wrapped by statement
+// Expression wrapped by statement
 class ExprStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
-        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), expr(e) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), expr(e) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ExprStmt * clone() const override { return new ExprStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Assembly statement `asm ... ( "..." : ... )`
+// Assembly statement: asm ... ( "..." : ... )
 class AsmStmt final : public Stmt {
-public:
+  public:
         bool isVolatile;
         ptr<Expr> instruction;
@@ -108 +106 @@
 
         AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
-                std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
-                std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
-                std::vector<Label> && labels = {})
-        : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
-          output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
-          gotoLabels(std::move(gotoLabels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                         const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
+                         const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
+                         const std::vector<Label> && labels = {})
+                : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
+                  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
+                  gotoLabels(std::move(gotoLabels)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         AsmStmt * clone() const override { return new AsmStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// C-preprocessor directive `#...`
+// C-preprocessor directive: #...
 class DirectiveStmt final : public Stmt {
-public:
+  public:
         std::string directive;
 
         DirectiveStmt( const CodeLocation & loc, const std::string & directive,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), directive(directive) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                   std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), directive(directive) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// If conditional statement `if (...) ... else ...`
+// If statement: if (...) ... else ...
 class IfStmt final : public Stmt {
-public:
-        ptr<Expr> cond;
-        ptr<Stmt> thenPart;
-        ptr<Stmt> elsePart;
+  public:
+        ptr<Expr> cond;
+        ptr<Stmt> then;
+        ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
 
-        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
-                const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
-          inits(std::move(inits)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
+                        const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
+                        const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
+                  inits(std::move(inits)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         IfStmt * clone() const override { return new IfStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Switch or choose conditional statement `switch (...) { ... }`
+// Switch or choose statement: switch (...) { ... }
 class SwitchStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
-        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
+                                const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Case label `case ...:` `default:`
+// Case label: case ...: or default:
 class CaseStmt final : public Stmt {
-public:
-        /// Null for the default label.
+  public:
+        // Null for the default label.
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
-        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+        CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
+                          const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() const { return !cond; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CaseStmt * clone() const override { return new CaseStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// While loop `while (...) ...` `do ... while (...);
-class WhileStmt final : public Stmt {
-public:
+// While loop: while (...) ... else ... or do ... while (...) else ...;
+class WhileDoStmt final : public Stmt {
+  public:
         ptr<Expr> cond;
         ptr<Stmt> body;
+        ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
 
-        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
-          isDoWhile(isDoWhile) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
-        MUTATE_FRIEND
-};
-
-/// For loop `for (... ; ... ; ...) ...`
+        WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
+                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, 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 = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        WhileDoStmt * clone() const override { return new WhileDoStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
+// For loop: for (... ; ... ; ...) ... else ...
 class ForStmt final : public Stmt {
-public:
+  public:
         std::vector<ptr<Stmt>> inits;
         ptr<Expr> cond;
         ptr<Expr> inc;
         ptr<Stmt> body;
-
-        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
-          body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        ptr<Stmt> else_;
+
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
+                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
+
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ForStmt * clone() const override { return new ForStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Branch control flow statement `goto ...` `break` `continue` `fallthru`
+// Branch control flow statement: goto ... or break or continue or fallthru
 class BranchStmt final : public Stmt {
-public:
+  public:
         enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
         static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
@@ -240 +246 @@
         Kind kind;
 
-        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
-                std::vector<Label> && labels = {} );
-        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
-          computedTarget(computedTarget), kind(Goto) {}
+        BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
+        BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
 
         const char * kindName() const { return kindNames[kind]; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         BranchStmt * clone() const override { return new BranchStmt{ *this }; }
         MUTATE_FRIEND
@@ -257 +260 @@
 };
 
-/// Return statement `return ...`
+// Return statement: return ...
 class ReturnStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
-        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), expr(expr) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), expr(expr) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Kind of exception
+// Kind of exception
 enum ExceptionKind { Terminate, Resume };
 
-/// Throw statement `throw ...`
+// Throw statement: throw ...
 class ThrowStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
         ptr<Expr> target;
         ExceptionKind kind;
 
-        ThrowStmt(
-                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
+                           const Expr * target, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Try statement `try { ... } ...`
+// Try statement: try { ... } ...
 class TryStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
         std::vector<ptr<CatchStmt>> handlers;
         ptr<FinallyStmt> finally;
 
-        TryStmt(
-                const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
+                         const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+                         const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         TryStmt * clone() const override { return new TryStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Catch clause of try statement
+// Catch clause of try statement
 class CatchStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
         ptr<Expr> cond;
@@ -319 +320 @@
         ExceptionKind kind;
 
-        CatchStmt(
-                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                const Stmt * body, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
+                           const Stmt * body, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         CatchStmt * clone() const override { return new CatchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Finally clause of try statement
+// Finally clause of try statement
 class FinallyStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
 
         FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                 std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Suspend statement
+// Suspend statement
 class SuspendStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> then;
         enum Type { None, Coroutine, Generator } type = None;
 
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), then(then), type(type) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
 class WaitForStmt final : public Stmt {
-public:
+  public:
         struct Target {
                 ptr<Expr> func;
@@ -389 +389 @@
         OrElse orElse;
 
-        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+                : Stmt(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
 };
 
-/// Any declaration in a (compound) statement.
+// Any declaration in a (compound) statement.
 class DeclStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
 
-        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), decl(decl) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+        DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), decl(decl) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DeclStmt * clone() const override { return new DeclStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Represents an implicit application of a constructor or destructor.
+// Represents an implicit application of a constructor or destructor.
 class ImplicitCtorDtorStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                                  std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Mutex Statement
+// Mutex Statement
 class MutexStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> stmt;
         std::vector<ptr<Expr>> mutexObjs;
 
         MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                           const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         MutexStmt * clone() const override { return new MutexStmt{ *this }; }
         MUTATE_FRIEND
 };
-
-}
+} // namespace ast
 
 #undef MUTATE_FRIEND
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/AST/Visitor.hpp

@@ -10 +10 @@
 // Created On       : Thr May 9 15:28:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:25:07 2021
-// Update Count     : 1
+// Last Modified On : Tue Feb  1 09:09:34 2022
+// Update Count     : 2
 //
 
@@ -38 +38 @@
     virtual const ast::Stmt *             visit( const ast::DirectiveStmt        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::IfStmt               * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::WhileStmt            * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::WhileDoStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 19:00:42 2021
-// Update Count     : 536
+// Last Modified On : Wed Feb  2 20:30:30 2022
+// Update Count     : 541
 //
 #include "CodeGenerator.h"
@@ -42 +42 @@
         bool wantSpacing( Statement * stmt) {
                 return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
-                        dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
+                        dynamic_cast< WhileDoStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
         }
 
@@ -955 +955 @@
                 output << " ) ";
 
-                ifStmt->get_thenPart()->accept( *visitor );
-
-                if ( ifStmt->get_elsePart() != 0) {
+                ifStmt->get_then()->accept( *visitor );
+
+                if ( ifStmt->get_else() != 0) {
                         output << " else ";
-                        ifStmt->get_elsePart()->accept( *visitor );
+                        ifStmt->get_else()->accept( *visitor );
                 } // if
         }
@@ -1020 +1020 @@
                         output << "fallthru";
                         break;
+                  default: ;                                                                    // prevent warning
                 } // switch
                 // print branch target for labelled break/continue/fallthru in debug mode
@@ -1125 +1126 @@
         }
 
-        void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
-                if ( whileStmt->get_isDoWhile() ) {
+        void CodeGenerator::postvisit( WhileDoStmt * whileDoStmt ) {
+                if ( whileDoStmt->get_isDoWhile() ) {
                         output << "do";
                 } else {
                         output << "while (";
-                        whileStmt->get_condition()->accept( *visitor );
+                        whileDoStmt->get_condition()->accept( *visitor );
                         output << ")";
                 } // if
                 output << " ";
 
-                output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
-                whileStmt->get_body()->accept( *visitor );
+                output << CodeGenerator::printLabels( whileDoStmt->get_body()->get_labels() );
+                whileDoStmt->get_body()->accept( *visitor );
 
                 output << indent;
 
-                if ( whileStmt->get_isDoWhile() ) {
+                if ( whileDoStmt->get_isDoWhile() ) {
                         output << " while (";
-                        whileStmt->get_condition()->accept( *visitor );
+                        whileDoStmt->get_condition()->accept( *visitor );
                         output << ");";
                 } // if

src/CodeGen/CodeGenerator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:35:38 2021
-// Update Count     : 63
+// Last Modified On : Tue Feb  1 09:23:21 2022
+// Update Count     : 64
 //
 
@@ -116 +116 @@
                 void postvisit( WaitForStmt * );
                 void postvisit( WithStmt * );
-                void postvisit( WhileStmt * );
+                void postvisit( WhileDoStmt * );
                 void postvisit( ForStmt * );
                 void postvisit( NullStmt * );

src/Common/CodeLocationTools.cpp

@@ -10 +10 @@
 // Created On       : Fri Dec  4 15:42:00 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:35:37 2021
-// Update Count     : 2
+// Last Modified On : Tue Feb  1 09:14:39 2022
+// Update Count     : 3
 //
 
@@ -109 +109 @@
     macro(DirectiveStmt, Stmt) \
     macro(IfStmt, Stmt) \
-    macro(WhileStmt, Stmt) \
+    macro(WhileDoStmt, Stmt) \
     macro(ForStmt, Stmt) \
     macro(SwitchStmt, Stmt) \

src/Common/PassVisitor.h

@@ -92 +92 @@
         virtual void visit( IfStmt * ifStmt ) override final;
         virtual void visit( const IfStmt * ifStmt ) override final;
-        virtual void visit( WhileStmt * whileStmt ) override final;
-        virtual void visit( const WhileStmt * whileStmt ) override final;
+        virtual void visit( WhileDoStmt * whileDoStmt ) override final;
+        virtual void visit( const WhileDoStmt * whileDoStmt ) override final;
         virtual void visit( ForStmt * forStmt ) override final;
         virtual void visit( const ForStmt * forStmt ) override final;
@@ -277 +277 @@
         virtual Statement * mutate( DirectiveStmt * dirStmt ) override final;
         virtual Statement * mutate( IfStmt * ifStmt ) override final;
-        virtual Statement * mutate( WhileStmt * whileStmt ) override final;
+        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) override final;
         virtual Statement * mutate( ForStmt * forStmt ) override final;
         virtual Statement * mutate( SwitchStmt * switchStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -1189 +1189 @@
                 maybeAccept_impl( node->initialization, *this );
                 visitExpression ( node->condition );
-                node->thenPart = visitStatement( node->thenPart );
-                node->elsePart = visitStatement( node->elsePart );
+                node->then = visitStatement( node->then );
+                node->else_ = visitStatement( node->else_ );
         }
         VISIT_END( node );
@@ -1203 +1203 @@
                 maybeAccept_impl( node->initialization, *this );
                 visitExpression ( node->condition );
-                visitStatement  ( node->thenPart );
-                visitStatement  ( node->elsePart );
+                visitStatement  ( node->then );
+                visitStatement  ( node->else_ );
         }
         VISIT_END( node );
@@ -1217 +1217 @@
                 maybeMutate_impl( node->initialization, *this );
                 node->condition = mutateExpression( node->condition );
-                node->thenPart  = mutateStatement ( node->thenPart  );
-                node->elsePart  = mutateStatement ( node->elsePart  );
+                node->then  = mutateStatement ( node->then  );
+                node->else_  = mutateStatement ( node->else_  );
         }
         MUTATE_END( Statement, node );
@@ -1224 +1224 @@
 
 //--------------------------------------------------------------------------
-// WhileStmt
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( WhileStmt * node ) {
+// WhileDoStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( WhileDoStmt * node ) {
         VISIT_START( node );
 
@@ -1241 +1241 @@
 
 template< typename pass_type >
-void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
+void PassVisitor< pass_type >::visit( const WhileDoStmt * node ) {
         VISIT_START( node );
 
@@ -1256 +1256 @@
 
 template< typename pass_type >
-Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
+Statement * PassVisitor< pass_type >::mutate( WhileDoStmt * node ) {
         MUTATE_START( node );
 

src/ControlStruct/ExceptTranslateNew.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  8 11:53:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 16:50:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 18:49:58 2022
+// Update Count     : 1
 //
 

src/ControlStruct/FixLabels.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:39:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:19:17 2022
+// Update Count     : 9
 //
 
@@ -20 +20 @@
 #include "AST/Stmt.hpp"
 #include "ControlStruct/MultiLevelExit.hpp"
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
-class FixLabelsCore final : public ast::WithGuards {
+class FixLabelsCore final : public WithGuards {
         LabelToStmt labelTable;
-public:
+  public:
         FixLabelsCore() : labelTable() {}
 
-        void previsit( const ast::FunctionDecl * );
-        const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
-        void previsit( const ast::Stmt * );
-        void previsit( const ast::BranchStmt * );
-        void previsit( const ast::LabelAddressExpr * );
+        void previsit( const FunctionDecl * );
+        const FunctionDecl * postvisit( const FunctionDecl * );
+        void previsit( const Stmt * );
+        void previsit( const BranchStmt * );
+        void previsit( const LabelAddressExpr * );
 
-        void setLabelsDef( const std::vector<ast::Label> &, const ast::Stmt * );
-        void setLabelsUsage( const ast::Label & );
+        void setLabelsDef( const std::vector<Label> &, const Stmt * );
+        void setLabelsUsage( const Label & );
 };
 
-void FixLabelsCore::previsit( const ast::FunctionDecl * ) {
+void FixLabelsCore::previsit( const FunctionDecl * ) {
         GuardValue( labelTable ).clear();
 }
 
-const ast::FunctionDecl * FixLabelsCore::postvisit(
-                const ast::FunctionDecl * decl ) {
+const FunctionDecl * FixLabelsCore::postvisit(
+        const FunctionDecl * decl ) {
         if ( nullptr == decl->stmts ) return decl;
         for ( auto kvp : labelTable ) {
                 if ( nullptr == kvp.second ) {
                         SemanticError( kvp.first.location,
-                                "Use of undefined label: " + kvp.first.name );
+                                                   "Use of undefined label: " + kvp.first.name );
                 }
         }
-        return ast::mutate_field( decl, &ast::FunctionDecl::stmts,
-                multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
+        return mutate_field( decl, &FunctionDecl::stmts,
+                                                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
 }
 
-void FixLabelsCore::previsit( const ast::Stmt * stmt ) {
+void FixLabelsCore::previsit( const Stmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -63 +61 @@
 }
 
-void FixLabelsCore::previsit( const ast::BranchStmt * stmt ) {
+void FixLabelsCore::previsit( const BranchStmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -72 +70 @@
 }
 
-void FixLabelsCore::previsit( const ast::LabelAddressExpr * expr ) {
+void FixLabelsCore::previsit( const LabelAddressExpr * expr ) {
         assert( !expr->arg.empty() );
         setLabelsUsage( expr->arg );
@@ -78 +76 @@
 
 void FixLabelsCore::setLabelsDef(
-                const std::vector<ast::Label> & labels, const ast::Stmt * stmt ) {
+        const std::vector<Label> & labels, const Stmt * stmt ) {
         assert( !labels.empty() );
         assert( stmt );
@@ -89 +87 @@
                         // Duplicate definition, this is an error.
                         SemanticError( label.location,
-                                "Duplicate definition of label: " + label.name );
+                                                   "Duplicate definition of label: " + label.name );
                 } else {
                         // Perviously used, but not defined until now.
@@ -98 +96 @@
 
 // Label was used, if it is new add it to the table.
-void FixLabelsCore::setLabelsUsage( const ast::Label & label ) {
+void FixLabelsCore::setLabelsUsage( const Label & label ) {
         if ( labelTable.find( label ) == labelTable.end() ) {
                 labelTable[ label ] = nullptr;
@@ -104 +102 @@
 }
 
-} // namespace
-
-void fixLabels( ast::TranslationUnit & translationUnit ) {
-        ast::Pass<FixLabelsCore>::run( translationUnit );
+void fixLabels( TranslationUnit & translationUnit ) {
+        Pass<FixLabelsCore>::run( translationUnit );
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/FixLabels.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:36:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  1 09:40:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:18:43 2022
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 
 namespace ast {
-        class TranslationUnit;
+class TranslationUnit;
 }
 
 namespace ControlStruct {
-
-/// normalizes label definitions and generates multi-level exit labels
+// normalizes label definitions and generates multi-level exit labels
 void fixLabels( ast::TranslationUnit & translationUnit );
-
 }
 

src/ControlStruct/ForExprMutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 11 22:26:52 2019
-// Update Count     : 14
+// Last Modified On : Tue Feb  1 09:26:12 2022
+// Update Count     : 16
 //
 
@@ -45 +45 @@
                 return hoist( forStmt, forStmt->initialization );
         }
-        Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
-                return hoist( whileStmt, whileStmt->initialization );
+        Statement * ForExprMutator::postmutate( WhileDoStmt * whileDoStmt ) {
+                return hoist( whileDoStmt, whileDoStmt->initialization );
         }
 } // namespace ControlStruct

src/ControlStruct/ForExprMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 15:32:48 2017
-// Update Count     : 5
+// Last Modified On : Tue Feb  1 09:18:50 2022
+// Update Count     : 7
 //
 
@@ -18 +18 @@
 class IfStmt;
 class ForStmt;
-class WhileStmt;
+class WhileDoStmt;
 class Statement;
 
@@ -24 +24 @@
         class ForExprMutator {
           public:
-                Statement *postmutate( IfStmt * );
-                Statement *postmutate( ForStmt * );
-                Statement *postmutate( WhileStmt * );
+                Statement * postmutate( IfStmt * );
+                Statement * postmutate( ForStmt * );
+                Statement * postmutate( WhileDoStmt * );
         };
 } // namespace ControlStruct

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jan 21 10:32:00 2020
-// Update Count     : 160
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb  1 09:12:09 2022
+// Update Count     : 162
 //
 
@@ -27 +27 @@
 
 namespace ControlStruct {
-        bool LabelFixer::Entry::insideLoop() {
-                return ( dynamic_cast< ForStmt * > ( definition ) ||
-                        dynamic_cast< WhileStmt * > ( definition )  );
+bool LabelFixer::Entry::insideLoop() {
+        return ( dynamic_cast< ForStmt * > ( definition ) ||
+                dynamic_cast< WhileDoStmt * > ( definition )  );
+}
+
+LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
+        if ( generator == 0 )
+                generator = LabelGenerator::getGenerator();
+}
+
+void LabelFixer::previsit( FunctionDecl * ) {
+        // need to go into a nested function in a fresh state
+        GuardValue( labelTable );
+        labelTable.clear();
+}
+
+void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
+        PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+        // We start in the body so we can stop when we hit another FunctionDecl.
+        maybeMutate( functionDecl->statements, mlem );
+}
+
+// prune to at most one label definition for each statement
+void LabelFixer::previsit( Statement * stmt ) {
+        std::list< Label > &labels = stmt->get_labels();
+
+        if ( ! labels.empty() ) {
+                // only remember one label for each statement
+                Label current = setLabelsDef( labels, stmt );
+        } // if
+}
+
+void LabelFixer::previsit( BranchStmt * branchStmt ) {
+        previsit( ( Statement *)branchStmt );
+
+        // for labeled branches, add an entry to the label table
+        Label target = branchStmt->get_target();
+        if ( target != "" ) {
+                setLabelsUsg( target, branchStmt );
+        }
+}
+
+void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
+        Label & target = addrExpr->arg;
+        assert( target != "" );
+        setLabelsUsg( target, addrExpr );
+}
+
+
+// Sets the definition of the labelTable entry to be the provided statement for every label in
+// the list parameter. Happens for every kind of statement.
+Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
+        assert( definition != 0 );
+        assert( llabel.size() > 0 );
+
+        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
+                Label & l = *i;
+                l.set_statement( definition ); // attach statement to the label to be used later
+                if ( labelTable.find( l ) == labelTable.end() ) {
+                        // All labels on this statement need to use the same entry,
+                        // so this should only be created once.
+                        // undefined and unused until now, add an entry
+                        labelTable[ l ] = new Entry( definition );
+                } else if ( labelTable[ l ]->defined() ) {
+                        // defined twice, error
+                        SemanticError( l.get_statement()->location,
+                                "Duplicate definition of label: " + l.get_name() );
+                } else {
+                        // used previously, but undefined until now -> link with this entry
+                        // Question: Is changing objects important?
+                        delete labelTable[ l ];
+                        labelTable[ l ] = new Entry( definition );
+                } // if
+        } // for
+
+        // Produce one of the labels attached to this statement to be temporarily used as the
+        // canonical label.
+        return labelTable[ llabel.front() ]->get_label();
+}
+
+// A label was used, add it to the table if it isn't already there
+template< typename UsageNode >
+void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
+        assert( use != 0 );
+
+        // add label with an unknown origin
+        if ( labelTable.find( orgValue ) == labelTable.end() ) {
+                labelTable[ orgValue ] = new Entry( 0 );
+        }
+}
+
+// Builds a table that maps a label to its defining statement.
+std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
+        for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
+                if ( ! i->second->defined() ) {
+                        SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
+                }
+                (*ret)[ i->first ] = i->second->get_definition();
         }
 
-        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
-                if ( generator == 0 )
-                        generator = LabelGenerator::getGenerator();
-        }
-
-        void LabelFixer::previsit( FunctionDecl * ) {
-                // need to go into a nested function in a fresh state
-                GuardValue( labelTable );
-                labelTable.clear();
-        }
-
-        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
-                // We start in the body so we can stop when we hit another FunctionDecl.
-                maybeMutate( functionDecl->statements, mlem );
-        }
-
-        // prune to at most one label definition for each statement
-        void LabelFixer::previsit( Statement * stmt ) {
-                std::list< Label > &labels = stmt->get_labels();
-
-                if ( ! labels.empty() ) {
-                        // only remember one label for each statement
-                        Label current = setLabelsDef( labels, stmt );
-                } // if
-        }
-
-        void LabelFixer::previsit( BranchStmt * branchStmt ) {
-                previsit( ( Statement *)branchStmt );
-
-                // for labeled branches, add an entry to the label table
-                Label target = branchStmt->get_target();
-                if ( target != "" ) {
-                        setLabelsUsg( target, branchStmt );
-                }
-        }
-
-        void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
-                Label & target = addrExpr->arg;
-                assert( target != "" );
-                setLabelsUsg( target, addrExpr );
-        }
-
-
-        // Sets the definition of the labelTable entry to be the provided statement for every label in
-        // the list parameter. Happens for every kind of statement.
-        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
-                assert( definition != 0 );
-                assert( llabel.size() > 0 );
-
-                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
-                        Label & l = *i;
-                        l.set_statement( definition ); // attach statement to the label to be used later
-                        if ( labelTable.find( l ) == labelTable.end() ) {
-                                // All labels on this statement need to use the same entry,
-                                // so this should only be created once.
-                                // undefined and unused until now, add an entry
-                                labelTable[ l ] = new Entry( definition );
-                        } else if ( labelTable[ l ]->defined() ) {
-                                // defined twice, error
-                                SemanticError( l.get_statement()->location,
-                                        "Duplicate definition of label: " + l.get_name() );
-                        } else {
-                                // used previously, but undefined until now -> link with this entry
-                                // Question: Is changing objects important?
-                                delete labelTable[ l ];
-                                labelTable[ l ] = new Entry( definition );
-                        } // if
-                } // for
-
-                // Produce one of the labels attached to this statement to be temporarily used as the
-                // canonical label.
-                return labelTable[ llabel.front() ]->get_label();
-        }
-
-        // A label was used, add it to the table if it isn't already there
-        template< typename UsageNode >
-        void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
-                assert( use != 0 );
-
-                // add label with an unknown origin
-                if ( labelTable.find( orgValue ) == labelTable.end() ) {
-                        labelTable[ orgValue ] = new Entry( 0 );
-                }
-        }
-
-        // Builds a table that maps a label to its defining statement.
-        std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
-                std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
-                for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
-                        if ( ! i->second->defined() ) {
-                                SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
-                        }
-                        (*ret)[ i->first ] = i->second->get_definition();
-                }
-
-                return ret;
-        }
+        return ret;
+}
 }  // namespace ControlStruct
 

src/ControlStruct/LabelFixer.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:17:24 2017
-// Update Count     : 34
+// Last Modified On : Mon Jan 31 22:28:04 2022
+// Update Count     : 35
 //
 
@@ -26 +26 @@
 
 namespace ControlStruct {
-        /// normalizes label definitions and generates multi-level exit labels
-        class LabelGenerator;
+// normalizes label definitions and generates multi-level exit labels
+class LabelGenerator;
 
-        class LabelFixer final : public WithGuards {
-          public:
-                LabelFixer( LabelGenerator *gen = 0 );
+class LabelFixer final : public WithGuards {
+  public:
+        LabelFixer( LabelGenerator *gen = 0 );
 
-                std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
+        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
 
-                // Declarations
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
+        // Declarations
+        void previsit( FunctionDecl *functionDecl );
+        void postvisit( FunctionDecl *functionDecl );
 
-                // Statements
-                void previsit( Statement *stmt );
-                void previsit( BranchStmt *branchStmt );
+        // Statements
+        void previsit( Statement *stmt );
+        void previsit( BranchStmt *branchStmt );
 
-                // Expressions
-                void previsit( LabelAddressExpr *addrExpr );
+        // Expressions
+        void previsit( LabelAddressExpr *addrExpr );
 
-                Label setLabelsDef( std::list< Label > &, Statement *definition );
-                template< typename UsageNode >
-                void setLabelsUsg( Label, UsageNode *usage = 0 );
+        Label setLabelsDef( std::list< Label > &, Statement *definition );
+        template< typename UsageNode >
+        void setLabelsUsg( Label, UsageNode *usage = 0 );
+
+  private:
+        class Entry {
+                public:
+                Entry( Statement *to ) : definition( to ) {}
+                bool defined() { return ( definition != 0 ); }
+                bool insideLoop();
+
+                Label get_label() const { return label; }
+                void set_label( Label lab ) { label = lab; }
+
+                Statement *get_definition() const { return definition; }
+                void set_definition( Statement *def ) { definition = def; }
 
           private:
-                class Entry {
-                        public:
-                        Entry( Statement *to ) : definition( to ) {}
-                        bool defined() { return ( definition != 0 ); }
-                        bool insideLoop();
+                Label label;
+                Statement *definition;
+        };
 
-                        Label get_label() const { return label; }
-                        void set_label( Label lab ) { label = lab; }
-
-                        Statement *get_definition() const { return definition; }
-                        void set_definition( Statement *def ) { definition = def; }
-
-                  private:
-                        Label label;
-                        Statement *definition;
-                };
-
-                std::map < Label, Entry *> labelTable;
-                LabelGenerator *generator;
-        };
+        std::map < Label, Entry *> labelTable;
+        LabelGenerator *generator;
+};
 } // namespace ControlStruct
 

src/ControlStruct/LabelGenerator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:18:00 2021
-// Update Count     : 17
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:26 2022
+// Update Count     : 28
 //
 
@@ -17 +17 @@
 #include <sstream>              // for ostringstream
 #include <list>                 // for list
+using namespace std;
 
 #include "LabelGenerator.h"
 
-#include "AST/Attribute.hpp"
-#include "AST/Label.hpp"
-#include "AST/Stmt.hpp"
 #include "SynTree/Attribute.h"  // for Attribute
 #include "SynTree/Label.h"      // for Label, operator<<
@@ -28 +26 @@
 
 namespace ControlStruct {
-
 int LabelGenerator::current = 0;
 LabelGenerator * LabelGenerator::labelGenerator = nullptr;
 
-        LabelGenerator * LabelGenerator::getGenerator() {
-                if ( LabelGenerator::labelGenerator == 0 )
-                        LabelGenerator::labelGenerator = new LabelGenerator();
-                return labelGenerator;
-        }
-
-        Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
-                std::ostringstream os;
-                os << "__L" << current++ << "__" << suffix;
-                if ( stmt && ! stmt->get_labels().empty() ) {
-                        os << "_" << stmt->get_labels().front() << "__";
-                } // if
-                std::string ret = os.str();
-                Label l( ret );
-                l.get_attributes().push_back( new Attribute("unused") );
-                return l;
-        }
-
-ast::Label LabelGenerator::newLabel(
-                const std::string & suffix, const ast::Stmt * stmt ) {
-        assert( stmt );
-
-        std::ostringstream os;
-        os << "__L" << current++ << "__" << suffix;
-        if ( stmt && !stmt->labels.empty() ) {
-                os << "_" << stmt->labels.front() << "__";
-        }
-        ast::Label ret_label( stmt->location, os.str() );
-        ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
-        return ret_label;
+LabelGenerator * LabelGenerator::getGenerator() {
+        if ( LabelGenerator::labelGenerator == 0 )
+                LabelGenerator::labelGenerator = new LabelGenerator();
+        return labelGenerator;
 }
 
+Label LabelGenerator::newLabel( string suffix, Statement * stmt ) {
+        ostringstream os;
+        os << "__L_OLD" << current++ << "__" << suffix;
+        if ( stmt && ! stmt->get_labels().empty() ) {
+                os << "_" << stmt->get_labels().front() << "__";
+        } // if
+        string ret = os.str();
+        Label l( ret );
+        l.get_attributes().push_back( new Attribute( "unused" ) );
+        return l;
+}
 } // namespace ControlStruct
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/ControlStruct/LabelGenerator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:16:00 2021
-// Update Count     : 8
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:10 2022
+// Update Count     : 16
 //
 
@@ -21 +21 @@
 
 class Statement;
+
 namespace ast {
-        class Stmt;
-        class Label;
+class Stmt;
+class Label;
 }
 
 namespace ControlStruct {
-
 class LabelGenerator {
         static int current;
         static LabelGenerator *labelGenerator;
-protected:
+  protected:
         LabelGenerator() {}
-public:
+  public:
         static LabelGenerator *getGenerator();
         static Label newLabel(std::string suffix, Statement * stmt = nullptr);
-        static ast::Label newLabel( const std::string&, const ast::Stmt * );
-        static void reset() { current = 0; }
-        static void rewind() { current--; }
 };
-
 } // namespace ControlStruct
 

src/ControlStruct/MLEMutator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jan 22 11:50:00 2020
-// Update Count     : 223
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 20:18:57 2022
+// Update Count     : 227
 //
 
@@ -39 +39 @@
         namespace {
                 bool isLoop( const MultiLevelExitMutator::Entry & e ) {
-                        return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
+                        return dynamic_cast< WhileDoStmt * >( e.get_controlStructure() )
                                 || dynamic_cast< ForStmt * >( e.get_controlStructure() );
                 }
@@ -136 +136 @@
                         }
                 }
-                assertf( false, "Could not find label '%s' on statement %s",
+                assertf( false, "CFA internal error: could not find label '%s' on statement %s",
                         originalTarget.get_name().c_str(), toString( stmt ).c_str() );
         }
@@ -295 +295 @@
         }
 
-        void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
-                return prehandleLoopStmt( whileStmt );
+        void MultiLevelExitMutator::premutate( WhileDoStmt * whileDoStmt ) {
+                return prehandleLoopStmt( whileDoStmt );
         }
 
@@ -303 +303 @@
         }
 
-        Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
-                return posthandleLoopStmt( whileStmt );
+        Statement * MultiLevelExitMutator::postmutate( WhileDoStmt * whileDoStmt ) {
+                return posthandleLoopStmt( whileDoStmt );
         }
 
@@ -395 +395 @@
                 }
                 assert( ! enclosingControlStructures.empty() );
-                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ), "Control structure enclosing a case clause must be a switch, but is: %s", toCString( enclosingControlStructures.back().get_controlStructure() ) );
+                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ),
+                                 "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
+                                 toCString( enclosingControlStructures.back().get_controlStructure() ) );
                 if ( caseStmt->isDefault() ) {
                         if ( enclosingControlStructures.back().isFallDefaultUsed() ) {

src/ControlStruct/MLEMutator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jan 22 11:50:00 2020
-// Update Count     : 48
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb  1 09:27:24 2022
+// Update Count     : 50
 //
 
@@ -42 +42 @@
                 void premutate( CompoundStmt *cmpndStmt );
                 Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
-                void premutate( WhileStmt *whileStmt );
-                Statement * postmutate( WhileStmt *whileStmt );
+                void premutate( WhileDoStmt *whileDoStmt );
+                Statement * postmutate( WhileDoStmt *whileDoStmt );
                 void premutate( ForStmt *forStmt );
                 Statement * postmutate( ForStmt *forStmt );
@@ -67 +67 @@
                                 stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
 
-                        explicit Entry( WhileStmt *stmt, Label breakExit, Label contExit ) :
+                        explicit Entry( WhileDoStmt *stmt, Label breakExit, Label contExit ) :
                                 stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
 

src/ControlStruct/MultiLevelExit.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:48:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:56:00 2021
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 23:07:54 2022
+// Update Count     : 33
 //
 
@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
-#include "ControlStruct/LabelGenerator.h"
+#include "LabelGeneratorNew.hpp"
 
 #include <set>
+using namespace std;
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
 class Entry {
-public:
-        const ast::Stmt * stmt;
-private:
+  public:
+        const Stmt * stmt;
+  private:
         // Organized like a manual ADT. Avoids creating a bunch of dead data.
         struct Target {
-                ast::Label label;
+                Label label;
                 bool used = false;
-                Target( const ast::Label & label ) : label( label ) {}
+                Target( const Label & label ) : label( label ) {}
                 Target() : label( CodeLocation() ) {}
         };
@@ -41 +40 @@
 
         enum Kind {
-                ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
+                ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
         } kind;
 
         bool fallDefaultValid = true;
 
-        static ast::Label & useTarget( Target & target ) {
+        static Label & useTarget( Target & target ) {
                 target.used = true;
                 return target.label;
         }
-
-public:
-        Entry( const ast::ForStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmt ) {}
-        Entry( const ast::WhileStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmt ) {}
-        Entry( const ast::CompoundStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmt ) {}
-        Entry( const ast::IfStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmt ) {}
-        Entry( const ast::CaseStmt *stmt, ast::Label fallExit ) :
-                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmt ) {}
-        Entry( const ast::SwitchStmt *stmt, ast::Label breakExit, ast::Label fallDefaultExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmt ) {}
-        Entry( const ast::TryStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmt ) {}
-
-        bool isContTarget() const { return kind <= WhileStmt; }
-        bool isBreakTarget() const { return CaseStmt != kind; }
-        bool isFallTarget() const { return CaseStmt == kind; }
-        bool isFallDefaultTarget() const { return SwitchStmt == kind; }
-
-        ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
-        ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
-        ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
-        ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
-
-        bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
-        bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
-        bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
-        bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
+  public:
+        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
+        Entry( const WhileDoStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileDoStmtK ) {}
+        Entry( const CompoundStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
+        Entry( const IfStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
+        Entry( const CaseStmt *stmt, Label fallExit ) :
+                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
+        Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
+        Entry( const TryStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
+
+        bool isContTarget() const { return kind <= WhileDoStmtK; }
+        bool isBreakTarget() const { return kind != CaseStmtK; }
+        bool isFallTarget() const { return kind == CaseStmtK; }
+        bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
+
+        // These routines set a target as being "used" by a BranchStmt
+        Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
+        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
+        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
+        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
+
+        // These routines check if a specific label for a statement is used by a BranchStmt
+        bool isContUsed() const { assert( kind <= WhileDoStmtK ); return secondTarget.used; }
+        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
+        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
+        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
         void seenDefault() { fallDefaultValid = false; }
         bool isFallDefaultValid() const { return fallDefaultValid; }
 };
 
-// Helper predicates used in std::find_if calls (it doesn't take methods):
+// Helper predicates used in find_if calls (it doesn't take methods):
 bool isBreakTarget( const Entry & entry ) {
         return entry.isBreakTarget();
@@ -103 +103 @@
 
 struct MultiLevelExitCore final :
-                public ast::WithVisitorRef<MultiLevelExitCore>,
-                public ast::WithShortCircuiting, public ast::WithGuards {
+        public WithVisitorRef<MultiLevelExitCore>,
+        public WithShortCircuiting, public WithGuards {
         MultiLevelExitCore( const LabelToStmt & lt );
 
-        void previsit( const ast::FunctionDecl * );
-
-        const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
-        const ast::BranchStmt * postvisit( const ast::BranchStmt * );
-        void previsit( const ast::WhileStmt * );
-        const ast::WhileStmt * postvisit( const ast::WhileStmt * );
-        void previsit( const ast::ForStmt * );
-        const ast::ForStmt * postvisit( const ast::ForStmt * );
-        const ast::CaseStmt * previsit( const ast::CaseStmt * );
-        void previsit( const ast::IfStmt * );
-        const ast::IfStmt * postvisit( const ast::IfStmt * );
-        void previsit( const ast::SwitchStmt * );
-        const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
-        void previsit( const ast::ReturnStmt * );
-        void previsit( const ast::TryStmt * );
-        void postvisit( const ast::TryStmt * );
-        void previsit( const ast::FinallyStmt * );
-
-        const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
+        void previsit( const FunctionDecl * );
+
+        const CompoundStmt * previsit( const CompoundStmt * );
+        const BranchStmt * postvisit( const BranchStmt * );
+        void previsit( const WhileDoStmt * );
+        const WhileDoStmt * postvisit( const WhileDoStmt * );
+        void previsit( const ForStmt * );
+        const ForStmt * postvisit( const ForStmt * );
+        const CaseStmt * previsit( const CaseStmt * );
+        void previsit( const IfStmt * );
+        const IfStmt * postvisit( const IfStmt * );
+        void previsit( const SwitchStmt * );
+        const SwitchStmt * postvisit( const SwitchStmt * );
+        void previsit( const ReturnStmt * );
+        void previsit( const TryStmt * );
+        void postvisit( const TryStmt * );
+        void previsit( const FinallyStmt * );
+
+        const Stmt * mutateLoop( const Stmt * body, Entry& );
 
         const LabelToStmt & target_table;
-        std::set<ast::Label> fallthrough_labels;
-        std::vector<Entry> enclosing_control_structures;
-        ast::Label break_label;
+        set<Label> fallthrough_labels;
+        vector<Entry> enclosing_control_structures;
+        Label break_label;
         bool inFinally;
 
@@ -138 +138 @@
         const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
 
-        std::list<ast::ptr<ast::Stmt>> fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
+        list<ptr<Stmt>> fixBlock(
+                const list<ptr<Stmt>> & kids, bool caseClause );
 
         template<typename UnaryPredicate>
         auto findEnclosingControlStructure( UnaryPredicate pred ) {
-                return std::find_if( enclosing_control_structures.rbegin(),
-                        enclosing_control_structures.rend(), pred );
+                return find_if( enclosing_control_structures.rbegin(),
+                                                enclosing_control_structures.rend(), pred );
         }
 };
 
-ast::NullStmt * labelledNullStmt(
-                const CodeLocation & cl, const ast::Label & label ) {
-        return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
+NullStmt * labelledNullStmt(
+        const CodeLocation & cl, const Label & label ) {
+        return new NullStmt( cl, vector<Label>{ label } );
 }
 
@@ -158 +158 @@
 {}
 
-void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
+void MultiLevelExitCore::previsit( const FunctionDecl * ) {
         visit_children = false;
 }
 
-const ast::CompoundStmt * MultiLevelExitCore::previsit(
-                const ast::CompoundStmt * stmt ) {
+const CompoundStmt * MultiLevelExitCore::previsit(
+        const CompoundStmt * stmt ) {
         visit_children = false;
-        bool isLabeled = !stmt->labels.empty();
+
+        // if the stmt is labelled then generate a label to check in postvisit if the label is used
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
         }
 
-        auto mutStmt = ast::mutate( stmt );
+        auto mutStmt = mutate( stmt );
         // A child statement may set the break label.
-        mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
+        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
 
         if ( isLabeled ) {
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 Entry & entry = enclosing_control_structures.back();
-                if ( !entry.useBreakExit().empty() ) {
+                if ( ! entry.useBreakExit().empty() ) {
                         break_label = entry.useBreakExit();
                 }
@@ -187 +189 @@
 
 size_t getUnusedIndex(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+        const Stmt * stmt, const Label & originalTarget ) {
         const size_t size = stmt->labels.size();
 
-        // If the label is empty, we can skip adding the unused attribute:
-        if ( originalTarget.empty() ) return size;
+        // If the label is empty, do not add unused attribute.
+  if ( originalTarget.empty() ) return size;
 
         // Search for a label that matches the originalTarget.
         for ( size_t i = 0 ; i < size ; ++i ) {
-                const ast::Label & label = stmt->labels[i];
+                const Label & label = stmt->labels[i];
                 if ( label == originalTarget ) {
-                        for ( const ast::Attribute * attr : label.attributes ) {
+                        for ( const Attribute * attr : label.attributes ) {
                                 if ( attr->name == "unused" ) return size;
                         }
@@ -203 +205 @@
                 }
         }
-        assertf( false, "Could not find label '%s' on statement %s",
-                originalTarget.name.c_str(), toString( stmt ).c_str() );
-}
-
-const ast::Stmt * addUnused(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+        assertf( false, "CFA internal error: could not find label '%s' on statement %s",
+                         originalTarget.name.c_str(), toString( stmt ).c_str() );
+}
+
+const Stmt * addUnused(
+        const Stmt * stmt, const Label & originalTarget ) {
         size_t i = getUnusedIndex( stmt, originalTarget );
         if ( i == stmt->labels.size() ) {
                 return stmt;
         }
-        ast::Stmt * mutStmt = ast::mutate( stmt );
-        mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
+        Stmt * mutStmt = mutate( stmt );
+        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
         return mutStmt;
 }
 
-const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
-        std::vector<Entry>::reverse_iterator targetEntry =
+// This routine updates targets on enclosing control structures to indicate which
+//     label is used by the BranchStmt that is passed
+const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
+        vector<Entry>::reverse_iterator targetEntry =
                 enclosing_control_structures.rend();
+
+        // Labels on different stmts require different approaches to access
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Goto:
+          case BranchStmt::Goto:
                 return stmt;
-        case ast::BranchStmt::Continue:
-        case ast::BranchStmt::Break: {
-                bool isContinue = stmt->kind == ast::BranchStmt::Continue;
-                // Handle unlabeled break and continue.
-                if ( stmt->target.empty() ) {
-                        if ( isContinue ) {
-                                targetEntry = findEnclosingControlStructure( isContinueTarget );
-                        } else {
-                                if ( enclosing_control_structures.empty() ) {
-                                        SemanticError( stmt->location,
-                                                "'break' outside a loop, 'switch', or labelled block" );
-                                }
-                                targetEntry = findEnclosingControlStructure( isBreakTarget );
-                        }
-                // Handle labeled break and continue.
-                } else {
-                        // Lookup label in table to find attached control structure.
-                        targetEntry = findEnclosingControlStructure(
-                                [ targetStmt = target_table.at(stmt->target) ](auto entry){
-                                        return entry.stmt == targetStmt;
-                                } );
-                }
-                // Ensure that selected target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
-                        SemanticError(
-                                stmt->location,
-                                toString( (isContinue ? "'continue'" : "'break'"),
-                                        " target must be an enclosing ",
-                                        (isContinue ? "loop: " : "control structure: "),
-                                        stmt->originalTarget ) );
-                }
-                break;
-        }
-        case ast::BranchStmt::FallThrough: {
-                targetEntry = findEnclosingControlStructure( isFallthroughTarget );
-                // Check that target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-                if ( !stmt->target.empty() ) {
-                        // Labelled fallthrough: target must be a valid fallthough label.
-                        if ( !fallthrough_labels.count( stmt->target ) ) {
-                                SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
-                        }
-                        return new ast::BranchStmt(
-                                stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
-                }
-                break;
-        }
-        case ast::BranchStmt::FallThroughDefault: {
-                targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
-
-                // Check that this is in a switch or choose statement.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-
-                // Check that the switch or choose has a default clause.
-                auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
-                        targetEntry->stmt );
-                bool foundDefault = false;
-                for ( auto subStmt : switchStmt->stmts ) {
-                        const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
-                        if ( caseStmt->isDefault() ) {
-                                foundDefault = true;
-                                break;
-                        }
-                }
-                if ( !foundDefault ) {
-                        SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
-                }
-                break;
-        }
-        default:
+          case BranchStmt::Continue:
+          case BranchStmt::Break: {
+                  bool isContinue = stmt->kind == BranchStmt::Continue;
+                  // Handle unlabeled break and continue.
+                  if ( stmt->target.empty() ) {
+                          if ( isContinue ) {
+                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
+                          } else {
+                                  if ( enclosing_control_structures.empty() ) {
+                                          SemanticError( stmt->location,
+                                                                         "'break' outside a loop, 'switch', or labelled block" );
+                                  }
+                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
+                          }
+                          // Handle labeled break and continue.
+                  } else {
+                          // Lookup label in table to find attached control structure.
+                          targetEntry = findEnclosingControlStructure(
+                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
+                                          return entry.stmt == targetStmt;
+                                  } );
+                  }
+                  // Ensure that selected target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && ! isContinueTarget( *targetEntry ) ) ) {
+                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
+                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
+                                                        stmt->originalTarget ) );
+                  }
+                  break;
+          }
+          // handle fallthrough in case/switch stmts
+          case BranchStmt::FallThrough: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
+                  // Check that target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+                  if ( ! stmt->target.empty() ) {
+                          // Labelled fallthrough: target must be a valid fallthough label.
+                          if ( ! fallthrough_labels.count( stmt->target ) ) {
+                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
+                                                                                                                   stmt->originalTarget ) );
+                          }
+                          return new BranchStmt( stmt->location, BranchStmt::Goto, stmt->originalTarget );
+                  }
+                  break;
+          }
+          case BranchStmt::FallThroughDefault: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
+
+                  // Check if in switch or choose statement.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+
+                  // Check if switch or choose has default clause.
+                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
+                  bool foundDefault = false;
+                  for ( auto subStmt : switchStmt->stmts ) {
+                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
+                          if ( caseStmt->isDefault() ) {
+                                  foundDefault = true;
+                                  break;
+                          }
+                  }
+                  if ( ! foundDefault ) {
+                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
+                                                         "control structure with a 'default' clause" );
+                  }
+                  break;
+          }
+          default:
                 assert( false );
         }
 
-        // Branch error checks: get the appropriate label name:
-        // (This label will always be replaced.)
-        ast::Label exitLabel( CodeLocation(), "" );
+        // Branch error checks: get the appropriate label name, which is always replaced.
+        Label exitLabel( CodeLocation(), "" );
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Break:
-                assert( !targetEntry->useBreakExit().empty() );
+          case BranchStmt::Break:
+                assert( ! targetEntry->useBreakExit().empty() );
                 exitLabel = targetEntry->useBreakExit();
                 break;
-        case ast::BranchStmt::Continue:
-                assert( !targetEntry->useContExit().empty() );
+          case BranchStmt::Continue:
+                assert( ! targetEntry->useContExit().empty() );
                 exitLabel = targetEntry->useContExit();
                 break;
-        case ast::BranchStmt::FallThrough:
-                assert( !targetEntry->useFallExit().empty() );
+          case BranchStmt::FallThrough:
+                assert( ! targetEntry->useFallExit().empty() );
                 exitLabel = targetEntry->useFallExit();
                 break;
-        case ast::BranchStmt::FallThroughDefault:
-                assert( !targetEntry->useFallDefaultExit().empty() );
+          case BranchStmt::FallThroughDefault:
+                assert( ! targetEntry->useFallDefaultExit().empty() );
                 exitLabel = targetEntry->useFallDefaultExit();
                 // Check that fallthrough default comes before the default clause.
-                if ( !targetEntry->isFallDefaultValid() ) {
-                        SemanticError( stmt->location,
-                                "'fallthrough default' must precede the 'default' clause" );
+                if ( ! targetEntry->isFallDefaultValid() ) {
+                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
                 }
                 break;
-        default:
+          default:
                 assert(0);
         }
@@ -333 +335 @@
         targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
 
-        // Replace this with a goto to make later passes more uniform.
-        return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
-}
-
-void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
+        // Replace with goto to make later passes more uniform.
+        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
+}
+
+void MultiLevelExitCore::previsit( const WhileDoStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
+const WhileDoStmt * MultiLevelExitCore::postvisit( const WhileDoStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
 
-void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
+const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
@@ -355 +357 @@
 // Mimic what the built-in push_front would do anyways. It is O(n).
 void push_front(
-                std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
+        vector<ptr<Stmt>> & vec, const Stmt * element ) {
         vec.emplace_back( nullptr );
         for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
-                vec[ i ] = std::move( vec[ i - 1 ] );
+                vec[ i ] = move( vec[ i - 1 ] );
         }
         vec[ 0 ] = element;
 }
 
-const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
+const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
         visit_children = false;
 
-        // If it is the default, mark the default as seen.
+        // If default, mark seen.
         if ( stmt->isDefault() ) {
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 enclosing_control_structures.back().seenDefault();
         }
 
         // The cond may not exist, but if it does update it now.
-        visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
+        visitor->maybe_accept( stmt, &CaseStmt::cond );
 
         // Just save the mutated node for simplicity.
-        ast::CaseStmt * mutStmt = ast::mutate( stmt );
-
-        ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
-        if ( !mutStmt->stmts.empty() ) {
+        CaseStmt * mutStmt = mutate( stmt );
+
+        Label fallLabel = newLabel( "fallThrough", stmt );
+        if ( ! mutStmt->stmts.empty() ) {
                 // Ensure that the stack isn't corrupted by exceptions in fixBlock.
                 auto guard = makeFuncGuard(
                         [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
                         [this](){ enclosing_control_structures.pop_back(); }
-                );
+                        );
 
                 // These should already be in a block.
-                auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
+                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
                 block->kids = fixBlock( block->kids, true );
 
                 // Add fallthrough label if necessary.
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 Entry & entry = enclosing_control_structures.back();
                 if ( entry.isFallUsed() ) {
-                        mutStmt->stmts.push_back(
-                                labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
-                }
-        }
-        assert( !enclosing_control_structures.empty() );
+                        mutStmt->stmts.push_back( labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
+                }
+        }
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
-        assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
-                "Control structure enclosing a case clause must be a switch, but is: %s",
-                toString( entry.stmt ).c_str() );
+        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
+                         "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
+                         toString( entry.stmt ).c_str() );
         if ( mutStmt->isDefault() ) {
                 if ( entry.isFallDefaultUsed() ) {
                         // Add fallthrough default label if necessary.
-                        push_front( mutStmt->stmts, labelledNullStmt(
-                                stmt->location, entry.useFallDefaultExit()
-                        ) );
+                        push_front( mutStmt->stmts, labelledNullStmt( stmt->location, entry.useFallDefaultExit() ) );
                 }
         }
@@ -414 +413 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
-        bool labeledBlock = !stmt->labels.empty();
+void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
+        bool labeledBlock = ! stmt->labels.empty();
         if ( labeledBlock ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
@@ -423 +422 @@
 }
 
-const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
-        bool labeledBlock = !stmt->labels.empty();
+const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
+        bool labeledBlock = ! stmt->labels.empty();
         if ( labeledBlock ) {
                 auto this_label = enclosing_control_structures.back().useBreakExit();
-                if ( !this_label.empty() ) {
+                if ( ! this_label.empty() ) {
                         break_label = this_label;
                 }
@@ -434 +433 @@
 }
 
-bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
-        const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
+bool isDefaultCase( const ptr<Stmt> & stmt ) {
+        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
         return caseStmt->isDefault();
 }
 
-void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
-        ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
-        auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
-
-        const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
-                ? (it)->strict_as<ast::CaseStmt>() : nullptr;
-        ast::Label defaultLabel = defaultCase
-                ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
-                : ast::Label( stmt->location, "" );
+void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
+        Label label = newLabel( "switchBreak", stmt );
+        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
+
+        const CaseStmt * defaultCase = it != stmt->stmts.rend() ? (it)->strict_as<CaseStmt>() : nullptr;
+        Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase ) : Label( stmt->location, "" );
         enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
         GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
 
-        // Collect valid labels for fallthrough. It starts with all labels at
-        // this level, then removed as we see them in traversal.
-        for ( const ast::Stmt * stmt : stmt->stmts ) {
-                auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
+        // Collect valid labels for fallthrough. It starts with all labels at this level, then remove as each is seen during
+        // traversal.
+        for ( const Stmt * stmt : stmt->stmts ) {
+                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
                 if ( caseStmt->stmts.empty() ) continue;
-                auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
-                for ( const ast::Stmt * stmt : block->kids ) {
-                        for ( const ast::Label & l : stmt->labels ) {
+                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
+                for ( const Stmt * stmt : block->kids ) {
+                        for ( const Label & l : stmt->labels ) {
                                 fallthrough_labels.insert( l );
                         }
@@ -465 +461 @@
 }
 
-const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
-        assert( !enclosing_control_structures.empty() );
+const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == stmt );
 
-        // Only run if we need to generate the break label.
+        // Only run to generate the break label.
         if ( entry.isBreakUsed() ) {
-                // To keep the switch statements uniform (all direct children of a
-                // SwitchStmt should be CastStmts), append the exit label and break
-                // to the last case, create a default case is there are no cases.
-                ast::SwitchStmt * mutStmt = ast::mutate( stmt );
+                // To keep the switch statements uniform (all direct children of a SwitchStmt should be CastStmts), append the
+                // exit label and break to the last case, create a default case if no cases.
+                SwitchStmt * mutStmt = mutate( stmt );
                 if ( mutStmt->stmts.empty() ) {
-                        mutStmt->stmts.push_back( new ast::CaseStmt(
-                                mutStmt->location, nullptr, {} ));
-                }
-
-                auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
-                auto mutCase = ast::mutate( caseStmt );
+                        mutStmt->stmts.push_back( new CaseStmt( mutStmt->location, nullptr, {} ) );
+                }
+
+                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
+                auto mutCase = mutate( caseStmt );
                 mutStmt->stmts.back() = mutCase;
 
-                ast::Label label( mutCase->location, "breakLabel" );
-                auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
+                Label label( mutCase->location, "breakLabel" );
+                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
                 branch->labels.push_back( entry.useBreakExit() );
                 mutCase->stmts.push_back( branch );
@@ -495 +489 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
         if ( inFinally ) {
                 SemanticError( stmt->location, "'return' may not appear in a finally clause" );
@@ -501 +495 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
-        bool isLabeled = !stmt->labels.empty();
+void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
@@ -510 +504 @@
 }
 
-void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
-        bool isLabeled = !stmt->labels.empty();
+void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
                 auto this_label = enclosing_control_structures.back().useBreakExit();
-                if ( !this_label.empty() ) {
+                if ( ! this_label.empty() ) {
                         break_label = this_label;
                 }
@@ -520 +514 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
-        GuardAction([this, old = std::move(enclosing_control_structures)](){
-                enclosing_control_structures = std::move(old);
-        });
-        enclosing_control_structures = std::vector<Entry>();
+void MultiLevelExitCore::previsit( const FinallyStmt * ) {
+        GuardAction([this, old = move( enclosing_control_structures)](){ enclosing_control_structures = move(old); });
+        enclosing_control_structures = vector<Entry>();
         GuardValue( inFinally ) = true;
 }
 
-const ast::Stmt * MultiLevelExitCore::mutateLoop(
-                const ast::Stmt * body, Entry & entry ) {
+const Stmt * MultiLevelExitCore::mutateLoop(
+        const Stmt * body, Entry & entry ) {
         if ( entry.isBreakUsed() ) {
                 break_label = entry.useBreakExit();
         }
 
+        // if continue is used insert a continue label into the back of the body of the loop
         if ( entry.isContUsed() ) {
-                ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
+                CompoundStmt * new_body = new CompoundStmt( body->location );
+                // {}
                 new_body->kids.push_back( body );
+                // {
+                //  body
+                // }
                 new_body->kids.push_back(
                         labelledNullStmt( body->location, entry.useContExit() ) );
+                // {
+                //  body
+                //  ContinueLabel: {}
+                // }
                 return new_body;
         }
@@ -549 +550 @@
         // Remember is loop before going onto mutate the body.
         // The labels will be folded in if they are used.
-        ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
-        ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
+        Label breakLabel = newLabel( "loopBreak", loopStmt );
+        Label contLabel = newLabel( "loopContinue", loopStmt );
         enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
+        // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
+        // children will tag labels as being used during their traversal which occurs before postvisit
+
+        // GuardAction calls the lambda after the node is done being visited
         GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
 }
@@ -557 +562 @@
 template<typename LoopNode>
 const LoopNode * MultiLevelExitCore::posthandleLoopStmt( const LoopNode * loopStmt ) {
-        assert( !enclosing_control_structures.empty() );
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == loopStmt );
 
-        // Now we check if the labels are used and add them if so.
-        return ast::mutate_field(
-                loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
-}
-
-std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
-        // Unfortunately we can't use the automatic error collection.
+        // Now check if the labels are used and add them if so.
+        return mutate_field( loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
+        // this call to mutate_field compares loopStmt->body and the result of mutateLoop
+        //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
+        //              the stmts will only differ if a label is used
+}
+
+list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
+        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
+        // Unfortunately cannot use automatic error collection.
         SemanticErrorException errors;
 
-        std::list<ast::ptr<ast::Stmt>> ret;
+        list<ptr<Stmt>> ret;
 
         // Manually visit each child.
-        for ( const ast::ptr<ast::Stmt> & kid : kids ) {
+        for ( const ptr<Stmt> & kid : kids ) {
                 if ( is_case_clause ) {
                         // Once a label is seen, it's no longer a valid for fallthrough.
-                        for ( const ast::Label & l : kid->labels ) {
+                        for ( const Label & l : kid->labels ) {
                                 fallthrough_labels.erase( l );
                         }
@@ -588 +595 @@
                 }
 
-                if ( !break_label.empty() ) {
-                        ret.push_back(
-                                labelledNullStmt( ret.back()->location, break_label ) );
-                        break_label = ast::Label( CodeLocation(), "" );
-                }
-        }
-
-        if ( !errors.isEmpty() ) {
+                if ( ! break_label.empty() ) {
+                        ret.push_back( labelledNullStmt( ret.back()->location, break_label ) );
+                        break_label = Label( CodeLocation(), "" );
+                }
+        }
+
+        if ( ! errors.isEmpty() ) {
                 throw errors;
         }
@@ -601 +607 @@
 }
 
-} // namespace
-
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt * stmt,
-                const LabelToStmt & labelTable ) {
+const CompoundStmt * multiLevelExitUpdate(
+        const CompoundStmt * stmt,
+        const LabelToStmt & labelTable ) {
         // Must start in the body, so FunctionDecls can be a stopping point.
-        ast::Pass<MultiLevelExitCore> visitor( labelTable );
-        const ast::CompoundStmt * ret = stmt->accept( visitor );
+        Pass<MultiLevelExitCore> visitor( labelTable );
+        const CompoundStmt * ret = stmt->accept( visitor );
         return ret;
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:49:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:34:06 2022
+// Update Count     : 6
 //
 
@@ -19 +19 @@
 
 namespace ast {
-        class CompoundStmt;
-        class Label;
-        class Stmt;
+class CompoundStmt;
+class Label;
+class Stmt;
 }
 
 namespace ControlStruct {
-
 using LabelToStmt = std::map<ast::Label, const ast::Stmt *>;
 
-/// Mutate a function body to handle multi-level exits.
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt *, const LabelToStmt & );
-
+// Mutate a function body to handle multi-level exits.
+const ast::CompoundStmt * multiLevelExitUpdate( const ast::CompoundStmt *, const LabelToStmt & );
 }
 

src/ControlStruct/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Henry Xue
-## Last Modified On : Tue Jul 20 04:10:50 2021
-## Update Count     : 5
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat Jan 29 12:04:19 2022
+## Update Count     : 7
 ###############################################################################
 
@@ -22 +22 @@
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ForExprMutator.h \
+        ControlStruct/HoistControlDecls.cpp \
+        ControlStruct/HoistControlDecls.hpp \
         ControlStruct/LabelFixer.cc \
         ControlStruct/LabelFixer.h \
         ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelGenerator.h \
+        ControlStruct/LabelGeneratorNew.cpp \
+        ControlStruct/LabelGeneratorNew.hpp \
         ControlStruct/MLEMutator.cc \
         ControlStruct/MLEMutator.h \

src/InitTweak/InitTweak.cc

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 19 19:22:00 2021
-// Update Count     : 19
+// Last Modified On : Mon Dec  6 13:21:00 2021
+// Update Count     : 20
 //
 
@@ -1191 +1191 @@
         }
 
-        bool isCopyFunction( const ast::FunctionDecl * decl ) {
-                const ast::FunctionType * ftype = decl->type;
-                if ( ftype->params.size() != 2 ) return false;
-
-                const ast::Type * t1 = getPointerBase( ftype->params.front() );
-                if ( ! t1 ) return false;
-                const ast::Type * t2 = ftype->params.back();
-
-                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
-        }
+bool isAssignment( const ast::FunctionDecl * decl ) {
+        return isAssignment( decl->name ) && isCopyFunction( decl );
+}
+
+bool isDestructor( const ast::FunctionDecl * decl ) {
+        return isDestructor( decl->name );
+}
+
+bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
+        return isConstructor( decl->name ) && 1 == decl->params.size();
+}
+
+bool isCopyConstructor( const ast::FunctionDecl * decl ) {
+        return isConstructor( decl->name ) && 2 == decl->params.size();
+}
+
+bool isCopyFunction( const ast::FunctionDecl * decl ) {
+        const ast::FunctionType * ftype = decl->type;
+        if ( ftype->params.size() != 2 ) return false;
+
+        const ast::Type * t1 = getPointerBase( ftype->params.front() );
+        if ( ! t1 ) return false;
+        const ast::Type * t2 = ftype->params.back();
+
+        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
+}
 
         const FunctionDecl * isAssignment( const Declaration * decl ) {

src/InitTweak/InitTweak.h

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 19 14:18:00 2021
-// Update Count     : 7
+// Last Modified On : Mon Dec  6 13:20:00 2021
+// Update Count     : 8
 //
 
@@ -31 +31 @@
         const FunctionDecl * isCopyConstructor( const Declaration * decl );
         const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
+        bool isAssignment( const ast::FunctionDecl * decl );
+        bool isDestructor( const ast::FunctionDecl * decl );
+        bool isDefaultConstructor( const ast::FunctionDecl * decl );
+        bool isCopyConstructor( const ast::FunctionDecl * decl );
         bool isCopyFunction( const ast::FunctionDecl * decl );
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 14 17:28:53 2021
-// Update Count     : 900
+// Last Modified On : Wed Feb  2 09:15:49 2022
+// Update Count     : 905
 //
 
@@ -390 +390 @@
 Statement * build_expr( ExpressionNode * ctl );
 
-struct IfCtrl {
-        IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
+struct CondCtl {
+        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
                 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
 
@@ -409 +409 @@
 };
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
+Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
 Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_case( ExpressionNode * ctl );
 Statement * build_default();
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
+Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
 Statement * build_branch( BranchStmt::Type kind );
 Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
@@ -424 +424 @@
 Statement * build_resume( ExpressionNode * ctl );
 Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
-Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
-Statement * build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body );
+Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
+Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );

src/Parser/StatementNode.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// StatementNode.cc --
+// StatementNode.cc -- Transform from parse data-structures to AST data-structures, usually deleting the parse
+//     data-structure after the transformation.
 //
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct 24 04:20:55 2020
-// Update Count     : 383
+// Last Modified On : Wed Feb  2 20:29:30 2022
+// Update Count     : 425
 //
 
@@ -63 +64 @@
         // convert from StatementNode list to Statement list
         StatementNode * node = dynamic_cast< StatementNode * >(prev);
-        std::list< Statement * > stmts;
+        list< Statement * > stmts;
         buildMoveList( stmt, stmts );
         // splice any new Statements to end of current Statements
@@ -78 +79 @@
 } // build_expr
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init ) {
+Expression * build_if_control( CondCtl * ctl, list< Statement * > & init ) {
         if ( ctl->init != 0 ) {
                 buildMoveList( ctl->init, init );
@@ -100 +101 @@
 } // build_if_control
 
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
-        Statement * thenb, * elseb = nullptr;
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( then_stmt, branches );
-        assert( branches.size() == 1 );
-        thenb = branches.front();
-
-        if ( else_stmt ) {
-                std::list< Statement * > branches;
-                buildMoveList< Statement, StatementNode >( else_stmt, branches );
-                assert( branches.size() == 1 );
-                elseb = branches.front();
-        } // if
-
-        std::list< Statement * > init;
-        Expression * cond = build_if_control( ctl, init );
-        return new IfStmt( cond, thenb, elseb, init );
+Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+
+        Statement * astthen, * astelse = nullptr;
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( then, aststmt );
+        assert( aststmt.size() == 1 );
+        astthen = aststmt.front();
+
+        if ( else_ ) {
+                list< Statement * > aststmt;
+                buildMoveList< Statement, StatementNode >( else_, aststmt );
+                assert( aststmt.size() == 1 );
+                astelse = aststmt.front();
+        } // if
+
+        return new IfStmt( astcond, astthen, astelse, astinit );
 } // build_if
 
 Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
-        if ( ! isSwitch ) {                                                                             // choose statement
-                for ( Statement * stmt : branches ) {
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        if ( ! isSwitch ) {                                                                     // choose statement
+                for ( Statement * stmt : aststmt ) {
                         CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
                         if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
@@ -131 +133 @@
                 } // for
         } // if
-        // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
+        // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
+        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
 } // build_switch
 
 Statement * build_case( ExpressionNode * ctl ) {
-        std::list< Statement * > branches;
-        return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
+        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
 } // build_case
 
 Statement * build_default() {
-        std::list< Statement * > branches;
-        return new CaseStmt( nullptr, branches, true );
+        return new CaseStmt( nullptr, {}, true );                       // stmt starts empty and then added to
 } // build_default
 
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
-        assert( branches.size() == 1 );
-
-        std::list< Statement * > init;
-        Expression * cond = build_if_control( ctl, init );
-        return new WhileStmt( cond, branches.front(), init, false );
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
+
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+
+        return new WhileDoStmt( astcond, aststmt.front(), astelse.front(), astinit, false );
 } // build_while
 
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
-        assert( branches.size() == 1 );
-
-        std::list< Statement * > init;
-        return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), init, true );
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );                                          // compound created if empty
+
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+
+        // do-while cannot have declarations in the contitional, so init is always empty
+        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
 } // build_do_while
 
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
-        assert( branches.size() == 1 );
-
-        std::list< Statement * > init;
-        if ( forctl->init != 0 ) {
-                buildMoveList( forctl->init, init );
-        } // if
-
-        Expression * cond = 0;
-        if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
-
-        Expression * incr = 0;
-        if ( forctl->change != 0 )
-                incr = maybeMoveBuild< Expression >(forctl->change);
-
+Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
+        list< Statement * > astinit;                                            // maybe empty
+        buildMoveList( forctl->init, astinit );
+
+        Expression * astcond = nullptr;                                         // maybe empty
+        astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
+
+        Expression * astincr = nullptr;                                         // maybe empty
+        astincr = maybeMoveBuild< Expression >(forctl->change);
         delete forctl;
-        return new ForStmt( init, cond, incr, branches.front() );
+
+        list< Statement * > aststmt;                                            // loop body, compound created if empty
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+
+        list< Statement * > astelse;                                            // else clause, maybe empty
+        buildMoveList< Statement, StatementNode >( else_, astelse );
+
+        return new ForStmt( astinit, astcond, astincr, aststmt.front(), astelse.front() );
 } // build_for
 
@@ -191 +197 @@
 } // build_branch
 
-Statement * build_branch( std::string * identifier, BranchStmt::Type kind ) {
+Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
         Statement * ret = new BranchStmt( * identifier, kind );
         delete identifier;                                                                      // allocated by lexer
@@ -202 +208 @@
 
 Statement * build_return( ExpressionNode * ctl ) {
-        std::list< Expression * > exps;
+        list< Expression * > exps;
         buildMoveList( ctl, exps );
         return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
@@ -208 +214 @@
 
 Statement * build_throw( ExpressionNode * ctl ) {
-        std::list< Expression * > exps;
+        list< Expression * > exps;
         buildMoveList( ctl, exps );
-        assertf( exps.size() < 2, "This means we are leaking memory");
+        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
         return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
 } // build_throw
 
 Statement * build_resume( ExpressionNode * ctl ) {
-        std::list< Expression * > exps;
+        list< Expression * > exps;
         buildMoveList( ctl, exps );
-        assertf( exps.size() < 2, "This means we are leaking memory");
+        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
         return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
 } // build_resume
@@ -227 +233 @@
 } // build_resume_at
 
-Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt ) {
-        std::list< CatchStmt * > branches;
-        buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
-        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
-        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
-        return new TryStmt( tryBlock, branches, finallyBlock );
+Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
+        list< CatchStmt * > aststmt;
+        buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
+        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
+        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
+        return new TryStmt( tryBlock, aststmt, finallyBlock );
 } // build_try
 
 Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( body, branches );
-        assert( branches.size() == 1 );
-        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( body, aststmt );
+        assert( aststmt.size() == 1 );
+        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
 } // build_catch
 
 Statement * build_finally( StatementNode * stmt ) {
-        std::list< Statement * > branches;
-        buildMoveList< Statement, StatementNode >( stmt, branches );
-        assert( branches.size() == 1 );
-        return new FinallyStmt( dynamic_cast< CompoundStmt * >( branches.front() ) );
+        list< Statement * > aststmt;
+        buildMoveList< Statement, StatementNode >( stmt, aststmt );
+        assert( aststmt.size() == 1 );
+        return new FinallyStmt( dynamic_cast< CompoundStmt * >( aststmt.front() ) );
 } // build_finally
 
@@ -254 +260 @@
         node->type = type;
 
-        std::list< Statement * > stmts;
+        list< Statement * > stmts;
         buildMoveList< Statement, StatementNode >( then, stmts );
         if(!stmts.empty()) {
@@ -319 +325 @@
 } // build_waitfor_timeout
 
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_stmt, ExpressionNode * else_when ) {
+WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_, ExpressionNode * else_when ) {
         auto node = new WaitForStmt();
 
@@ -326 +332 @@
         node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
 
-        node->orelse.statement  = maybeMoveBuild<Statement >( else_stmt );
+        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
         node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
 
@@ -333 +339 @@
 
 Statement * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
-        std::list< Expression * > e;
+        list< Expression * > e;
         buildMoveList( exprs, e );
         Statement * s = maybeMoveBuild<Statement>( stmt );
@@ -361 +367 @@
 
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
-        std::list< Expression * > out, in;
-        std::list< ConstantExpr * > clob;
+        list< Expression * > out, in;
+        list< ConstantExpr * > clob;
 
         buildMoveList( output, out );
@@ -375 +381 @@
 
 Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
-        std::list< Expression * > expList;
+        list< Expression * > expList;
         buildMoveList( exprs, expList );
         Statement * body = maybeMoveBuild<Statement>( stmt );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 15 09:20:17 2021
-// Update Count     : 5163
+// Last Modified On : Tue Feb  1 11:06:13 2022
+// Update Count     : 5167
 //
 
@@ -238 +238 @@
         WaitForStmt * wfs;
         Expression * constant;
-        IfCtrl * ifctl;
+        CondCtl * ifctl;
         ForCtrl * fctl;
         enum OperKinds compop;
@@ -327 +327 @@
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
-%type<ifctl> if_control_expression
+%type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> inclexcl
@@ -1123 +1123 @@
 
 if_statement:
-        IF '(' if_control_expression ')' statement                      %prec THEN
+        IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
-        | IF '(' if_control_expression ')' statement ELSE statement
+        | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
-if_control_expression:
+conditional_declaration:
         comma_expression
-                { $$ = new IfCtrl( nullptr, $1 ); }
+                { $$ = new CondCtl( nullptr, $1 ); }
         | c_declaration                                                                         // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | cfa_declaration                                                                       // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | declaration comma_expression                                          // semi-colon separated
-                { $$ = new IfCtrl( $1, $2 ); }
+                { $$ = new CondCtl( $1, $2 ); }
         ;
 
@@ -1193 +1193 @@
 iteration_statement:
         WHILE '(' ')' statement                                                         // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
+                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
@@ -1203 +1204 @@
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
@@ -1209 +1211 @@
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
         | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
-                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
         ;
 

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 11:58:00 2020
-// Update Count     : 242
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb  1 16:27:14 2022
+// Update Count     : 245
 //
 
@@ -80 +80 @@
                 void previsit( AsmStmt * asmStmt );
                 void previsit( IfStmt * ifStmt );
-                void previsit( WhileStmt * whileStmt );
+                void previsit( WhileDoStmt * whileDoStmt );
                 void previsit( ForStmt * forStmt );
                 void previsit( SwitchStmt * switchStmt );
@@ -502 +502 @@
         }
 
-        void Resolver_old::previsit( WhileStmt * whileStmt ) {
-                findIntegralExpression( whileStmt->condition, indexer );
+        void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
+                findIntegralExpression( whileDoStmt->condition, indexer );
         }
 
@@ -572 +572 @@
 
         void Resolver_old::previsit( CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // Until we are very sure this invarent (ifs that move between passes have then)
                 // holds, check it. This allows a check for when to decode the mangling.
                 if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
-                        assert( ifStmt->thenPart );
+                        assert( ifStmt->then );
                 }
                 // Encode the catchStmt so the condition can see the declaration.
@@ -588 +588 @@
                 // Decode the catchStmt so everything is stored properly.
                 IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
-                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
                         assert( ifStmt->condition );
-                        assert( ifStmt->elsePart );
+                        assert( ifStmt->else_ );
                         catchStmt->cond = ifStmt->condition;
-                        catchStmt->body = ifStmt->elsePart;
+                        catchStmt->body = ifStmt->else_;
                         ifStmt->condition = nullptr;
-                        ifStmt->elsePart = nullptr;
+                        ifStmt->else_ = nullptr;
                         delete ifStmt;
                 }
@@ -1272 +1272 @@
                 const ast::AsmStmt *         previsit( const ast::AsmStmt * );
                 const ast::IfStmt *          previsit( const ast::IfStmt * );
-                const ast::WhileStmt *       previsit( const ast::WhileStmt * );
+                const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
                 const ast::ForStmt *         previsit( const ast::ForStmt * );
                 const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
@@ -1581 +1581 @@
         }
 
-        const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
+        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
                 return ast::mutate_field(
-                        whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
+                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
         }
 
@@ -1669 +1669 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // Until we are very sure this invarent (ifs that move between passes have then)
                 // holds, check it. This allows a check for when to decode the mangling.
                 if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
-                        assert( ifStmt->thenPart );
+                        assert( ifStmt->then );
                 }
                 // Encode the catchStmt so the condition can see the declaration.
@@ -1687 +1687 @@
                 // Decode the catchStmt so everything is stored properly.
                 const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
-                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
                         assert( ifStmt->cond );
-                        assert( ifStmt->elsePart );
+                        assert( ifStmt->else_ );
                         ast::CatchStmt * stmt = ast::mutate( catchStmt );
                         stmt->cond = ifStmt->cond;
-                        stmt->body = ifStmt->elsePart;
+                        stmt->body = ifStmt->else_;
                         // ifStmt should be implicately deleted here.
                         return stmt;

src/SymTab/Validate.cc

@@ -453 +453 @@
         }
 
+        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ForallPointerDecay_old> fpd;
+                acceptAll( translationUnit, fpd );
+        }
+
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
                 validate_A( translationUnit );
@@ -470 +475 @@
                 type->accept( fpd );
         }
-
 
         void HoistTypeDecls::handleType( Type * type ) {

src/SymTab/Validate.h

@@ -42 +42 @@
         void validate_E( std::list< Declaration * > &translationUnit );
         void validate_F( std::list< Declaration * > &translationUnit );
+        void decayForallPointers( std::list< Declaration * > & translationUnit );
 
         const ast::Type * validateType(

src/SynTree/Mutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:35:36 2021
-// Update Count     : 18
+// Last Modified On : Tue Feb  1 09:26:49 2022
+// Update Count     : 20
 //
 #pragma once
@@ -42 +42 @@
         virtual Statement * mutate( DirectiveStmt * dirStmt ) = 0;
         virtual Statement * mutate( IfStmt * ifStmt ) = 0;
-        virtual Statement * mutate( WhileStmt * whileStmt ) = 0;
+        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) = 0;
         virtual Statement * mutate( ForStmt * forStmt ) = 0;
         virtual Statement * mutate( SwitchStmt * switchStmt ) = 0;

src/SynTree/Statement.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Jan 20 16:03:00 2020
-// Update Count     : 71
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Feb  2 20:19:33 2022
+// Update Count     : 90
 //
 
@@ -29 +29 @@
 #include "SynTree/Label.h"         // for Label, operator<<
 
-using std::string;
-using std::endl;
-
-Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
-
-void Statement::print( std::ostream & os, Indenter indent ) const {
+using namespace std;
+
+
+Statement::Statement( const list<Label> & labels ) : labels( labels ) {}
+
+void Statement::print( ostream & os, Indenter indent ) const {
         if ( ! labels.empty() ) {
                 os << indent << "... Labels: {";
@@ -54 +54 @@
 }
 
-void ExprStmt::print( std::ostream & os, Indenter indent ) const {
-        os << "Expression Statement:" << endl << indent+1;
-        expr->print( os, indent+1 );
-}
-
-
-AsmStmt::AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+void ExprStmt::print( ostream & os, Indenter indent ) const {
+        os << "Expression Statement:" << endl << indent + 1;
+        expr->print( os, indent + 1 );
+}
+
+
+AsmStmt::AsmStmt( bool voltile, Expression * instruction, const list<Expression *> output, const list<Expression *> input, const list<ConstantExpr *> clobber, const list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -75 +75 @@
 }
 
-void AsmStmt::print( std::ostream & os, Indenter indent ) const {
+void AsmStmt::print( ostream & os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
-        os << indent+1 << "instruction: " << endl << indent;
-        instruction->print( os, indent+1 );
+        os << indent + 1 << "instruction: " << endl << indent;
+        instruction->print( os, indent + 1 );
         if ( ! output.empty() ) {
-                os << endl << indent+1 << "output: " << endl;
-                printAll( output, os, indent+1 );
+                os << endl << indent + 1 << "output: " << endl;
+                printAll( output, os, indent + 1 );
         } // if
         if ( ! input.empty() ) {
-                os << indent+1 << "input: " << endl;
-                printAll( input, os, indent+1 );
+                os << indent + 1 << "input: " << endl;
+                printAll( input, os, indent + 1 );
         } // if
         if ( ! clobber.empty() ) {
-                os << indent+1 << "clobber: " << endl;
-                printAll( clobber, os, indent+1 );
+                os << indent + 1 << "clobber: " << endl;
+                printAll( clobber, os, indent + 1 );
         } // if
 }
 
 
-DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
-
-void DirectiveStmt::print( std::ostream & os, Indenter ) const {
+DirectiveStmt::DirectiveStmt( const string & directive ) : Statement(), directive( directive ) {}
+
+void DirectiveStmt::print( ostream & os, Indenter ) const {
         os << "GCC Directive:" << directive << endl;
 }
@@ -120 +120 @@
 }
 
-void BranchStmt::print( std::ostream & os, Indenter indent ) const {
-        assert(type < 5);
+void BranchStmt::print( ostream & os, Indenter indent ) const {
+        assertf(type < BranchStmts, "CFA internal error: invalid branch statement" );
         os << "Branch (" << brType[type] << ")" << endl ;
-        if ( target != "" ) os << indent+1 << "with target: " << target << endl;
-        if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
-        if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
+        if ( target != "" ) os << indent + 1 << "with target: " << target << endl;
+        if ( originalTarget != "" ) os << indent + 1 << "with original target: " << originalTarget << endl;
+        if ( computedTarget != nullptr ) os << indent + 1 << "with computed target: " << computedTarget << endl;
 }
 
@@ -136 +136 @@
 }
 
-void ReturnStmt::print( std::ostream & os, Indenter indent ) const {
+void ReturnStmt::print( ostream & os, Indenter indent ) const {
         os << "Return Statement, returning: ";
         if ( expr != nullptr ) {
-                os << endl << indent+1;
-                expr->print( os, indent+1 );
+                os << endl << indent + 1;
+                expr->print( os, indent + 1 );
         }
         os << endl;
 }
 
-IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
-        Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
+IfStmt::IfStmt( Expression * condition, Statement * then, Statement * else_, const list<Statement *> initialization ):
+        Statement(), condition( condition ), then( then ), else_( else_ ), initialization( initialization ) {}
 
 IfStmt::IfStmt( const IfStmt & other ) :
-        Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {
+        Statement( other ), condition( maybeClone( other.condition ) ), then( maybeClone( other.then ) ), else_( maybeClone( other.else_ ) ) {
         cloneAll( other.initialization, initialization );
 }
@@ -156 +156 @@
         deleteAll( initialization );
         delete condition;
-        delete thenPart;
-        delete elsePart;
-}
-
-void IfStmt::print( std::ostream & os, Indenter indent ) const {
+        delete then;
+        delete else_;
+}
+
+void IfStmt::print( ostream & os, Indenter indent ) const {
         os << "If on condition: " << endl;
-        os << indent+1;
-        condition->print( os, indent+1 );
+        os << indent + 1;
+        condition->print( os, indent + 1 );
 
         if ( !initialization.empty() ) {
                 os << indent << "... with initialization: \n";
                 for ( const Statement * stmt : initialization ) {
-                        os << indent+1;
-                        stmt->print( os, indent+1 );
+                        os << indent + 1;
+                        stmt->print( os, indent + 1 );
                 }
                 os << endl;
@@ -176 +176 @@
         os << indent << "... then: " << endl;
 
-        os << indent+1;
-        thenPart->print( os, indent+1 );
-
-        if ( elsePart != nullptr ) {
+        os << indent + 1;
+        then->print( os, indent + 1 );
+
+        if ( else_ != nullptr ) {
                 os << indent << "... else: " << endl;
-                os << indent+1;
-                elsePart->print( os, indent+1 );
+                os << indent + 1;
+                else_->print( os, indent + 1 );
         } // if
 }
 
-SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> & statements ):
+SwitchStmt::SwitchStmt( Expression * condition, const list<Statement *> & statements ):
         Statement(), condition( condition ), statements( statements ) {
 }
@@ -201 +201 @@
 }
 
-void SwitchStmt::print( std::ostream & os, Indenter indent ) const {
+void SwitchStmt::print( ostream & os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
@@ -207 +207 @@
 
         for ( const Statement * stmt : statements ) {
-                stmt->print( os, indent+1 );
-        }
-}
-
-CaseStmt::CaseStmt( Expression * condition, const std::list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
-        Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+                stmt->print( os, indent + 1 );
+        }
+}
+
+CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
+                Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
 }
 
 CaseStmt::CaseStmt( const CaseStmt & other ) :
-        Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
+                Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
         cloneAll( other.stmts, stmts );
 }
@@ -226 +226 @@
 }
 
-CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
+CaseStmt * CaseStmt::makeDefault( const list<Label> & labels, list<Statement *> stmts ) {
         CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
         stmt->labels = labels;
@@ -232 +232 @@
 }
 
-void CaseStmt::print( std::ostream & os, Indenter indent ) const {
+void CaseStmt::print( ostream & os, Indenter indent ) const {
         if ( isDefault() ) os << indent << "Default ";
         else {
@@ -241 +241 @@
 
         for ( Statement * stmt : stmts ) {
-                os << indent+1;
-                stmt->print( os, indent+1 );
-        }
-}
-
-WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
-        Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
-}
-
-WhileStmt::WhileStmt( const WhileStmt & other ):
+                os << indent + 1;
+                stmt->print( os, indent + 1 );
+        }
+}
+
+WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, const list< Statement * > & initialization, bool isDoWhile ):
+        Statement(), condition( condition ), body( body ), else_( nullptr ), initialization( initialization ), isDoWhile( isDoWhile) {
+}
+
+WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, Statement * else_, const list< Statement * > & initialization, bool isDoWhile ):
+        Statement(), condition( condition), body( body ), else_( else_ ), initialization( initialization ), isDoWhile( isDoWhile) {
+}
+
+WhileDoStmt::WhileDoStmt( const WhileDoStmt & other ):
         Statement( other ), condition( maybeClone( other.condition ) ), body( maybeClone( other.body ) ), isDoWhile( other.isDoWhile ) {
 }
 
-WhileStmt::~WhileStmt() {
+WhileDoStmt::~WhileDoStmt() {
         delete body;
         delete condition;
 }
 
-void WhileStmt::print( std::ostream & os, Indenter indent ) const {
+void WhileDoStmt::print( ostream & os, Indenter indent ) const {
         os << "While on condition: " << endl ;
-        condition->print( os, indent+1 );
+        condition->print( os, indent + 1 );
 
         os << indent << "... with body: " << endl;
 
-        if ( body != nullptr ) body->print( os, indent+1 );
-}
-
-ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
-        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+        if ( body != nullptr ) body->print( os, indent + 1 );
+}
+
+ForStmt::ForStmt( const list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body, Statement * else_ ):
+        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ), else_( else_ ) {
 }
 
 ForStmt::ForStmt( const ForStmt & other ):
-        Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ) {
+        Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ), else_( maybeClone( other.else_ ) ) {
                 cloneAll( other.initialization, initialization );
 
@@ -283 +287 @@
         delete increment;
         delete body;
-}
-
-void ForStmt::print( std::ostream & os, Indenter indent ) const {
+        delete else_;
+}
+
+void ForStmt::print( ostream & os, Indenter indent ) const {
         Statement::print( os, indent ); // print labels
 
@@ -293 +298 @@
                 os << indent << "... initialization: \n";
                 for ( Statement * stmt : initialization ) {
-                        os << indent+1;
-                        stmt->print( os, indent+1 );
+                        os << indent + 1;
+                        stmt->print( os, indent + 1 );
                 }
         }
 
         if ( condition != nullptr ) {
-                os << indent << "... condition: \n" << indent+1;
-                condition->print( os, indent+1 );
+                os << indent << "... condition: \n" << indent + 1;
+                condition->print( os, indent + 1 );
         }
 
         if ( increment != nullptr ) {
-                os << "\n" << indent << "... increment: \n" << indent+1;
-                increment->print( os, indent+1 );
+                os << "\n" << indent << "... increment: \n" << indent + 1;
+                increment->print( os, indent + 1 );
         }
 
         if ( body != nullptr ) {
-                os << "\n" << indent << "... with body: \n" << indent+1;
-                body->print( os, indent+1 );
+                os << "\n" << indent << "... with body: \n" << indent + 1;
+                body->print( os, indent + 1 );
+        }
+
+        if ( else_ != nullptr ) {
+                os << "\n" << indent << "... with body: \n" << indent + 1;
+                else_->print( os, indent + 1 );
         }
         os << endl;
@@ -329 +339 @@
 }
 
-void ThrowStmt::print( std::ostream & os, Indenter indent) const {
+void ThrowStmt::print( ostream & os, Indenter indent) const {
         if ( target ) os << "Non-Local ";
         os << "Throw Statement, raising: ";
-        expr->print(os, indent+1);
+        expr->print(os, indent + 1);
         if ( target ) {
                 os << "... at: ";
-                target->print(os, indent+1);
-        }
-}
-
-TryStmt::TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
+                target->print(os, indent + 1);
+        }
+}
+
+TryStmt::TryStmt( CompoundStmt * tryBlock, const list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
         Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
@@ -353 +363 @@
 }
 
-void TryStmt::print( std::ostream & os, Indenter indent ) const {
+void TryStmt::print( ostream & os, Indenter indent ) const {
         os << "Try Statement" << endl;
-        os << indent << "... with block:" << endl << indent+1;
-        block->print( os, indent+1 );
+        os << indent << "... with block:" << endl << indent + 1;
+        block->print( os, indent + 1 );
 
         // handlers
         os << indent << "... and handlers:" << endl;
         for ( const CatchStmt * stmt : handlers ) {
-                os << indent+1;
-                stmt->print( os, indent+1 );
+                os << indent + 1;
+                stmt->print( os, indent + 1 );
         }
 
         // finally block
         if ( finallyBlock != nullptr ) {
-                os << indent << "... and finally:" << endl << indent+1;
-                finallyBlock->print( os, indent+1 );
+                os << indent << "... and finally:" << endl << indent + 1;
+                finallyBlock->print( os, indent + 1 );
         } // if
 }
@@ -386 +396 @@
 }
 
-void CatchStmt::print( std::ostream & os, Indenter indent ) const {
+void CatchStmt::print( ostream & os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
 
         os << indent << "... catching: ";
-        decl->printShort( os, indent+1 );
+        decl->printShort( os, indent + 1 );
         os << endl;
 
         if ( cond ) {
-                os << indent << "... with conditional:" << endl << indent+1;
-                cond->print( os, indent+1 );
+                os << indent << "... with conditional:" << endl << indent + 1;
+                cond->print( os, indent + 1 );
         }
 
         os << indent << "... with block:" << endl;
-        os << indent+1;
-        body->print( os, indent+1 );
+        os << indent + 1;
+        body->print( os, indent + 1 );
 }
 
@@ -414 +424 @@
 }
 
-void FinallyStmt::print( std::ostream & os, Indenter indent ) const {
+void FinallyStmt::print( ostream & os, Indenter indent ) const {
         os << "Finally Statement" << endl;
-        os << indent << "... with block:" << endl << indent+1;
-        block->print( os, indent+1 );
+        os << indent << "... with block:" << endl << indent + 1;
+        block->print( os, indent + 1 );
 }
 
@@ -429 +439 @@
 }
 
-void SuspendStmt::print( std::ostream & os, Indenter indent ) const {
+void SuspendStmt::print( ostream & os, Indenter indent ) const {
         os << "Suspend Statement";
         switch (type) {
@@ -486 +496 @@
 }
 
-void WaitForStmt::print( std::ostream & os, Indenter indent ) const {
+void WaitForStmt::print( ostream & os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
         indent += 1;
@@ -521 +531 @@
 
 
-WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Declaration("", noStorageClasses, LinkageSpec::Cforall), exprs( exprs ), stmt( stmt ) {}
+WithStmt::WithStmt( const list< Expression * > & exprs, Statement * stmt ) : Declaration("", noStorageClasses, LinkageSpec::Cforall), exprs( exprs ), stmt( stmt ) {}
 WithStmt::WithStmt( const WithStmt & other ) : Declaration( other ), stmt( maybeClone( other.stmt ) ) {
         cloneAll( other.exprs, exprs );
@@ -530 +540 @@
 }
 
-void WithStmt::print( std::ostream & os, Indenter indent ) const {
+void WithStmt::print( ostream & os, Indenter indent ) const {
         os << "With statement" << endl;
         os << indent << "... with expressions: " << endl;
-        printAll( exprs, os, indent+1 );
-        os << indent << "... with statement:" << endl << indent+1;
-        stmt->print( os, indent+1 );
-}
-
-
-NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
-}
-
-void NullStmt::print( std::ostream & os, Indenter indent ) const {
+        printAll( exprs, os, indent + 1 );
+        os << indent << "... with statement:" << endl << indent + 1;
+        stmt->print( os, indent + 1 );
+}
+
+
+NullStmt::NullStmt( const list<Label> & labels ) : Statement( labels ) {
+}
+
+void NullStmt::print( ostream & os, Indenter indent ) const {
         os << "Null Statement" << endl;
         Statement::print( os, indent );
@@ -558 +568 @@
 }
 
-void ImplicitCtorDtorStmt::print( std::ostream & os, Indenter indent ) const {
+void ImplicitCtorDtorStmt::print( ostream & os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
         os << indent << "... with Ctor/Dtor: ";
-        callStmt->print( os, indent+1);
+        callStmt->print( os, indent + 1);
         os << endl;
 }
 
-MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs ) 
+MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs ) 
         : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
 
@@ -577 +587 @@
 }
 
-void MutexStmt::print( std::ostream & os, Indenter indent ) const {
+void MutexStmt::print( ostream & os, Indenter indent ) const {
         os << "Mutex Statement" << endl;
         os << indent << "... with Expressions: " << endl;
         for (auto * obj : mutexObjs) {
-                os << indent+1;
-                obj->print( os, indent+1);
+                os << indent + 1;
+                obj->print( os, indent + 1);
                 os << endl;
         }
-        os << indent << "... with Statement: " << endl << indent+1;
-        stmt->print( os, indent+1 );
+        os << indent << "... with Statement: " << endl << indent + 1;
+        stmt->print( os, indent + 1 );
 }
 

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jan 10 14:13:24 2020
-// Update Count     : 85
+// Last Modified On : Wed Feb  2 20:15:30 2022
+// Update Count     : 98
 //
 
@@ -107 +107 @@
         std::list<Label> gotolabels;
 
-        AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( bool voltile, Expression * instruction, const std::list<Expression *> output, const std::list<Expression *> input, const std::list<ConstantExpr *> clobber, const std::list<Label> gotolabels );
         AsmStmt( const AsmStmt & other );
         virtual ~AsmStmt();
@@ -148 +148 @@
   public:
         Expression * condition;
-        Statement * thenPart;
-        Statement * elsePart;
+        Statement * then;
+        Statement * else_;
         std::list<Statement *> initialization;
 
-        IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
-                        std::list<Statement *> initialization = std::list<Statement *>() );
+        IfStmt( Expression * condition, Statement * then, Statement * else_,
+                        const std::list<Statement *> initialization = std::list<Statement *>() );
         IfStmt( const IfStmt & other );
         virtual ~IfStmt();
@@ -160 +160 @@
         Expression * get_condition() { return condition; }
         void set_condition( Expression * newValue ) { condition = newValue; }
-        Statement * get_thenPart() { return thenPart; }
-        void set_thenPart( Statement * newValue ) { thenPart = newValue; }
-        Statement * get_elsePart() { return elsePart; }
-        void set_elsePart( Statement * newValue ) { elsePart = newValue; }
+        Statement * get_then() { return then; }
+        void set_then( Statement * newValue ) { then = newValue; }
+        Statement * get_else() { return else_; }
+        void set_else( Statement * newValue ) { else_ = newValue; }
 
         virtual IfStmt * clone() const override { return new IfStmt( *this ); }
@@ -225 +225 @@
 };
 
-class WhileStmt : public Statement {
+class WhileDoStmt : public Statement {
   public:
         Expression * condition;
         Statement * body;
+        Statement * else_;
         std::list<Statement *> initialization;
         bool isDoWhile;
 
-        WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
-        WhileStmt( const WhileStmt & other );
-        virtual ~WhileStmt();
+        WhileDoStmt( Expression * condition, Statement * body, const std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileDoStmt( Expression * condition, Statement * body, Statement * else_, const std::list<Statement *> & initialization, bool isDoWhile = false );
+        WhileDoStmt( const WhileDoStmt & other );
+        virtual ~WhileDoStmt();
 
         Expression * get_condition() { return condition; }
@@ -243 +245 @@
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-        virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
+        virtual WhileDoStmt * clone() const override { return new WhileDoStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }
@@ -256 +258 @@
         Expression * increment;
         Statement * body;
-
-        ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
+        Statement * else_;
+
+        ForStmt( const std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr, Statement * else_ = nullptr );
         ForStmt( const ForStmt & other );
         virtual ~ForStmt();
@@ -278 +281 @@
 class BranchStmt : public Statement {
   public:
-        enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
+        enum Type { Goto, Break, Continue, FallThrough, FallThroughDefault, BranchStmts };
 
         // originalTarget kept for error messages.
@@ -357 +360 @@
         FinallyStmt * finallyBlock;
 
-        TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
+        TryStmt( CompoundStmt * tryBlock, const std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
         TryStmt( const TryStmt & other );
         virtual ~TryStmt();
@@ -540 +543 @@
         std::list<Expression *> mutexObjs; // list of mutex objects to acquire
 
-        MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
+        MutexStmt( Statement * stmt, const std::list<Expression *> mutexObjs );
         MutexStmt( const MutexStmt & other );
         virtual ~MutexStmt();

src/SynTree/SynTree.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:56:44 2021
-// Update Count     : 13
+// Last Modified On : Tue Feb  1 09:22:33 2022
+// Update Count     : 14
 //
 
@@ -45 +45 @@
 class DirectiveStmt;
 class IfStmt;
-class WhileStmt;
+class WhileDoStmt;
 class ForStmt;
 class SwitchStmt;

src/SynTree/Visitor.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:35:35 2021
-// Update Count     : 15
+// Last Modified On : Tue Feb  1 09:26:57 2022
+// Update Count     : 17
 //
 
@@ -60 +60 @@
         virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
         virtual void visit( const IfStmt * ifStmt ) = 0;
-        virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
-        virtual void visit( const WhileStmt * whileStmt ) = 0;
+        virtual void visit( WhileDoStmt * node ) { visit( const_cast<const WhileDoStmt *>(node) ); }
+        virtual void visit( const WhileDoStmt * whileDoStmt ) = 0;
         virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
         virtual void visit( const ForStmt * forStmt ) = 0;

src/Validate/module.mk

@@ -16 +16 @@
 
 SRC_VALIDATE = \
+        Validate/Autogen.cpp \
+        Validate/Autogen.hpp \
         Validate/CompoundLiteral.cpp \
         Validate/CompoundLiteral.hpp \

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Nov 30 10:25:00 2021
-// Update Count     : 659
+// Last Modified On : Wed Jan 26 14:09:00 2022
+// Update Count     : 670
 //
 
@@ -55 +55 @@
 #include "ControlStruct/ExceptTranslate.h"  // for translateEHM
 #include "ControlStruct/FixLabels.hpp"      // for fixLabels
+#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
@@ -73 +74 @@
 #include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
+#include "Validate/Autogen.hpp"             // for autogenerateRoutines
 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
 #include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
@@ -78 +80 @@
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
 #include "Virtual/ExpandCasts.h"            // for expandCasts
-
 
 static void NewPass( const char * const name ) {
@@ -326 +327 @@
                 PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
                 PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
-                PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
 
                 CodeTools::fillLocations( translationUnit );
 
                 if( useNewAST ) {
+                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
+                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
+                        CodeTools::fillLocations( translationUnit );
+
                         if (Stats::Counters::enabled) {
                                 ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
@@ -338 +342 @@
 
                         forceFillCodeLocations( transUnit );
+
+                        // Must happen before autogen routines are added.
+                        PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
+
+                        // Must be after enum and pointer decay.
+                        // Must be before compound literals.
+                        PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
 
                         PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
@@ -409 +420 @@
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
                         PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
                         PASS( "Validate-F", SymTab::validate_F( translationUnit ) );