Changes in src/ResolvExpr/AlternativeFinder.cc [033ff37:6f096d2]

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (3 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 25 22:37:46 2019
-// Update Count     : 37
+// Last Modified On : Thu Nov  1 21:00:56 2018
+// Update Count     : 35
 //
 
@@ -79 +79 @@
                 void postvisit( OffsetofExpr * offsetofExpr );
                 void postvisit( OffsetPackExpr * offsetPackExpr );
+                void postvisit( AttrExpr * attrExpr );
                 void postvisit( LogicalExpr * logicalExpr );
                 void postvisit( ConditionalExpr * conditionalExpr );
@@ -1403 +1404 @@
         }
 
+        namespace {
+                void resolveAttr( SymTab::Indexer::IdData data, const FunctionType * function, Type * argType, const TypeEnvironment &env, AlternativeFinder & finder ) {
+                        // assume no polymorphism
+                        // assume no implicit conversions
+                        assert( function->parameters.size() == 1 );
+                        PRINT(
+                                std::cerr << "resolvAttr: funcDecl is ";
+                                data.id->print( std::cerr );
+                                std::cerr << " argType is ";
+                                argType->print( std::cerr );
+                                std::cerr << std::endl;
+                        )
+                        const SymTab::Indexer & indexer = finder.get_indexer();
+                        AltList & alternatives = finder.get_alternatives();
+                        if ( typesCompatibleIgnoreQualifiers( argType, function->parameters.front()->get_type(), indexer, env ) ) {
+                                Cost cost = Cost::zero;
+                                Expression * newExpr = data.combine( cost );
+                                alternatives.push_back( Alternative{
+                                        new AttrExpr{ newExpr, argType->clone() }, env, OpenVarSet{},
+                                        AssertionList{}, Cost::zero, cost } );
+                                for ( DeclarationWithType * retVal : function->returnVals ) {
+                                        alternatives.back().expr->result = retVal->get_type()->clone();
+                                } // for
+                        } // if
+                }
+        }
+
+        void AlternativeFinder::Finder::postvisit( AttrExpr * attrExpr ) {
+                // assume no 'pointer-to-attribute'
+                NameExpr * nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
+                assert( nameExpr );
+                std::list< SymTab::Indexer::IdData > attrList;
+                indexer.lookupId( nameExpr->get_name(), attrList );
+                if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
+                        for ( auto & data : attrList ) {
+                                const DeclarationWithType * id = data.id;
+                                // check if the type is function
+                                if ( const FunctionType * function = dynamic_cast< const FunctionType * >( id->get_type() ) ) {
+                                        // assume exactly one parameter
+                                        if ( function->parameters.size() == 1 ) {
+                                                if ( attrExpr->get_isType() ) {
+                                                        resolveAttr( data, function, attrExpr->get_type(), env, altFinder);
+                                                } else {
+                                                        AlternativeFinder finder( indexer, env );
+                                                        finder.find( attrExpr->get_expr() );
+                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
+                                                                if ( choice->expr->get_result()->size() == 1 ) {
+                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder );
+                                                                } // fi
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // if
+                        } // for
+                } else {
+                        for ( auto & data : attrList ) {
+                                Cost cost = Cost::zero;
+                                Expression * newExpr = data.combine( cost );
+                                alternatives.push_back( Alternative{
+                                        newExpr, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost } );
+                                renameTypes( alternatives.back().expr );
+                        } // for
+                } // if
+        }
+
         void AlternativeFinder::Finder::postvisit( LogicalExpr * logicalExpr ) {
                 AlternativeFinder firstFinder( indexer, env );