---

expr_result.h

Go to the documentation of this file.

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

#ifndef expr_result_h
#define expr_result_h

#include <ptree.h>
#include "annotation.h"
#include "type_rep.h"

//
// INTERFACE definition follows 
//


class Function_symbol;
struct Expr_result {
    struct Dummy;
    enum Kind {
        k_RValue,
        k_LValue,
        k_Function,
        k_BoundMember,
        k_BoundPMF
    };

 private:
    Ptree*            tree;     // result tree
    Type              type;     // result type
    Function_symbol*  symbol;   // function symbol, if result is an ambiguous function name
    Kind              kind;
    Ptree*            obj_tree; // associated object for a member function call
 public:
    Ptree*           get_tree() const { return tree; }
    const Type&      get_type() const { return type; }
    Function_symbol* get_function() const { return symbol; }
    Kind             get_kind() const { return kind; }
    Ptree*           get_object() const { return obj_tree; }

    bool is_function()     const { return kind == k_Function; }
    bool is_bound_member() const { return kind == k_BoundMember || kind == k_BoundPMF; }
    bool is_bound_pmf()    const { return kind == k_BoundPMF; }

    void set_kind(Kind k) { kind = k; }
    void set_tree(Ptree* t) { tree = t; }

    /* /symbol/ deserves an explanation: at certain places, an
       overloaded function name can appear. According to 13.4:
       - initializer for a variable
       - RHS of an assignment
       - parameter of a function
       - parameter of a user-defined operator
       - return value
       - in a type cast (i.e. `(int (*)(int)) foo')
       - inside a pair of parens which is one of the above
       When we encounter such a case, type.is_valid() will be false
       (and Kind will be k_Function) and symbol will point to the
       function being used/called. At all other places, we reject
       overloaded functions.

       When a symbol like this is found in one of the above cases,
       the caller must figure out what it is, and annotate it. */

    /* Invariant: type is never a reference */
    /* Invariant: type.is_valid() == (kind == k_LValue || kind == k_RValue) */

    // these two are needed by Paranoid_visitor & friends
    Expr_result() : tree(0), type(), symbol(), obj_tree(0) { }
    Expr_result(Dummy*) : tree(0), type(), symbol(), obj_tree(0) { }

    // normal expression value
    template<class T>
    Expr_result(Annotated<T>* tree, Kind k)
        : tree(tree), type(tree->get_type()), symbol(0), kind(k), obj_tree(0)
        { assert(type.is_valid()); }

    Expr_result(Ptree* tree, Type t, Kind k)
        : tree(tree), type(t), symbol(0), kind(k), obj_tree(0)
        { assert(type.is_valid()); }

    // function symbol
    template<class T>
    Expr_result(Annotated<T>* tree, Function_symbol* sym)
        : tree(tree), type(), symbol(sym), kind(k_Function), obj_tree(0) { }

    // bound member function
    Expr_result(Ptree* object, Ptree* function, Function_symbol* sym)
        : tree(function), type(), symbol(sym), kind(k_BoundMember), obj_tree(object) { }

    Expr_result(Ptree* object, Ptree* function, Type t)
        : tree(function), type(t), symbol(0), kind(k_BoundPMF), obj_tree(object) { }

public:  
  bool is_lvalue() const;
  
  bool is_value() const;
  
  void convert_to(Type t);
  
  void convert_to_qual(Type t);
  
  void set_value(Ptree* value, Type t);
  
  void convert_to_rvalue();
  
  void convert_to_pointer();
  
  void convert_to_fpointer();
  
  void do_integral_promotions();
  
  /* Missing: 4.6 to 4.9 */
  
  void convert_to_bool();
  
  void adjust_reference();
  
  void do_std_conversions();
  
  bool is_modifyable_lvalue() const;
  
  bool is_npc() const;
};

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



inline bool
Expr_result::is_lvalue() const
{
    return kind == k_LValue;
}


inline bool
Expr_result::is_value() const
{
    return kind == k_LValue || kind == k_RValue;
}


inline void
Expr_result::convert_to(Type t)
{
    assert(t.is_valid() && !t.is_class_type());
    if (t != type) {
        set_value(make_cast_expr(tree, t), t);
    }
}


inline void
Expr_result::convert_to_qual(Type t)
{
    assert(t.is_valid() && t.is_same_unqualified_type(type));
    if (t != type)
        set_value(make_cast_expr_unchecked(tree, t), t);
}


inline void
Expr_result::do_integral_promotions()
{
    convert_to_rvalue();
    convert_to(type.get_promoted_integer());
}

#endif // expr_result_h

---