Index: src/ControlStruct/ForExprMutator.cc
===================================================================
--- src/ControlStruct/ForExprMutator.cc	(revision 91d658470970fa957fbb17770ddc08f0334a9883)
+++ src/ControlStruct/ForExprMutator.cc	(revision a9276626ec4caba86cf7ab2282d94188f1f65e6d)
@@ -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 : Fri Aug 18 10:22:00 2017
-// Update Count     : 12
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:52 2019
+// Update Count     : 14
 //
 
@@ -21,5 +21,5 @@
 
 namespace ControlStruct {
-	Statement *hoist( Statement *originalStmt, std::list<Statement *> &init ) {
+	Statement * hoist( Statement * originalStmt, std::list<Statement *> & init ) {
 		// If no hoisting is needed, skip:
 		if ( 0 == init.size() ) {
@@ -29,6 +29,6 @@
 		// Create compound statement, move initializers outside,
 		// the resut of the original stays as is.
-		CompoundStmt *block = new CompoundStmt();
-		std::list<Statement *> &stmts = block->get_kids();
+		CompoundStmt * block = new CompoundStmt();
+		std::list<Statement *> & stmts = block->get_kids();
 		stmts.splice( stmts.end(), init );
 
@@ -38,12 +38,12 @@
 	}
 
-	Statement *ForExprMutator::postmutate( IfStmt *ifStmt ) {
+	Statement * ForExprMutator::postmutate( IfStmt * ifStmt ) {
 		return hoist( ifStmt, ifStmt->initialization );
 	}
-	Statement *ForExprMutator::postmutate( ForStmt *forStmt ) {
+	Statement * ForExprMutator::postmutate( ForStmt * forStmt ) {
 		// hoist any initializer declarations to make them C89 (rather than C99)
 		return hoist( forStmt, forStmt->initialization );
 	}
-	Statement *ForExprMutator::postmutate( WhileStmt *whileStmt ) {
+	Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
 		return hoist( whileStmt, whileStmt->initialization );
 	}
Index: src/ControlStruct/LabelFixer.cc
===================================================================
--- src/ControlStruct/LabelFixer.cc	(revision 91d658470970fa957fbb17770ddc08f0334a9883)
+++ src/ControlStruct/LabelFixer.cc	(revision a9276626ec4caba86cf7ab2282d94188f1f65e6d)
@@ -9,7 +9,7 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Jul 28 13:32:43 2015
-// Update Count     : 156
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:26:02 2019
+// Update Count     : 159
 //
 
@@ -32,5 +32,5 @@
 	}
 
-	LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+	LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
 		if ( generator == 0 )
 			generator = LabelGenerator::getGenerator();
@@ -49,5 +49,5 @@
 
 	// prune to at most one label definition for each statement
-	void LabelFixer::previsit( Statement *stmt ) {
+	void LabelFixer::previsit( Statement * stmt ) {
 		std::list< Label > &labels = stmt->get_labels();
 
@@ -58,5 +58,5 @@
 	}
 
-	void LabelFixer::previsit( BranchStmt *branchStmt ) {
+	void LabelFixer::previsit( BranchStmt * branchStmt ) {
 		previsit( ( Statement *)branchStmt );
 
@@ -75,7 +75,7 @@
 
 
-	// sets the definition of the labelTable entry to be the provided
-	// statement for every label in the list parameter. Happens for every kind of statement
-	Label LabelFixer::setLabelsDef( std::list< Label > &llabel, Statement *definition ) {
+	// sets the definition of the labelTable entry to be the provided statement for every label in the list
+	// parameter. Happens for every kind of statement
+	Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
 		assert( definition != 0 );
 		assert( llabel.size() > 0 );
@@ -100,6 +100,5 @@
 		} // for
 
-		// produce one of the labels attached to this statement to be
-		// temporarily used as the canonical label
+		// produce one of the labels attached to this statement to be temporarily used as the canonical label
 		return labelTable[ llabel.front() ]->get_label();
 	}
@@ -117,5 +116,5 @@
 
 	// Builds a table that maps a label to its defining statement.
-	std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+	std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
 		std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
 		for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
Index: src/ControlStruct/LabelGenerator.cc
===================================================================
--- src/ControlStruct/LabelGenerator.cc	(revision 91d658470970fa957fbb17770ddc08f0334a9883)
+++ src/ControlStruct/LabelGenerator.cc	(revision a9276626ec4caba86cf7ab2282d94188f1f65e6d)
@@ -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 : Thr Aug 14 14:14:00 2015
-// Update Count     : 14
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Mar 11 22:23:20 2019
+// Update Count     : 15
 //
 
@@ -24,10 +24,9 @@
 
 namespace ControlStruct {
-	LabelGenerator *LabelGenerator::labelGenerator = 0;
+	LabelGenerator * LabelGenerator::labelGenerator = 0;
 
-	LabelGenerator *LabelGenerator::getGenerator() {
+	LabelGenerator * LabelGenerator::getGenerator() {
 		if ( LabelGenerator::labelGenerator == 0 )
 			LabelGenerator::labelGenerator = new LabelGenerator();
-
 		return labelGenerator;
 	}
@@ -38,5 +37,5 @@
 		if ( stmt && ! stmt->get_labels().empty() ) {
 			os << "_" << stmt->get_labels().front() << "__";
-		}
+		} // if
 		std::string ret = os.str();
 		Label l( ret );
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 91d658470970fa957fbb17770ddc08f0334a9883)
+++ src/SynTree/Statement.h	(revision a9276626ec4caba86cf7ab2282d94188f1f65e6d)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar  8 14:53:02 2018
-// Update Count     : 78
+// Last Modified On : Tue Mar 12 09:01:53 2019
+// Update Count     : 83
 //
 
@@ -19,5 +19,5 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
-#include <vector>	                 // for vector
+#include <vector>				   // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -43,8 +43,8 @@
 	const std::list<Label> & get_labels() const { return labels; }
 
-	virtual Statement *clone() const override = 0;
-	virtual void accept( Visitor &v ) override = 0;
-	virtual Statement *acceptMutator( Mutator &m ) override = 0;
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual Statement * clone() const override = 0;
+	virtual void accept( Visitor & v ) override = 0;
+	virtual Statement * acceptMutator( Mutator & m ) override = 0;
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -55,5 +55,5 @@
 	CompoundStmt();
 	CompoundStmt( std::list<Statement *> stmts );
-	CompoundStmt( const CompoundStmt &other );
+	CompoundStmt( const CompoundStmt & other );
 	virtual ~CompoundStmt();
 
@@ -62,8 +62,8 @@
 	void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-	virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -72,25 +72,25 @@
 	NullStmt( const std::list<Label> & labels = {} );
 
-	virtual NullStmt *clone() const override { return new NullStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual NullStmt * clone() const override { return new NullStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class ExprStmt : public Statement {
   public:
-	Expression *expr;
-
-	ExprStmt( Expression *expr );
-	ExprStmt( const ExprStmt &other );
+	Expression * expr;
+
+	ExprStmt( Expression * expr );
+	ExprStmt( const ExprStmt & other );
 	virtual ~ExprStmt();
 
-	Expression *get_expr() { return expr; }
-	void set_expr( Expression *newValue ) { expr = newValue; }
-
-	virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	Expression * get_expr() { return expr; }
+	void set_expr( Expression * newValue ) { expr = newValue; }
+
+	virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -98,11 +98,11 @@
   public:
 	bool voltile;
-	Expression *instruction;
+	Expression * instruction;
 	std::list<Expression *> output, input;
 	std::list<ConstantExpr *> clobber;
 	std::list<Label> gotolabels;
 
-	AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
-	AsmStmt( const AsmStmt &other );
+	AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+	AsmStmt( const AsmStmt & other );
 	virtual ~AsmStmt();
 
@@ -114,9 +114,9 @@
 	void set_output( const std::list<Expression *> & newValue ) { output = newValue; }
 	std::list<Expression *> & get_input() { return input; }
-	void set_input( const std::list<Expression *> &newValue ) { input = newValue; }
+	void set_input( const std::list<Expression *> & newValue ) { input = newValue; }
 	std::list<ConstantExpr *> & get_clobber() { return clobber; }
-	void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
+	void set_clobber( const std::list<ConstantExpr *> & newValue ) { clobber = newValue; }
 	std::list<Label> & get_gotolabels() { return gotolabels; }
-	void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
+	void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
 
 	virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
@@ -141,26 +141,26 @@
 class IfStmt : public Statement {
   public:
-	Expression *condition;
-	Statement *thenPart;
-	Statement *elsePart;
+	Expression * condition;
+	Statement * thenPart;
+	Statement * elsePart;
 	std::list<Statement *> initialization;
 
-	IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
+	IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
 			std::list<Statement *> initialization = std::list<Statement *>() );
-	IfStmt( const IfStmt &other );
+	IfStmt( const IfStmt & other );
 	virtual ~IfStmt();
 
-	std::list<Statement *> &get_initialization() { return initialization; }
-	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; }
-
-	virtual IfStmt *clone() const override { return new IfStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	std::list<Statement *> & get_initialization() { return initialization; }
+	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; }
+
+	virtual IfStmt * clone() const override { return new IfStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -170,18 +170,18 @@
 	std::list<Statement *> statements;
 
-	SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
-	SwitchStmt( const SwitchStmt &other );
+	SwitchStmt( Expression * condition, const std::list<Statement *> & statements );
+	SwitchStmt( const SwitchStmt & other );
 	virtual ~SwitchStmt();
 
-	Expression *get_condition() { return condition; }
-	void set_condition( Expression *newValue ) { condition = newValue; }
+	Expression * get_condition() { return condition; }
+	void set_condition( Expression * newValue ) { condition = newValue; }
 
 	std::list<Statement *> & get_statements() { return statements; }
 
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-	virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+	virtual SwitchStmt * clone() const override { return new SwitchStmt( *this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 };
@@ -192,6 +192,6 @@
 	std::list<Statement *> stmts;
 
-	CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
-	CaseStmt( const CaseStmt &other );
+	CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
+	CaseStmt( const CaseStmt & other );
 	virtual ~CaseStmt();
 
@@ -201,15 +201,15 @@
 	void set_default(bool b) { _isDefault = b; }
 
-	Expression * &get_condition() { return condition; }
-	void set_condition( Expression *newValue ) { condition = newValue; }
-
-	std::list<Statement *> &get_statements() { return stmts; }
-	void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
-
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-
-	virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	Expression * & get_condition() { return condition; }
+	void set_condition( Expression * newValue ) { condition = newValue; }
+
+	std::list<Statement *> & get_statements() { return stmts; }
+	void set_statements( std::list<Statement *> & newValue ) { stmts = newValue; }
+
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+
+	virtual CaseStmt * clone() const override { return new CaseStmt( *this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
 	bool _isDefault;
@@ -218,25 +218,24 @@
 class WhileStmt : public Statement {
   public:
-	Expression *condition;
-	Statement *body;
+	Expression * condition;
+	Statement * body;
 	std::list<Statement *> initialization;
 	bool isDoWhile;
 
-	WhileStmt( Expression *condition,
-	       Statement *body, std::list<Statement *> & initialization, bool isDoWhile = false );
-	WhileStmt( const WhileStmt &other );
+	WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
+	WhileStmt( const WhileStmt & other );
 	virtual ~WhileStmt();
 
-	Expression *get_condition() { return condition; }
-	void set_condition( Expression *newValue ) { condition = newValue; }
-	Statement *get_body() { return body; }
-	void set_body( Statement *newValue ) { body = newValue; }
+	Expression * get_condition() { return condition; }
+	void set_condition( Expression * newValue ) { condition = newValue; }
+	Statement * get_body() { return body; }
+	void set_body( Statement * newValue ) { body = newValue; }
 	bool get_isDoWhile() { return isDoWhile; }
 	void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-	virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -244,25 +243,24 @@
   public:
 	std::list<Statement *> initialization;
-	Expression *condition;
-	Expression *increment;
-	Statement *body;
-
-	ForStmt( std::list<Statement *> initialization,
-	     Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
-	ForStmt( const ForStmt &other );
+	Expression * condition;
+	Expression * increment;
+	Statement * body;
+
+	ForStmt( std::list<Statement *> initialization, Expression * condition = 0, Expression * increment = 0, Statement * body = 0 );
+	ForStmt( const ForStmt & other );
 	virtual ~ForStmt();
 
-	std::list<Statement *> &get_initialization() { return initialization; }
-	Expression *get_condition() { return condition; }
-	void set_condition( Expression *newValue ) { condition = newValue; }
-	Expression *get_increment() { return increment; }
-	void set_increment( Expression *newValue ) { increment = newValue; }
-	Statement *get_body() { return body; }
-	void set_body( Statement *newValue ) { body = newValue; }
-
-	virtual ForStmt *clone() const override { return new ForStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	std::list<Statement *> & get_initialization() { return initialization; }
+	Expression * get_condition() { return condition; }
+	void set_condition( Expression * newValue ) { condition = newValue; }
+	Expression * get_increment() { return increment; }
+	void set_increment( Expression * newValue ) { increment = newValue; }
+	Statement * get_body() { return body; }
+	void set_body( Statement * newValue ) { body = newValue; }
+
+	virtual ForStmt * clone() const override { return new ForStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -274,9 +272,9 @@
 	const Label originalTarget;
 	Label target;
-	Expression *computedTarget;
+	Expression * computedTarget;
 	Type type;
 
 	BranchStmt( Label target, Type ) throw (SemanticErrorException);
-	BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
+	BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
 
 	Label get_originalTarget() { return originalTarget; }
@@ -284,33 +282,33 @@
 	void set_target( Label newValue ) { target = newValue; }
 
-	Expression *get_computedTarget() { return computedTarget; }
+	Expression * get_computedTarget() { return computedTarget; }
 	void set_target( Expression * newValue ) { computedTarget = newValue; }
 
 	Type get_type() { return type; }
-	const char *get_typename() { return brType[ type ]; }
-
-	virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	const char * get_typename() { return brType[ type ]; }
+
+	virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
-	static const char *brType[];
+	static const char * brType[];
 };
 
 class ReturnStmt : public Statement {
   public:
-	Expression *expr;
-
-	ReturnStmt( Expression *expr );
-	ReturnStmt( const ReturnStmt &other );
+	Expression * expr;
+
+	ReturnStmt( Expression * expr );
+	ReturnStmt( const ReturnStmt & other );
 	virtual ~ReturnStmt();
 
-	Expression *get_expr() { return expr; }
-	void set_expr( Expression *newValue ) { expr = newValue; }
-
-	virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	Expression * get_expr() { return expr; }
+	void set_expr( Expression * newValue ) { expr = newValue; }
+
+	virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -324,5 +322,5 @@
 
 	ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
-	ThrowStmt( const ThrowStmt &other );
+	ThrowStmt( const ThrowStmt & other );
 	virtual ~ThrowStmt();
 
@@ -333,8 +331,8 @@
 	void set_target( Expression * newTarget ) { target = newTarget; }
 
-	virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -345,19 +343,19 @@
 	FinallyStmt * finallyBlock;
 
-	TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
-	TryStmt( const TryStmt &other );
+	TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = 0 );
+	TryStmt( const TryStmt & other );
 	virtual ~TryStmt();
 
-	CompoundStmt *get_block() const { return block; }
-	void set_block( CompoundStmt *newValue ) { block = newValue; }
+	CompoundStmt * get_block() const { return block; }
+	void set_block( CompoundStmt * newValue ) { block = newValue; }
 	std::list<CatchStmt *>& get_catchers() { return handlers; }
 
-	FinallyStmt *get_finally() const { return finallyBlock; }
-	void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
-
-	virtual TryStmt *clone() const override { return new TryStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	FinallyStmt * get_finally() const { return finallyBlock; }
+	void set_finally( FinallyStmt * newValue ) { finallyBlock = newValue; }
+
+	virtual TryStmt * clone() const override { return new TryStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -367,42 +365,42 @@
 
 	const Kind kind;
-	Declaration *decl;
-	Expression *cond;
-	Statement *body;
-
-	CatchStmt( Kind kind, Declaration *decl,
-	           Expression *cond, Statement *body );
-	CatchStmt( const CatchStmt &other );
+	Declaration * decl;
+	Expression * cond;
+	Statement * body;
+
+	CatchStmt( Kind kind, Declaration * decl,
+	           Expression * cond, Statement * body );
+	CatchStmt( const CatchStmt & other );
 	virtual ~CatchStmt();
 
 	Kind get_kind() { return kind; }
-	Declaration *get_decl() { return decl; }
-	void set_decl( Declaration *newValue ) { decl = newValue; }
-	Expression *get_cond() { return cond; }
-	void set_cond( Expression *newCond ) { cond = newCond; }
-	Statement *get_body() { return body; }
-	void set_body( Statement *newValue ) { body = newValue; }
-
-	virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	Declaration * get_decl() { return decl; }
+	void set_decl( Declaration * newValue ) { decl = newValue; }
+	Expression * get_cond() { return cond; }
+	void set_cond( Expression * newCond ) { cond = newCond; }
+	Statement * get_body() { return body; }
+	void set_body( Statement * newValue ) { body = newValue; }
+
+	virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
 class FinallyStmt : public Statement {
   public:
-	CompoundStmt *block;
-
-	FinallyStmt( CompoundStmt *block );
-	FinallyStmt( const FinallyStmt &other );
+	CompoundStmt * block;
+
+	FinallyStmt( CompoundStmt * block );
+	FinallyStmt( const FinallyStmt & other );
 	virtual ~FinallyStmt();
 
-	CompoundStmt *get_block() const { return block; }
-	void set_block( CompoundStmt *newValue ) { block = newValue; }
-
-	virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	CompoundStmt * get_block() const { return block; }
+	void set_block( CompoundStmt * newValue ) { block = newValue; }
+
+	virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
@@ -438,8 +436,8 @@
 	} orelse;
 
-	virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 
 };
@@ -464,23 +462,22 @@
 class DeclStmt : public Statement {
   public:
-	Declaration *decl;
-
-	DeclStmt( Declaration *decl );
-	DeclStmt( const DeclStmt &other );
+	Declaration * decl;
+
+	DeclStmt( Declaration * decl );
+	DeclStmt( const DeclStmt & other );
 	virtual ~DeclStmt();
 
-	Declaration *get_decl() const { return decl; }
-	void set_decl( Declaration *newValue ) { decl = newValue; }
-
-	virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-};
-
-
-/// represents an implicit application of a constructor or destructor. Qualifiers are replaced
-/// immediately before and after the call so that qualified objects can be constructed
-/// with the same functions as unqualified objects.
+	Declaration * get_decl() const { return decl; }
+	void set_decl( Declaration * newValue ) { decl = newValue; }
+
+	virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
+
+/// represents an implicit application of a constructor or destructor. Qualifiers are replaced immediately before and
+/// after the call so that qualified objects can be constructed with the same functions as unqualified objects.
 class ImplicitCtorDtorStmt : public Statement {
   public:
@@ -492,11 +489,11 @@
 	virtual ~ImplicitCtorDtorStmt();
 
-	Statement *get_callStmt() const { return callStmt; }
+	Statement * get_callStmt() const { return callStmt; }
 	void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-	virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+	virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+	virtual void accept( Visitor & v ) override { v.visit( this ); }
+	virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+	virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 
