---

expr_annotator.h

Go to the documentation of this file.

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

#ifndef expr_annotator_h
#define expr_annotator_h

#include "paranoid_visitor.h"
#include "expr_result.h"

//
// INTERFACE definition follows 
//


class Source;
class Symbol_table;
class Function_symbol;
class Abstract_scope;
class Overload_resolver;
class Expr_annotator : public Paranoid_visitor<Expr_result> {
    Abstract_scope* current_scope;
 public:
    static const int PTR_DELEGATION_LIMIT = 100;

public:  
  /***************************** Expr_annotator ****************************/
  Expr_annotator(Abstract_scope* scope, Source* source);
  
  Expr_result visit_infix(PtreeInfixExpr *p);
  
  /************************* Atoms (literal, names) ************************/
  
  Expr_result visit_leaf(Leaf* l);
  
  Expr_result visit_name(Ptree* p);
  
  Expr_result visit_this(LeafThis* p);
  
  /****************************** Parentheses ******************************/
  
  Expr_result visit_paren(PtreeParenExpr* e);
  
  /*************************** Postfix operators ***************************/
  
  Expr_result visit_postfix(PtreePostfixExpr* e);
  
  Expr_result visit_unary(PtreeUnaryExpr* e);
  
  Expr_result visit_delete(PtreeDeleteExpr* pde);
  
  /********************************** New **********************************/
  
  Expr_result visit_new(PtreeNewExpr* p_);
  
  Expr_result visit_sizeof(PtreeSizeofExpr* e);
  
  Expr_result visit_throw(PtreeThrowExpr* p);
  
  Expr_result visit_dotmember(PtreeDotMemberExpr* e);
  
  Expr_result visit_arrowmember(PtreeArrowMemberExpr* e);
  
  Expr_result visit_pm(PtreePmExpr* e);
  
  Expr_result visit_cond(PtreeCondExpr* p);
  
  Expr_result do_fstyle_cast(Type target, Ptree* arglist);
  
  void add_parms_from_arglist(Overload_resolver* resolver, Ptree* p);
  
  Expr_result visit_fstylecastexpr(PtreeFstyleCastExpr* e);
  
  Expr_result visit_funcall(PtreeFuncallExpr* e);
  
  Expr_result visit_cast(PtreeCastExpr* p);
  
  /* Visit brace. This simplifies initializer handling. */
  Expr_result visit_brace(PtreeBrace* b);
  
  Expr_result visit_assign(PtreeAssignExpr* p);
  
  Expr_result visit_array(PtreeArrayExpr* p);

private:  
  Expr_result visit_comma(PtreeCommaExpr* e);
  
  Expr_result process_binary_operator(Ptree* oper, Expr_result l, Expr_result r);
  
  // static Type
  // cast_to_enum_predicate(Type t)
  // {
  //     if (t.is_int() || t.is_enum_type())
  //         return make_unary_function_type(t, t);
  //     return Type();
  // }
  
  Expr_result process_unary_operator(Ptree* oper, Expr_result arg);
  
  /**************************** Member reference ***************************/
  
  Expr_result process_member_access(Expr_result lhs, Ptree* rhs_tree);
  
  Expr_result process_pm_expr(Expr_result lhs, const Expr_result& rhs);
  
  /************************ Function Call and Casts ************************/
  /**************************** Helper functions ***************************/
  
  // bool
  // convert_expr_to_bool(Expr_result* res)
  // {
  //     Implicit_conversion* ics = generate_implicit_conversion(*res, bool_type, 0,
  //                                                             true, false, false);
  //     if (!ics)
  //         return false;
  
  //     *res = ics->make_tree(*res);
  //     return true;
  // }
  
  // bool
  // convert_expr_to_integral(Expr_result* res)
  // {
  //     if (res->get_type().is_class_type()) {
  //         Overload_resolver resolver;
  //         resolver.add_arg(*res);
  //         resolver.add_builtin_unary_ops(cast_to_enum_predicate);
  //         if (!resolver.get_best(0))
  //             return false;
  //         *res = resolver.get_arg(0);
  //         return true;
  //     }
  //     if (res->get_type().is_int() || res->get_type().is_enum_type())
  //         return true;
  //     return false;
  // }
  
  Type get_cast_type(Ptree* type_args);
  
  Expr_result get_cast_expr(Ptree* tree);
  
  bool try_static_cast(Type target, bool enforce_const, Expr_result* res);
  
  /************************ These generate the trees ***********************/
  Expr_result do_dynamic_cast(Ptree* type_args, Ptree* cast_args);
  
  Expr_result do_reinterpret_cast(Ptree* type_args, Ptree* cast_args);
  
  Expr_result do_static_cast(Ptree* type_args, Ptree* cast_args);
  
  Expr_result do_const_cast(Ptree* type_args, Ptree* cast_args);
  
  Expr_result do_ccast(Type t, Ptree* arg);
  
  Expr_result do_funcall(Expr_result lhs, Ptree* arglist);
};

bool try_reinterpret_cast(Type t, bool enforce_const, Expr_result* res);

/******************************* Assignment ******************************/

Type binary_multeq_predicate(Type l, Type r);

Type binary_addeq_predicate(Type l, Type r);

Type binary_inteq_predicate(Type l, Type r);

#endif // expr_annotator_h

---