Changeset 66f8528 for src/InitTweak

Timestamp:

Dec 15, 2016, 5:16:42 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

43385ca, f7ff3fb

Parents:

5802a4f (diff), 596f987b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into tuples

Conflicts:

src/ResolvExpr/CommonType.cc
src/tests/.expect/32/extension.txt
src/tests/.expect/32/gccExtensions.txt
src/tests/.expect/64/declarationSpecifier.txt
src/tests/.expect/64/extension.txt
src/tests/.expect/64/gccExtensions.txt
src/tests/.expect/castError.txt
src/tests/Makefile.am

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (1 diff)
• InitTweak.cc (modified) (5 diffs)

src/InitTweak/FixInit.cc

@@ -346 +346 @@
 
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
-                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
+                                if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;

src/InitTweak/InitTweak.cc

@@ -304 +304 @@
 
         namespace {
+                DeclarationWithType * getCalledFunction( Expression * expr );
+
+                template<typename CallExpr>
+                DeclarationWithType * handleDerefCalledFunction( CallExpr * expr ) {
+                        // (*f)(x) => should get "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->get_args().empty(), "Can't get called function from dereference with no arguments" );
+                        return getCalledFunction( expr->get_args().front() );
+                }
+
                 DeclarationWithType * getCalledFunction( Expression * expr ) {
                         assert( expr );
@@ -312 +323 @@
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 return getCalledFunction( castExpr->get_arg() );
+                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
+                                return handleDerefCalledFunction( untypedExpr );
+                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
+                                return handleDerefCalledFunction( appExpr );
                         }
                         return nullptr;
@@ -377 +392 @@
 
         namespace {
+                std::string funcName( Expression * func );
+
+                template<typename CallExpr>
+                std::string handleDerefName( CallExpr * expr ) {
+                        // (*f)(x) => should get name "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->get_args().empty(), "Can't get function name from dereference with no arguments" );
+                        return funcName( expr->get_args().front() );
+                }
+
                 std::string funcName( Expression * func ) {
                         if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
@@ -388 +414 @@
                         } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
                                 return funcName( memberExpr->get_member() );
+                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( func ) ) {
+                                return handleDerefName( untypedExpr );
+                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) {
+                                return handleDerefName( appExpr );
                         } else {
                                 assertf( false, "Unexpected expression type being called as a function in call expression" );
@@ -395 +425 @@
 
         std::string getFunctionName( Expression * 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 ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
                         return funcName( appExpr->get_function() );