Changes in / [7b2c8c3c:34c32f0]

Location:

src

Files:

• AST/Pass.impl.hpp (modified) (2 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (8 diffs)

src/AST/Pass.impl.hpp

@@ -1050 +1050 @@
         VISIT_START( node );
 
+<<<<<<< HEAD
+        VISIT(
+                maybe_accept( node, &MutexStmt::mutexObjs );
+                {
+                        // mutex statements introduce a level of scope (for the initialization)
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &MutexStmt::stmt );
+                        
+                }
+        )
+=======
         if ( __visit_children() ) {
                 // mutex statements introduce a level of scope (for the initialization)
@@ -1056 +1067 @@
                 maybe_accept( node, &MutexStmt::mutexObjs );
         }
+>>>>>>> e21f2536b7495654ded040259b42b7e2325b8360
 
         VISIT_END( Stmt, node );

src/ControlStruct/MultiLevelExit.cpp

@@ -71 +71 @@
         bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
 
+        // These routines set a target as being "used" by a BranchStmt
         Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
         Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
@@ -76 +77 @@
         Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
 
+        // These routines check if a specific label for a statement is used by a BranchStmt
         bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
         bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
@@ -164 +166 @@
         const CompoundStmt * stmt ) {
         visit_children = false;
+
+        // if the stmt is labelled then generate a label to check in postvisit if the label is used
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
@@ -217 +221 @@
 }
 
+// This routine updates targets on enclosing control structures to indicate which
+//     label is used by the BranchStmt that is passed
 const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
         vector<Entry>::reverse_iterator targetEntry =
                 enclosing_control_structures.rend();
+
+        // Labels on different stmts require different approaches to access
         switch ( stmt->kind ) {
           case BranchStmt::Goto:
@@ -253 +261 @@
                   break;
           }
+          // handle fallthrough in case/switch stmts
           case BranchStmt::FallThrough: {
                   targetEntry = findEnclosingControlStructure( isFallthroughTarget );
@@ -530 +539 @@
         }
 
+        // if continue is used insert a continue label into the back of the body of the loop
         if ( entry.isContUsed() ) {
                 CompoundStmt * new_body = new CompoundStmt( body->location );
+                // {}
                 new_body->kids.push_back( body );
+                // {
+                //  body
+                // }
                 new_body->kids.push_back(
                         labelledNullStmt( body->location, entry.useContExit() ) );
+                // {
+                //  body
+                //  ContinueLabel: {}
+                // }
                 return new_body;
         }
@@ -548 +566 @@
         Label contLabel = newLabel( "loopContinue", loopStmt );
         enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
+        // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
+        // children will tag labels as being used during their traversal which occurs before postvisit
+
+        // GuardAction calls the lambda after the node is done being visited
         GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
 }
@@ -560 +582 @@
         return mutate_field(
                 loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
+        // this call to mutate_field compares loopStmt->body and the result of mutateLoop
+        //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
+        //              the stmts will only differ if a label is used
 }