Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ControlStruct/MultiLevelExit.cpp

    r3e5db5b4 r66daee4  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 13:48:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:56:00 2021
    13 // 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
    1414//
    1515
    … …  
    1818#include "AST/Pass.hpp"
    1919#include "AST/Stmt.hpp"
    20 #include "ControlStruct/LabelGenerator.h"
     20#include "LabelGeneratorNew.hpp"
    2121
    2222#include <set>
     23using namespace std;
     24using namespace ast;
    2325
    2426namespace ControlStruct {
    25 
    26 namespace {
    27 
    2827class Entry {
    29 public:
    30         const ast::Stmt * stmt;
    31 private:
     28  public:
     29        const Stmt * stmt;
     30  private:
    3231        // Organized like a manual ADT. Avoids creating a bunch of dead data.
    3332        struct Target {
    34                 ast::Label label;
     33                Label label;
    3534                bool used = false;
    36                 Target( const ast::Label & label ) : label( label ) {}
     35                Target( const Label & label ) : label( label ) {}
    3736                Target() : label( CodeLocation() ) {}
    3837        };
    … …  
    4140
    4241        enum Kind {
    43                 ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
     42                ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
    4443        } kind;
    4544
    4645        bool fallDefaultValid = true;
    4746
    48         static ast::Label & useTarget( Target & target ) {
     47        static Label & useTarget( Target & target ) {
    4948                target.used = true;
    5049                return target.label;
    5150        }
    5251
    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; }
    73 
    74         // 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); }
    79 
    80         // 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; }
     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; }
     72
     73        Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
     74        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
     75        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
     76        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
     77
     78        bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
     79        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
     80        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
     81        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
    8582        void seenDefault() { fallDefaultValid = false; }
    8683        bool isFallDefaultValid() const { return fallDefaultValid; }
    8784};
    8885
    89 // Helper predicates used in std::find_if calls (it doesn't take methods):
     86// Helper predicates used in find_if calls (it doesn't take methods):
    9087bool isBreakTarget( const Entry & entry ) {
    9188        return entry.isBreakTarget();
    … …  
    105102
    106103struct MultiLevelExitCore final :
    107                 public ast::WithVisitorRef<MultiLevelExitCore>,
    108                 public ast::WithShortCircuiting, public ast::WithGuards {
     104        public WithVisitorRef<MultiLevelExitCore>,
     105        public WithShortCircuiting, public WithGuards {
    109106        MultiLevelExitCore( const LabelToStmt & lt );
    110107
    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& );
     108        void previsit( const FunctionDecl * );
     109
     110        const CompoundStmt * previsit( const CompoundStmt * );
     111        const BranchStmt * postvisit( const BranchStmt * );
     112        void previsit( const WhileStmt * );
     113        const WhileStmt * postvisit( const WhileStmt * );
     114        void previsit( const ForStmt * );
     115        const ForStmt * postvisit( const ForStmt * );
     116        const CaseStmt * previsit( const CaseStmt * );
     117        void previsit( const IfStmt * );
     118        const IfStmt * postvisit( const IfStmt * );
     119        void previsit( const SwitchStmt * );
     120        const SwitchStmt * postvisit( const SwitchStmt * );
     121        void previsit( const ReturnStmt * );
     122        void previsit( const TryStmt * );
     123        void postvisit( const TryStmt * );
     124        void previsit( const FinallyStmt * );
     125
     126        const Stmt * mutateLoop( const Stmt * body, Entry& );
    130127
    131128        const LabelToStmt & target_table;
    132         std::set<ast::Label> fallthrough_labels;
    133         std::vector<Entry> enclosing_control_structures;
    134         ast::Label break_label;
     129        set<Label> fallthrough_labels;
     130        vector<Entry> enclosing_control_structures;
     131        Label break_label;
    135132        bool inFinally;
    136133
    … …  
    140137        const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
    141138
    142         std::list<ast::ptr<ast::Stmt>> fixBlock(
    143                 const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
     139        list<ptr<Stmt>> fixBlock(
     140                const list<ptr<Stmt>> & kids, bool caseClause );
    144141
    145142        template<typename UnaryPredicate>
    146143        auto findEnclosingControlStructure( UnaryPredicate pred ) {
    147                 return std::find_if( enclosing_control_structures.rbegin(),
    148                         enclosing_control_structures.rend(), pred );
     144                return find_if( enclosing_control_structures.rbegin(),
     145                                                enclosing_control_structures.rend(), pred );
    149146        }
    150147};
    151148
    152 ast::NullStmt * labelledNullStmt(
    153                 const CodeLocation & cl, const ast::Label & label ) {
    154         return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
     149NullStmt * labelledNullStmt(
     150        const CodeLocation & cl, const Label & label ) {
     151        return new NullStmt( cl, vector<Label>{ label } );
    155152}
    156153
    … …  
    160157{}
    161158
    162 void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
     159void MultiLevelExitCore::previsit( const FunctionDecl * ) {
    163160        visit_children = false;
    164161}
    165162
    166 const ast::CompoundStmt * MultiLevelExitCore::previsit(
    167                 const ast::CompoundStmt * stmt ) {
     163const CompoundStmt * MultiLevelExitCore::previsit(
     164        const CompoundStmt * stmt ) {
    168165        visit_children = false;
    169 
    170         // if the stmt is labelled then generate a label to check in postvisit if the label is used
    171166        bool isLabeled = !stmt->labels.empty();
    172167        if ( isLabeled ) {
    173                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     168                Label breakLabel = newLabel( "blockBreak", stmt );
    174169                enclosing_control_structures.emplace_back( stmt, breakLabel );
    175170                GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    176171        }
    177172
    178         auto mutStmt = ast::mutate( stmt );
     173        auto mutStmt = mutate( stmt );
    179174        // A child statement may set the break label.
    180         mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
     175        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
    181176
    182177        if ( isLabeled ) {
    … …  
    191186
    192187size_t getUnusedIndex(
    193                 const ast::Stmt * stmt, const ast::Label & originalTarget ) {
     188        const Stmt * stmt, const Label & originalTarget ) {
    194189        const size_t size = stmt->labels.size();
    195190
    196         // If the label is empty, we can skip adding the unused attribute:
    197         if ( originalTarget.empty() ) return size;
     191        // If the label is empty, do not add unused attribute.
     192  if ( originalTarget.empty() ) return size;
    198193
    199194        // Search for a label that matches the originalTarget.
    200195        for ( size_t i = 0 ; i < size ; ++i ) {
    201                 const ast::Label & label = stmt->labels[i];
     196                const Label & label = stmt->labels[i];
    202197                if ( label == originalTarget ) {
    203                         for ( const ast::Attribute * attr : label.attributes ) {
     198                        for ( const Attribute * attr : label.attributes ) {
    204199                                if ( attr->name == "unused" ) return size;
    205200                        }
    … …  
    208203        }
    209204        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 ) {
     205                         originalTarget.name.c_str(), toString( stmt ).c_str() );
     206}
     207
     208const Stmt * addUnused(
     209        const Stmt * stmt, const Label & originalTarget ) {
    215210        size_t i = getUnusedIndex( stmt, originalTarget );
    216211        if ( i == stmt->labels.size() ) {
    217212                return stmt;
    218213        }
    219         ast::Stmt * mutStmt = ast::mutate( stmt );
    220         mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
     214        Stmt * mutStmt = mutate( stmt );
     215        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
    221216        return mutStmt;
    222217}
    223218
    224 // This routine updates targets on enclosing control structures to indicate which
    225 //     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 =
     219const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
     220        vector<Entry>::reverse_iterator targetEntry =
    228221                enclosing_control_structures.rend();
    229 
    230         // Labels on different stmts require different approaches to access
    231222        switch ( stmt->kind ) {
    232         case ast::BranchStmt::Goto:
     223          case BranchStmt::Goto:
    233224                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:
     225          case BranchStmt::Continue:
     226          case BranchStmt::Break: {
     227                  bool isContinue = stmt->kind == BranchStmt::Continue;
     228                  // Handle unlabeled break and continue.
     229                  if ( stmt->target.empty() ) {
     230                          if ( isContinue ) {
     231                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
     232                          } else {
     233                                  if ( enclosing_control_structures.empty() ) {
     234                                          SemanticError( stmt->location,
     235                                                                         "'break' outside a loop, 'switch', or labelled block" );
     236                                  }
     237                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
     238                          }
     239                          // Handle labeled break and continue.
     240                  } else {
     241                          // Lookup label in table to find attached control structure.
     242                          targetEntry = findEnclosingControlStructure(
     243                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
     244                                          return entry.stmt == targetStmt;
     245                                  } );
     246                  }
     247                  // Ensure that selected target is valid.
     248                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
     249                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
     250                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
     251                                                        stmt->originalTarget ) );
     252                  }
     253                  break;
     254          }
     255          case BranchStmt::FallThrough: {
     256                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
     257                  // Check that target is valid.
     258                  if ( targetEntry == enclosing_control_structures.rend() ) {
     259                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     260                  }
     261                  if ( !stmt->target.empty() ) {
     262                          // Labelled fallthrough: target must be a valid fallthough label.
     263                          if ( !fallthrough_labels.count( stmt->target ) ) {
     264                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
     265                                                                                                                   stmt->originalTarget ) );
     266                          }
     267                          return new BranchStmt(
     268                                  stmt->location, BranchStmt::Goto, stmt->originalTarget );
     269                  }
     270                  break;
     271          }
     272          case BranchStmt::FallThroughDefault: {
     273                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
     274
     275                  // Check if in switch or choose statement.
     276                  if ( targetEntry == enclosing_control_structures.rend() ) {
     277                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     278                  }
     279
     280                  // Check if switch or choose has default clause.
     281                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
     282                  bool foundDefault = false;
     283                  for ( auto subStmt : switchStmt->stmts ) {
     284                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
     285                          if ( caseStmt->isDefault() ) {
     286                                  foundDefault = true;
     287                                  break;
     288                          }
     289                  }
     290                  if ( ! foundDefault ) {
     291                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
     292                                                         "control structure with a 'default' clause" );
     293                  }
     294                  break;
     295          }
     296          default:
    309297                assert( false );
    310298        }
    311299
    312300        // Branch error checks: get the appropriate label name:
    313         // (This label will always be replaced.)
    314         ast::Label exitLabel( CodeLocation(), "" );
     301        // (This label is always replaced.)
     302        Label exitLabel( CodeLocation(), "" );
    315303        switch ( stmt->kind ) {
    316         case ast::BranchStmt::Break:
     304          case BranchStmt::Break:
    317305                assert( !targetEntry->useBreakExit().empty() );
    318306                exitLabel = targetEntry->useBreakExit();
    319307                break;
    320         case ast::BranchStmt::Continue:
     308          case BranchStmt::Continue:
    321309                assert( !targetEntry->useContExit().empty() );
    322310                exitLabel = targetEntry->useContExit();
    323311                break;
    324         case ast::BranchStmt::FallThrough:
     312          case BranchStmt::FallThrough:
    325313                assert( !targetEntry->useFallExit().empty() );
    326314                exitLabel = targetEntry->useFallExit();
    327315                break;
    328         case ast::BranchStmt::FallThroughDefault:
     316          case BranchStmt::FallThroughDefault:
    329317                assert( !targetEntry->useFallDefaultExit().empty() );
    330318                exitLabel = targetEntry->useFallDefaultExit();
    331319                // Check that fallthrough default comes before the default clause.
    332320                if ( !targetEntry->isFallDefaultValid() ) {
    333                         SemanticError( stmt->location,
    334                                 "'fallthrough default' must precede the 'default' clause" );
     321                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
    335322                }
    336323                break;
    337         default:
     324          default:
    338325                assert(0);
    339326        }
    … …  
    342329        targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
    343330
    344         // Replace this with a goto 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 ) {
     331        // Replace with goto to make later passes more uniform.
     332        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
     333}
     334
     335void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
    349336        return prehandleLoopStmt( stmt );
    350337}
    351338
    352 const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
     339const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
    353340        return posthandleLoopStmt( stmt );
    354341}
    355342
    356 void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
     343void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
    357344        return prehandleLoopStmt( stmt );
    358345}
    359346
    360 const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
     347const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
    361348        return posthandleLoopStmt( stmt );
    362349}
    … …  
    364351// Mimic what the built-in push_front would do anyways. It is O(n).
    365352void push_front(
    366                 std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
     353        vector<ptr<Stmt>> & vec, const Stmt * element ) {
    367354        vec.emplace_back( nullptr );
    368355        for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
    369                 vec[ i ] = std::move( vec[ i - 1 ] );
     356                vec[ i ] = move( vec[ i - 1 ] );
    370357        }
    371358        vec[ 0 ] = element;
    372359}
    373360
    374 const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
     361const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
    375362        visit_children = false;
    376363
    377         // If it is the default, mark the default as seen.
     364        // If default, mark seen.
    378365        if ( stmt->isDefault() ) {
    379366                assert( !enclosing_control_structures.empty() );
    … …  
    382369
    383370        // The cond may not exist, but if it does update it now.
    384         visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
     371        visitor->maybe_accept( stmt, &CaseStmt::cond );
    385372
    386373        // 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() ) {
     374        CaseStmt * mutStmt = mutate( stmt );
     375
     376        Label fallLabel = newLabel( "fallThrough", stmt );
     377        if ( ! mutStmt->stmts.empty() ) {
    391378                // Ensure that the stack isn't corrupted by exceptions in fixBlock.
    392379                auto guard = makeFuncGuard(
    393380                        [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
    394381                        [this](){ enclosing_control_structures.pop_back(); }
    395                 );
     382                        );
    396383
    397384                // These should already be in a block.
    398                 auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
     385                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
    399386                block->kids = fixBlock( block->kids, true );
    400387
    401388                // Add fallthrough label if necessary.
    402                 assert( !enclosing_control_structures.empty() );
     389                assert( ! enclosing_control_structures.empty() );
    403390                Entry & entry = enclosing_control_structures.back();
    404391                if ( entry.isFallUsed() ) {
    … …  
    407394                }
    408395        }
    409         assert( !enclosing_control_structures.empty() );
     396        assert( ! enclosing_control_structures.empty() );
    410397        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() );
     398        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
     399                         "Control structure enclosing a case clause must be a switch, but is: %s",
     400                         toString( entry.stmt ).c_str() );
    414401        if ( mutStmt->isDefault() ) {
    415402                if ( entry.isFallDefaultUsed() ) {
    416403                        // Add fallthrough default label if necessary.
    417404                        push_front( mutStmt->stmts, labelledNullStmt(
    418                                 stmt->location, entry.useFallDefaultExit()
    419                         ) );
     405                                                        stmt->location, entry.useFallDefaultExit()
     406                                                        ) );
    420407                }
    421408        }
    … …  
    423410}
    424411
    425 void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
     412void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
    426413        bool labeledBlock = !stmt->labels.empty();
    427414        if ( labeledBlock ) {
    428                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     415                Label breakLabel = newLabel( "blockBreak", stmt );
    429416                enclosing_control_structures.emplace_back( stmt, breakLabel );
    430417                GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
    … …  
    432419}
    433420
    434 const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
     421const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
    435422        bool labeledBlock = !stmt->labels.empty();
    436423        if ( labeledBlock ) {
    … …  
    443430}
    444431
    445 bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
    446         const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
     432bool isDefaultCase( const ptr<Stmt> & stmt ) {
     433        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
    447434        return caseStmt->isDefault();
    448435}
    449436
    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 = defaultCase
    457                 ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
    458                 : ast::Label( stmt->location, "" );
     437void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
     438        Label label = newLabel( "switchBreak", stmt );
     439        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
     440
     441        const CaseStmt * defaultCase = it != stmt->stmts.rend()
     442                ? (it)->strict_as<CaseStmt>() : nullptr;
     443        Label defaultLabel = defaultCase
     444                ? newLabel( "fallThroughDefault", defaultCase )
     445                : Label( stmt->location, "" );
    459446        enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
    460447        GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    461448
    462449        // Collect valid labels for fallthrough. It starts with all labels at
    463         // this level, then removed as we see them in traversal.
    464         for ( const ast::Stmt * stmt : stmt->stmts ) {
    465                 auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
     450        // this level, then remove as each is seen during traversal.
     451        for ( const Stmt * stmt : stmt->stmts ) {
     452                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
    466453                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 ) {
     454                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
     455                for ( const Stmt * stmt : block->kids ) {
     456                        for ( const Label & l : stmt->labels ) {
    470457                                fallthrough_labels.insert( l );
    471458                        }
    … …  
    474461}
    475462
    476 const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
     463const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
    477464        assert( !enclosing_control_structures.empty() );
    478465        Entry & entry = enclosing_control_structures.back();
    479466        assert( entry.stmt == stmt );
    480467
    481         // Only run if we need to generate the break label.
     468        // Only run to generate the break label.
    482469        if ( entry.isBreakUsed() ) {
    483470                // To keep the switch statements uniform (all direct children of a
    484471                // SwitchStmt should be CastStmts), append the exit label and break
    485472                // to the last case, create a default case is there are no cases.
    486                 ast::SwitchStmt * mutStmt = ast::mutate( stmt );
     473                SwitchStmt * mutStmt = mutate( stmt );
    487474                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 );
     475                        mutStmt->stmts.push_back( new CaseStmt(
     476                                                                                  mutStmt->location, nullptr, {} ));
     477                }
     478
     479                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
     480                auto mutCase = mutate( caseStmt );
    494481                mutStmt->stmts.back() = mutCase;
    495482
    496                 ast::Label label( mutCase->location, "breakLabel" );
    497                 auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
     483                Label label( mutCase->location, "breakLabel" );
     484                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
    498485                branch->labels.push_back( entry.useBreakExit() );
    499486                mutCase->stmts.push_back( branch );
    … …  
    504491}
    505492
    506 void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
     493void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
    507494        if ( inFinally ) {
    508495                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
    … …  
    510497}
    511498
    512 void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
     499void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
    513500        bool isLabeled = !stmt->labels.empty();
    514501        if ( isLabeled ) {
    515                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     502                Label breakLabel = newLabel( "blockBreak", stmt );
    516503                enclosing_control_structures.emplace_back( stmt, breakLabel );
    517504                GuardAction([this](){ enclosing_control_structures.pop_back(); } );
    … …  
    519506}
    520507
    521 void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
     508void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
    522509        bool isLabeled = !stmt->labels.empty();
    523510        if ( isLabeled ) {
    … …  
    529516}
    530517
    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>();
     518void MultiLevelExitCore::previsit( const FinallyStmt * ) {
     519        GuardAction([this, old = move(enclosing_control_structures)](){
     520                                        enclosing_control_structures = move(old);
     521                                });
     522        enclosing_control_structures = vector<Entry>();
    536523        GuardValue( inFinally ) = true;
    537524}
    538525
    539 const ast::Stmt * MultiLevelExitCore::mutateLoop(
    540                 const ast::Stmt * body, Entry & entry ) {
     526const Stmt * MultiLevelExitCore::mutateLoop(
     527        const Stmt * body, Entry & entry ) {
    541528        if ( entry.isBreakUsed() ) {
    542529                break_label = entry.useBreakExit();
    543530        }
    544531
    545         // if continue is used insert a continue label into the back of the body of the loop
    546532        if ( entry.isContUsed() ) {
    547                 ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
    548                 // {}
     533                CompoundStmt * new_body = new CompoundStmt( body->location );
    549534                new_body->kids.push_back( body );
    550                 // {
    551                 //  body
    552                 // }
    553535                new_body->kids.push_back(
    554536                        labelledNullStmt( body->location, entry.useContExit() ) );
    555                 // {
    556                 //  body
    557                 //  ContinueLabel: {}
    558                 // }
    559537                return new_body;
    560538        }
    … …  
    567545        // Remember is loop before going onto mutate the body.
    568546        // 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 );
     547        Label breakLabel = newLabel( "loopBreak", loopStmt );
     548        Label contLabel = newLabel( "loopContinue", loopStmt );
    571549        enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
    572         // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
    573         // children will tag labels as being used during their traversal which occurs before postvisit
    574 
    575         // GuardAction calls the lambda after the node is done being visited
    576550        GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
    577551}
    … …  
    583557        assert( entry.stmt == loopStmt );
    584558
    585         // Now we check if the labels are used and add them if so.
    586         return ast::mutate_field(
     559        // Now check if the labels are used and add them if so.
     560        return mutate_field(
    587561                loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
    588         // this call to mutate_field compares loopStmt->body and the result of mutateLoop
    589         //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
    590         //              the stmts will only differ if a label is used
    591 }
    592 
    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.
     562}
     563
     564list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
     565        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
     566        // Unfortunately cannot use automatic error collection.
    596567        SemanticErrorException errors;
    597568
    598         std::list<ast::ptr<ast::Stmt>> ret;
     569        list<ptr<Stmt>> ret;
    599570
    600571        // Manually visit each child.
    601         for ( const ast::ptr<ast::Stmt> & kid : kids ) {
     572        for ( const ptr<Stmt> & kid : kids ) {
    602573                if ( is_case_clause ) {
    603574                        // Once a label is seen, it's no longer a valid for fallthrough.
    604                         for ( const ast::Label & l : kid->labels ) {
     575                        for ( const Label & l : kid->labels ) {
    605576                                fallthrough_labels.erase( l );
    606577                        }
    … …  
    616587                        ret.push_back(
    617588                                labelledNullStmt( ret.back()->location, break_label ) );
    618                         break_label = ast::Label( CodeLocation(), "" );
     589                        break_label = Label( CodeLocation(), "" );
    619590                }
    620591        }
    … …  
    626597}
    627598
    628 } // namespace
    629 
    630 const ast::CompoundStmt * multiLevelExitUpdate(
    631         const ast::CompoundStmt * stmt,
    632                 const LabelToStmt & labelTable ) {
     599const CompoundStmt * multiLevelExitUpdate(
     600        const CompoundStmt * stmt,
     601        const LabelToStmt & labelTable ) {
    633602        // 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 );
     603        Pass<MultiLevelExitCore> visitor( labelTable );
     604        const CompoundStmt * ret = stmt->accept( visitor );
    636605        return ret;
    637606}
    638 
    639607} // namespace ControlStruct
    640608
Note: See TracChangeset for help on using the changeset viewer.