Changeset d7aa12c for src/InitTweak

Timestamp:

May 23, 2019, 11:55:32 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

b5fed34

Parents:

9d6e7fa9

Message:

Implemented eval for new AST

Location:

src/InitTweak

Files:

• InitTweak.cc (modified) (8 diffs)
• InitTweak.h (modified) (1 diff)

src/InitTweak/InitTweak.cc

@@ -346 +346 @@
         namespace {
                 DeclarationWithType * getCalledFunction( Expression * expr );
+                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr );
 
                 template<typename CallExpr>
@@ -355 +356 @@
                         return getCalledFunction( expr->get_args().front() );
                 }
+
+                template<typename CallExpr>
+                const ast::DeclWithType * handleDerefCalledFunction( const CallExpr * expr ) {
+                        // (*f)(x) => should get "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->args.empty(), "Cannot get called function from dereference with no arguments" );
+                        return getCalledFunction( expr->args.front() );
+                }
+
 
                 DeclarationWithType * getCalledFunction( Expression * expr ) {
@@ -375 +386 @@
                         return nullptr;
                 }
+
+                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr ) {
+                        assert( expr );
+                        if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( expr ) ) {
+                                return varExpr->var;
+                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( expr ) ) {
+                                return memberExpr->member;
+                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( expr ) ) {
+                                return getCalledFunction( castExpr->arg );
+                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( expr ) ) {
+                                return handleDerefCalledFunction( untypedExpr );
+                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * > ( expr ) ) {
+                                return handleDerefCalledFunction( appExpr );
+                        } else if ( const ast::AddressExpr * addrExpr = dynamic_cast< const ast::AddressExpr * >( expr ) ) {
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( const ast::CommaExpr * commaExpr = dynamic_cast< const ast::CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
+                        }
+                        return nullptr;
+                }
         }
 
@@ -382 +413 @@
                 } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
                         return getCalledFunction( untyped->get_function() );
+                }
+                assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
+        }
+
+        const ast::DeclWithType * getFunction( const ast::Expr * expr ) {
+                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
+                        return getCalledFunction( appExpr->func );
+                } else if ( const ast::UntypedExpr * untyped = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
+                        return getCalledFunction( untyped->func );
                 }
                 assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
@@ -492 +532 @@
         namespace {
                 std::string funcName( Expression * func );
+                std::string funcName( const ast::Expr * func );
 
                 template<typename CallExpr>
@@ -500 +541 @@
                         assertf( ! expr->get_args().empty(), "Cannot get function name from dereference with no arguments" );
                         return funcName( expr->get_args().front() );
+                }
+
+                template<typename CallExpr>
+                std::string handleDerefName( const CallExpr * expr ) {
+                        // (*f)(x) => should get name "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->args.empty(), "Cannot get function name from dereference with no arguments" );
+                        return funcName( expr->args.front() );
                 }
 
@@ -523 +573 @@
                         }
                 }
+
+                std::string funcName( const ast::Expr * func ) {
+                        if ( const ast::NameExpr * nameExpr = dynamic_cast< const ast::NameExpr * >( func ) ) {
+                                return nameExpr->name;
+                        } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
+                                return varExpr->var->name;
+                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+                                return funcName( castExpr->arg );
+                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
+                                return memberExpr->member->name;
+                        } else if ( const ast::UntypedMemberExpr * memberExpr = dynamic_cast< const ast::UntypedMemberExpr * > ( func ) ) {
+                                return funcName( memberExpr->member );
+                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( func ) ) {
+                                return handleDerefName( untypedExpr );
+                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( func ) ) {
+                                return handleDerefName( appExpr );
+                        } else if ( const ast::ConstructorExpr * ctorExpr = dynamic_cast< const ast::ConstructorExpr * >( func ) ) {
+                                return funcName( getCallArg( ctorExpr->callExpr, 0 ) );
+                        } else {
+                                assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() );
+                        }
+                }
         }
 
@@ -533 +605 @@
                 } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
                         return funcName( untypedExpr->get_function() );
+                } else {
+                        std::cerr << expr << std::endl;
+                        assertf( false, "Unexpected expression type passed to getFunctionName" );
+                }
+        }
+
+        std::string getFunctionName( const ast::Expr * expr ) {
+                // there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
+                // return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
+                // can't possibly do anything reasonable.
+                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
+                        return funcName( appExpr->func );
+                } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
+                        return funcName( untypedExpr->func );
                 } else {
                         std::cerr << expr << std::endl;

src/InitTweak/InitTweak.h

@@ -79 +79 @@
         /// returns the name of the function being called
         std::string getFunctionName( Expression * expr );
+        std::string getFunctionName( const ast::Expr * expr );
 
         /// returns the argument to a call expression in position N indexed from 0