Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Convert.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -9,7 +9,7 @@
 // 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 : Tue Feb  1 16:27:15 2022
+// Update Count     : 39
 //
 
@@ -393,6 +393,6 @@
 		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,8 +419,8 @@
 	}
 
-	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 ),
@@ -1872,6 +1872,6 @@
 			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,7 +1902,7 @@
 	}
 
-	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),
Index: src/AST/Fwd.hpp
===================================================================
--- src/AST/Fwd.hpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Fwd.hpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +44,5 @@
 class DirectiveStmt;
 class IfStmt;
-class WhileStmt;
+class WhileDoStmt;
 class ForStmt;
 class SwitchStmt;
Index: src/AST/Node.cpp
===================================================================
--- src/AST/Node.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Node.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,6 +146,6 @@
 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 >;
Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Pass.hpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -146,5 +146,5 @@
 	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;
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Pass.impl.hpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -756,6 +756,6 @@
 		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,7 +764,7 @@
 
 //--------------------------------------------------------------------------
-// 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,7 +772,7 @@
 		// 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  );
 	}
 
Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Print.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -511,12 +511,12 @@
 		++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,5 +524,5 @@
 	}
 
-	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;
Index: src/AST/Stmt.hpp
===================================================================
--- src/AST/Stmt.hpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Stmt.hpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +42,5 @@
 		: 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,9 +56,9 @@
 
 	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,5 +88,5 @@
 	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,12 +139,12 @@
   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,19 +191,23 @@
 
 // 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,9 +220,13 @@
 	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 ); }
Index: src/AST/Visitor.hpp
===================================================================
--- src/AST/Visitor.hpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/AST/Visitor.hpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +38,5 @@
     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;
Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/CodeGen/CodeGenerator.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +42,5 @@
 	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,9 +955,9 @@
 		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,22 +1125,22 @@
 	}
 
-	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
Index: src/CodeGen/CodeGenerator.h
===================================================================
--- src/CodeGen/CodeGenerator.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/CodeGen/CodeGenerator.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +116,5 @@
 		void postvisit( WaitForStmt * );
 		void postvisit( WithStmt * );
-		void postvisit( WhileStmt * );
+		void postvisit( WhileDoStmt * );
 		void postvisit( ForStmt * );
 		void postvisit( NullStmt * );
Index: src/Common/CodeLocationTools.cpp
===================================================================
--- src/Common/CodeLocationTools.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Common/CodeLocationTools.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +109,5 @@
     macro(DirectiveStmt, Stmt) \
     macro(IfStmt, Stmt) \
-    macro(WhileStmt, Stmt) \
+    macro(WhileDoStmt, Stmt) \
     macro(ForStmt, Stmt) \
     macro(SwitchStmt, Stmt) \
Index: src/Common/PassVisitor.h
===================================================================
--- src/Common/PassVisitor.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Common/PassVisitor.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -92,6 +92,6 @@
 	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,5 +277,5 @@
 	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;
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Common/PassVisitor.impl.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -1189,6 +1189,6 @@
 		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,6 +1203,6 @@
 		maybeAccept_impl( node->initialization, *this );
 		visitExpression ( node->condition );
-		visitStatement  ( node->thenPart );
-		visitStatement  ( node->elsePart );
+		visitStatement  ( node->then );
+		visitStatement  ( node->else_ );
 	}
 	VISIT_END( node );
@@ -1217,6 +1217,6 @@
 		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,7 +1224,7 @@
 
 //--------------------------------------------------------------------------
-// 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,5 +1241,5 @@
 
 template< typename pass_type >
-void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
+void PassVisitor< pass_type >::visit( const WhileDoStmt * node ) {
 	VISIT_START( node );
 
@@ -1256,5 +1256,5 @@
 
 template< typename pass_type >
-Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
+Statement * PassVisitor< pass_type >::mutate( WhileDoStmt * node ) {
 	MUTATE_START( node );
 
Index: src/ControlStruct/ForExprMutator.cc
===================================================================
--- src/ControlStruct/ForExprMutator.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/ForExprMutator.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,6 +45,6 @@
 		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
Index: src/ControlStruct/ForExprMutator.h
===================================================================
--- src/ControlStruct/ForExprMutator.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/ForExprMutator.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +18,5 @@
 class IfStmt;
 class ForStmt;
-class WhileStmt;
+class WhileDoStmt;
 class Statement;
 
@@ -26,5 +26,5 @@
 		Statement * postmutate( IfStmt * );
 		Statement * postmutate( ForStmt * );
-		Statement * postmutate( WhileStmt * );
+		Statement * postmutate( WhileDoStmt * );
 	};
 } // namespace ControlStruct
Index: src/ControlStruct/HoistControlDecls.cpp
===================================================================
--- src/ControlStruct/HoistControlDecls.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/HoistControlDecls.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,6 +35,5 @@
 
 	CompoundStmt * block = new CompoundStmt( stmt->location ); // create empty compound statement
-	//    {
-	//    }
+	//    {}
 
 	for ( const Stmt * next : stmt->inits ) {			// link conditional declarations into compound
@@ -69,6 +68,6 @@
 		return hoist<ForStmt>( stmt );
 	}
-	const Stmt * postvisit( const WhileStmt * stmt ) {
-		return hoist<WhileStmt>( stmt );
+	const Stmt * postvisit( const WhileDoStmt * stmt ) {
+		return hoist<WhileDoStmt>( stmt );
 	}
 };
Index: src/ControlStruct/LabelFixer.cc
===================================================================
--- src/ControlStruct/LabelFixer.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/LabelFixer.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +29,5 @@
 bool LabelFixer::Entry::insideLoop() {
 	return ( dynamic_cast< ForStmt * > ( definition ) ||
-		dynamic_cast< WhileStmt * > ( definition )  );
+		dynamic_cast< WhileDoStmt * > ( definition )  );
 }
 
Index: src/ControlStruct/MLEMutator.cc
===================================================================
--- src/ControlStruct/MLEMutator.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/MLEMutator.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -9,7 +9,7 @@
 // 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,5 +39,5 @@
 	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,6 +295,6 @@
 	}
 
-	void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
-		return prehandleLoopStmt( whileStmt );
+	void MultiLevelExitMutator::premutate( WhileDoStmt * whileDoStmt ) {
+		return prehandleLoopStmt( whileDoStmt );
 	}
 
@@ -303,6 +303,6 @@
 	}
 
-	Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
-		return posthandleLoopStmt( whileStmt );
+	Statement * MultiLevelExitMutator::postmutate( WhileDoStmt * whileDoStmt ) {
+		return posthandleLoopStmt( whileDoStmt );
 	}
 
Index: src/ControlStruct/MLEMutator.h
===================================================================
--- src/ControlStruct/MLEMutator.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/MLEMutator.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -9,7 +9,7 @@
 // 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,6 +42,6 @@
 		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,5 +67,5 @@
 				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 ) {}
 
Index: src/ControlStruct/MultiLevelExit.cpp
===================================================================
--- src/ControlStruct/MultiLevelExit.cpp	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ControlStruct/MultiLevelExit.cpp	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +40,5 @@
 
 	enum Kind {
-		ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
+		ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
 	} kind;
 
@@ -53,6 +53,6 @@
 	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,5 +66,5 @@
 		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; }
@@ -72,5 +72,5 @@
 
 	// These routines set a target as being "used" by a BranchStmt
-	Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
+	Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
 	Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
 	Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
@@ -78,5 +78,5 @@
 
 	// These routines check if a specific label for a statement is used by a BranchStmt
-	bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
+	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; }
@@ -112,6 +112,6 @@
 	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 * );
@@ -342,9 +342,9 @@
 }
 
-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 );
 }
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Parser/ParseNode.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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 : Tue Feb  1 11:06:18 2022
+// Update Count     : 903
 //
 
@@ -414,7 +414,7 @@
 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 * els = nullptr );
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * els = nullptr );
+Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * els = nullptr );
 Statement * build_branch( BranchStmt::Type kind );
 Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Parser/StatementNode.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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 : Tue Feb  1 18:39:00 2022
+// Update Count     : 395
 //
 
@@ -145,43 +145,53 @@
 } // build_default
 
-Statement * build_while( CondCtl * ctl, StatementNode * stmt ) {
-	std::list< Statement * > branches;
-	buildMoveList< Statement, StatementNode >( stmt, branches );
-	assert( branches.size() == 1 );
-
+Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
 	std::list< Statement * > init;
 	Expression * cond = build_if_control( ctl, init );
-	return new WhileStmt( cond, branches.front(), init, false );
+
+	std::list< Statement * > aststmt;
+	buildMoveList< Statement, StatementNode >( stmt, aststmt );
+	assert( aststmt.size() == 1 );
+
+	std::list< Statement * > astelse;
+	buildMoveList< Statement, StatementNode >( else_, astelse );
+
+	return new WhileDoStmt( cond, aststmt.front(), astelse.front(), init, false );
 } // build_while
 
-Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt ) {
-	std::list< Statement * > branches;
-	buildMoveList< Statement, StatementNode >( stmt, branches );
-	assert( branches.size() == 1 );
+Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
+	std::list< Statement * > aststmt;
+	buildMoveList< Statement, StatementNode >( stmt, aststmt );
+	assert( aststmt.size() == 1 );
+
+	std::list< Statement * > astelse;
+	buildMoveList< Statement, StatementNode >( else_, astelse );
 
 	std::list< Statement * > init;
-	return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), init, true );
+	return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), init, true );
 } // build_do_while
 
-Statement * build_for( ForCtrl * forctl, StatementNode * stmt ) {
-	std::list< Statement * > branches;
-	buildMoveList< Statement, StatementNode >( stmt, branches );
-	assert( branches.size() == 1 );
-
+Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
 	std::list< Statement * > init;
-	if ( forctl->init != 0 ) {
+	if ( forctl->init != nullptr ) {
 		buildMoveList( forctl->init, init );
 	} // if
 
-	Expression * cond = 0;
-	if ( forctl->condition != 0 )
+	Expression * cond = nullptr;
+	if ( forctl->condition != nullptr )
 		cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
 
-	Expression * incr = 0;
-	if ( forctl->change != 0 )
+	Expression * incr = nullptr;
+	if ( forctl->change != nullptr )
 		incr = maybeMoveBuild< Expression >(forctl->change);
 
+	std::list< Statement * > aststmt;
+	buildMoveList< Statement, StatementNode >( stmt, aststmt );
+	assert( aststmt.size() == 1 );
+
+	std::list< Statement * > astelse;
+	buildMoveList< Statement, StatementNode >( else_, astelse );
+
 	delete forctl;
-	return new ForStmt( init, cond, incr, branches.front() );
+	return new ForStmt( init, cond, incr, aststmt.front(), astelse.front() );
 } // build_for
 
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/Parser/parser.yy	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +1197,6 @@
 		{ $$ = 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,5 +1204,6 @@
 		{ $$ = 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,5 +1211,6 @@
 	  	{ $$ = 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 ) ); }
 	;
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/ResolvExpr/Resolver.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -9,7 +9,7 @@
 // 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,5 +80,5 @@
 		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,6 +502,6 @@
 	}
 
-	void Resolver_old::previsit( WhileStmt * whileStmt ) {
-		findIntegralExpression( whileStmt->condition, indexer );
+	void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
+		findIntegralExpression( whileDoStmt->condition, indexer );
 	}
 
@@ -572,8 +572,8 @@
 
 	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,11 +588,11 @@
 		// 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,5 +1272,5 @@
 		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,7 +1581,7 @@
 	}
 
-	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,8 +1669,8 @@
 
 	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,10 +1687,10 @@
 		// 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;
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/SynTree/Mutator.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +42,5 @@
 	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;
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/SynTree/Statement.cc	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -9,7 +9,7 @@
 // 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 : Tue Feb  1 17:55:29 2022
+// Update Count     : 79
 //
 
@@ -145,9 +145,9 @@
 }
 
-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,6 +156,6 @@
 	deleteAll( initialization );
 	delete condition;
-	delete thenPart;
-	delete elsePart;
+	delete then;
+	delete else_;
 }
 
@@ -177,10 +177,10 @@
 
 	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,18 +246,22 @@
 }
 
-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, 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_, 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,10 +272,10 @@
 }
 
-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,4 +287,5 @@
 	delete increment;
 	delete body;
+	delete else_;
 }
 
@@ -311,4 +316,9 @@
 		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;
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/SynTree/Statement.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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 : Tue Feb  1 17:07:32 2022
+// Update Count     : 93
 //
 
@@ -148,9 +148,9 @@
   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,8 +160,8 @@
 	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,14 +225,16 @@
 };
 
-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, std::list<Statement *> & initialization, bool isDoWhile = false );
+	WhileDoStmt( Expression * condition, Statement * body, Statement * els, std::list<Statement *> & initialization, bool isDoWhile = false );
+	WhileDoStmt( const WhileDoStmt & other );
+	virtual ~WhileDoStmt();
 
 	Expression * get_condition() { return condition; }
@@ -243,5 +245,5 @@
 	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,6 +258,7 @@
 	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();
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/SynTree/SynTree.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,5 +45,5 @@
 class DirectiveStmt;
 class IfStmt;
-class WhileStmt;
+class WhileDoStmt;
 class ForStmt;
 class SwitchStmt;
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision 729c991d035ba957fa9ab544647fc563407bd5cf)
+++ src/SynTree/Visitor.h	(revision 3b0bc169405b67c6da2825bdc47c869fa9d0fd59)
@@ -10,6 +10,6 @@
 // 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,6 +60,6 @@
 	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;