Changeset 0f19d763 for src/ResolvExpr

Timestamp:

Jun 17, 2015, 4:17:37 PM (10 years ago)

Author:

Aaron Moss <a3moss@…>

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:

eb50842

Parents:

09d789c

Message:

Comments and indentation fixes

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (19 diffs)
• AlternativeFinder.h (modified) (1 diff)
• RenameVars.cc (modified) (3 diffs)
• RenameVars.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -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 +109 @@
                                                         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 {
@@ -124 +125 @@
                                 )
 
-                                // 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;
                                 }
+                        }
 
                 }
@@ -184 +185 @@
                                 printAlts( finder.alternatives, std::cout );
                                 )
-                                *out++ = finder;
+                        *out++ = finder;
                 }
         }
@@ -206 +207 @@
                         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 ) {
@@ -222 +223 @@
                         std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
                         )
-                        }
+        }
 
         void AlternativeFinder::findWithAdjustment( Expression *expr ) {
@@ -353 +354 @@
 
         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
@@ -382 +382 @@
                                         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++;
                         }
@@ -430 +430 @@
                                         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;
                         }
@@ -445 +445 @@
                         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; }
@@ -454 +454 @@
                                 std::cout << std::endl;
                                 )
-                                AssertionSet newHave, newerNeed( newNeed );
+                        AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
                         OpenVarSet newOpenVars( openVars );
@@ -467 +467 @@
                                 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 );
-                                        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;
-                                }
+                        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;
+                        }
                 }
         }
@@ -510 +510 @@
                         decls.print( std::cout );
                         )
-                        addToIndexer( have, decls );
+                addToIndexer( have, decls );
                 AssertionSet newNeed;
                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
@@ -534 +534 @@
                                 printAssertionSet( resultNeed, std::cout, 8 );
                                 )
-                                inferParameters( resultNeed, resultHave, newAlt, openVars, out );
+                        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()))
@@ -560 +562 @@
                 Tuples::TupleAssignSpotter tassign( this );
                 if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
-                        // take care of possible tuple assignments, or discard expression
+                        // TODO take care of possible tuple assignments, or discard expression
                         return;
                 } // else ...
@@ -571 +573 @@
                                 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() ) ) {
@@ -604 +606 @@
                                                 printAlts( funcOpFinder.alternatives, std::cout, 8 );
                                                 )
-                                                }
+                                }
 
                                 for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
@@ -737 +739 @@
                 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
         }
 

src/ResolvExpr/AlternativeFinder.h

@@ -30 +30 @@
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
                 void find( Expression *expr, bool adjust = false );
+                /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
                 void findWithAdjustment( Expression *expr );
                 AltList &get_alternatives() { return alternatives; }

src/ResolvExpr/RenameVars.cc

@@ -118 +118 @@
 ///     type->print( std::cout );
 ///     std::cout << std::endl;
+                        // copies current name mapping into new mapping
                         mapStack.push_front( mapStack.front() );
+                        // renames all "forall" type names to `_${level}_${name}'
                         for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 std::ostrstream output;
@@ -125 +127 @@
                                 mapStack.front()[ (*i)->get_name() ] = newname;
                                 (*i)->set_name( newname );
+                                // ditto for assertion names, the next level in
                                 level++;
                                 acceptAll( (*i)->get_assertions(), *this );
@@ -132 +135 @@
 
         void RenameVars::typeAfter( Type *type ) {
+                // clears name mapping added by typeBefore()
                 if ( ! type->get_forall().empty() ) {
                         mapStack.pop_front();

src/ResolvExpr/RenameVars.h

@@ -25 +25 @@
 
 namespace ResolvExpr {
+
+        /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
         class RenameVars : public Visitor {
           public: