---

overload_resolver.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef overload_resolver_h
#define overload_resolver_h

#include <vector>
#include <types.h>
#include <iosfwd>
#include "expr_result.h"

//
// INTERFACE definition follows 
//


class Implicit_conversion;
class Function_signature;
class Function_symbol;
class Overload_resolver;
struct Overload_candidate : public LightObject {
    Function_signature*                fsig;
    std::vector<Implicit_conversion*>  args;

public:  
  /********************** Overload_resolver::Candidate *********************/
  Overload_candidate(Function_signature* sig);
  
  ~Overload_candidate();
  
  bool is_better_than(Overload_candidate* other);
  
  void fill_in_tree(Overload_resolver* resolver);
};    

class Overload_resolver {
 public:
    typedef Overload_candidate Candidate;
 private:
    std::vector<Candidate*> candidates;

    bool                      have_object;
    bool                      is_operator;
    /* parameters. If there is an implicit object argument, it
       is first in this list. */
    std::vector<Expr_result>  args;

    friend class Overload_candidate;

public:  
  /*************************** Overload_resolver ***************************/
  Overload_resolver(bool is_operator);
  
  void add_arg(const Expr_result& res);
  
  void set_object(const Expr_result& res);
  
  bool is_object() const;
  
  void add_signature(Function_signature* sig);
  
  void add_signature_with_type(Function_signature* sig, Type t);
  
  void add_builtin_incdec(bool is_increment);
  
  void add_builtin_unary_ops(Type (*predicate)(Type t));
  
  void add_builtin_binary_ops(Type (*predicate)(Type t1, Type t2));
  
  void add_function(Function_symbol* fsym, bool allow_dups);
  
  Overload_candidate* get_best(bool* is_ambig);
  
  unsigned get_arg_count() const;
  
  void dump(std::ostream& os);
  
  Expr_result& get_arg(int i);

private:  
  bool have_signature(Function_signature* fsig, unsigned limit);
};

//
// IMPLEMENTATION of inline functions (and needed classes)
//



inline bool
Overload_resolver::is_object() const
{
    return have_object;    
}


inline unsigned
Overload_resolver::get_arg_count() const
{
    return args.size();
}


inline Expr_result&
Overload_resolver::get_arg(int i)
{
    return args[i];
}

#endif // overload_resolver_h

---