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