---

expr_result.cc

Go to the documentation of this file.

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

#include "expr_result.h"
#include "expr_result_i.h"


#line 126 "expr_result.cpp"

void
Expr_result::set_value(Ptree* value, Type t)
{
    assert(t.is_valid());

    tree = value;
    obj_tree = 0;
    symbol = 0;
    if (t.get_kind() == Type::k_Reference) {
        type = t.get_basis_type();
        kind = k_LValue;
    } else {
        type = t;
        kind = k_RValue;
    }
}

#line 143 "expr_result.cpp"

void
Expr_result::convert_to_rvalue()
{
    if (!type.is_valid()) {
        compile_error("attempt to access value of an expression without type");
    } else if (!is_lvalue()) {
        /* intentionally left blank */
    } else if (type.get_kind() != Type::k_Array && type.get_kind() != Type::k_Function) {
        if (!type.is_complete())
            compile_error("attempt to access object of incomplete type");
        if (!type.is_class_type())
            convert_to(type.get_unqualified_type());
        kind = k_RValue;
    }
}

#line 160 "expr_result.cpp"

void
Expr_result::convert_to_pointer()
{
    if (!type.is_valid()) {
        compile_error("attempt to access value of an expression without type");
    } else if (type.get_kind() == Type::k_Array) {
        /* FIXME: the string-literal-to-unqualified-pointer conversion
           is NOT handled (yet) because it's deprecated. */
        convert_to(type.get_basis_type().make_pointer_type());
        kind = k_RValue;
    }
}

#line 174 "expr_result.cpp"

void
Expr_result::convert_to_fpointer()
{
    if (!type.is_valid()) {
        compile_error("attempt to access value of an expression without type");
    } else if (type.get_kind() == Type::k_Function) {
        convert_to(type.make_pointer_type());
        kind = k_RValue;
    }
}

#line 194 "expr_result.cpp"

/* Missing: 4.6 to 4.9 */

void
Expr_result::convert_to_bool()
{
    do_std_conversions();
    if (type.is_arithmetic_type() || type.is_enum_type() || type.get_kind() == Type::k_Pointer || type.get_kind() == Type::k_Member) {
        convert_to(bool_type);
    } else {
        compile_error("unable to convert `" + type.get_human_readable_type() + "' to bool");
    }
}

#line 208 "expr_result.cpp"

void
Expr_result::adjust_reference()
{
    if (type.get_kind() == Type::k_Reference) {
        convert_to(type.get_basis_type());
        kind = k_LValue;
    }
}

#line 218 "expr_result.cpp"

void
Expr_result::do_std_conversions()
{
    convert_to_rvalue();
    convert_to_pointer();
    convert_to_fpointer();
}

#line 228 "expr_result.cpp"

bool
Expr_result::is_modifyable_lvalue() const
{
    return kind == k_LValue && !type.is_qualified(Type::q_Const);
}

#line 234 "expr_result.cpp"

bool
Expr_result::is_npc() const
{
    using namespace std;

    if (!type.is_int() || !tree)
        return false;

    /* only literal nulls allowed */
    if (Leaf* l = dynamic_cast<Leaf*>(tree)) {
        char* c = l->ToString();
        if (*c == '0' && c[strspn(c, "0xXuUlL")] == 0)
            return true;
    }
    return false;
}

---