[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 | // |
---|
[4e7171f] | 7 | // StatementNode.cc -- Transform from parse data-structures to AST data-structures, usually deleting the parse |
---|
| 8 | // data-structure after the transformation. |
---|
[b87a5ed] | 9 | // |
---|
| 10 | // Author : Rodolfo G. Esteves |
---|
| 11 | // Created On : Sat May 16 14:59:41 2015 |
---|
[f259682] | 12 | // Last Modified By : Peter A. Buhr |
---|
| 13 | // Last Modified On : Fri Aug 11 11:44:15 2023 |
---|
| 14 | // Update Count : 429 |
---|
[b87a5ed] | 15 | // |
---|
| 16 | |
---|
[c468150] | 17 | #include "StatementNode.h" |
---|
| 18 | |
---|
[e3e16bc] | 19 | #include <cassert> // for assert, strict_dynamic_cast, assertf |
---|
[d180746] | 20 | #include <memory> // for unique_ptr |
---|
| 21 | #include <string> // for string |
---|
[51b7345] | 22 | |
---|
[bb7422a] | 23 | #include "AST/Label.hpp" // for Label |
---|
| 24 | #include "AST/Stmt.hpp" // for Stmt, AsmStmt, BranchStmt, CaseCla... |
---|
[d180746] | 25 | #include "Common/SemanticError.h" // for SemanticError |
---|
| 26 | #include "Common/utility.h" // for maybeMoveBuild, maybeBuild |
---|
[c468150] | 27 | #include "DeclarationNode.h" // for DeclarationNode |
---|
| 28 | #include "ExpressionNode.h" // for ExpressionNode |
---|
[d180746] | 29 | #include "parserutility.h" // for notZeroExpr |
---|
| 30 | |
---|
| 31 | class Declaration; |
---|
[51b7345] | 32 | |
---|
| 33 | using namespace std; |
---|
| 34 | |
---|
[6611177] | 35 | // Some helpers for cases that really want a single node but check for lists. |
---|
| 36 | static const ast::Stmt * buildMoveSingle( StatementNode * node ) { |
---|
| 37 | std::vector<ast::ptr<ast::Stmt>> list; |
---|
| 38 | buildMoveList( node, list ); |
---|
| 39 | assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" ); |
---|
| 40 | return list.front().release(); |
---|
| 41 | } |
---|
| 42 | |
---|
| 43 | static const ast::Stmt * buildMoveOptional( StatementNode * node ) { |
---|
| 44 | std::vector<ast::ptr<ast::Stmt>> list; |
---|
| 45 | buildMoveList( node, list ); |
---|
| 46 | assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" ); |
---|
| 47 | return list.empty() ? nullptr : list.front().release(); |
---|
| 48 | } |
---|
| 49 | |
---|
[61fc4f6] | 50 | StatementNode::StatementNode( DeclarationNode * decl ) { |
---|
[c0aa336] | 51 | assert( decl ); |
---|
[61fc4f6] | 52 | DeclarationNode * agg = decl->extractAggregate(); |
---|
[c0aa336] | 53 | if ( agg ) { |
---|
[bb7422a] | 54 | StatementNode * nextStmt = new StatementNode( |
---|
| 55 | new ast::DeclStmt( decl->location, maybeBuild( decl ) ) ); |
---|
[44adf1b] | 56 | next = nextStmt; |
---|
| 57 | if ( decl->next ) { |
---|
| 58 | next->next = new StatementNode( decl->next ); |
---|
| 59 | decl->next = nullptr; |
---|
[1d4580a] | 60 | } // if |
---|
| 61 | } else { |
---|
[44adf1b] | 62 | if ( decl->next ) { |
---|
| 63 | next = new StatementNode( decl->next ); |
---|
| 64 | decl->next = nullptr; |
---|
[c0aa336] | 65 | } // if |
---|
| 66 | agg = decl; |
---|
[1d4580a] | 67 | } // if |
---|
[bb7422a] | 68 | // Local copy to avoid accessing the pointer after it is moved from. |
---|
| 69 | CodeLocation declLocation = agg->location; |
---|
| 70 | stmt.reset( new ast::DeclStmt( declLocation, maybeMoveBuild( agg ) ) ); |
---|
[c0aa336] | 71 | } // StatementNode::StatementNode |
---|
[1d4580a] | 72 | |
---|
[c468150] | 73 | StatementNode * StatementNode::add_label( |
---|
| 74 | const CodeLocation & location, |
---|
| 75 | const std::string * name, |
---|
| 76 | DeclarationNode * attr ) { |
---|
| 77 | stmt->labels.emplace_back( location, |
---|
| 78 | *name, |
---|
| 79 | attr ? std::move( attr->attributes ) |
---|
| 80 | : std::vector<ast::ptr<ast::Attribute>>{} ); |
---|
| 81 | delete attr; |
---|
| 82 | delete name; |
---|
| 83 | return this; |
---|
| 84 | } |
---|
| 85 | |
---|
[6611177] | 86 | ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) { |
---|
| 87 | ClauseNode * prev = this; |
---|
[1d4580a] | 88 | // find end of list and maintain previous pointer |
---|
[44adf1b] | 89 | for ( ClauseNode * curr = prev; curr != nullptr; curr = curr->next ) { |
---|
| 90 | ClauseNode * node = curr; |
---|
[bb7422a] | 91 | assert( dynamic_cast<ast::CaseClause *>( node->clause.get() ) ); |
---|
[8cc5cb0] | 92 | prev = curr; |
---|
| 93 | } // for |
---|
[44adf1b] | 94 | ClauseNode * node = prev; |
---|
[e82aa9df] | 95 | // convert from StatementNode list to Statement list |
---|
[bb7422a] | 96 | std::vector<ast::ptr<ast::Stmt>> stmts; |
---|
[7ecbb7e] | 97 | buildMoveList( stmt, stmts ); |
---|
[e82aa9df] | 98 | // splice any new Statements to end of current Statements |
---|
[bb7422a] | 99 | auto caseStmt = strict_dynamic_cast<ast::CaseClause *>( node->clause.get() ); |
---|
| 100 | for ( auto const & newStmt : stmts ) { |
---|
| 101 | caseStmt->stmts.emplace_back( newStmt ); |
---|
| 102 | } |
---|
| 103 | stmts.clear(); |
---|
[8cc5cb0] | 104 | return this; |
---|
[6611177] | 105 | } // ClauseNode::append_last_case |
---|
[8cc5cb0] | 106 | |
---|
[bb7422a] | 107 | ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) { |
---|
| 108 | if ( ast::Expr * e = maybeMoveBuild( ctl ) ) { |
---|
| 109 | return new ast::ExprStmt( location, e ); |
---|
| 110 | } else { |
---|
| 111 | return new ast::NullStmt( location ); |
---|
| 112 | } |
---|
[401e61f] | 113 | } // build_expr |
---|
[8cc5cb0] | 114 | |
---|
[bb7422a] | 115 | static ast::Expr * build_if_control( CondCtl * ctl, |
---|
| 116 | std::vector<ast::ptr<ast::Stmt>> & inits ) { |
---|
| 117 | assert( inits.empty() ); |
---|
| 118 | if ( nullptr != ctl->init ) { |
---|
| 119 | buildMoveList( ctl->init, inits ); |
---|
[936e9f4] | 120 | } // if |
---|
| 121 | |
---|
[bb7422a] | 122 | ast::Expr * cond = nullptr; |
---|
[a01f7c94] | 123 | if ( ctl->condition ) { |
---|
[ab780e6] | 124 | cond = maybeMoveBuild( ctl->condition ); |
---|
[a01f7c94] | 125 | } else { |
---|
[bb7422a] | 126 | for ( ast::ptr<ast::Stmt> & stmt : inits ) { |
---|
[a01f7c94] | 127 | // build the && of all of the declared variables compared against 0 |
---|
[bb7422a] | 128 | auto declStmt = stmt.strict_as<ast::DeclStmt>(); |
---|
| 129 | auto dwt = declStmt->decl.strict_as<ast::DeclWithType>(); |
---|
[ab780e6] | 130 | ast::Expr * nze = new ast::VariableExpr( dwt->location, dwt ); |
---|
[bb7422a] | 131 | cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze; |
---|
[a01f7c94] | 132 | } |
---|
| 133 | } |
---|
[6d49ea3] | 134 | delete ctl; |
---|
[ee3c93d] | 135 | return cond; |
---|
[401e61f] | 136 | } // build_if_control |
---|
[ee3c93d] | 137 | |
---|
[bb7422a] | 138 | ast::Stmt * build_if( const CodeLocation & location, CondCtl * ctl, StatementNode * then, StatementNode * else_ ) { |
---|
| 139 | std::vector<ast::ptr<ast::Stmt>> astinit; // maybe empty |
---|
| 140 | ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set |
---|
[436bbe5] | 141 | |
---|
[5541a44e] | 142 | ast::Stmt const * astthen = buildMoveSingle( then ); |
---|
| 143 | ast::Stmt const * astelse = buildMoveOptional( else_ ); |
---|
[ee3c93d] | 144 | |
---|
[bb7422a] | 145 | return new ast::IfStmt( location, astcond, astthen, astelse, |
---|
| 146 | std::move( astinit ) |
---|
| 147 | ); |
---|
[401e61f] | 148 | } // build_if |
---|
[2f22cc4] | 149 | |
---|
[6611177] | 150 | ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) { |
---|
[bb7422a] | 151 | std::vector<ast::ptr<ast::CaseClause>> aststmt; |
---|
[6611177] | 152 | buildMoveList( stmt, aststmt ); |
---|
[bb7422a] | 153 | // If it is not a switch it is a choose statement. |
---|
| 154 | if ( ! isSwitch ) { |
---|
| 155 | for ( ast::ptr<ast::CaseClause> & stmt : aststmt ) { |
---|
| 156 | // Code after "case" is the end of case list. |
---|
| 157 | if ( !stmt->stmts.empty() ) { |
---|
| 158 | auto mutStmt = ast::mutate( stmt.get() ); |
---|
| 159 | // I believe the stmts are actually always one block. |
---|
| 160 | auto stmts = mutStmt->stmts.front().get_and_mutate(); |
---|
| 161 | auto block = strict_dynamic_cast<ast::CompoundStmt *>( stmts ); |
---|
| 162 | block->kids.push_back( new ast::BranchStmt( block->location, |
---|
| 163 | ast::BranchStmt::Break, |
---|
| 164 | ast::Label( block->location ) ) ); |
---|
| 165 | stmt = mutStmt; |
---|
[6a276a0] | 166 | } // if |
---|
| 167 | } // for |
---|
| 168 | } // if |
---|
[436bbe5] | 169 | // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements |
---|
[bb7422a] | 170 | return new ast::SwitchStmt( location, |
---|
| 171 | maybeMoveBuild( ctl ), std::move( aststmt ) ); |
---|
[401e61f] | 172 | } // build_switch |
---|
| 173 | |
---|
[6611177] | 174 | ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) { |
---|
[bb7422a] | 175 | // stmt starts empty and then added to |
---|
| 176 | auto expr = maybeMoveBuild( ctl ); |
---|
[6611177] | 177 | return new ast::CaseClause( location, expr, {} ); |
---|
[401e61f] | 178 | } // build_case |
---|
| 179 | |
---|
[bb7422a] | 180 | ast::CaseClause * build_default( const CodeLocation & location ) { |
---|
| 181 | // stmt starts empty and then added to |
---|
| 182 | return new ast::CaseClause( location, nullptr, {} ); |
---|
[401e61f] | 183 | } // build_default |
---|
| 184 | |
---|
[bb7422a] | 185 | ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) { |
---|
| 186 | std::vector<ast::ptr<ast::Stmt>> astinit; // maybe empty |
---|
| 187 | ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set |
---|
[3b0bc16] | 188 | |
---|
[bb7422a] | 189 | return new ast::WhileDoStmt( location, |
---|
| 190 | astcond, |
---|
[6611177] | 191 | buildMoveSingle( stmt ), |
---|
| 192 | buildMoveOptional( else_ ), |
---|
[bb7422a] | 193 | std::move( astinit ), |
---|
[3e94a23] | 194 | ast::While |
---|
[bb7422a] | 195 | ); |
---|
[401e61f] | 196 | } // build_while |
---|
[2f22cc4] | 197 | |
---|
[bb7422a] | 198 | ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) { |
---|
[4e7171f] | 199 | // do-while cannot have declarations in the contitional, so init is always empty |
---|
[bb7422a] | 200 | return new ast::WhileDoStmt( location, |
---|
[ab780e6] | 201 | maybeMoveBuild( ctl ), |
---|
[6611177] | 202 | buildMoveSingle( stmt ), |
---|
| 203 | buildMoveOptional( else_ ), |
---|
[bb7422a] | 204 | {}, |
---|
[3e94a23] | 205 | ast::DoWhile |
---|
[bb7422a] | 206 | ); |
---|
[401e61f] | 207 | } // build_do_while |
---|
[2f22cc4] | 208 | |
---|
[bb7422a] | 209 | ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) { |
---|
| 210 | std::vector<ast::ptr<ast::Stmt>> astinit; // maybe empty |
---|
[436bbe5] | 211 | buildMoveList( forctl->init, astinit ); |
---|
[2f22cc4] | 212 | |
---|
[bb7422a] | 213 | ast::Expr * astcond = nullptr; // maybe empty |
---|
[ab780e6] | 214 | astcond = maybeMoveBuild( forctl->condition ); |
---|
[2f22cc4] | 215 | |
---|
[bb7422a] | 216 | ast::Expr * astincr = nullptr; // maybe empty |
---|
[702e826] | 217 | astincr = maybeMoveBuild( forctl->change ); |
---|
[436bbe5] | 218 | delete forctl; |
---|
[2f22cc4] | 219 | |
---|
[bb7422a] | 220 | return new ast::ForStmt( location, |
---|
| 221 | std::move( astinit ), |
---|
| 222 | astcond, |
---|
| 223 | astincr, |
---|
[6611177] | 224 | buildMoveSingle( stmt ), |
---|
| 225 | buildMoveOptional( else_ ) |
---|
[bb7422a] | 226 | ); |
---|
[401e61f] | 227 | } // build_for |
---|
[2f22cc4] | 228 | |
---|
[bb7422a] | 229 | ast::Stmt * build_branch( const CodeLocation & location, ast::BranchStmt::Kind kind ) { |
---|
| 230 | return new ast::BranchStmt( location, |
---|
| 231 | kind, |
---|
| 232 | ast::Label( location ) |
---|
| 233 | ); |
---|
[401e61f] | 234 | } // build_branch |
---|
| 235 | |
---|
[bb7422a] | 236 | ast::Stmt * build_branch( const CodeLocation & location, string * identifier, ast::BranchStmt::Kind kind ) { |
---|
| 237 | ast::Stmt * ret = new ast::BranchStmt( location, |
---|
| 238 | kind, |
---|
| 239 | ast::Label( location, *identifier ) |
---|
| 240 | ); |
---|
| 241 | delete identifier; // allocated by lexer |
---|
[ab57786] | 242 | return ret; |
---|
[401e61f] | 243 | } // build_branch |
---|
| 244 | |
---|
[bb7422a] | 245 | ast::Stmt * build_computedgoto( ExpressionNode * ctl ) { |
---|
| 246 | ast::Expr * expr = maybeMoveBuild( ctl ); |
---|
| 247 | return new ast::BranchStmt( expr->location, expr ); |
---|
[401e61f] | 248 | } // build_computedgoto |
---|
[8cc5cb0] | 249 | |
---|
[bb7422a] | 250 | ast::Stmt * build_return( const CodeLocation & location, ExpressionNode * ctl ) { |
---|
| 251 | std::vector<ast::ptr<ast::Expr>> exps; |
---|
[7ecbb7e] | 252 | buildMoveList( ctl, exps ); |
---|
[bb7422a] | 253 | return new ast::ReturnStmt( location, |
---|
| 254 | exps.size() > 0 ? exps.back().release() : nullptr |
---|
| 255 | ); |
---|
[401e61f] | 256 | } // build_return |
---|
[daf1af8] | 257 | |
---|
[bb7422a] | 258 | static ast::Stmt * build_throw_stmt( |
---|
| 259 | const CodeLocation & location, |
---|
| 260 | ExpressionNode * ctl, |
---|
| 261 | ast::ExceptionKind kind ) { |
---|
| 262 | std::vector<ast::ptr<ast::Expr>> exps; |
---|
[7ecbb7e] | 263 | buildMoveList( ctl, exps ); |
---|
[436bbe5] | 264 | assertf( exps.size() < 2, "CFA internal error: leaking memory" ); |
---|
[bb7422a] | 265 | return new ast::ThrowStmt( location, |
---|
| 266 | kind, |
---|
| 267 | !exps.empty() ? exps.back().release() : nullptr, |
---|
| 268 | (ast::Expr *)nullptr |
---|
| 269 | ); |
---|
| 270 | } |
---|
| 271 | |
---|
| 272 | ast::Stmt * build_throw( const CodeLocation & loc, ExpressionNode * ctl ) { |
---|
| 273 | return build_throw_stmt( loc, ctl, ast::Terminate ); |
---|
[401e61f] | 274 | } // build_throw |
---|
[daf1af8] | 275 | |
---|
[bb7422a] | 276 | ast::Stmt * build_resume( const CodeLocation & loc, ExpressionNode * ctl ) { |
---|
| 277 | return build_throw_stmt( loc, ctl, ast::Resume ); |
---|
[401e61f] | 278 | } // build_resume |
---|
[daf1af8] | 279 | |
---|
[bb7422a] | 280 | ast::Stmt * build_resume_at( ExpressionNode * ctl, ExpressionNode * target ) { |
---|
[794c15b] | 281 | (void)ctl; |
---|
| 282 | (void)target; |
---|
| 283 | assertf( false, "resume at (non-local throw) is not yet supported," ); |
---|
[401e61f] | 284 | } // build_resume_at |
---|
[321f55d] | 285 | |
---|
[6611177] | 286 | ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) { |
---|
[bb7422a] | 287 | std::vector<ast::ptr<ast::CatchClause>> aststmt; |
---|
[6611177] | 288 | buildMoveList( catch_, aststmt ); |
---|
[bb7422a] | 289 | ast::CompoundStmt * tryBlock = strict_dynamic_cast<ast::CompoundStmt *>( maybeMoveBuild( try_ ) ); |
---|
| 290 | ast::FinallyClause * finallyBlock = nullptr; |
---|
| 291 | if ( finally_ ) { |
---|
| 292 | finallyBlock = dynamic_cast<ast::FinallyClause *>( finally_->clause.release() ); |
---|
| 293 | } |
---|
| 294 | return new ast::TryStmt( location, |
---|
| 295 | tryBlock, |
---|
| 296 | std::move( aststmt ), |
---|
| 297 | finallyBlock |
---|
| 298 | ); |
---|
[401e61f] | 299 | } // build_try |
---|
| 300 | |
---|
[bb7422a] | 301 | ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) { |
---|
| 302 | return new ast::CatchClause( location, |
---|
| 303 | kind, |
---|
| 304 | maybeMoveBuild( decl ), |
---|
| 305 | maybeMoveBuild( cond ), |
---|
[6611177] | 306 | buildMoveSingle( body ) |
---|
[bb7422a] | 307 | ); |
---|
[401e61f] | 308 | } // build_catch |
---|
| 309 | |
---|
[bb7422a] | 310 | ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) { |
---|
| 311 | return new ast::FinallyClause( location, |
---|
[6611177] | 312 | strict_dynamic_cast<const ast::CompoundStmt *>( |
---|
| 313 | buildMoveSingle( stmt ) |
---|
| 314 | ) |
---|
[bb7422a] | 315 | ); |
---|
[401e61f] | 316 | } // build_finally |
---|
[1d4580a] | 317 | |
---|
[835d6e8] | 318 | ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) { |
---|
[6611177] | 319 | return new ast::SuspendStmt( location, |
---|
| 320 | strict_dynamic_cast<const ast::CompoundStmt *, nullptr>( |
---|
| 321 | buildMoveOptional( then ) |
---|
| 322 | ), |
---|
| 323 | kind |
---|
| 324 | ); |
---|
[9fd9d015] | 325 | } // build_suspend |
---|
[427854b] | 326 | |
---|
[bb7422a] | 327 | ast::WaitForStmt * build_waitfor( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) { |
---|
| 328 | auto clause = new ast::WaitForClause( location ); |
---|
[c86b08d] | 329 | clause->target = maybeBuild( targetExpr ); |
---|
[bb7422a] | 330 | clause->stmt = maybeMoveBuild( stmt ); |
---|
[ab780e6] | 331 | clause->when_cond = maybeMoveBuild( when ); |
---|
[2065609] | 332 | |
---|
[44adf1b] | 333 | ExpressionNode * next = targetExpr->next; |
---|
| 334 | targetExpr->next = nullptr; |
---|
[bb7422a] | 335 | buildMoveList( next, clause->target_args ); |
---|
[2065609] | 336 | |
---|
[135b431] | 337 | delete targetExpr; |
---|
| 338 | |
---|
[bb7422a] | 339 | existing->clauses.insert( existing->clauses.begin(), clause ); |
---|
[135b431] | 340 | |
---|
[9fd9d015] | 341 | return existing; |
---|
[401e61f] | 342 | } // build_waitfor |
---|
[135b431] | 343 | |
---|
[bb7422a] | 344 | ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) { |
---|
| 345 | existing->else_stmt = maybeMoveBuild( stmt ); |
---|
[ab780e6] | 346 | existing->else_cond = maybeMoveBuild( when ); |
---|
[135b431] | 347 | |
---|
[bb7422a] | 348 | (void)location; |
---|
[9fd9d015] | 349 | return existing; |
---|
| 350 | } // build_waitfor_else |
---|
[135b431] | 351 | |
---|
[bb7422a] | 352 | ast::WaitForStmt * build_waitfor_timeout( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ) { |
---|
| 353 | existing->timeout_time = maybeMoveBuild( timeout ); |
---|
| 354 | existing->timeout_stmt = maybeMoveBuild( stmt ); |
---|
[ab780e6] | 355 | existing->timeout_cond = maybeMoveBuild( when ); |
---|
[135b431] | 356 | |
---|
[bb7422a] | 357 | (void)location; |
---|
[9fd9d015] | 358 | return existing; |
---|
[401e61f] | 359 | } // build_waitfor_timeout |
---|
[135b431] | 360 | |
---|
[c86b08d] | 361 | ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) { |
---|
[6a4dae6] | 362 | ast::WhenClause * clause = new ast::WhenClause( loc ); |
---|
[ab780e6] | 363 | clause->when_cond = maybeMoveBuild( when ); |
---|
[6a4dae6] | 364 | clause->stmt = maybeMoveBuild( stmt ); |
---|
| 365 | clause->target = maybeMoveBuild( targetExpr ); |
---|
| 366 | return new ast::WaitUntilStmt::ClauseNode( clause ); |
---|
[c86b08d] | 367 | } |
---|
| 368 | ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) { |
---|
[6a4dae6] | 369 | ast::WhenClause * clause = new ast::WhenClause( loc ); |
---|
[ab780e6] | 370 | clause->when_cond = maybeMoveBuild( when ); |
---|
[6a4dae6] | 371 | clause->stmt = maybeMoveBuild( stmt ); |
---|
| 372 | return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause ); |
---|
[c86b08d] | 373 | } |
---|
[6a4dae6] | 374 | |
---|
[c86b08d] | 375 | ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation & loc, ast::WaitUntilStmt::ClauseNode * root ) { |
---|
[6a4dae6] | 376 | ast::WaitUntilStmt * retStmt = new ast::WaitUntilStmt( loc ); |
---|
| 377 | retStmt->predicateTree = root; |
---|
| 378 | |
---|
| 379 | // iterative tree traversal |
---|
| 380 | std::vector<ast::WaitUntilStmt::ClauseNode *> nodeStack; // stack needed for iterative traversal |
---|
| 381 | ast::WaitUntilStmt::ClauseNode * currNode = nullptr; |
---|
| 382 | ast::WaitUntilStmt::ClauseNode * lastInternalNode = nullptr; |
---|
| 383 | ast::WaitUntilStmt::ClauseNode * cleanup = nullptr; // used to cleanup removed else/timeout |
---|
| 384 | nodeStack.push_back(root); |
---|
| 385 | |
---|
| 386 | do { |
---|
| 387 | currNode = nodeStack.back(); |
---|
| 388 | nodeStack.pop_back(); // remove node since it will be processed |
---|
| 389 | |
---|
| 390 | switch (currNode->op) { |
---|
| 391 | case ast::WaitUntilStmt::ClauseNode::LEAF: |
---|
| 392 | retStmt->clauses.push_back(currNode->leaf); |
---|
| 393 | break; |
---|
| 394 | case ast::WaitUntilStmt::ClauseNode::ELSE: |
---|
| 395 | retStmt->else_stmt = currNode->leaf->stmt |
---|
| 396 | ? ast::deepCopy( currNode->leaf->stmt ) |
---|
| 397 | : nullptr; |
---|
| 398 | retStmt->else_cond = currNode->leaf->when_cond |
---|
| 399 | ? ast::deepCopy( currNode->leaf->when_cond ) |
---|
| 400 | : nullptr; |
---|
| 401 | |
---|
| 402 | delete currNode->leaf; |
---|
| 403 | break; |
---|
| 404 | case ast::WaitUntilStmt::ClauseNode::TIMEOUT: |
---|
| 405 | retStmt->timeout_time = currNode->leaf->target |
---|
| 406 | ? ast::deepCopy( currNode->leaf->target ) |
---|
| 407 | : nullptr; |
---|
| 408 | retStmt->timeout_stmt = currNode->leaf->stmt |
---|
| 409 | ? ast::deepCopy( currNode->leaf->stmt ) |
---|
| 410 | : nullptr; |
---|
| 411 | retStmt->timeout_cond = currNode->leaf->when_cond |
---|
| 412 | ? ast::deepCopy( currNode->leaf->when_cond ) |
---|
| 413 | : nullptr; |
---|
| 414 | |
---|
| 415 | delete currNode->leaf; |
---|
| 416 | break; |
---|
| 417 | default: |
---|
| 418 | nodeStack.push_back( currNode->right ); // process right after left |
---|
| 419 | nodeStack.push_back( currNode->left ); |
---|
| 420 | |
---|
| 421 | // Cut else/timeout out of the tree |
---|
| 422 | if ( currNode->op == ast::WaitUntilStmt::ClauseNode::LEFT_OR ) { |
---|
| 423 | if ( lastInternalNode ) |
---|
| 424 | lastInternalNode->right = currNode->left; |
---|
| 425 | else // if not set then root is LEFT_OR |
---|
| 426 | retStmt->predicateTree = currNode->left; |
---|
| 427 | |
---|
| 428 | currNode->left = nullptr; |
---|
| 429 | cleanup = currNode; |
---|
| 430 | } |
---|
| 431 | |
---|
| 432 | lastInternalNode = currNode; |
---|
| 433 | break; |
---|
| 434 | } |
---|
| 435 | } while ( !nodeStack.empty() ); |
---|
| 436 | |
---|
| 437 | if ( cleanup ) delete cleanup; |
---|
| 438 | |
---|
| 439 | return retStmt; |
---|
[c86b08d] | 440 | } |
---|
| 441 | |
---|
[bb7422a] | 442 | ast::Stmt * build_with( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) { |
---|
| 443 | std::vector<ast::ptr<ast::Expr>> e; |
---|
[a378ca7] | 444 | buildMoveList( exprs, e ); |
---|
[bb7422a] | 445 | ast::Stmt * s = maybeMoveBuild( stmt ); |
---|
| 446 | return new ast::DeclStmt( location, new ast::WithStmt( location, std::move( e ), s ) ); |
---|
[401e61f] | 447 | } // build_with |
---|
[a378ca7] | 448 | |
---|
[bb7422a] | 449 | ast::Stmt * build_compound( const CodeLocation & location, StatementNode * first ) { |
---|
| 450 | auto cs = new ast::CompoundStmt( location ); |
---|
| 451 | buildMoveList( first, cs->kids ); |
---|
[b87a5ed] | 452 | return cs; |
---|
[401e61f] | 453 | } // build_compound |
---|
[51b7345] | 454 | |
---|
[a025ea8] | 455 | // A single statement in a control structure is always converted to a compound statement so subsequent generated code |
---|
| 456 | // can be placed within this compound statement. Otherwise, code generation has to constantly check for a single |
---|
| 457 | // statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a |
---|
| 458 | // conical form for code generation. |
---|
[bb7422a] | 459 | StatementNode * maybe_build_compound( const CodeLocation & location, StatementNode * first ) { |
---|
[a025ea8] | 460 | // Optimization: if the control-structure statement is a compound statement, do not wrap it. |
---|
| 461 | // e.g., if (...) {...} do not wrap the existing compound statement. |
---|
[bb7422a] | 462 | if ( !dynamic_cast<ast::CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr |
---|
| 463 | return new StatementNode( build_compound( location, first ) ); |
---|
[a025ea8] | 464 | } // if |
---|
| 465 | return first; |
---|
| 466 | } // maybe_build_compound |
---|
| 467 | |
---|
[f135b50] | 468 | // Question |
---|
[32d6fdc] | 469 | ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) { |
---|
[bb7422a] | 470 | std::vector<ast::ptr<ast::Expr>> out, in; |
---|
| 471 | std::vector<ast::ptr<ast::ConstantExpr>> clob; |
---|
[e82aa9df] | 472 | |
---|
[7ecbb7e] | 473 | buildMoveList( output, out ); |
---|
| 474 | buildMoveList( input, in ); |
---|
| 475 | buildMoveList( clobber, clob ); |
---|
[bb7422a] | 476 | return new ast::AsmStmt( location, |
---|
[32d6fdc] | 477 | is_volatile, |
---|
| 478 | maybeMoveBuild( instruction ), |
---|
[bb7422a] | 479 | std::move( out ), |
---|
| 480 | std::move( in ), |
---|
| 481 | std::move( clob ), |
---|
| 482 | gotolabels ? gotolabels->labels : std::vector<ast::Label>() |
---|
| 483 | ); |
---|
[401e61f] | 484 | } // build_asm |
---|
[7f5566b] | 485 | |
---|
[bb7422a] | 486 | ast::Stmt * build_directive( const CodeLocation & location, string * directive ) { |
---|
| 487 | auto stmt = new ast::DirectiveStmt( location, *directive ); |
---|
| 488 | delete directive; |
---|
| 489 | return stmt; |
---|
[401e61f] | 490 | } // build_directive |
---|
[61fc4f6] | 491 | |
---|
[bb7422a] | 492 | ast::Stmt * build_mutex( const CodeLocation & location, ExpressionNode * exprs, StatementNode * stmt ) { |
---|
| 493 | std::vector<ast::ptr<ast::Expr>> expList; |
---|
[de52331] | 494 | buildMoveList( exprs, expList ); |
---|
[bb7422a] | 495 | ast::Stmt * body = maybeMoveBuild( stmt ); |
---|
| 496 | return new ast::MutexStmt( location, body, std::move( expList ) ); |
---|
[de52331] | 497 | } // build_mutex |
---|
| 498 | |
---|
[eb779d5] | 499 | ast::Stmt * build_corun( const CodeLocation & location, StatementNode * stmt ) { |
---|
| 500 | ast::Stmt * body = maybeMoveBuild( stmt ); |
---|
| 501 | return new ast::CorunStmt( location, body ); |
---|
| 502 | } // build_corun |
---|
| 503 | |
---|
[3d9d017] | 504 | ast::Stmt * build_cofor( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt ) { |
---|
| 505 | std::vector<ast::ptr<ast::Stmt>> astinit; // maybe empty |
---|
| 506 | buildMoveList( forctl->init, astinit ); |
---|
| 507 | |
---|
| 508 | ast::Expr * astcond = nullptr; // maybe empty |
---|
[ab780e6] | 509 | astcond = maybeMoveBuild( forctl->condition ); |
---|
[3d9d017] | 510 | |
---|
| 511 | ast::Expr * astincr = nullptr; // maybe empty |
---|
| 512 | astincr = maybeMoveBuild( forctl->change ); |
---|
| 513 | delete forctl; |
---|
| 514 | |
---|
| 515 | return new ast::CoforStmt( location, |
---|
| 516 | std::move( astinit ), |
---|
| 517 | astcond, |
---|
| 518 | astincr, |
---|
| 519 | buildMoveSingle( stmt ) |
---|
| 520 | ); |
---|
| 521 | } // build_cofor |
---|
| 522 | |
---|
[51b7345] | 523 | // Local Variables: // |
---|
[b87a5ed] | 524 | // tab-width: 4 // |
---|
| 525 | // mode: c++ // |
---|
| 526 | // compile-command: "make install" // |
---|
[51b7345] | 527 | // End: // |
---|