Changeset c13e8dc8 for src/SynTree/Statement.cc

Timestamp:

Dec 5, 2017, 2:35:03 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

f9feab8

Parents:

9c35431 (diff), 65197c2 (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' into cleanup-dtors

File:

• src/SynTree/Statement.cc (modified) (19 diffs)

src/SynTree/Statement.cc

@@ -32 +32 @@
 using std::endl;
 
-Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
+Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
 
 void Statement::print( std::ostream & os, Indenter ) const {
@@ -46 +46 @@
 Statement::~Statement() {}
 
-ExprStmt::ExprStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -60 +60 @@
 
 
-AsmStmt::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 ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -96 +96 @@
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
-BranchStmt::BranchStmt( std::list<Label> labels, Label target, Type type ) throw ( SemanticError ) :
-        Statement( labels ), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
+BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticError ) :
+        Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
         //actually this is a syntactic error signaled by the parser
         if ( type == BranchStmt::Goto && target.empty() ) {
@@ -104 +104 @@
 }
 
-BranchStmt::BranchStmt( std::list<Label> labels, Expression *computedTarget, Type type ) throw ( SemanticError ) :
-        Statement( labels ), computedTarget( computedTarget ), type( type ) {
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticError ) :
+        Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
                 throw SemanticError("Computed target not valid in branch statement");
@@ -118 +118 @@
 }
 
-ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -135 +135 @@
 }
 
-IfStmt::IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
-        Statement( labels ), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
+IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
+        Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
 
 IfStmt::IfStmt( const IfStmt & other ) :
@@ -176 +176 @@
 }
 
-SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
-        Statement( labels ), condition( condition ), statements( statements ) {
+SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
+        Statement(), condition( condition ), statements( statements ) {
 }
 
@@ -201 +201 @@
 }
 
-CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
-        Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+        Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
 }
@@ -216 +216 @@
 }
 
-CaseStmt * CaseStmt::makeDefault( std::list<Label> labels, std::list<Statement *> stmts ) {
-        return new CaseStmt( labels, 0, stmts, true );
+CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
+        CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
+        stmt->labels = labels;
+        return stmt;
 }
 
@@ -233 +235 @@
 }
 
-WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition, Statement *body, bool isDoWhile ):
-        Statement( labels ), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
+        Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
 }
 
@@ -255 +257 @@
 }
 
-ForStmt::ForStmt( std::list<Label> labels, std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
-        Statement( labels ), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
+        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
 }
 
@@ -302 +304 @@
 }
 
-ThrowStmt::ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target ) :
-                Statement( labels ), kind(kind), expr(expr), target(target)     {
+ThrowStmt::ThrowStmt( Kind kind, Expression * expr, Expression * target ) :
+                Statement(), kind(kind), expr(expr), target(target)     {
         assertf(Resume == kind || nullptr == target, "Non-local termination throw is not accepted." );
 }
@@ -326 +328 @@
 }
 
-TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
-        Statement( labels ), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
+TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
+        Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
 
@@ -359 +361 @@
 }
 
-CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
-        Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
+        Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
                 assertf( decl, "Catch clause must have a declaration." );
 }
@@ -391 +393 @@
 
 
-FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *block ) : Statement( labels ), block( block ) {
-        assert( labels.empty() ); // finally statement cannot be labeled
+FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
 }
 
@@ -408 +409 @@
 }
 
-WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
+WaitForStmt::WaitForStmt() : Statement() {
         timeout.time      = nullptr;
         timeout.statement = nullptr;
@@ -455 +456 @@
 }
 
-NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
-NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
+
+WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Statement(), exprs( exprs ), stmt( stmt ) {}
+WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
+        cloneAll( other.exprs, exprs );
+}
+WithStmt::~WithStmt() {
+        deleteAll( exprs );
+        delete stmt;
+}
+
+void WithStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "With statement" << endl;
+        os << indent << "... with statement:" << endl << indent+1;
+        stmt->print( os, indent+1 );
+}
+
+
+NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
+}
 
 void NullStmt::print( std::ostream &os, Indenter ) const {
@@ -462 +480 @@
 }
 
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement(), callStmt( callStmt ) {
         assert( callStmt );
 }