Changes in src/SynTree/Statement.h [e67991f:ee3c93d]

File:

• src/SynTree/Statement.h (modified) (23 diffs)

src/SynTree/Statement.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 12 09:01:53 2019
-// Update Count     : 83
+// Last Modified On : Thu Mar  8 14:53:02 2018
+// Update Count     : 78
 //
 
@@ -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 void accept( Visitor & v ) const 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;
 };
 
@@ -56 +55 @@
         CompoundStmt();
         CompoundStmt( std::list<Statement *> stmts );
-        CompoundStmt( const CompoundStmt & other );
+        CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
 
@@ -63 +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 void accept( Visitor & v ) const 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;
 };
 
@@ -74 +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 void accept( Visitor & v ) const 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 void accept( Visitor & v ) const 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;
 };
 
@@ -102 +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();
 
@@ -118 +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; }
-
-        virtual AsmStmt * clone() const override { return new AsmStmt( *this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        void set_gotolabels( const std::list<Label> &newValue ) { gotolabels = newValue; }
+
+        virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
@@ -138 +133 @@
         virtual ~DirectiveStmt(){}
 
-        virtual DirectiveStmt * clone() const override { return new DirectiveStmt( *this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const 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 DirectiveStmt * clone() const { return new DirectiveStmt( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 
 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 void accept( Visitor & v ) const 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;
 };
 
@@ -177 +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 void accept( Visitor & v ) const 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;
 
 };
@@ -200 +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();
 
@@ -209 +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 void accept( Visitor & v ) const 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;
@@ -227 +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 void accept( Visitor & v ) const 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;
 };
 
@@ -253 +244 @@
   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 void accept( Visitor & v ) const 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;
 };
 
@@ -283 +274 @@
         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; }
@@ -293 +284 @@
         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 void accept( Visitor & v ) const 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 void accept( Visitor & v ) const 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;
 };
 
@@ -335 +324 @@
 
         ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
-        ThrowStmt( const ThrowStmt & other );
+        ThrowStmt( const ThrowStmt &other );
         virtual ~ThrowStmt();
 
@@ -344 +333 @@
         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 void accept( Visitor & v ) const 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;
 };
 
@@ -357 +345 @@
         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 void accept( Visitor & v ) const 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;
 };
 
@@ -380 +367 @@
 
         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 void accept( Visitor & v ) const 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 void accept( Visitor & v ) const 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;
 };
 
@@ -453 +438 @@
         } orelse;
 
-        virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
+        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;
+
+};
+
+class WithStmt : public Statement {
+public:
+        std::list< Expression * > exprs;
+        Statement * stmt;
+
+        WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
+        WithStmt( const WithStmt & other );
+        virtual ~WithStmt();
+
+        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const 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 WithStmt : public Statement {
-// public:
-//      std::list< Expression * > exprs;
-//      Statement * stmt;
-
-//      WithStmt( const std::list< Expression * > & exprs, Statement * stmt );
-//      WithStmt( const WithStmt & other );
-//      virtual ~WithStmt();
-
-//      virtual WithStmt * clone() const override { return new WithStmt( *this ); }
-//      virtual void accept( Visitor & v ) override { v.visit( this ); }
-//      virtual void accept( Visitor & v ) const override { v.visit( this ); }
-//      virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-//      virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-// };
+};
 
 
@@ -481 +464 @@
 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 void accept( Visitor & v ) const 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:
@@ -509 +492 @@
         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 void accept( Visitor & v ) const 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;
 };