source: src/ControlStruct/MultiLevelExit.cpp@ 1931bb01

ADT ast-experimental pthread-emulation qualifiedEnum
Last change on this file since 1931bb01 was e5628db, checked in by caparsons <caparson@…>, 3 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
  • Property mode set to 100644
File size: 21.9 KB
Line 
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// MultiLevelExit.cpp -- Replaces CFA's local control flow with C's versions.
8//
9// Author : Andrew Beach
10// Created On : Mon Nov 1 13:48:00 2021
11// Last Modified By : Andrew Beach
12// Last Modified On : Mon Mar 28 9:42:00 2022
13// Update Count : 34
14//
15
16#include "MultiLevelExit.hpp"
17
18#include "AST/Pass.hpp"
19#include "AST/Stmt.hpp"
20#include "Common/CodeLocationTools.hpp"
21#include "LabelGeneratorNew.hpp"
22
23#include <set>
24using namespace std;
25using namespace ast;
26
27namespace ControlStruct {
28class Entry {
29 public:
30 const Stmt * stmt;
31 private:
32 // Organized like a manual ADT. Avoids creating a bunch of dead data.
33 struct Target {
34 Label label;
35 bool used = false;
36 Target( const Label & label ) : label( label ) {}
37 Target() : label( CodeLocation() ) {}
38 };
39 Target firstTarget;
40 Target secondTarget;
41
42 enum Kind {
43 ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseClauseK, SwitchStmtK, TryStmtK
44 } kind;
45
46 bool fallDefaultValid = true;
47
48 static Label & useTarget( Target & target ) {
49 target.used = true;
50 return target.label;
51 }
52 public:
53 Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
54 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
55 Entry( const WhileDoStmt * stmt, Label breakExit, Label contExit ) :
56 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileDoStmtK ) {}
57 Entry( const CompoundStmt *stmt, Label breakExit ) :
58 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
59 Entry( const IfStmt *stmt, Label breakExit ) :
60 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
61 Entry( const CaseClause *, const CompoundStmt *stmt, Label fallExit ) :
62 stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseClauseK ) {}
63 Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
64 stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
65 Entry( const TryStmt *stmt, Label breakExit ) :
66 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
67
68 bool isContTarget() const { return kind <= WhileDoStmtK; }
69 bool isBreakTarget() const { return kind != CaseClauseK; }
70 bool isFallTarget() const { return kind == CaseClauseK; }
71 bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
72
73 // These routines set a target as being "used" by a BranchStmt
74 Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
75 Label useBreakExit() { assert( kind != CaseClauseK ); return useTarget(firstTarget); }
76 Label useFallExit() { assert( kind == CaseClauseK ); return useTarget(firstTarget); }
77 Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
78
79 // These routines check if a specific label for a statement is used by a BranchStmt
80 bool isContUsed() const { assert( kind <= WhileDoStmtK ); return secondTarget.used; }
81 bool isBreakUsed() const { assert( kind != CaseClauseK ); return firstTarget.used; }
82 bool isFallUsed() const { assert( kind == CaseClauseK ); return firstTarget.used; }
83 bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
84 void seenDefault() { fallDefaultValid = false; }
85 bool isFallDefaultValid() const { return fallDefaultValid; }
86};
87
88// Helper predicates used in find_if calls (it doesn't take methods):
89bool isBreakTarget( const Entry & entry ) {
90 return entry.isBreakTarget();
91}
92
93bool isContinueTarget( const Entry & entry ) {
94 return entry.isContTarget();
95}
96
97bool isFallthroughTarget( const Entry & entry ) {
98 return entry.isFallTarget();
99}
100
101bool isFallthroughDefaultTarget( const Entry & entry ) {
102 return entry.isFallDefaultTarget();
103}
104
105struct MultiLevelExitCore final :
106 public WithVisitorRef<MultiLevelExitCore>,
107 public WithShortCircuiting, public WithGuards {
108 MultiLevelExitCore( const LabelToStmt & lt );
109
110 void previsit( const FunctionDecl * );
111
112 const CompoundStmt * previsit( const CompoundStmt * );
113 const BranchStmt * postvisit( const BranchStmt * );
114 void previsit( const WhileDoStmt * );
115 const WhileDoStmt * postvisit( const WhileDoStmt * );
116 void previsit( const ForStmt * );
117 const ForStmt * postvisit( const ForStmt * );
118 const CaseClause * previsit( const CaseClause * );
119 void previsit( const IfStmt * );
120 const IfStmt * postvisit( const IfStmt * );
121 void previsit( const SwitchStmt * );
122 const SwitchStmt * postvisit( const SwitchStmt * );
123 void previsit( const ReturnStmt * );
124 void previsit( const TryStmt * );
125 void postvisit( const TryStmt * );
126 void previsit( const FinallyClause * );
127
128 const Stmt * mutateLoop( const Stmt * body, Entry& );
129
130 const LabelToStmt & target_table;
131 set<Label> fallthrough_labels;
132 vector<Entry> enclosing_control_structures;
133 Label break_label;
134 bool inFinally;
135
136 template<typename LoopNode>
137 void prehandleLoopStmt( const LoopNode * loopStmt );
138 template<typename LoopNode>
139 const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
140
141 list<ptr<Stmt>> fixBlock(
142 const list<ptr<Stmt>> & kids, bool caseClause );
143
144 template<typename UnaryPredicate>
145 auto findEnclosingControlStructure( UnaryPredicate pred ) {
146 return find_if( enclosing_control_structures.rbegin(),
147 enclosing_control_structures.rend(), pred );
148 }
149};
150
151NullStmt * labelledNullStmt(
152 const CodeLocation & cl, const Label & label ) {
153 return new NullStmt( cl, vector<Label>{ label } );
154}
155
156MultiLevelExitCore::MultiLevelExitCore( const LabelToStmt & lt ) :
157 target_table( lt ), break_label( CodeLocation(), "" ),
158 inFinally( false )
159{}
160
161void MultiLevelExitCore::previsit( const FunctionDecl * ) {
162 visit_children = false;
163}
164
165const CompoundStmt * MultiLevelExitCore::previsit(
166 const CompoundStmt * stmt ) {
167 visit_children = false;
168
169 // if the stmt is labelled then generate a label to check in postvisit if the label is used
170 bool isLabeled = ! stmt->labels.empty();
171 if ( isLabeled ) {
172 Label breakLabel = newLabel( "blockBreak", stmt );
173 enclosing_control_structures.emplace_back( stmt, breakLabel );
174 GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
175 }
176
177 auto mutStmt = mutate( stmt );
178 // A child statement may set the break label.
179 mutStmt->kids = fixBlock( stmt->kids, false );
180
181 if ( isLabeled ) {
182 assert( ! enclosing_control_structures.empty() );
183 Entry & entry = enclosing_control_structures.back();
184 if ( ! entry.useBreakExit().empty() ) {
185 break_label = entry.useBreakExit();
186 }
187 }
188 return mutStmt;
189}
190
191size_t getUnusedIndex(
192 const Stmt * stmt, const Label & originalTarget ) {
193 const size_t size = stmt->labels.size();
194
195 // If the label is empty, do not add unused attribute.
196 if ( originalTarget.empty() ) return size;
197
198 // Search for a label that matches the originalTarget.
199 for ( size_t i = 0 ; i < size ; ++i ) {
200 const Label & label = stmt->labels[i];
201 if ( label == originalTarget ) {
202 for ( const Attribute * attr : label.attributes ) {
203 if ( attr->name == "unused" ) return size;
204 }
205 return i;
206 }
207 }
208 assertf( false, "CFA internal error: could not find label '%s' on statement %s",
209 originalTarget.name.c_str(), toString( stmt ).c_str() );
210}
211
212const Stmt * addUnused(
213 const Stmt * stmt, const Label & originalTarget ) {
214 size_t i = getUnusedIndex( stmt, originalTarget );
215 if ( i == stmt->labels.size() ) {
216 return stmt;
217 }
218 Stmt * mutStmt = mutate( stmt );
219 mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
220 return mutStmt;
221}
222
223// This routine updates targets on enclosing control structures to indicate which
224// label is used by the BranchStmt that is passed
225const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
226 vector<Entry>::reverse_iterator targetEntry =
227 enclosing_control_structures.rend();
228
229 // Labels on different stmts require different approaches to access
230 switch ( stmt->kind ) {
231 case BranchStmt::Goto:
232 return stmt;
233 case BranchStmt::Continue:
234 case BranchStmt::Break: {
235 bool isContinue = stmt->kind == BranchStmt::Continue;
236 // Handle unlabeled break and continue.
237 if ( stmt->target.empty() ) {
238 if ( isContinue ) {
239 targetEntry = findEnclosingControlStructure( isContinueTarget );
240 } else {
241 if ( enclosing_control_structures.empty() ) {
242 SemanticError( stmt->location,
243 "'break' outside a loop, 'switch', or labelled block" );
244 }
245 targetEntry = findEnclosingControlStructure( isBreakTarget );
246 }
247 // Handle labeled break and continue.
248 } else {
249 // Lookup label in table to find attached control structure.
250 targetEntry = findEnclosingControlStructure(
251 [ targetStmt = target_table.at(stmt->target) ](auto entry){
252 return entry.stmt == targetStmt;
253 } );
254 }
255 // Ensure that selected target is valid.
256 if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && ! isContinueTarget( *targetEntry ) ) ) {
257 SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
258 " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
259 stmt->originalTarget ) );
260 }
261 break;
262 }
263 // handle fallthrough in case/switch stmts
264 case BranchStmt::FallThrough: {
265 targetEntry = findEnclosingControlStructure( isFallthroughTarget );
266 // Check that target is valid.
267 if ( targetEntry == enclosing_control_structures.rend() ) {
268 SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
269 }
270 if ( ! stmt->target.empty() ) {
271 // Labelled fallthrough: target must be a valid fallthough label.
272 if ( ! fallthrough_labels.count( stmt->target ) ) {
273 SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
274 stmt->originalTarget ) );
275 }
276 return new BranchStmt( stmt->location, BranchStmt::Goto, stmt->originalTarget );
277 }
278 break;
279 }
280 case BranchStmt::FallThroughDefault: {
281 targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
282
283 // Check if in switch or choose statement.
284 if ( targetEntry == enclosing_control_structures.rend() ) {
285 SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
286 }
287
288 // Check if switch or choose has default clause.
289 auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
290 bool foundDefault = false;
291 for ( auto caseStmt : switchStmt->cases ) {
292 if ( caseStmt->isDefault() ) {
293 foundDefault = true;
294 break;
295 }
296 }
297 if ( ! foundDefault ) {
298 SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
299 "control structure with a 'default' clause" );
300 }
301 break;
302 }
303 default:
304 assert( false );
305 }
306
307 // Branch error checks: get the appropriate label name, which is always replaced.
308 Label exitLabel( CodeLocation(), "" );
309 switch ( stmt->kind ) {
310 case BranchStmt::Break:
311 assert( ! targetEntry->useBreakExit().empty() );
312 exitLabel = targetEntry->useBreakExit();
313 break;
314 case BranchStmt::Continue:
315 assert( ! targetEntry->useContExit().empty() );
316 exitLabel = targetEntry->useContExit();
317 break;
318 case BranchStmt::FallThrough:
319 assert( ! targetEntry->useFallExit().empty() );
320 exitLabel = targetEntry->useFallExit();
321 break;
322 case BranchStmt::FallThroughDefault:
323 assert( ! targetEntry->useFallDefaultExit().empty() );
324 exitLabel = targetEntry->useFallDefaultExit();
325 // Check that fallthrough default comes before the default clause.
326 if ( ! targetEntry->isFallDefaultValid() ) {
327 SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
328 }
329 break;
330 default:
331 assert(0);
332 }
333
334 // Add unused attribute to silence warnings.
335 targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
336
337 // Replace with goto to make later passes more uniform.
338 return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
339}
340
341void MultiLevelExitCore::previsit( const WhileDoStmt * stmt ) {
342 return prehandleLoopStmt( stmt );
343}
344
345const WhileDoStmt * MultiLevelExitCore::postvisit( const WhileDoStmt * stmt ) {
346 return posthandleLoopStmt( stmt );
347}
348
349void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
350 return prehandleLoopStmt( stmt );
351}
352
353const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
354 return posthandleLoopStmt( stmt );
355}
356
357// Mimic what the built-in push_front would do anyways. It is O(n).
358void push_front(
359 vector<ptr<Stmt>> & vec, const Stmt * element ) {
360 vec.emplace_back( nullptr );
361 for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
362 vec[ i ] = move( vec[ i - 1 ] );
363 }
364 vec[ 0 ] = element;
365}
366
367const CaseClause * MultiLevelExitCore::previsit( const CaseClause * stmt ) {
368 visit_children = false;
369
370 // If default, mark seen.
371 if ( stmt->isDefault() ) {
372 assert( ! enclosing_control_structures.empty() );
373 enclosing_control_structures.back().seenDefault();
374 }
375
376 // The cond may not exist, but if it does update it now.
377 visitor->maybe_accept( stmt, &CaseClause::cond );
378
379 // Just save the mutated node for simplicity.
380 CaseClause * mutStmt = mutate( stmt );
381
382 Label fallLabel = newLabel( "fallThrough", stmt->location );
383 if ( ! mutStmt->stmts.empty() ) {
384 // These should already be in a block.
385 auto first = mutStmt->stmts.front().get_and_mutate();
386 auto block = strict_dynamic_cast<CompoundStmt *>( first );
387
388 // Ensure that the stack isn't corrupted by exceptions in fixBlock.
389 auto guard = makeFuncGuard(
390 [&](){ enclosing_control_structures.emplace_back( mutStmt, block, fallLabel ); },
391 [this](){ enclosing_control_structures.pop_back(); }
392 );
393
394 block->kids = fixBlock( block->kids, true );
395
396 // Add fallthrough label if necessary.
397 assert( ! enclosing_control_structures.empty() );
398 Entry & entry = enclosing_control_structures.back();
399 if ( entry.isFallUsed() ) {
400 mutStmt->stmts.push_back( labelledNullStmt( block->location, entry.useFallExit() ) );
401 }
402 }
403 assert( ! enclosing_control_structures.empty() );
404 Entry & entry = enclosing_control_structures.back();
405 assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
406 "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
407 toString( entry.stmt ).c_str() );
408 if ( mutStmt->isDefault() ) {
409 if ( entry.isFallDefaultUsed() ) {
410 // Add fallthrough default label if necessary.
411 push_front( mutStmt->stmts, labelledNullStmt( stmt->location, entry.useFallDefaultExit() ) );
412 }
413 }
414 return mutStmt;
415}
416
417void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
418 bool labeledBlock = ! stmt->labels.empty();
419 if ( labeledBlock ) {
420 Label breakLabel = newLabel( "blockBreak", stmt );
421 enclosing_control_structures.emplace_back( stmt, breakLabel );
422 GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
423 }
424}
425
426const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
427 bool labeledBlock = ! stmt->labels.empty();
428 if ( labeledBlock ) {
429 auto this_label = enclosing_control_structures.back().useBreakExit();
430 if ( ! this_label.empty() ) {
431 break_label = this_label;
432 }
433 }
434 return stmt;
435}
436
437static bool isDefaultCase( const ptr<CaseClause> & caseClause ) {
438 return caseClause->isDefault();
439}
440
441void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
442 Label label = newLabel( "switchBreak", stmt );
443 auto it = find_if( stmt->cases.rbegin(), stmt->cases.rend(), isDefaultCase );
444
445 const CaseClause * defaultCase = it != stmt->cases.rend() ? (*it) : nullptr;
446 Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase->location ) : Label( stmt->location, "" );
447 enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
448 GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
449
450 // Collect valid labels for fallthrough. It starts with all labels at this level, then remove as each is seen during
451 // traversal.
452 for ( const CaseClause * caseStmt : stmt->cases ) {
453 if ( caseStmt->stmts.empty() ) continue;
454 auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
455 for ( const Stmt * stmt : block->kids ) {
456 for ( const Label & l : stmt->labels ) {
457 fallthrough_labels.insert( l );
458 }
459 }
460 }
461}
462
463const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
464 assert( ! enclosing_control_structures.empty() );
465 Entry & entry = enclosing_control_structures.back();
466 assert( entry.stmt == stmt );
467
468 // Only run to generate the break label.
469 if ( entry.isBreakUsed() ) {
470 // To keep the switch statements uniform (all direct children of a SwitchStmt should be CastStmts), append the
471 // exit label and break to the last case, create a default case if no cases.
472 SwitchStmt * mutStmt = mutate( stmt );
473 if ( mutStmt->cases.empty() ) {
474 mutStmt->cases.push_back( new CaseClause( mutStmt->location, nullptr, {} ) );
475 }
476
477 auto caseStmt = mutStmt->cases.back().get();
478 auto mutCase = mutate( caseStmt );
479 mutStmt->cases.back() = mutCase;
480
481 Label label( mutCase->location, "breakLabel" );
482 auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
483 branch->labels.push_back( entry.useBreakExit() );
484 mutCase->stmts.push_back( branch );
485
486 return mutStmt;
487 }
488 return stmt;
489}
490
491void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
492 if ( inFinally ) {
493 SemanticError( stmt->location, "'return' may not appear in a finally clause" );
494 }
495}
496
497void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
498 bool isLabeled = ! stmt->labels.empty();
499 if ( isLabeled ) {
500 Label breakLabel = newLabel( "blockBreak", stmt );
501 enclosing_control_structures.emplace_back( stmt, breakLabel );
502 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
503 }
504}
505
506void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
507 bool isLabeled = ! stmt->labels.empty();
508 if ( isLabeled ) {
509 auto this_label = enclosing_control_structures.back().useBreakExit();
510 if ( ! this_label.empty() ) {
511 break_label = this_label;
512 }
513 }
514}
515
516void MultiLevelExitCore::previsit( const FinallyClause * ) {
517 GuardAction([this, old = move( enclosing_control_structures)](){ enclosing_control_structures = move(old); });
518 enclosing_control_structures = vector<Entry>();
519 GuardValue( inFinally ) = true;
520}
521
522const Stmt * MultiLevelExitCore::mutateLoop(
523 const Stmt * body, Entry & entry ) {
524 if ( entry.isBreakUsed() ) {
525 break_label = entry.useBreakExit();
526 }
527
528 // if continue is used insert a continue label into the back of the body of the loop
529 if ( entry.isContUsed() ) {
530 CompoundStmt * new_body = new CompoundStmt( body->location );
531 // {}
532 new_body->kids.push_back( body );
533 // {
534 // body
535 // }
536 new_body->kids.push_back(
537 labelledNullStmt( body->location, entry.useContExit() ) );
538 // {
539 // body
540 // ContinueLabel: {}
541 // }
542 return new_body;
543 }
544
545 return body;
546}
547
548template<typename LoopNode>
549void MultiLevelExitCore::prehandleLoopStmt( const LoopNode * loopStmt ) {
550 // Remember is loop before going onto mutate the body.
551 // The labels will be folded in if they are used.
552 Label breakLabel = newLabel( "loopBreak", loopStmt );
553 Label contLabel = newLabel( "loopContinue", loopStmt );
554 enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
555 // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
556 // children will tag labels as being used during their traversal which occurs before postvisit
557
558 // GuardAction calls the lambda after the node is done being visited
559 GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
560}
561
562template<typename LoopNode>
563const LoopNode * MultiLevelExitCore::posthandleLoopStmt( const LoopNode * loopStmt ) {
564 assert( ! enclosing_control_structures.empty() );
565 Entry & entry = enclosing_control_structures.back();
566 assert( entry.stmt == loopStmt );
567
568 // Now check if the labels are used and add them if so.
569 return mutate_field( loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
570 // this call to mutate_field compares loopStmt->body and the result of mutateLoop
571 // if they are the same the node isn't mutated, if they differ then the new mutated node is returned
572 // the stmts will only differ if a label is used
573}
574
575list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
576 const list<ptr<Stmt>> & kids, bool is_case_clause ) {
577 // Unfortunately cannot use automatic error collection.
578 SemanticErrorException errors;
579
580 list<ptr<Stmt>> ret;
581
582 // Manually visit each child.
583 for ( const ptr<Stmt> & kid : kids ) {
584 if ( is_case_clause ) {
585 // Once a label is seen, it's no longer a valid for fallthrough.
586 for ( const Label & l : kid->labels ) {
587 fallthrough_labels.erase( l );
588 }
589 }
590
591 ptr<Stmt> else_stmt = nullptr;
592 Stmt * loop_kid = nullptr;
593 // check if loop node and if so add else clause if it exists
594 const WhileDoStmt * whilePtr = dynamic_cast<const WhileDoStmt *>(kid.get());
595 if ( whilePtr && whilePtr->else_) {
596 else_stmt = whilePtr->else_;
597 WhileDoStmt * mutate_ptr = mutate(whilePtr);
598 mutate_ptr->else_ = nullptr;
599 loop_kid = mutate_ptr;
600 }
601 const ForStmt * forPtr = dynamic_cast<const ForStmt *>(kid.get());
602 if ( forPtr && forPtr->else_) {
603 else_stmt = forPtr->else_;
604 ForStmt * mutate_ptr = mutate(forPtr);
605 mutate_ptr->else_ = nullptr;
606 loop_kid = mutate_ptr;
607 }
608
609 try {
610 if (else_stmt) ret.push_back( loop_kid->accept( *visitor ) );
611 else ret.push_back( kid->accept( *visitor ) );
612 } catch ( SemanticErrorException & e ) {
613 errors.append( e );
614 }
615
616 if (else_stmt) ret.push_back(else_stmt);
617
618 if ( ! break_label.empty() ) {
619 ret.push_back( labelledNullStmt( ret.back()->location, break_label ) );
620 break_label = Label( CodeLocation(), "" );
621 }
622 }
623
624 if ( ! errors.isEmpty() ) {
625 throw errors;
626 }
627 return ret;
628}
629
630const CompoundStmt * multiLevelExitUpdate(
631 const CompoundStmt * stmt,
632 const LabelToStmt & labelTable ) {
633 // Must start in the body, so FunctionDecls can be a stopping point.
634 Pass<MultiLevelExitCore> visitor( labelTable );
635 const CompoundStmt * ret = stmt->accept( visitor );
636 // There are some unset code locations slipping in, possibly by Labels.
637 const Node * node = localFillCodeLocations( ret->location, ret );
638 return strict_dynamic_cast<const CompoundStmt *>( node );
639}
640} // namespace ControlStruct
641
642// Local Variables: //
643// tab-width: 4 //
644// mode: c++ //
645// compile-command: "make install" //
646// End: //
Note: See TracBrowser for help on using the repository browser.