Changes in src/SynTree/Statement.h [70d826cd:50377a4]

File:

• src/SynTree/Statement.h (modified) (24 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 : Thu Aug 17 15:37:53 2017
-// Update Count     : 72
+// Last Modified On : Sun Sep  3 20:46:46 2017
+// Update Count     : 77
 //
 
@@ -43 +43 @@
         const std::list<Label> & get_labels() const { return labels; }
 
-        virtual Statement *clone() const = 0;
-        virtual void accept( Visitor &v ) = 0;
-        virtual Statement *acceptMutator( Mutator &m ) = 0;
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -54 +54 @@
 
         CompoundStmt( std::list<Label> labels );
+        CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
@@ -61 +62 @@
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
 
-        virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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 +73 @@
         NullStmt( std::list<Label> labels );
 
-        virtual NullStmt *clone() const { return new NullStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -89 +90 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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 +99 @@
   public:
         bool voltile;
-        ConstantExpr *instruction;
+        Expression *instruction;
         std::list<Expression *> output, input;
         std::list<ConstantExpr *> clobber;
         std::list<Label> gotolabels;
 
-        AsmStmt( std::list<Label> labels, bool voltile, ConstantExpr *instruction, std::list<Expression *> input, std::list<Expression *> output, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+        AsmStmt( std::list<Label> labels, 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();
@@ -109 +110 @@
         bool get_voltile() { return voltile; }
         void set_voltile( bool newValue ) { voltile = newValue; }
-        ConstantExpr *get_instruction() { return instruction; }
-        void set_instruction( ConstantExpr *newValue ) { instruction = newValue; }
-        std::list<Expression *> &get_output() { return output; }
-        void set_output( const std::list<Expression *> &newValue ) { output = newValue; }
-        std::list<Expression *> &get_input() { return input; }
+        Expression * get_instruction() { return instruction; }
+        void set_instruction( Expression * newValue ) { instruction = newValue; }
+        std::list<Expression *> & get_output() { return output; }
+        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; }
-        std::list<ConstantExpr *> &get_clobber() { return clobber; }
+        std::list<ConstantExpr *> & get_clobber() { return clobber; }
         void set_clobber( const std::list<ConstantExpr *> &newValue ) { clobber = newValue; }
-        std::list<Label> &get_gotolabels() { return gotolabels; }
+        std::list<Label> & get_gotolabels() { return gotolabels; }
         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, int indent = 0 ) const;
+        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;
 };
 
@@ -146 +147 @@
         void set_elsePart( Statement *newValue ) { elsePart = newValue; }
 
-        virtual IfStmt *clone() const { return new IfStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -155 +156 @@
   public:
         Expression * condition;
-
-        SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
+        std::list<Statement *> statements;
+
+        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
@@ -165 +167 @@
         std::list<Statement *> & get_statements() { return statements; }
 
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Statement *> 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;
+
 };
 
@@ -179 +180 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
@@ -194 +195 @@
         void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
 
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-
-        virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
@@ -221 +222 @@
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
 
-        virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -247 +248 @@
         void set_body( Statement *newValue ) { body = newValue; }
 
-        virtual ForStmt *clone() const { return new ForStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -276 +277 @@
         const char *get_typename() { return brType[ type ]; }
 
-        virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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[];
@@ -295 +296 @@
         void set_expr( Expression *newValue ) { expr = newValue; }
 
-        virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -319 +320 @@
         void set_target( Expression * newTarget ) { target = newTarget; }
 
-        virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
 class TryStmt : public Statement {
   public:
-        CompoundStmt *block;
+        CompoundStmt * block;
         std::list<CatchStmt *> handlers;
-        FinallyStmt *finallyBlock;
+        FinallyStmt * finallyBlock;
 
         TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
@@ -342 +343 @@
         void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
 
-        virtual TryStmt *clone() const { return new TryStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -370 +371 @@
         void set_body( Statement *newValue ) { body = newValue; }
 
-        virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -387 +388 @@
         void set_block( CompoundStmt *newValue ) { block = newValue; }
 
-        virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -424 +425 @@
         } orelse;
 
-        virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 
 };
@@ -444 +445 @@
         void set_decl( Declaration *newValue ) { decl = newValue; }
 
-        virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
+        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;
 };
 
@@ -466 +467 @@
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
 
-        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-};
-
-
-std::ostream & operator<<( std::ostream & out, const Statement * statement );
+        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;
+};
 
 // Local Variables: //