Changes in src/GenPoly/Box.cc [c29d9ce:82dd287]

File:

• src/GenPoly/Box.cc (modified) (8 diffs)

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue Aug 11 16:22:35 2015
-// Update Count     : 89
+// Last Modified On : Wed Jun 24 16:19:07 2015
+// Update Count     : 10
 //
 
@@ -77 +77 @@
                         Expression *handleIntrinsics( ApplicationExpr *appExpr );
                         ObjectDecl *makeTemporary( Type *type );
-
+  
+                        std::map< std::string, DeclarationWithType *> assignOps;
                         typedef std::map< std::string, FunctionDecl *> AdapterMap;
-                        std::map< std::string, DeclarationWithType *> assignOps;
                         std::stack< AdapterMap > adapters;
                         DeclarationWithType *retval;
@@ -168 +168 @@
                         TyVarMap dummyTyVars;
                         return isPolyRet( function, name, dummyTyVars );
-                }
-
-                bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars ) {
-                        std::string dummyString;
-                        return isPolyRet( function, dummyString, otherTyVars );
                 }
 
@@ -531 +526 @@
                 }
 
-                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
-                        // collect a list of function types passed as parameters or implicit parameters (assertions)
+                void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                         std::list< FunctionType *> functions;
@@ -543 +537 @@
                                 findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
                         } // for
-
-                        // parameter function types for which an appropriate adapter has been generated.
-                        // we cannot use the types after applying substitutions, since two different 
-                        // parameter types may be unified to the same type
                         std::set< std::string > adaptersDone;
-
                         for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                FunctionType *originalFunction = (*funType)->clone();
                                 FunctionType *realFunction = (*funType)->clone();
+                                assert( env );
+                                env->apply( realFunction );
+
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
-
-                                // only attempt to create an adapter or pass one as a parameter if we haven't 
-                                // already done so for this pre-substitution parameter function type.
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
-                                        std::string mangleName = SymTab::Mangler::mangle( realFunction );
-                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
-                                        
-                                        // apply substitution to type variables to figure out what the 
-                                        // adapter's type should look like
-                                        assert( env );
-                                        env->apply( realFunction );
-                                        mangleName = SymTab::Mangler::mangle( realFunction );
+                                        AdapterMap & adapters = Pass1::adapters.top();
+                                        AdapterMap::iterator adapter = adapters.find( mangleName );
 
                                         if ( needsAdapter( realFunction, exprTyVars, true ) ) {
@@ -571 +553 @@
                                                 // create a new adapter.
                                                 appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
-                                        } else {
-                                                if ( isPolyRet( originalFunction, exprTyVars ) ) {
-                                                        // if the return type involved polymorphic types, then
-                                                        // the adapter will need to take those polymorphic types
-                                                        // as pointers. Therefore, there can be two different
-                                                        // functions with the same mangled name, so we need two adapter map
-                                                        // stacks and also we need the mangled names to be different.
-                                                        mangleName += "polyret_";
-                                                }
-
-                                                AdapterMap & adapters = Pass1::adapters.top();
-                                                AdapterMap::iterator adapter = adapters.find( mangleName );
-                                                if ( adapter == adapters.end() ) {
-                                                        // adapter has not been created yet in the current scope, so define it
-                                                        FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
-                                                        adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
-                                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
-                                                } // if
-                                                assert( adapter != adapters.end() );
-
-                                                // add the appropriate adapter as a parameter
-                                                appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
-                                        } // if
+                                                continue;
+                                        } else if ( adapter == adapters.end() ) {
+                                                FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
+                                                adapter = adapters.insert( adapters.begin(), std::pair< std::string, FunctionDecl *>( mangleName, newAdapter ) );
+                                                stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                        } // if
+                                        assert( adapter != adapters.end() );
+                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
+                                        // appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
+                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 } // if
                         } // for
@@ -911 +880 @@
 
                 void Pass1::doBeginScope() {
-                        // actually, maybe this could (should?) push
-                        // a copy of the current map
                         adapters.push(AdapterMap());
                 }
@@ -1084 +1051 @@
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
                                 if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
-                                        // change initialization of a polymorphic value object
-                                        // to allocate storage with alloca
                                         TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
                                         assert( typeInst );
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
                                         alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
-
-                                        delete objectDecl->get_init();
-
-                                        std::list<Expression*> designators;
-                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
+                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                        assign->get_args().push_back( new VariableExpr( objectDecl ) );
+                                        assign->get_args().push_back( alloc );
+                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, assign ) );
                                 }
                         }