source: translator/ResolvExpr/AlternativeFinder.h @ 02e9ae2

#ifndef ALTERNATIVEFINDER_H
#define ALTERNATIVEFINDER_H

#include <set>

#include "Alternative.h"
#include "Unify.h"
#include "SynTree/SynTree.h"
#include "SymTab/Indexer.h"
#include "SynTree/TypeSubstitution.h"

namespace ResolvExpr {
    class AlternativeFinder : public Visitor {
      public:
        AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
        void find( Expression *expr, bool adjust = false );
        void findWithAdjustment( Expression *expr );
        AltList &get_alternatives() { return alternatives; }
  
        // make this look like an STL container so that we can apply generic algorithms
        typedef Alternative value_type;
        typedef AltList::iterator iterator;
        typedef AltList::const_iterator const_iterator;
        AltList::iterator begin() { return alternatives.begin(); }
        AltList::iterator end() { return alternatives.end(); }
        AltList::const_iterator begin() const { return alternatives.begin(); }
        AltList::const_iterator end() const { return alternatives.end(); }
  
        const SymTab::Indexer &get_indexer() const { return indexer; }
        const TypeEnvironment &get_environ() const { return env; }
      private:
        virtual void visit( ApplicationExpr *applicationExpr );
        virtual void visit( UntypedExpr *untypedExpr );
        virtual void visit( AddressExpr *addressExpr );
        virtual void visit( CastExpr *castExpr );
        virtual void visit( UntypedMemberExpr *memberExpr );
        virtual void visit( MemberExpr *memberExpr );
        virtual void visit( NameExpr *variableExpr );
        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 );
      public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
        template< typename InputIterator, typename OutputIterator >
            void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );

      private:
        template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name );
        bool instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave );
        template< typename OutputIterator >
            void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out );
        template< typename OutputIterator >
            void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
        void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );

        const SymTab::Indexer &indexer;
        AltList alternatives;
        const TypeEnvironment &env;
    }; // AlternativeFinder

    Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
} // namespace ResolvExpr

#endif // ALTERNATIVEFINDER_H