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

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 : Peter A. Buhr
-// Last Modified On : Thu Mar 24 16:43:11 2016
-// Update Count     : 181
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Mar 30 15:47:19 2016
+// Update Count     : 203
 //
 
@@ -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;
@@ -59 +60 @@
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
+          void fallbackInit( ConstructorInit * ctorInit );
 
                 std::list< Type * > functionReturn;
@@ -95 +97 @@
                         return newExpr;
                 }
-  
+
                 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -126 +128 @@
                         } // if
                 }
-  
+
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -159 +161 @@
                         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;
         }
 
@@ -258 +253 @@
                         forStmt->set_condition( newExpr );
                 } // if
-                
+
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
@@ -272 +267 @@
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
-  
+
                 visitor.Visitor::visit( switchStmt );
         }
@@ -314 +309 @@
         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;
                 }
@@ -326 +321 @@
                                 string n = ne->get_name();
                                 if (n == "0") {
-                                        initContext = new BasicType(Type::Qualifiers(), 
+                                        initContext = new BasicType(Type::Qualifiers(),
                                                                                                 BasicType::SignedInt);
                                 } else {
@@ -332 +327 @@
                                         initContext = decl->get_type();
                                 }
-                        } else if (ConstantExpr * e = 
+                        } else if (ConstantExpr * e =
                                            dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
                                 Constant *c = e->get_constant();
@@ -355 +350 @@
                                                         singleInit->set_value( ce->get_arg() );
                                                         ce->set_arg( NULL );
-                                                        delete ce;                                                                      
+                                                        delete ce;
                                                 }
                                         }
@@ -471 +466 @@
 #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