Changes in src/SynTree/Statement.cc [ba3706f:61255ad]

File:

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

src/SynTree/Statement.cc

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