Changeset 335d81f

Timestamp:

Jul 19, 2019, 3:29:37 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

884f1409

Parents:

85dac33

Message:

getFunction has const version and maybeImpure[IgnoreUnique?] have const input.

Location:

src

Files:

• InitTweak/InitTweak.cc (modified) (2 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• Tuples/TupleExpansion.cc (modified) (5 diffs)
• Tuples/Tuples.h (modified) (1 diff)

src/InitTweak/InitTweak.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 10 13:30:00 2019
-// Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun 19 14:34:00 2019
+// Update Count     : 6
 //
 
@@ -633 +633 @@
                         return nullptr;
                 }
+
+                DeclarationWithType * getFunctionCore( const Expression * expr ) {
+                        if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
+                                return getCalledFunction( appExpr->function );
+                        } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
+                                return getCalledFunction( untyped->function );
+                        }
+                        assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
+                }
         }
 
         DeclarationWithType * getFunction( Expression * expr ) {
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
-                        return getCalledFunction( appExpr->get_function() );
-                } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
-                        return getCalledFunction( untyped->get_function() );
-                }
-                assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
+                return getFunctionCore( expr );
+        }
+
+        const DeclarationWithType * getFunction( const Expression * expr ) {
+                return getFunctionCore( expr );
         }
 

src/InitTweak/InitTweak.h

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 10 13:30:00 2019
-// Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 19 14:18:00 2019
+// Update Count     : 6
 //
 
@@ -61 +61 @@
         /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
         DeclarationWithType * getFunction( Expression * expr );
+        const DeclarationWithType * getFunction( const Expression * expr );
         const ast::DeclWithType * getFunction( const ast::Expr * expr );
 

src/Tuples/TupleExpansion.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 13 18:14:12 2019
-// Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 19 14:39:00 2019
+// Update Count     : 22
 //
 
@@ -364 +364 @@
                         ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-                        void previsit( ApplicationExpr * appExpr ) {
+                        void previsit( const ApplicationExpr * appExpr ) {
                                 visit_children = false;
-                                if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
-                                        if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
+                                if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
+                                        if ( function->linkage == LinkageSpec::Intrinsic ) {
+                                                if ( function->name == "*?" || function->name == "?[?]" ) {
                                                         // intrinsic dereference, subscript are pure, but need to recursively look for impurity
                                                         visit_children = true;
@@ -377 +377 @@
                                 maybeImpure = true;
                         }
-                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
-                        void previsit( UniqueExpr * ) {
+                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
+                        void previsit( const UniqueExpr * ) {
                                 if ( ignoreUnique ) {
                                         // bottom out at unique expression.
@@ -393 +393 @@
         } // namespace
 
-        bool maybeImpure( Expression * expr ) {
+        bool maybeImpure( const Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( false );
                 expr->accept( detector );
@@ -399 +399 @@
         }
 
-        bool maybeImpureIgnoreUnique( Expression * expr ) {
+        bool maybeImpureIgnoreUnique( const Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( true );
                 expr->accept( detector );

src/Tuples/Tuples.h

@@ -55 +55 @@
 
         /// returns true if the expression may contain side-effects.
-        bool maybeImpure( Expression * expr );
+        bool maybeImpure( const Expression * expr );
         bool maybeImpure( const ast::Expr * expr );
 
         /// Returns true if the expression may contain side-effect,
         /// ignoring the presence of unique expressions.
-        bool maybeImpureIgnoreUnique( Expression * expr );
+        bool maybeImpureIgnoreUnique( const Expression * expr );
         bool maybeImpureIgnoreUnique( const ast::Expr * expr );
 } // namespace Tuples