Changes in src/ResolvExpr/Resolver.cc [3b0bc16:7583c02]

File:

• src/ResolvExpr/Resolver.cc (modified) (9 diffs)

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 16:27:14 2022
-// Update Count     : 245
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 242
 //
 
@@ -80 +80 @@
                 void previsit( AsmStmt * asmStmt );
                 void previsit( IfStmt * ifStmt );
-                void previsit( WhileDoStmt * whileDoStmt );
+                void previsit( WhileStmt * whileStmt );
                 void previsit( ForStmt * forStmt );
                 void previsit( SwitchStmt * switchStmt );
@@ -502 +502 @@
         }
 
-        void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
-                findIntegralExpression( whileDoStmt->condition, indexer );
+        void Resolver_old::previsit( WhileStmt * whileStmt ) {
+                findIntegralExpression( whileStmt->condition, indexer );
         }
 
@@ -572 +572 @@
 
         void Resolver_old::previsit( CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have then)
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
                 // holds, check it. This allows a check for when to decode the mangling.
                 if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
-                        assert( ifStmt->then );
+                        assert( ifStmt->thenPart );
                 }
                 // Encode the catchStmt so the condition can see the declaration.
@@ -588 +588 @@
                 // Decode the catchStmt so everything is stored properly.
                 IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
-                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
                         assert( ifStmt->condition );
-                        assert( ifStmt->else_ );
+                        assert( ifStmt->elsePart );
                         catchStmt->cond = ifStmt->condition;
-                        catchStmt->body = ifStmt->else_;
+                        catchStmt->body = ifStmt->elsePart;
                         ifStmt->condition = nullptr;
-                        ifStmt->else_ = nullptr;
+                        ifStmt->elsePart = nullptr;
                         delete ifStmt;
                 }
@@ -1272 +1272 @@
                 const ast::AsmStmt *         previsit( const ast::AsmStmt * );
                 const ast::IfStmt *          previsit( const ast::IfStmt * );
-                const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
+                const ast::WhileStmt *       previsit( const ast::WhileStmt * );
                 const ast::ForStmt *         previsit( const ast::ForStmt * );
                 const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
@@ -1581 +1581 @@
         }
 
-        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
+        const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
                 return ast::mutate_field(
-                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
+                        whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
         }
 
@@ -1669 +1669 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have then)
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
                 // holds, check it. This allows a check for when to decode the mangling.
                 if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
-                        assert( ifStmt->then );
+                        assert( ifStmt->thenPart );
                 }
                 // Encode the catchStmt so the condition can see the declaration.
@@ -1687 +1687 @@
                 // Decode the catchStmt so everything is stored properly.
                 const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
-                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
                         assert( ifStmt->cond );
-                        assert( ifStmt->else_ );
+                        assert( ifStmt->elsePart );
                         ast::CatchStmt * stmt = ast::mutate( catchStmt );
                         stmt->cond = ifStmt->cond;
-                        stmt->body = ifStmt->else_;
+                        stmt->body = ifStmt->elsePart;
                         // ifStmt should be implicately deleted here.
                         return stmt;