Changes in src/ResolvExpr/Resolver.cc [679864e1:f9cebb5]

File:

• src/ResolvExpr/Resolver.cc (modified) (18 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 : Tue Sep 15 16:24:07 2015
-// Update Count     : 181
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 12 17:45:42 2016
+// Update Count     : 204
 //
 
@@ -24 +24 @@
 #include "SynTree/Initializer.h"
 #include "SymTab/Indexer.h"
-#include "utility.h"
+#include "SymTab/Autogen.h"
+#include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 #include <iostream>
@@ -33 +35 @@
           public:
                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
-  
+
                 virtual void visit( FunctionDecl *functionDecl );
                 virtual void visit( ObjectDecl *functionDecl );
                 virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( EnumDecl * enumDecl );
 
                 virtual void visit( ArrayType * at );
+                virtual void visit( PointerType * at );
 
                 virtual void visit( ExprStmt *exprStmt );
@@ -47 +51 @@
                 virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
-                virtual void visit( ChooseStmt *switchStmt );
                 virtual void visit( CaseStmt *caseStmt );
                 virtual void visit( BranchStmt *branchStmt );
@@ -54 +57 @@
                 virtual void visit( SingleInit *singleInit );
                 virtual void visit( ListInit *listInit );
+                virtual void visit( ConstructorInit *ctorInit );
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
 
+                template< typename PtrType >
+                void handlePtrType( PtrType * type );
+
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
-
+          void fallbackInit( ConstructorInit * ctorInit );
                 std::list< Type * > functionReturn;
                 Type *initContext;
                 Type *switchType;
+                bool inEnumDecl = false;
         };
 
@@ -82 +90 @@
         }
 
+
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
@@ -87 +96 @@
                         env.makeSubstitution( *expr->get_env() );
                 }
-
-                Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        global_renamer.reset();
-                        TypeEnvironment env;
-                        Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
-                        finishExpr( newExpr, env );
-                        return newExpr;
-                }
-  
+        } // namespace
+
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                global_renamer.reset();
+                TypeEnvironment env;
+                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                finishExpr( newExpr, env );
+                return newExpr;
+        }
+
+        namespace {
                 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -126 +137 @@
                         } // if
                 }
-  
+
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -159 +170 @@
                         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;
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since
+                        // the enum type is still incomplete at this point. Use signed int instead.
+                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                }
                 SymTab::Indexer::visit( objectDecl );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // delete newly created signed int type
+                        delete initContext;
+                }
+                initContext = temp;
+        }
+
+        template< typename PtrType >
+        void Resolver::handlePtrType( PtrType * type ) {
+                if ( type->get_dimension() ) {
+                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
+                        delete type->get_dimension();
+                        type->set_dimension( newExpr );
+                }
         }
 
         void Resolver::visit( ArrayType * at ) {
-                if ( at->get_dimension() ) {
-                        BasicType arrayLenType = BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                        CastExpr *castExpr = new CastExpr( at->get_dimension(), arrayLenType.clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, *this );
-                        delete at->get_dimension();
-                        at->set_dimension( newExpr );
-                }
+                handlePtrType( at );
                 Visitor::visit( at );
+        }
+
+        void Resolver::visit( PointerType * pt ) {
+                handlePtrType( pt );
+                Visitor::visit( pt );
         }
 
@@ -205 +241 @@
         }
 
+        void Resolver::visit( EnumDecl * enumDecl ) {
+                // in case we decide to allow nested enums
+                bool oldInEnumDecl = inEnumDecl;
+                inEnumDecl = true;
+                SymTab::Indexer::visit( enumDecl );
+                inEnumDecl = oldInEnumDecl;
+        }
+
         void Resolver::visit( ExprStmt *exprStmt ) {
                 if ( exprStmt->get_expr() ) {
@@ -251 +295 @@
                         forStmt->set_condition( newExpr );
                 } // if
-                
+
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
@@ -265 +309 @@
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
-  
+
                 visitor.Visitor::visit( switchStmt );
         }
 
         void Resolver::visit( SwitchStmt *switchStmt ) {
-                handleSwitchStmt( switchStmt, *this );
-        }
-
-        void Resolver::visit( ChooseStmt *switchStmt ) {
                 handleSwitchStmt( switchStmt, *this );
         }
@@ -307 +347 @@
         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;
                 }
@@ -319 +359 @@
                                 string n = ne->get_name();
                                 if (n == "0") {
-                                        initContext = new BasicType(Type::Qualifiers(), 
+                                        initContext = new BasicType(Type::Qualifiers(),
                                                                                                 BasicType::SignedInt);
                                 } else {
-                                        DeclarationWithType * decl = lookupId(n);
+                                        DeclarationWithType * decl = lookupId( n );
                                         initContext = decl->get_type();
                                 }
-                        } else if (ConstantExpr * e = 
+                        } else if (ConstantExpr * e =
                                            dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
                                 Constant *c = e->get_constant();
@@ -344 +384 @@
                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
                                                 if ( isCharType( pt->get_base() ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, e.g.
-                                                        // char x[] = "hello";
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
                                                         CastExpr *ce = dynamic_cast< CastExpr * >( newExpr );
                                                         singleInit->set_value( ce->get_arg() );
                                                         ce->set_arg( NULL );
-                                                        delete ce;                                                                      
+                                                        delete ce;
                                                 }
                                         }
@@ -396 +435 @@
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin_initializers();
-                InitIterator end = listInit->end_initializers();
+                InitIterator iter = listInit->begin();
+                InitIterator end = listInit->end();
 
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
@@ -407 +446 @@
                 } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseStruct(), iter, end );
-                } else if ( UnionInstType * st = dynamic_cast< UnionInstType * >( initContext ) ) {
+                } else if ( UnionInstType *st = dynamic_cast< UnionInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseUnion(), iter, end );
-                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                        // try again...
-                        initContext = tt->get_baseType()->get_base();
-                        visit(listInit);
                 } else {
-                        assert( dynamic_cast< BasicType * >( initContext ) );
                         // basic types are handled here
                         Visitor::visit( listInit );
@@ -470 +504 @@
 #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 );
+                delete ctorInit->get_dtor();
+                ctorInit->set_dtor( NULL );
+                maybeAccept( ctorInit->get_init(), *this );
+        }
+
+        void Resolver::visit( ConstructorInit *ctorInit ) {
+                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;
+                }
+
+                // found a constructor - can get rid of C-style initializer
+                delete ctorInit->get_init();
+                ctorInit->set_init( NULL );
+
+                // intrinsic single parameter constructors and destructors do nothing. Since this was
+                // implicitly generated, there's no way for it to have side effects, so get rid of it
+                // to clean up generated code.
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                        delete ctorInit->get_ctor();
+                        ctorInit->set_ctor( NULL );
+                }
+
+                // xxx - todo
+                // if ( InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                //      // can reduce the constructor down to a SingleInit using the
+                //      // second argument from the ctor call
+                // }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
+                        delete ctorInit->get_dtor();
+                        ctorInit->set_dtor( NULL );
+                }
+        }
 } // namespace ResolvExpr