[b87a5ed] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo |
---|
| 3 | // |
---|
| 4 | // The contents of this file are covered under the licence agreement in the |
---|
| 5 | // file "LICENCE" distributed with Cforall. |
---|
| 6 | // |
---|
| 7 | // StatementNode.cc -- |
---|
| 8 | // |
---|
| 9 | // Author : Rodolfo G. Esteves |
---|
| 10 | // Created On : Sat May 16 14:59:41 2015 |
---|
| 11 | // Last Modified By : Peter A. Buhr |
---|
| 12 | // Last Modified On : Sat May 16 15:10:45 2015 |
---|
| 13 | // Update Count : 7 |
---|
| 14 | // |
---|
| 15 | |
---|
[51b7345] | 16 | #include <list> |
---|
| 17 | #include <algorithm> |
---|
| 18 | #include <cassert> |
---|
| 19 | |
---|
| 20 | #include "ParseNode.h" |
---|
| 21 | #include "SynTree/Statement.h" |
---|
| 22 | #include "SynTree/Expression.h" |
---|
| 23 | #include "parseutility.h" |
---|
| 24 | #include "utility.h" |
---|
| 25 | |
---|
| 26 | using namespace std; |
---|
| 27 | |
---|
[b87a5ed] | 28 | const char *StatementNode::StType[] = { |
---|
| 29 | "Exp", "If", "Switch", "Case", "Default", "Choose", "Fallthru", |
---|
| 30 | "While", "Do", "For", |
---|
| 31 | "Goto", "Continue", "Break", "Return", "Throw", |
---|
| 32 | "Try", "Catch", "Finally", "Asm", |
---|
| 33 | "Decl" |
---|
| 34 | }; |
---|
| 35 | |
---|
| 36 | StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} |
---|
| 37 | |
---|
| 38 | StatementNode::StatementNode( string name_) : ParseNode( name_), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {} |
---|
| 39 | |
---|
| 40 | StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) { |
---|
| 41 | if ( decl ) { |
---|
| 42 | if ( DeclarationNode *agg = decl->extractAggregate() ) { |
---|
| 43 | this->decl = agg; |
---|
| 44 | StatementNode *nextStmt = new StatementNode; |
---|
| 45 | nextStmt->type = Decl; |
---|
| 46 | nextStmt->decl = decl; |
---|
| 47 | next = nextStmt; |
---|
| 48 | if ( decl->get_link() ) { |
---|
| 49 | next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) ); |
---|
| 50 | decl->set_next( 0 ); |
---|
| 51 | } |
---|
| 52 | } else { |
---|
| 53 | if ( decl->get_link() ) { |
---|
| 54 | next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ); |
---|
| 55 | decl->set_next( 0 ); |
---|
| 56 | } |
---|
| 57 | this->decl = decl; |
---|
| 58 | } |
---|
| 59 | } |
---|
[51b7345] | 60 | } |
---|
| 61 | |
---|
[b87a5ed] | 62 | StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block_ ) : |
---|
| 63 | type( t ), control( ctrl_label ), block( block_), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) { |
---|
| 64 | if ( t == Default ) |
---|
| 65 | control = 0; |
---|
[51b7345] | 66 | } |
---|
| 67 | |
---|
[b87a5ed] | 68 | StatementNode::StatementNode( Type t, string *_target ) : |
---|
| 69 | type( t ), control( 0 ), block( 0 ), labels( 0 ), target(_target ), decl( 0 ), isCatchRest ( false ) {} |
---|
[51b7345] | 70 | |
---|
[b87a5ed] | 71 | StatementNode::~StatementNode() { |
---|
| 72 | delete control; |
---|
| 73 | delete block; |
---|
| 74 | delete labels; |
---|
| 75 | delete target; |
---|
| 76 | delete decl; |
---|
[51b7345] | 77 | } |
---|
| 78 | |
---|
[b87a5ed] | 79 | StatementNode * StatementNode::newCatchStmt( DeclarationNode *d, StatementNode *s, bool catchRestP ) { |
---|
| 80 | StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s ); |
---|
| 81 | ret->addDeclaration( d ); |
---|
| 82 | ret->setCatchRest( catchRestP ); |
---|
[51b7345] | 83 | |
---|
[b87a5ed] | 84 | return ret; |
---|
[51b7345] | 85 | } |
---|
| 86 | |
---|
| 87 | std::string StatementNode::get_target() const{ |
---|
[b87a5ed] | 88 | if ( target ) |
---|
| 89 | return *target; |
---|
[51b7345] | 90 | |
---|
[b87a5ed] | 91 | return string(""); |
---|
[51b7345] | 92 | } |
---|
| 93 | |
---|
[b87a5ed] | 94 | StatementNode * StatementNode::clone() const { |
---|
| 95 | StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) ); |
---|
| 96 | if ( target ) { |
---|
| 97 | newnode->target = new string( *target ); |
---|
| 98 | } else { |
---|
| 99 | newnode->target = 0; |
---|
| 100 | } |
---|
| 101 | newnode->decl = maybeClone( decl ); |
---|
| 102 | return newnode; |
---|
[51b7345] | 103 | } |
---|
| 104 | |
---|
[b87a5ed] | 105 | void StatementNode::set_control( ExpressionNode *c ) { |
---|
| 106 | control = c; |
---|
[51b7345] | 107 | } |
---|
| 108 | |
---|
[b87a5ed] | 109 | StatementNode * StatementNode::set_block( StatementNode *b ) { |
---|
| 110 | block = b; |
---|
[51b7345] | 111 | |
---|
[b87a5ed] | 112 | return this; |
---|
[51b7345] | 113 | } |
---|
| 114 | |
---|
[b87a5ed] | 115 | ExpressionNode *StatementNode::get_control() const { |
---|
| 116 | return control; |
---|
[51b7345] | 117 | } |
---|
| 118 | |
---|
[b87a5ed] | 119 | StatementNode *StatementNode::get_block() const { |
---|
| 120 | return block; |
---|
[51b7345] | 121 | } |
---|
| 122 | |
---|
[b87a5ed] | 123 | StatementNode::Type StatementNode::get_type() const { |
---|
| 124 | return type; |
---|
[51b7345] | 125 | } |
---|
| 126 | |
---|
[b87a5ed] | 127 | StatementNode *StatementNode::add_label( std::string *l ) { |
---|
| 128 | if ( l != 0 ) { |
---|
| 129 | if ( labels == 0 ) |
---|
| 130 | labels = new std::list<std::string>(); |
---|
[51b7345] | 131 | |
---|
[b87a5ed] | 132 | labels->push_front(*l ); |
---|
| 133 | delete l; |
---|
| 134 | } |
---|
| 135 | return this; |
---|
[51b7345] | 136 | } |
---|
| 137 | |
---|
[b87a5ed] | 138 | std::list<std::string> *StatementNode::get_labels() const { return labels; } |
---|
[51b7345] | 139 | |
---|
[b87a5ed] | 140 | StatementNode *StatementNode::add_controlexp( ExpressionNode *e ) { |
---|
| 141 | if ( control && e ) |
---|
| 142 | control->add_to_list( e ); // xxx - check this |
---|
[51b7345] | 143 | |
---|
[b87a5ed] | 144 | return this; |
---|
[51b7345] | 145 | } |
---|
| 146 | |
---|
[b87a5ed] | 147 | StatementNode *StatementNode::append_block( StatementNode *stmt ) { |
---|
| 148 | if ( stmt != 0 ) { |
---|
| 149 | if ( block == 0 ) |
---|
| 150 | block = stmt; |
---|
| 151 | else |
---|
| 152 | block->set_link( stmt ); |
---|
| 153 | } |
---|
| 154 | return this; |
---|
[51b7345] | 155 | } |
---|
| 156 | |
---|
[b87a5ed] | 157 | StatementNode *StatementNode::append_last_case( StatementNode *stmt ) { |
---|
| 158 | if ( stmt != 0 ) { |
---|
| 159 | StatementNode *next = ( StatementNode *)get_link(); |
---|
| 160 | if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default ) ) |
---|
| 161 | next->append_last_case ( stmt ); |
---|
| 162 | else |
---|
| 163 | if ( block == 0 ) |
---|
| 164 | block = stmt; |
---|
| 165 | else |
---|
| 166 | block->set_link( stmt ); |
---|
| 167 | } |
---|
| 168 | return this; |
---|
[51b7345] | 169 | } |
---|
| 170 | |
---|
| 171 | void StatementNode::print( std::ostream &os, int indent ) const { |
---|
[b87a5ed] | 172 | if ( labels != 0 ) |
---|
[a32b204] | 173 | if (! labels->empty()) { |
---|
[b87a5ed] | 174 | std::list<std::string>::const_iterator i; |
---|
| 175 | |
---|
| 176 | os << '\r' << string( indent, ' '); |
---|
[a32b204] | 177 | for ( i = labels->begin(); i != labels->end(); i++ ) |
---|
[b87a5ed] | 178 | os << *i << ":"; |
---|
| 179 | os << endl; |
---|
| 180 | } |
---|
| 181 | |
---|
[a32b204] | 182 | switch ( type ) { |
---|
[b87a5ed] | 183 | case Decl: |
---|
| 184 | decl->print( os, indent ); |
---|
| 185 | break; |
---|
| 186 | case Exp: |
---|
| 187 | if ( control ) { |
---|
| 188 | os << string( indent, ' ' ); |
---|
| 189 | control->print( os, indent ); |
---|
| 190 | os << endl; |
---|
| 191 | } else |
---|
| 192 | os << string( indent, ' ' ) << "Null Statement" << endl; |
---|
| 193 | break; |
---|
| 194 | default: |
---|
| 195 | os << '\r' << string( indent, ' ') << StatementNode::StType[type] << endl; |
---|
| 196 | if ( type == Catch ) { |
---|
| 197 | if ( decl ) { |
---|
| 198 | os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl; |
---|
| 199 | decl->print( os, indent + 2*ParseNode::indent_by ); |
---|
| 200 | } else if ( isCatchRest ) { |
---|
| 201 | os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl; |
---|
| 202 | } else { |
---|
| 203 | ; // should never reach here |
---|
| 204 | } |
---|
| 205 | } |
---|
| 206 | if ( control ) { |
---|
| 207 | os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Expression: " << endl; |
---|
| 208 | control->printList( os, indent + 2*ParseNode::indent_by ); |
---|
| 209 | } |
---|
| 210 | if ( block ) { |
---|
| 211 | os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl; |
---|
| 212 | block->printList( os, indent + 2*ParseNode::indent_by ); |
---|
| 213 | } |
---|
| 214 | if ( target ) { |
---|
| 215 | os << '\r' << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl; |
---|
| 216 | } |
---|
| 217 | break; |
---|
| 218 | } |
---|
[51b7345] | 219 | } |
---|
| 220 | |
---|
| 221 | Statement *StatementNode::build() const { |
---|
[b87a5ed] | 222 | std::list<Statement *> branches; |
---|
| 223 | std::list<Expression *> exps; |
---|
| 224 | std::list<Label> labs; |
---|
| 225 | |
---|
| 226 | if ( labels != 0 ) { |
---|
| 227 | std::back_insert_iterator< std::list<Label> > lab_it( labs ); |
---|
| 228 | copy( labels->begin(), labels->end(), lab_it ); |
---|
| 229 | } |
---|
| 230 | |
---|
| 231 | // try { |
---|
| 232 | buildList<Statement, StatementNode>( get_block(), branches ); |
---|
| 233 | |
---|
[a32b204] | 234 | switch ( type ) { |
---|
[b87a5ed] | 235 | case Decl: |
---|
| 236 | return new DeclStmt( labs, maybeBuild< Declaration >( decl ) ); |
---|
| 237 | case Exp: |
---|
| 238 | { |
---|
| 239 | Expression *e = maybeBuild< Expression >( get_control() ); |
---|
| 240 | |
---|
| 241 | if ( e ) |
---|
| 242 | return new ExprStmt( labs, e ); |
---|
| 243 | else |
---|
| 244 | return new NullStmt( labs ); |
---|
| 245 | } |
---|
| 246 | case If: |
---|
| 247 | { |
---|
| 248 | Statement *thenb = 0, *elseb = 0; |
---|
| 249 | assert( branches.size() >= 1 ); |
---|
| 250 | |
---|
| 251 | thenb = branches.front(); |
---|
| 252 | branches.pop_front(); |
---|
[a32b204] | 253 | if ( ! branches.empty() ) { |
---|
[b87a5ed] | 254 | elseb = branches.front(); |
---|
| 255 | branches.pop_front(); |
---|
| 256 | } |
---|
| 257 | return new IfStmt( labs, notZeroExpr( get_control()->build() ), thenb, elseb ); |
---|
| 258 | } |
---|
| 259 | case While: |
---|
| 260 | assert( branches.size() == 1 ); |
---|
| 261 | return new WhileStmt( labs, notZeroExpr( get_control()->build() ), branches.front() ); |
---|
| 262 | case Do: |
---|
| 263 | assert( branches.size() == 1 ); |
---|
| 264 | return new WhileStmt( labs, notZeroExpr( get_control()->build() ), branches.front(), true ); |
---|
| 265 | case For: |
---|
| 266 | { |
---|
| 267 | assert( branches.size() == 1 ); |
---|
| 268 | |
---|
| 269 | ForCtlExprNode *ctl = dynamic_cast<ForCtlExprNode *>( get_control() ); |
---|
| 270 | assert( ctl != 0 ); |
---|
| 271 | |
---|
| 272 | Statement *stmt = 0; |
---|
| 273 | if ( ctl->get_init() != 0 ) |
---|
| 274 | stmt = ctl->get_init()->build(); |
---|
| 275 | |
---|
| 276 | Expression *cond = 0; |
---|
| 277 | if ( ctl->get_condition() != 0 ) |
---|
| 278 | cond = notZeroExpr( ctl->get_condition()->build() ); |
---|
| 279 | |
---|
| 280 | Expression *incr = 0; |
---|
| 281 | if ( ctl->get_change() != 0 ) |
---|
| 282 | incr = ctl->get_change()->build(); |
---|
| 283 | |
---|
| 284 | return new ForStmt( labs, stmt, cond, incr, branches.front() ); |
---|
| 285 | } |
---|
| 286 | case Switch: |
---|
| 287 | return new SwitchStmt( labs, get_control()->build(), branches ); |
---|
| 288 | case Choose: |
---|
| 289 | return new ChooseStmt( labs, get_control()->build(), branches ); |
---|
| 290 | case Fallthru: |
---|
| 291 | return new FallthruStmt( labs ); |
---|
| 292 | case Case: |
---|
| 293 | return new CaseStmt( labs, get_control()->build(), branches ); |
---|
| 294 | case Default: |
---|
| 295 | return new CaseStmt( labs, 0, branches, true ); |
---|
| 296 | case Goto: |
---|
| 297 | { |
---|
| 298 | if ( get_target() == "" ) { // computed goto |
---|
| 299 | assert( get_control() != 0 ); |
---|
| 300 | return new BranchStmt( labs, get_control()->build(), BranchStmt::Goto ); |
---|
| 301 | } |
---|
| 302 | |
---|
| 303 | return new BranchStmt( labs, get_target(), BranchStmt::Goto ); |
---|
| 304 | } |
---|
| 305 | case Break: |
---|
| 306 | return new BranchStmt( labs, get_target(), BranchStmt::Break ); |
---|
| 307 | case Continue: |
---|
| 308 | return new BranchStmt( labs, get_target(), BranchStmt::Continue ); |
---|
| 309 | case Return: |
---|
| 310 | case Throw : |
---|
| 311 | buildList( get_control(), exps ); |
---|
| 312 | if ( exps.size() ==0 ) |
---|
| 313 | return new ReturnStmt( labs, 0, type == Throw ); |
---|
| 314 | if ( exps.size() > 0 ) |
---|
| 315 | return new ReturnStmt( labs, exps.back(), type == Throw ); |
---|
| 316 | case Try: |
---|
| 317 | { |
---|
| 318 | assert( branches.size() >= 0 ); |
---|
| 319 | CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front()); |
---|
| 320 | branches.pop_front(); |
---|
| 321 | FinallyStmt *finallyBlock = 0; |
---|
| 322 | if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) { |
---|
| 323 | branches.pop_back(); |
---|
| 324 | } |
---|
| 325 | return new TryStmt( labs, tryBlock, branches, finallyBlock ); |
---|
| 326 | } |
---|
| 327 | case Catch: |
---|
| 328 | { |
---|
| 329 | assert( branches.size() == 1 ); |
---|
| 330 | |
---|
| 331 | return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), isCatchRest ); |
---|
| 332 | } |
---|
| 333 | case Finally: |
---|
| 334 | { |
---|
| 335 | assert( branches.size() == 1 ); |
---|
| 336 | CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() ); |
---|
| 337 | assert( block != 0 ); |
---|
| 338 | |
---|
| 339 | return new FinallyStmt( labs, block ); |
---|
| 340 | } |
---|
| 341 | default: |
---|
| 342 | // shouldn't be here |
---|
| 343 | return 0; |
---|
| 344 | } |
---|
[51b7345] | 345 | } |
---|
| 346 | |
---|
[b87a5ed] | 347 | CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) { |
---|
[51b7345] | 348 | } |
---|
| 349 | |
---|
[b87a5ed] | 350 | CompoundStmtNode::CompoundStmtNode( string *name_) : StatementNode(*name_), first( 0 ), last( 0 ) { |
---|
[51b7345] | 351 | } |
---|
| 352 | |
---|
[b87a5ed] | 353 | CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ): first( stmt ) { |
---|
| 354 | if ( first ) { |
---|
| 355 | last = ( StatementNode *)( stmt->get_last()); |
---|
| 356 | } else { |
---|
| 357 | last = 0; |
---|
| 358 | } |
---|
[51b7345] | 359 | } |
---|
| 360 | |
---|
[b87a5ed] | 361 | CompoundStmtNode::~CompoundStmtNode() { |
---|
| 362 | delete first; |
---|
[51b7345] | 363 | } |
---|
| 364 | |
---|
[b87a5ed] | 365 | void CompoundStmtNode::add_statement( StatementNode *stmt ) { |
---|
| 366 | if ( stmt != 0 ) { |
---|
| 367 | last->set_link( stmt ); |
---|
| 368 | last = ( StatementNode *)( stmt->get_link()); |
---|
| 369 | } |
---|
[51b7345] | 370 | } |
---|
| 371 | |
---|
[b87a5ed] | 372 | void CompoundStmtNode::print( ostream &os, int indent ) const { |
---|
| 373 | if ( first ) { |
---|
| 374 | first->printList( os, indent+2 ); |
---|
| 375 | } |
---|
[51b7345] | 376 | } |
---|
| 377 | |
---|
| 378 | Statement *CompoundStmtNode::build() const { |
---|
[b87a5ed] | 379 | std::list<Label> labs; |
---|
| 380 | std::list<std::string> *labels = get_labels(); |
---|
[51b7345] | 381 | |
---|
[b87a5ed] | 382 | if ( labels != 0 ) { |
---|
| 383 | std::back_insert_iterator< std::list<Label> > lab_it( labs ); |
---|
| 384 | copy( labels->begin(), labels->end(), lab_it ); |
---|
| 385 | } |
---|
[51b7345] | 386 | |
---|
[b87a5ed] | 387 | CompoundStmt *cs = new CompoundStmt( labs ); |
---|
| 388 | buildList( first, cs->get_kids() ); |
---|
| 389 | return cs; |
---|
[51b7345] | 390 | } |
---|
| 391 | |
---|
[b87a5ed] | 392 | void NullStmtNode::print( ostream &os, int indent ) const { |
---|
| 393 | os << "\r" << string( indent, ' ') << "Null Statement:" << endl; |
---|
[51b7345] | 394 | } |
---|
| 395 | |
---|
| 396 | Statement *NullStmtNode::build() const { |
---|
[b87a5ed] | 397 | return new NullStmt; |
---|
[51b7345] | 398 | } |
---|
| 399 | |
---|
| 400 | // Local Variables: // |
---|
[b87a5ed] | 401 | // tab-width: 4 // |
---|
| 402 | // mode: c++ // |
---|
| 403 | // compile-command: "make install" // |
---|
[51b7345] | 404 | // End: // |
---|