Changeset 17cb385 for src

Timestamp:

Feb 2, 2022, 7:51:30 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

941e14a

Parents:

fc72696c (diff), 4e7171f (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/Fwd.hpp (modified) (2 diffs)
• AST/Node.cpp (modified) (2 diffs)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (3 diffs)
• AST/Print.cpp (modified) (2 diffs)
• AST/Stmt.hpp (modified) (7 diffs)
• AST/Visitor.hpp (modified) (2 diffs)
• CodeGen/CodeGenerator.cc (modified) (4 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/ForExprMutator.cc (modified) (2 diffs)
• ControlStruct/ForExprMutator.h (modified) (3 diffs)
• ControlStruct/HoistControlDecls.cpp (modified) (3 diffs)
• ControlStruct/LabelFixer.cc (modified) (2 diffs)
• ControlStruct/LabelGeneratorNew.cpp (modified) (2 diffs)
• ControlStruct/MLEMutator.cc (modified) (4 diffs)
• ControlStruct/MLEMutator.h (modified) (3 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (12 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/StatementNode.cc (modified) (15 diffs)
• Parser/parser.yy (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (9 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/Statement.cc (modified) (8 diffs)
• SynTree/Statement.h (modified) (6 diffs)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/Visitor.h (modified) (2 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/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/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

@@ -756 +756 @@
                 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_ );
         }
 
@@ -764 +764 @@
 
 //--------------------------------------------------------------------------
-// WhileStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
+// WhileDoStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
         VISIT_START( node );
 
@@ -772 +772 @@
                 // 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  );
         }
 

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.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 22:38:53 2022
-// Update Count     : 12
+// Last Modified On : Tue Feb  1 17:44:46 2022
+// Update Count     : 24
 //
 
@@ -42 +42 @@
                 : ParseNode(loc), labels(std::move(labels)) {}
 
-        Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
+        Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}
 
         const Stmt * accept( Visitor & v ) const override = 0;
@@ -56 +56 @@
 
         CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
-                                 std::vector<Label>&& labels = {} )
+                                 std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
 
-        CompoundStmt( const CompoundStmt& o );
-        CompoundStmt( CompoundStmt&& o ) = default;
+        CompoundStmt( const CompoundStmt & o );
+        CompoundStmt( CompoundStmt && o ) = default;
 
         void push_back( const Stmt * s ) { kids.emplace_back( s ); }
@@ -88 +88 @@
         ptr<Expr> expr;
 
-        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
+        ExprStmt( const CodeLocation & loc, const Expr* e, std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), expr(e) {}
 
@@ -139 +139 @@
   public:
         ptr<Expr> cond;
-        ptr<Stmt> thenPart;
-        ptr<Stmt> elsePart;
+        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 = {},
+        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
+                        const Stmt * else_ = nullptr, std::vector<ptr<Stmt>> && inits = {},
                         std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
+                : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
                   inits(std::move(inits)) {}
 
@@ -191 +191 @@
 
 // While loop: while (...) ... else ... or do ... while (...) else ...;
-class WhileStmt final : public Stmt {
+class WhileDoStmt final : public Stmt {
   public:
         ptr<Expr> cond;
         ptr<Stmt> body;
-        ptr<Stmt> elsePart;
+        ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
 
-        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
+        WhileDoStmt( 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 }; }
+                : 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_,
+                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, 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
 };
@@ -216 +220 @@
         ptr<Expr> inc;
         ptr<Stmt> body;
-        ptr<Stmt> elsePart;
+        ptr<Stmt> else_;
 
         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 Expr * inc, const Stmt * body, 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, std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const Stmt * else_, 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 ); }

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 : Tue Feb  1 16:29:25 2022
+// Update Count     : 540
 //
 #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
         }
@@ -1125 +1125 @@
         }
 
-        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/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 : Sun Jan 30 09:14:46 2022
-// Update Count     : 6
+// 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;
 
@@ -26 +26 @@
                 Statement * postmutate( IfStmt * );
                 Statement * postmutate( ForStmt * );
-                Statement * postmutate( WhileStmt * );
+                Statement * postmutate( WhileDoStmt * );
         };
 } // namespace ControlStruct

src/ControlStruct/HoistControlDecls.cpp

@@ -10 +10 @@
 // Created On       : Fri Dec  3 15:34:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 18:52:35 2022
-// Update Count     : 23
+// Last Modified On : Tue Feb  1 18:59:47 2022
+// Update Count     : 25
 //
 
@@ -35 +35 @@
 
         CompoundStmt * block = new CompoundStmt( stmt->location ); // create empty compound statement
-        //    {
-        //    }
+        //    {}
 
         for ( const Stmt * next : stmt->inits ) {                       // link conditional declarations into compound
@@ -69 +68 @@
                 return hoist<ForStmt>( stmt );
         }
-        const Stmt * postvisit( const WhileStmt * stmt ) {
-                return hoist<WhileStmt>( stmt );
+        const Stmt * postvisit( const WhileDoStmt * stmt ) {
+                return hoist<WhileDoStmt>( stmt );
         }
 };

src/ControlStruct/LabelFixer.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 22:28:31 2022
-// Update Count     : 161
+// Last Modified On : Tue Feb  1 09:12:09 2022
+// Update Count     : 162
 //
 
@@ -29 +29 @@
 bool LabelFixer::Entry::insideLoop() {
         return ( dynamic_cast< ForStmt * > ( definition ) ||
-                dynamic_cast< WhileStmt * > ( definition )  );
+                dynamic_cast< WhileDoStmt * > ( definition )  );
 }
 

src/ControlStruct/LabelGeneratorNew.cpp

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 18:51:10 2022
-// Update Count     : 71
+// Last Modified On : Wed Feb  2 09:11:17 2022
+// Update Count     : 72
 //
 
@@ -28 +28 @@
         static int current = 0;
 
-        assert( ( (void)"CFA internal error: parameter statement cannot be null pointer", stmt ) );
+        assertf( stmt, "CFA internal error: parameter statement cannot be null pointer" );
 
         enum { size = 128 };
         char buf[size];                                                                         // space to build label
         int len = snprintf( buf, size, "__L%d__%s", current++, suffix.c_str() );
-        assert( ( (void)"CFA Internal error: buffer overflow creating label", len < size ) );
+        assertf( len < size, "CFA Internal error: buffer overflow creating label" );
 
         // What does this do?
         if ( ! stmt->labels.empty() ) {
                 len = snprintf( buf + len, size - len, "_%s__", stmt->labels.front().name.c_str() );
-                assert( ( (void)"CFA Internal error: buffer overflow creating label", len < size - len ) );
+                assertf( len < size - len, "CFA Internal error: buffer overflow creating label" );
         } // if
 

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 : Tue Feb  1 09:26:28 2022
+// Update Count     : 225
 //
 
@@ -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() );
                 }
@@ -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 );
         }
 

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

@@ -10 +10 @@
 // Created On       : Mon Nov  1 13:48:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 22:35:08 2022
-// Update Count     : 28
+// Last Modified On : Tue Feb  1 18:48:47 2022
+// Update Count     : 29
 //
 
@@ -40 +40 @@
 
         enum Kind {
-                ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
+                ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
         } kind;
 
@@ -53 +53 @@
         Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
-        Entry( const WhileStmt * stmt, Label breakExit, Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmtK ) {}
+        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 ) {}
@@ -66 +66 @@
                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
 
-        bool isContTarget() const { return kind <= WhileStmtK; }
+        bool isContTarget() const { return kind <= WhileDoStmtK; }
         bool isBreakTarget() const { return kind != CaseStmtK; }
         bool isFallTarget() const { return kind == CaseStmtK; }
         bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
 
-        Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
+        // 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); }
 
-        bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
+        // 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; }
@@ -110 +112 @@
         const CompoundStmt * previsit( const CompoundStmt * );
         const BranchStmt * postvisit( const BranchStmt * );
-        void previsit( const WhileStmt * );
-        const WhileStmt * postvisit( const WhileStmt * );
+        void previsit( const WhileDoStmt * );
+        const WhileDoStmt * postvisit( const WhileDoStmt * );
         void previsit( const ForStmt * );
         const ForStmt * postvisit( const ForStmt * );
@@ -164 +166 @@
         const CompoundStmt * stmt ) {
         visit_children = false;
+
+        // 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 ) {
@@ -217 +221 @@
 }
 
+// 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 BranchStmt::Goto:
@@ -253 +261 @@
                   break;
           }
+          // handle fallthrough in case/switch stmts
           case BranchStmt::FallThrough: {
                   targetEntry = findEnclosingControlStructure( isFallthroughTarget );
@@ -333 +342 @@
 }
 
-void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
+void MultiLevelExitCore::previsit( const WhileDoStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
+const WhileDoStmt * MultiLevelExitCore::postvisit( const WhileDoStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
@@ -530 +539 @@
         }
 
+        // if continue is used insert a continue label into the back of the body of the loop
         if ( entry.isContUsed() ) {
                 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;
         }
@@ -548 +566 @@
         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(); } );
 }
@@ -560 +582 @@
         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
 }
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jan 29 09:45:56 2022
-// Update Count     : 901
+// Last Modified On : Wed Feb  2 09:15:49 2022
+// Update Count     : 905
 //
 
@@ -410 +410 @@
 
 Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
-Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+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( CondCtl * 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 Jan 29 09:45:51 2022
-// Update Count     : 384
+// Last Modified On : Wed Feb  2 12:27:58 2022
+// Update Count     : 424
 //
 
@@ -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( CondCtl * 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( CondCtl * 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), {} ); // no init
 } // build_case
 
 Statement * build_default() {
-        std::list< Statement * > branches;
-        return new CaseStmt( nullptr, branches, true );
+        return new CaseStmt( nullptr, {}, true );                       // no init
 } // build_default
 
-Statement * build_while( CondCtl * 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 : Sun Jan 30 09:41:13 2022
-// Update Count     : 5165
+// Last Modified On : Tue Feb  1 11:06:13 2022
+// Update Count     : 5167
 //
 
@@ -1197 +1197 @@
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
         | WHILE '(' conditional_declaration ')' 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_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/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 11:55:19 2022
+// Update Count     : 80
 //
 
@@ -145 +145 @@
 }
 
-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_, std::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;
+        delete then;
+        delete else_;
 }
 
@@ -177 +177 @@
 
         os << indent+1;
-        thenPart->print( os, indent+1 );
-
-        if ( elsePart != nullptr ) {
+        then->print( os, indent+1 );
+
+        if ( else_ != nullptr ) {
                 os << indent << "... else: " << endl;
                 os << indent+1;
-                elsePart->print( os, indent+1 );
+                else_->print( os, indent+1 );
         } // if
 }
@@ -246 +246 @@
 }
 
-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 ):
+WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, const std::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 std::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( std::ostream & os, Indenter indent ) const {
         os << "While on condition: " << endl ;
         condition->print( os, indent+1 );
@@ -268 +272 @@
 }
 
-ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
-        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+ForStmt::ForStmt( std::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;
+        delete else_;
 }
 
@@ -311 +316 @@
                 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;

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 11:49:17 2022
+// Update Count     : 94
 //
 
@@ -148 +148 @@
   public:
         Expression * condition;
-        Statement * thenPart;
-        Statement * elsePart;
+        Statement * then;
+        Statement * else_;
         std::list<Statement *> initialization;
 
-        IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
+        IfStmt( Expression * condition, Statement * then, Statement * else_,
                         std::list<Statement *> initialization = std::list<Statement *>() );
         IfStmt( const IfStmt & other );
@@ -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( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr, Statement * else_ = nullptr );
         ForStmt( const ForStmt & other );
         virtual ~ForStmt();

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;