Changes in src/ResolvExpr/AlternativeFinder.cc [0f19d763:de62360d]

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (25 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 : Sat May 16 23:55:30 2015
-// Update Count     : 3
+// Last Modified On : Mon Jun 22 17:19:54 2015
+// Update Count     : 17
 //
 
@@ -89 +89 @@
                 };
 
-                /// Prunes a list of alternatives down to those that have the minimum conversion cost for a given return type; skips ambiguous interpretations
                 template< typename InputIterator, typename OutputIterator >
                 void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
@@ -108 +107 @@
                                                 PRINT(
                                                         std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
-                                                        )
+                                                )
                                                 selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
                                                 PRINT(
                                                         std::cout << "marking ambiguous" << std::endl;
-                                                        )
+                                                )
                                                 mapPlace->second.isAmbiguous = true;
                                         }
@@ -123 +122 @@
                         PRINT(
                                 std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
-                                )
+                        )
 
                         // accept the alternatives that were unambiguous
@@ -184 +183 @@
                                 std::cout << "findSubExprs" << std::endl;
                                 printAlts( finder.alternatives, std::cout );
-                                )
+                        )
                         *out++ = finder;
                 }
@@ -206 +205 @@
                         std::cout << "alternatives before prune:" << std::endl;
                         printAlts( alternatives, std::cout );
-                        )
+                )
                 AltList::iterator oldBegin = alternatives.begin();
                 pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
                 if ( alternatives.begin() == oldBegin ) {
-                        std::ostrstream stream;
+                        std::ostringstream stream;
                         stream << "Can't choose between alternatives for expression ";
                         expr->print( stream );
@@ -217 +216 @@
                         findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                         printAlts( winners, stream, 8 );
-                        throw SemanticError( std::string( stream.str(), stream.pcount() ) );
+                        throw SemanticError( stream.str() );
                 }
                 alternatives.erase( oldBegin, alternatives.end() );
                 PRINT(
                         std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-                        )
+                )
         }
 
@@ -265 +264 @@
                                 std::cout << "--- results are" << std::endl;
                                 printAll( (*actualExpr)->get_results(), std::cout, 8 );
-                                )
-                                std::list< DeclarationWithType* >::iterator startFormal = formal;
+                        )
+                        std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
                         for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
@@ -282 +281 @@
                                         std::cout << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cout, 8 );
-                                        )
-                                        Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
+                                )
+                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
                                         std::cout << std::endl << "cost is" << newCost << std::endl;
-                                        )
-
-                                        if ( newCost == Cost::infinity ) {
-                                                return newCost;
-                                        }
+                                )
+
+                                if ( newCost == Cost::infinity ) {
+                                        return newCost;
+                                }
                                 convCost += newCost;
                                 actualCost += newCost;
@@ -354 +353 @@
 
         bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
+                std::list< TypeEnvironment > toBeDone;
                 simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
                 // make sure we don't widen any existing bindings
@@ -381 +381 @@
                                         (*actual)->print( std::cerr );
                                         std::cerr << std::endl;
-                                        )
+                                )
                                 if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
                                         return false;
@@ -429 +429 @@
                                         std::cerr << "recursing with new set:" << std::endl;
                                         printAssertionSet( newNeed, std::cerr, 8 );
-                                        )
+                                )
                                 inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
                                 return;
@@ -444 +444 @@
                         curDecl->print( std::cerr );
                         std::cerr << std::endl;
-                        )
+                )
                 std::list< DeclarationWithType* > candidates;
                 decls.lookupId( curDecl->get_name(), candidates );
@@ -453 +453 @@
                                 (*candidate)->print( std::cout );
                                 std::cout << std::endl;
-                                )
+                        )
                         AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
@@ -466 +466 @@
                                 adjType->print( std::cerr );
                                 std::cerr << std::endl;
-                                )
+                        )
                         if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
                                 PRINT(
                                         std::cerr << "success!" << std::endl;
-                                        )
+                                )
                                 SymTab::Indexer newDecls( decls );
                                 addToIndexer( newHave, newDecls );
@@ -486 +486 @@
                                         (*candidate)->print( std::cout );
                                         std::cout << std::endl;
-                                        )
+                                )
                                 ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
@@ -509 +509 @@
                         std::cout << "============= new indexer" << std::endl;
                         decls.print( std::cout );
-                        )
+                )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -533 +533 @@
                                 std::cout << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cout, 8 );
-                                )
+                        )
                         inferParameters( resultNeed, resultHave, newAlt, openVars, out );
                 }
@@ -542 +542 @@
                 AlternativeFinder funcOpFinder( indexer, env );
 
-                AlternativeFinder funcFinder( indexer, env );
-
-                {
+                AlternativeFinder funcFinder( indexer, env ); {
                         NameExpr *fname;
                         if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-                                 && ( fname->get_name() == std::string("LabAddress")) ) {
-                                alternatives.push_back( Alternative( untypedExpr, env, Cost()) );
+                                 && ( fname->get_name() == std::string("&&")) ) {
+                                alternatives.push_back( Alternative( untypedExpr->clone(), env, Cost()) );
                                 return;
                         }
@@ -562 +560 @@
                 Tuples::TupleAssignSpotter tassign( this );
                 if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
-                        // TODO take care of possible tuple assignments, or discard expression
+                        // take care of possible tuple assignments, or discard expression
                         return;
                 } // else ...
@@ -572 +570 @@
                                 std::cout << "working on alternative: " << std::endl;
                                 func->print( std::cout, 8 );
-                                )
+                        )
                         // check if the type is pointer to function
                         PointerType *pointer;
@@ -605 +603 @@
                                                 std::cout << "known function ops:" << std::endl;
                                                 printAlts( funcOpFinder.alternatives, std::cout, 8 );
-                                                )
+                                        )
                                 }
 
@@ -644 +642 @@
                                 withFunc->env.print( std::cout, 8 );
                                 std::cout << "cost of conversion is:" << cvtCost << std::endl;
-                                )
-                                if ( cvtCost != Cost::infinity ) {
-                                        withFunc->cvtCost = cvtCost;
-                                        alternatives.push_back( *withFunc );
-                                } // if
+                        )
+                        if ( cvtCost != Cost::infinity ) {
+                                withFunc->cvtCost = cvtCost;
+                                alternatives.push_back( *withFunc );
+                        } // if
                 } // for
                 candidates.clear();
@@ -749 +747 @@
                                 newExpr.print( std::cerr );
                                 std::cerr << std::endl;
-                                )
+                        )
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
@@ -796 +794 @@
                         argType->print( std::cout );
                         std::cout << std::endl;
-                        )
-                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                                alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
-                                for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                        alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
-                                } // for
-                        } // if
+                )
+                if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
+                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
+                        } // for
+                } // if
         }