Changes in src/ResolvExpr/Resolver.cc [5b2f5bb:3cfe27f]

File:

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

src/ResolvExpr/Resolver.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Resolver.cc --
+// Resolver.cc -- 
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Mar 30 15:47:19 2016
-// Update Count     : 203
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Mar 24 16:43:11 2016
+// Update Count     : 181
 //
 
@@ -33 +33 @@
           public:
                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
-
+  
                 virtual void visit( FunctionDecl *functionDecl );
                 virtual void visit( ObjectDecl *functionDecl );
@@ -54 +54 @@
                 virtual void visit( SingleInit *singleInit );
                 virtual void visit( ListInit *listInit );
-                virtual void visit( ConstructorInit *ctorInit );
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
@@ -60 +59 @@
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
-          void fallbackInit( ConstructorInit * ctorInit );
 
                 std::list< Type * > functionReturn;
@@ -97 +95 @@
                         return newExpr;
                 }
-
+  
                 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -128 +126 @@
                         } // if
                 }
-
+  
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -161 +159 @@
                         return newExpr;
                 }
-
-        }
-
+  
+        }
+  
         void Resolver::visit( ObjectDecl *objectDecl ) {
                 Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
                 objectDecl->set_type( new_type );
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
+                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
+                // initContext because of a function type can contain object declarations in the return and parameter types. So
+                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
+                // the RHS.
+                Type *temp = initContext;
                 initContext = new_type;
                 SymTab::Indexer::visit( objectDecl );
+                initContext = temp;
         }
 
@@ -253 +258 @@
                         forStmt->set_condition( newExpr );
                 } // if
-
+                
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
@@ -267 +272 @@
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
-
+  
                 visitor.Visitor::visit( switchStmt );
         }
@@ -309 +314 @@
         bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
-                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
+                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar || 
                                 bt->get_kind() == BasicType::UnsignedChar;
                 }
@@ -321 +326 @@
                                 string n = ne->get_name();
                                 if (n == "0") {
-                                        initContext = new BasicType(Type::Qualifiers(),
+                                        initContext = new BasicType(Type::Qualifiers(), 
                                                                                                 BasicType::SignedInt);
                                 } else {
@@ -327 +332 @@
                                         initContext = decl->get_type();
                                 }
-                        } else if (ConstantExpr * e =
+                        } else if (ConstantExpr * e = 
                                            dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
                                 Constant *c = e->get_constant();
@@ -350 +355 @@
                                                         singleInit->set_value( ce->get_arg() );
                                                         ce->set_arg( NULL );
-                                                        delete ce;
+                                                        delete ce;                                                                      
                                                 }
                                         }
@@ -466 +471 @@
 #endif
         }
-
-        // ConstructorInit - fall back on C-style initializer
-        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
-                // could not find valid constructor, or found an intrinsic constructor
-                // fall back on C-style initializer
-                delete ctorInit->get_ctor();
-                ctorInit->set_ctor( NULL );
-                maybeAccept( ctorInit->get_init(), *this );
-        }
-
-        void Resolver::visit( ConstructorInit *ctorInit ) {
-                TypeEnvironment env;
-                try {
-                        maybeAccept( ctorInit->get_ctor(), *this );
-                        maybeAccept( ctorInit->get_dtor(), *this );
-                } catch ( SemanticError ) {
-                        // no alternatives for the constructor initializer - fallback on C-style initializer
-                        // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
-                        fallbackInit( ctorInit );
-                        return;
-                }
-
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * > ( ctorInit->get_ctor() ) ) {
-                        ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( exprStmt->get_expr() );
-                        assert( appExpr );
-                        VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() );
-                        assert( function );
-                        if ( LinkageSpec::isOverridable( function->get_var()->get_linkage() ) ) {
-                                // if the constructor that was found is intrinsic or autogenerated, reset to C-style
-                                // initializer so that code generation is easy to handle
-                                fallbackInit( ctorInit );
-                                return;
-                        }
-                }
-                // found a constructor - can get rid of C-style initializer
-                delete ctorInit->get_init();
-                ctorInit->set_init( NULL );
-        }
 } // namespace ResolvExpr