Changes in / [51b1202:a3a17ba]

Location:

src

Files:

• GenPoly/Box.cc (modified) (7 diffs)
• SymTab/Indexer.cc (modified) (4 diffs)
• SymTab/Indexer.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Thu Jul 30 14:35:40 2015
-// Update Count     : 54
+// Last Modified On : Tue Aug 11 16:22:35 2015
+// Update Count     : 89
 //
 
@@ -77 +77 @@
                         Expression *handleIntrinsics( ApplicationExpr *appExpr );
                         ObjectDecl *makeTemporary( Type *type );
-  
+
+                        typedef std::map< std::string, FunctionDecl *> AdapterMap;
                         std::map< std::string, DeclarationWithType *> assignOps;
-                        typedef std::map< std::string, FunctionDecl *> AdapterMap;
                         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 );
                 }
 
@@ -526 +531 @@
                 }
 
-                void Pass1::passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ) {
+                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
                         // collect a list of function types passed as parameters or implicit parameters (assertions)
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
@@ -545 +550 @@
 
                         for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
+                                FunctionType *originalFunction = (*funType)->clone();
                                 FunctionType *realFunction = (*funType)->clone();
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
@@ -559 +565 @@
                                         env->apply( realFunction );
                                         mangleName = SymTab::Mangler::mangle( realFunction );
-                                        AdapterMap & adapters = Pass1::adapters.top();
-                                        AdapterMap::iterator adapter = adapters.find( mangleName );
 
                                         if ( needsAdapter( realFunction, exprTyVars, true ) ) {
@@ -567 +571 @@
                                                 // create a new adapter.
                                                 appExpr->get_args().push_front( new NameExpr( makeAdapterName ( mangleName ) ) );
-                                                continue;
-                                        } else 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 ) );
+                                        } 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
-                                        assert( adapter != adapters.end() );
-
-                                        // add the appropriate adapter as a parameter
-                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
                                 } // if
                         } // for

src/SymTab/Indexer.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun  5 08:05:17 2015
-// Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 05 13:52:42 2015
+// Update Count     : 10
 //
 
@@ -26 +26 @@
 
 namespace SymTab {
+        template< typename Container, typename VisitorType >
+        inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
+                visitor.enterScope();
+                acceptAll( container, visitor );
+                visitor.leaveScope();
+        }
+
         Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
 
@@ -31 +38 @@
 
         void Indexer::visit( ObjectDecl *objectDecl ) {
+                enterScope();
                 maybeAccept( objectDecl->get_type(), *this );
+                leaveScope();
                 maybeAccept( objectDecl->get_init(), *this );
                 maybeAccept( objectDecl->get_bitfieldWidth(), *this );
@@ -149 +158 @@
                 leaveScope();
         }
+
+
+        void Indexer::visit( ApplicationExpr *applicationExpr ) {
+                acceptAllNewScope( applicationExpr->get_results(), *this );
+                maybeAccept( applicationExpr->get_function(), *this );
+                acceptAll( applicationExpr->get_args(), *this );
+        }
+
+        void Indexer::visit( UntypedExpr *untypedExpr ) {
+                acceptAllNewScope( untypedExpr->get_results(), *this );
+                acceptAll( untypedExpr->get_args(), *this );
+        }
+
+        void Indexer::visit( NameExpr *nameExpr ) {
+                acceptAllNewScope( nameExpr->get_results(), *this );
+        }
+
+        void Indexer::visit( AddressExpr *addressExpr ) {
+                acceptAllNewScope( addressExpr->get_results(), *this );
+                maybeAccept( addressExpr->get_arg(), *this );
+        }
+
+        void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
+                acceptAllNewScope( labAddressExpr->get_results(), *this );
+                maybeAccept( labAddressExpr->get_arg(), *this );
+        }
+
+        void Indexer::visit( CastExpr *castExpr ) {
+                acceptAllNewScope( castExpr->get_results(), *this );
+                maybeAccept( castExpr->get_arg(), *this );
+        }
+
+        void Indexer::visit( UntypedMemberExpr *memberExpr ) {
+                acceptAllNewScope( memberExpr->get_results(), *this );
+                maybeAccept( memberExpr->get_aggregate(), *this );
+        }
+
+        void Indexer::visit( MemberExpr *memberExpr ) {
+                acceptAllNewScope( memberExpr->get_results(), *this );
+                maybeAccept( memberExpr->get_aggregate(), *this );
+        }
+
+        void Indexer::visit( VariableExpr *variableExpr ) {
+                acceptAllNewScope( variableExpr->get_results(), *this );
+        }
+
+        void Indexer::visit( ConstantExpr *constantExpr ) {
+                acceptAllNewScope( constantExpr->get_results(), *this );
+                maybeAccept( constantExpr->get_constant(), *this );
+        }
+
+        void Indexer::visit( SizeofExpr *sizeofExpr ) {
+                acceptAllNewScope( sizeofExpr->get_results(), *this );
+                if ( sizeofExpr->get_isType() ) {
+                        maybeAccept( sizeofExpr->get_type(), *this );
+                } else {
+                        maybeAccept( sizeofExpr->get_expr(), *this );
+                }
+        }
+
+        void Indexer::visit( AttrExpr *attrExpr ) {
+                acceptAllNewScope( attrExpr->get_results(), *this );
+                if ( attrExpr->get_isType() ) {
+                        maybeAccept( attrExpr->get_type(), *this );
+                } else {
+                        maybeAccept( attrExpr->get_expr(), *this );
+                }
+        }
+
+        void Indexer::visit( LogicalExpr *logicalExpr ) {
+                acceptAllNewScope( logicalExpr->get_results(), *this );
+                maybeAccept( logicalExpr->get_arg1(), *this );
+                maybeAccept( logicalExpr->get_arg2(), *this );
+        }
+
+        void Indexer::visit( ConditionalExpr *conditionalExpr ) {
+                acceptAllNewScope( conditionalExpr->get_results(), *this );
+                maybeAccept( conditionalExpr->get_arg1(), *this );
+                maybeAccept( conditionalExpr->get_arg2(), *this );
+                maybeAccept( conditionalExpr->get_arg3(), *this );
+        }
+
+        void Indexer::visit( CommaExpr *commaExpr ) {
+                acceptAllNewScope( commaExpr->get_results(), *this );
+                maybeAccept( commaExpr->get_arg1(), *this );
+                maybeAccept( commaExpr->get_arg2(), *this );
+        }
+
+        void Indexer::visit( TupleExpr *tupleExpr ) {
+                acceptAllNewScope( tupleExpr->get_results(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
+        }
+
+        void Indexer::visit( SolvedTupleExpr *tupleExpr ) {
+                acceptAllNewScope( tupleExpr->get_results(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
+        }
+
+        void Indexer::visit( TypeExpr *typeExpr ) {
+                acceptAllNewScope( typeExpr->get_results(), *this );
+                maybeAccept( typeExpr->get_type(), *this );
+        }
+
+        void Indexer::visit( AsmExpr *asmExpr ) {
+                maybeAccept( asmExpr->get_inout(), *this );
+                maybeAccept( asmExpr->get_constraint(), *this );
+                maybeAccept( asmExpr->get_operand(), *this );
+        }
+
+        void Indexer::visit( UntypedValofExpr *valofExpr ) {
+                acceptAllNewScope( valofExpr->get_results(), *this );
+                maybeAccept( valofExpr->get_body(), *this );
+        }
+
 
         void Indexer::visit( ContextInstType *contextInst ) {

src/SymTab/Indexer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 19 16:51:21 2015
-// Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Aug 05 13:51:39 2015
+// Update Count     : 4
 //
 
@@ -43 +43 @@
 
                 virtual void visit( CompoundStmt *compoundStmt );
+
+                virtual void visit( ApplicationExpr *applicationExpr );
+                virtual void visit( UntypedExpr *untypedExpr );
+                virtual void visit( NameExpr *nameExpr );
+                virtual void visit( CastExpr *castExpr );
+                virtual void visit( AddressExpr *addressExpr );
+                virtual void visit( LabelAddressExpr *labAddressExpr );
+                virtual void visit( UntypedMemberExpr *memberExpr );
+                virtual void visit( MemberExpr *memberExpr );
+                virtual void visit( VariableExpr *variableExpr );
+                virtual void visit( ConstantExpr *constantExpr ); 
+                virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AttrExpr *attrExpr );
+                virtual void visit( LogicalExpr *logicalExpr );
+                virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( SolvedTupleExpr *tupleExpr );
+                virtual void visit( TypeExpr *typeExpr );
+                virtual void visit( AsmExpr *asmExpr );
+                virtual void visit( UntypedValofExpr *valofExpr );
 
                 virtual void visit( ContextInstType *contextInst );

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jul 22 13:16:00 2015
-// Update Count     : 194
+// Last Modified On : Wed Aug 05 14:00:24 2015
+// Update Count     : 195
 //
 
@@ -893 +893 @@
                 TypedefMap oldNames = typedefNames;
                 DeclarationWithType *ret = Mutator::mutate( objDecl );
+                typedefNames = oldNames;
                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) {
                         return new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, ret->get_isInline(), ret->get_isNoreturn() );
@@ -898 +899 @@
                         throw SemanticError( "invalid inline or _Noreturn specification in declaration of ", objDecl );
                 } // if
-                typedefNames = oldNames;
                 return ret;
         }