---

implicit_conversion.h

Go to the documentation of this file.

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

#ifndef implicit_conversion_h
#define implicit_conversion_h

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

//
// INTERFACE definition follows 
//


class Function_signature;
typedef std::map<Function_signature*, int> Conversion_op_map;

struct ICS_Types {
    enum Action {
        a_NullStep,

        /* table 9 in 13.3.3.1.1 */
        a_LValueToRValue,
        a_ArrayToPointer,
        a_FunctionToPointer,
        a_QualificationAdjustment,
        a_IntegralPromotion,
        a_FloatingPromotion,
        a_IntegralConversion,
        a_FloatingConversion,
        a_FloatingIntegralConversion,
        a_PointerConversion,
        a_PtrMemConversion,
        a_BoolConversion,
        a_DerivedToBaseConversion,

        /* user-defined ICS */
        a_CtorCall,
        a_ConversionOp,

        a_Ellipsis,

        a_BindReferenceToTemporary
//        a_OverloadResolution
    };

    enum Form {
        f_NoForm,               // used by steps which don't affect the form
        f_Standard,
        f_Userdef,
        f_Ellipsis
    };

    enum Rank {
        r_NoRank,               // used by steps which don't affect the rank
        r_Exact,
        r_Promotion,
        r_Conversion
    };

    enum Compare {
        c_CompareAll,
        c_CompareWithInitRules,
        c_CompareBeforeUserConversion
    };
    typedef Expr_result::Kind Kind;
};

struct ICS_Step : ICS_Types {
    Type                type;
    Kind                kind;
    Function_signature* function;
    Action              action;

    ICS_Step(Type type, Kind kind, Action action)
        : type(type), kind(kind), function(0), action(action) { }
    ICS_Step(Type type, Kind kind, Function_signature* function, Action action)
        : type(type), kind(kind), function(function), action(action) { }

public:  
  ICS_Step::Rank get_rank() const;
  
  ICS_Step::Form get_form() const;
  
  /*inline*/ bool
  is_lvalue_transformation() const;
  
  void dump(std::ostream& os) const;

private:  
  const char* get_action_name() const;
};


class Implicit_conversion : public LightObject, public ICS_Types {
 public:
    typedef ICS_Step           Step;
    typedef std::vector<Step>  Step_vec;
 private:
    Step_vec                   steps;

    std::string                warnings;

    bool                       maybe_npc;

    /* status */
    Form         form;
    Rank         rank;
    bool         ambiguous;
 public:
    Form get_form() const     { return form; }
    Rank get_rank() const     { return rank; }
    bool is_ambiguous() const { return ambiguous; }
    void set_ambiguous()      { ambiguous = true; }

public:  
  /************************** Implicit_conversion **************************/
  
  Implicit_conversion(const Expr_result& result, Function_signature* symbol_hint);
  
  ~Implicit_conversion();
  
  const Implicit_conversion::Step& get_current();
  
  bool is_npc() const;
  
  void warn_if_used(std::string s);
  
  void add_step(Step s);
  
  void add_conversion(Action a, Type t);
  
  bool convert_to_rvalue(Type target);
  
  void dump(std::ostream& os);
  
  bool uses_temporary() const;
  
  bool is_better_than(Implicit_conversion* other, Compare comparison_type);
  
  Expr_result make_tree(Expr_result expr);
  
  bool convert_reference(Type target);
  
  void append_from(Implicit_conversion* other);

private:  
  static bool scs_is_better_than(Step_vec::const_iterator a1, Step_vec::const_iterator e1, Step_vec::const_iterator a2, Step_vec::const_iterator e2);
};

/******************************* Functions *******************************/
void enumerate_conversion_ops(const Expr_result& expr, Conversion_op_map* output);

void gen_candidates(Expr_result expr, Type arg_type, Function_signature* symbol_hint, bool with_userdef, bool is_object, std::vector<Implicit_conversion*>* candidates);

Implicit_conversion* generate_implicit_conversion(Expr_result expr, Type arg_type, Function_signature* symbol_hint, bool with_userdef, bool is_copy_initialisation, bool is_implicit_object_arg);

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



inline const Implicit_conversion::Step&
Implicit_conversion::get_current()
{
    return steps.back();
}


inline bool
Implicit_conversion::is_npc() const
{
    return maybe_npc;
}

#endif // implicit_conversion_h

---