Changes in src/ControlStruct/MLEMutator.h [d180746:720a007]

File:

• src/ControlStruct/MLEMutator.h (modified) (5 diffs)

src/ControlStruct/MLEMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:19:59 2017
-// Update Count     : 35
+// Last Modified On : Thu Mar  8 16:42:32 2018
+// Update Count     : 41
 //
 
@@ -19 +19 @@
 #include <map>                     // for map
 #include <string>                  // for string
+#include <set>                     // for unordered_set
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "SynTree/Label.h"         // for Label
@@ -26 +28 @@
 
 namespace ControlStruct {
-class LabelGenerator;
+        class LabelGenerator;
 
-        class MLEMutator : public Mutator {
+        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
+          public:
                 class Entry;
-
-                typedef Mutator Parent;
-          public:
                 MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
                 ~MLEMutator();
 
-                virtual CompoundStmt *mutate( CompoundStmt *cmpndStmt ) override;
-                virtual Statement *mutate( WhileStmt *whileStmt ) override;
-                virtual Statement *mutate( ForStmt *forStmt ) override;
-                virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override;
-                virtual Statement *mutate( CaseStmt *caseStmt ) override;
-                virtual Statement *mutate( IfStmt *ifStmt ) override;
-                virtual Statement *mutate( SwitchStmt *switchStmt ) override;
+                void premutate( CompoundStmt *cmpndStmt );
+                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
+                void premutate( WhileStmt *whileStmt );
+                Statement * postmutate( WhileStmt *whileStmt );
+                void premutate( ForStmt *forStmt );
+                Statement * postmutate( ForStmt *forStmt );
+                void premutate( CaseStmt *caseStmt );
+                void premutate( IfStmt *ifStmt );
+                Statement * postmutate( IfStmt *ifStmt );
+                void premutate( SwitchStmt *switchStmt );
+                Statement * postmutate( SwitchStmt *switchStmt );
 
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
@@ -48 +52 @@
                 Label &get_breakLabel() { return breakLabel; }
                 void set_breakLabel( Label newValue ) { breakLabel = newValue; }
-          private:
+
                 class Entry {
                   public:
-                        explicit Entry( Statement *_loop, Label _breakExit, Label _contExit = Label("") ) :
-                                loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {}
+                        // specialized constructors for each combination of statement with labelled break/continue/fallthrough that is valid to cleanup the use cases
+                        explicit Entry( ForStmt *stmt, Label breakExit, Label contExit ) :
+                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
 
-                        bool operator==( const Statement *stmt ) { return ( loop == stmt ); }
-                        bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }
+                        explicit Entry( WhileStmt *stmt, Label breakExit, Label contExit ) :
+                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
 
-                        bool operator==( const Entry &other ) { return ( loop == other.get_controlStructure() ); }
+                        explicit Entry( CompoundStmt *stmt, Label breakExit ) :
+                                stmt( stmt ), breakExit( breakExit ) {}
 
-                        Statement *get_controlStructure() const { return loop; }
+                        explicit Entry( IfStmt *stmt, Label breakExit ) :
+                                stmt( stmt ), breakExit( breakExit ) {}
+
+                        explicit Entry( CaseStmt *stmt, Label fallExit ) :
+                                stmt( stmt ), fallExit( fallExit ) {}
+
+                        explicit Entry( SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
+                                stmt( stmt ), breakExit( breakExit ), fallDefaultExit( fallDefaultExit ) {}
+
+                        bool operator==( const Statement *other ) { return stmt == other; }
+                        bool operator!=( const Statement *other ) { return stmt != other; }
+
+                        bool operator==( const Entry &other ) { return stmt == other.get_controlStructure(); }
+
+                        Statement *get_controlStructure() const { return stmt; }
 
                         Label useContExit() { contUsed = true; return contExit; }
                         Label useBreakExit() { breakUsed = true; return breakExit; }
+                        Label useFallExit() { fallUsed = true; return fallExit; }
+                        Label useFallDefaultExit() { fallDefaultUsed = true; return fallDefaultExit; }
 
                         bool isContUsed() const { return contUsed; }
                         bool isBreakUsed() const { return breakUsed; }
+                        bool isFallUsed() const { return fallUsed; }
+                        bool isFallDefaultUsed() const { return fallDefaultUsed; }
+                        void seenDefault() { fallDefaultValid = false; }
+                        bool isFallDefaultValid() const { return fallDefaultValid; }
                   private:
-                        Statement *loop;
-                        Label breakExit, contExit;
-                        bool breakUsed, contUsed;
+                        Statement *stmt;
+                        Label breakExit, contExit, fallExit, fallDefaultExit;
+                        bool breakUsed = false, contUsed = false, fallUsed = false, fallDefaultUsed = false;
+                        bool fallDefaultValid = true;
                 };
 
+          private:
                 std::map< Label, Statement * > *targetTable;
+                std::set< Label > fallthroughLabels;
                 std::list< Entry > enclosingControlStructures;
                 Label breakLabel;
@@ -78 +107 @@
 
                 template< typename LoopClass >
-                Statement *handleLoopStmt( LoopClass *loopStmt );
+                void prehandleLoopStmt( LoopClass * loopStmt );
 
-                template< typename IfClass >
-                Statement *handleIfStmt( IfClass *switchStmt );
+                template< typename LoopClass >
+                Statement * posthandleLoopStmt( LoopClass * loopStmt );
 
-                template< typename SwitchClass >
-                Statement *handleSwitchStmt( SwitchClass *switchStmt );
-
-                void fixBlock( std::list< Statement * > &kids );
+                void fixBlock( std::list< Statement * > &kids, bool caseClause = false );
         };
 } // namespace ControlStruct