Changeset 501b08a

Timestamp:

Mar 15, 2019, 11:17:16 AM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

3f8ec70

Parents:

6dbeef7 (diff), 35a2d47 (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

Files:

• doc/bibliography/pl.bib (modified) (2 diffs)
• src/ControlStruct/ForExprMutator.cc (modified) (4 diffs)
• src/ControlStruct/LabelFixer.cc (modified) (7 diffs)
• src/ControlStruct/LabelGenerator.cc (modified) (3 diffs)
• src/SynTree/Statement.h (modified) (23 diffs)

doc/bibliography/pl.bib

@@ -2300 +2300 @@
 }
 
+@article{Ritchie93,
+    keywords    = {C, history},
+    contributer = {pabuhr@plg},
+    author      = {Ritchie, Dennis M.},
+    title       = {The Development of the {C} Language},
+    journal     = sigplan,
+    volume      = 28,
+    number      = 3,
+    month       = mar,
+    year        = 1993,
+    pages       = {201--208},
+    url         = {http://doi.acm.org/10.1145/155360.155580},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+} 
+
 @article{design,
     keywords    = {Smalltalk, designing classes},
@@ -2307 +2323 @@
     journal     = joop,
     year        = 1988,
-    volume      = 1, number = 2, pages = {22-35},
+    volume      = 1,
+    number      = 2,
+    pages       = {22-35},
     comment     = {
         Abstract classes represent standard protocols.  ``It is better to

src/ControlStruct/ForExprMutator.cc

@@ -9 +9 @@
 // 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 +21 @@
 
 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 +29 @@
                 // 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 +38 @@
         }
 
-        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 );
         }

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // 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 +32 @@
         }
 
-        LabelFixer::LabelFixer( LabelGenerator *gen ) : generator ( gen ) {
+        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
                 if ( generator == 0 )
                         generator = LabelGenerator::getGenerator();
@@ -49 +49 @@
 
         // 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 +58 @@
         }
 
-        void LabelFixer::previsit( BranchStmt *branchStmt ) {
+        void LabelFixer::previsit( BranchStmt * branchStmt ) {
                 previsit( ( Statement *)branchStmt );
 
@@ -75 +75 @@
 
 
-        // 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 +100 @@
                 } // 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 +116 @@
 
         // 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 ) {

src/ControlStruct/LabelGenerator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : 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 +24 @@
 
 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 +37 @@
                 if ( stmt && ! stmt->get_labels().empty() ) {
                         os << "_" << stmt->get_labels().front() << "__";
-                }
+                } // if
                 std::string ret = os.str();
                 Label l( ret );

src/SynTree/Statement.h

@@ -10 +10 @@
 // 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 +19 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
-#include <vector>                        // for vector
+#include <vector>                                  // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -43 +43 @@
         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 +55 @@
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
-        CompoundStmt( const CompoundStmt &other );
+        CompoundStmt( const CompoundStmt & other );
         virtual ~CompoundStmt();
 
@@ -62 +62 @@
         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 +72 @@
         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 +98 @@
   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 +114 @@
         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 +141 @@
 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 +170 @@
         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 +192 @@
         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 +201 @@
         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 +218 @@
 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 +243 @@
   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 +272 @@
         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 +282 @@
         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 +322 @@
 
         ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
-        ThrowStmt( const ThrowStmt &other );
+        ThrowStmt( const ThrowStmt & other );
         virtual ~ThrowStmt();
 
@@ -333 +331 @@
         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 +343 @@
         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 +365 @@
 
         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 +436 @@
         } 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 +462 @@
 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 +489 @@
         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;
 };