Changeset 335d81f


Ignore:
Timestamp:
Jul 19, 2019, 3:29:37 PM (2 years ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
884f140
Parents:
85dac33
Message:

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

Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/InitTweak.cc

    r85dac33 r335d81f  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 10 13:30:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jun 19 14:34:00 2019
     13// Update Count     : 6
    1414//
    1515
     
    633633                        return nullptr;
    634634                }
     635
     636                DeclarationWithType * getFunctionCore( const Expression * expr ) {
     637                        if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
     638                                return getCalledFunction( appExpr->function );
     639                        } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
     640                                return getCalledFunction( untyped->function );
     641                        }
     642                        assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
     643                }
    635644        }
    636645
    637646        DeclarationWithType * getFunction( Expression * expr ) {
    638                 if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
    639                         return getCalledFunction( appExpr->get_function() );
    640                 } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
    641                         return getCalledFunction( untyped->get_function() );
    642                 }
    643                 assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
     647                return getFunctionCore( expr );
     648        }
     649
     650        const DeclarationWithType * getFunction( const Expression * expr ) {
     651                return getFunctionCore( expr );
    644652        }
    645653
  • src/InitTweak/InitTweak.h

    r85dac33 r335d81f  
    99// Author           : Rob Schluntz
    1010// Created On       : Fri May 13 11:26:36 2016
    11 // Last Modified By : Aaron B. Moss
    12 // Last Modified On : Mon Jun 10 13:30:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 14:18:00 2019
     13// Update Count     : 6
    1414//
    1515
     
    6161        /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
    6262        DeclarationWithType * getFunction( Expression * expr );
     63        const DeclarationWithType * getFunction( const Expression * expr );
    6364        const ast::DeclWithType * getFunction( const ast::Expr * expr );
    6465
  • src/Tuples/TupleExpansion.cc

    r85dac33 r335d81f  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 13 18:14:12 2019
    13 // Update Count     : 21
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Jul 19 14:39:00 2019
     13// Update Count     : 22
    1414//
    1515
     
    364364                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
    365365
    366                         void previsit( ApplicationExpr * appExpr ) {
     366                        void previsit( const ApplicationExpr * appExpr ) {
    367367                                visit_children = false;
    368                                 if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
    369                                         if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
    370                                                 if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
     368                                if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
     369                                        if ( function->linkage == LinkageSpec::Intrinsic ) {
     370                                                if ( function->name == "*?" || function->name == "?[?]" ) {
    371371                                                        // intrinsic dereference, subscript are pure, but need to recursively look for impurity
    372372                                                        visit_children = true;
     
    377377                                maybeImpure = true;
    378378                        }
    379                         void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
    380                         void previsit( UniqueExpr * ) {
     379                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
     380                        void previsit( const UniqueExpr * ) {
    381381                                if ( ignoreUnique ) {
    382382                                        // bottom out at unique expression.
     
    393393        } // namespace
    394394
    395         bool maybeImpure( Expression * expr ) {
     395        bool maybeImpure( const Expression * expr ) {
    396396                PassVisitor<ImpurityDetector> detector( false );
    397397                expr->accept( detector );
     
    399399        }
    400400
    401         bool maybeImpureIgnoreUnique( Expression * expr ) {
     401        bool maybeImpureIgnoreUnique( const Expression * expr ) {
    402402                PassVisitor<ImpurityDetector> detector( true );
    403403                expr->accept( detector );
  • src/Tuples/Tuples.h

    r85dac33 r335d81f  
    5555
    5656        /// returns true if the expression may contain side-effects.
    57         bool maybeImpure( Expression * expr );
     57        bool maybeImpure( const Expression * expr );
    5858        bool maybeImpure( const ast::Expr * expr );
    5959
    6060        /// Returns true if the expression may contain side-effect,
    6161        /// ignoring the presence of unique expressions.
    62         bool maybeImpureIgnoreUnique( Expression * expr );
     62        bool maybeImpureIgnoreUnique( const Expression * expr );
    6363        bool maybeImpureIgnoreUnique( const ast::Expr * expr );
    6464} // namespace Tuples
Note: See TracChangeset for help on using the changeset viewer.