source: translator/ResolvExpr/AlternativeFinder.h @ 8c17ab0

/*
 * This file is part of the Cforall project
 *
 * $Id: AlternativeFinder.h,v 1.19 2005/08/29 20:14:15 rcbilson Exp $
 *
 */

#ifndef RESOLVEXPR_ALTERNATIVEFINDER_H
#define RESOLVEXPR_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;
};

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

} // namespace ResolvExpr

#endif /* #ifndef RESOLVEXPR_ALTERNATIVEFINDER_H */