Changeset 7c64920 for src/ResolvExpr

Timestamp:

May 25, 2015, 1:57:22 PM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

53a2e97

Parents:

5887db27

Message:

formatting

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // 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 By : Rob Schluntz
+// Last Modified On : Thu May 21 16:21:09 2015
+// Update Count     : 12
 //
 
@@ -107 +107 @@
                                                 PRINT(
                                                         std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
-                                                        )
-                                                        selected[ mangleName ] = current;
+                                                )
+                                                selected[ mangleName ] = current;
                                         } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
                                                 PRINT(
                                                         std::cout << "marking ambiguous" << std::endl;
-                                                        )
-                                                        mapPlace->second.isAmbiguous = true;
+                                                )
+                                                mapPlace->second.isAmbiguous = true;
                                         }
                                 } else {
@@ -122 +122 @@
                         PRINT(
                                 std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
-                                )
-
-                                // accept the alternatives that were unambiguous
-                                for ( std::map< std::string, PruneStruct >::iterator target = selected.begin(); target != selected.end(); ++target ) {
-                                        if ( ! target->second.isAmbiguous ) {
-                                                Alternative &alt = *target->second.candidate;
-                                                for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
-                                                        alt.env.applyFree( *result );
-                                                }
-                                                *out++ = alt;
+                        )
+
+                        // accept the alternatives that were unambiguous
+                        for ( std::map< std::string, PruneStruct >::iterator target = selected.begin(); target != selected.end(); ++target ) {
+                                if ( ! target->second.isAmbiguous ) {
+                                        Alternative &alt = *target->second.candidate;
+                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
+                                                alt.env.applyFree( *result );
                                         }
-                                }
+                                        *out++ = alt;
+                                }
+                        }
 
                 }
@@ -183 +183 @@
                                 std::cout << "findSubExprs" << std::endl;
                                 printAlts( finder.alternatives, std::cout );
-                                )
-                                *out++ = finder;
+                        )
+                        *out++ = finder;
                 }
         }
@@ -205 +205 @@
                         std::cout << "alternatives before prune:" << std::endl;
                         printAlts( alternatives, std::cout );
-                        )
-                        AltList::iterator oldBegin = alternatives.begin();
+                )
+                AltList::iterator oldBegin = alternatives.begin();
                 pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
                 if ( alternatives.begin() == oldBegin ) {
@@ -221 +221 @@
                 PRINT(
                         std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-                        )
-                        }
+                )
+        }
 
         void AlternativeFinder::findWithAdjustment( Expression *expr ) {
@@ -264 +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 ) {
@@ -281 +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;
@@ -381 +381 @@
                                         (*actual)->print( std::cerr );
                                         std::cerr << std::endl;
-                                        )
-                                        if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                                return false;
-                                        }
+                                )
+                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                        return false;
+                                }
                                 formal++;
                         }
@@ -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 );
+                                )
+                                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;
+                )
+                std::list< DeclarationWithType* > candidates;
                 decls.lookupId( curDecl->get_name(), candidates );
 ///   if ( candidates.empty() ) { std::cout << "no candidates!" << std::endl; }
@@ -453 +453 @@
                                 (*candidate)->print( std::cout );
                                 std::cout << std::endl;
-                                )
-                                AssertionSet newHave, newerNeed( newNeed );
+                        )
+                        AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
                         OpenVarSet newOpenVars( openVars );
@@ -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;
                                 )
-                                if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
-                                        PRINT(
-                                                std::cerr << "success!" << std::endl;
-                                                )
-                                                SymTab::Indexer newDecls( decls );
-                                        addToIndexer( newHave, newDecls );
-                                        Alternative newerAlt( newAlt );
-                                        newerAlt.env = newEnv;
-                                        assert( (*candidate)->get_uniqueId() );
-                                        Expression *varExpr = new VariableExpr( static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ) );
-                                        deleteAll( varExpr->get_results() );
-                                        varExpr->get_results().clear();
-                                        varExpr->get_results().push_front( adjType->clone() );
-                                        PRINT(
-                                                std::cout << "satisfying assertion " << curDecl->get_uniqueId() << " ";
-                                                curDecl->print( std::cout );
-                                                std::cout << " with declaration " << (*candidate)->get_uniqueId() << " ";
-                                                (*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
-                                        appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
-                                        inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
-                                } else {
-                                        delete adjType;
-                                }
+                                SymTab::Indexer newDecls( decls );
+                                addToIndexer( newHave, newDecls );
+                                Alternative newerAlt( newAlt );
+                                newerAlt.env = newEnv;
+                                assert( (*candidate)->get_uniqueId() );
+                                Expression *varExpr = new VariableExpr( static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ) );
+                                deleteAll( varExpr->get_results() );
+                                varExpr->get_results().clear();
+                                varExpr->get_results().push_front( adjType->clone() );
+                                PRINT(
+                                        std::cout << "satisfying assertion " << curDecl->get_uniqueId() << " ";
+                                        curDecl->print( std::cout );
+                                        std::cout << " with declaration " << (*candidate)->get_uniqueId() << " ";
+                                        (*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
+                                appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
+                        } else {
+                                delete adjType;
+                        }
                 }
         }
@@ -509 +509 @@
                         std::cout << "============= new indexer" << std::endl;
                         decls.print( std::cout );
-                        )
-                        addToIndexer( have, decls );
+                )
+                addToIndexer( have, decls );
                 AssertionSet newNeed;
                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
@@ -533 +533 @@
                                 std::cout << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cout, 8 );
-                                )
-                                inferParameters( resultNeed, resultHave, newAlt, openVars, out );
+                        )
+                        inferParameters( resultNeed, resultHave, newAlt, openVars, out );
                 }
         }
@@ -570 +570 @@
                                 std::cout << "working on alternative: " << std::endl;
                                 func->print( std::cout, 8 );
-                                )
-                                // check if the type is pointer to function
-                                PointerType *pointer;
+                        )
+                        // check if the type is pointer to function
+                        PointerType *pointer;
                         if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
@@ -603 +603 @@
                                                 std::cout << "known function ops:" << std::endl;
                                                 printAlts( funcOpFinder.alternatives, std::cout, 8 );
-                                                )
-                                                }
+                                        )
+                                }
 
                                 for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
@@ -642 +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();
@@ -737 +737 @@
                 indexer.lookupId( nameExpr->get_name(), declList );
                 PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
-                        for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
-                                VariableExpr newExpr( *i, nameExpr->get_argName() );
-                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
-                                PRINT(
-                                        std::cerr << "decl is ";
-                                        (*i)->print( std::cerr );
-                                        std::cerr << std::endl;
-                                        std::cerr << "newExpr is ";
-                                        newExpr.print( std::cerr );
-                                        std::cerr << std::endl;
-                                        )
-                                        renameTypes( alternatives.back().expr );
-                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                                        addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
-                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                                        addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
-                                } // if
-                        } // for
+                for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
+                        VariableExpr newExpr( *i, nameExpr->get_argName() );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                        PRINT(
+                                std::cerr << "decl is ";
+                                (*i)->print( std::cerr );
+                                std::cerr << std::endl;
+                                std::cerr << "newExpr is ";
+                                newExpr.print( std::cerr );
+                                std::cerr << std::endl;
+                        )
+                        renameTypes( alternatives.back().expr );
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                        } // if
+                } // for
         }
 
@@ -794 +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
         }