/* Evaluate expressions for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
fieldno++;
/* Skip static fields. */
- while (fieldno < TYPE_NFIELDS (struct_type)
- && field_is_static (&TYPE_FIELD (struct_type,
- fieldno)))
+ while (fieldno < struct_type->num_fields ()
+ && field_is_static (&struct_type->field (fieldno)))
fieldno++;
- if (fieldno >= TYPE_NFIELDS (struct_type))
+ if (fieldno >= struct_type->num_fields ())
error (_("too many initializers"));
field_type = TYPE_FIELD_TYPE (struct_type, fieldno);
- if (TYPE_CODE (field_type) == TYPE_CODE_UNION
+ if (field_type->code () == TYPE_CODE_UNION
&& TYPE_FIELD_NAME (struct_type, fieldno)[0] == '0')
error (_("don't know which variant you want to set"));
/* Recursive helper function for setting elements of array tuples.
The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND); the
element value is ELEMENT; EXP, POS and NOSIDE are as usual.
- Evaluates index expresions and sets the specified element(s) of
+ Evaluates index expressions and sets the specified element(s) of
ARRAY to ELEMENT. Returns last index value. */
static LONGEST
type1 = check_typedef (value_type (*arg1));
type2 = check_typedef (value_type (*arg2));
- if ((TYPE_CODE (type1) != TYPE_CODE_FLT
- && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+ if ((type1->code () != TYPE_CODE_FLT
+ && type1->code () != TYPE_CODE_DECFLOAT
&& !is_integral_type (type1))
- || (TYPE_CODE (type2) != TYPE_CODE_FLT
- && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+ || (type2->code () != TYPE_CODE_FLT
+ && type2->code () != TYPE_CODE_DECFLOAT
&& !is_integral_type (type2)))
return;
- if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
- || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+ if (type1->code () == TYPE_CODE_DECFLOAT
+ || type2->code () == TYPE_CODE_DECFLOAT)
{
/* No promotion required. */
}
- else if (TYPE_CODE (type1) == TYPE_CODE_FLT
- || TYPE_CODE (type2) == TYPE_CODE_FLT)
+ else if (type1->code () == TYPE_CODE_FLT
+ || type2->code () == TYPE_CODE_FLT)
{
switch (language->la_language)
{
break;
}
}
- else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
- && TYPE_CODE (type2) == TYPE_CODE_BOOL)
+ else if (type1->code () == TYPE_CODE_BOOL
+ && type2->code () == TYPE_CODE_BOOL)
{
/* No promotion required. */
}
break;
case language_opencl:
if (result_len <= TYPE_LENGTH (lookup_signed_typename
- (language, gdbarch, "int")))
+ (language, "int")))
{
promoted_type =
(unsigned_operation
- ? lookup_unsigned_typename (language, gdbarch, "int")
- : lookup_signed_typename (language, gdbarch, "int"));
+ ? lookup_unsigned_typename (language, "int")
+ : lookup_signed_typename (language, "int"));
}
else if (result_len <= TYPE_LENGTH (lookup_signed_typename
- (language, gdbarch, "long")))
+ (language, "long")))
{
promoted_type =
(unsigned_operation
- ? lookup_unsigned_typename (language, gdbarch, "long")
- : lookup_signed_typename (language, gdbarch,"long"));
+ ? lookup_unsigned_typename (language, "long")
+ : lookup_signed_typename (language,"long"));
}
break;
default:
if (TYPE_IS_REFERENCE (type))
type = TYPE_TARGET_TYPE (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_FUNC:
TYPE_MAIN_TYPE (type) = &m_main_type;
TYPE_LENGTH (type) = 1;
- TYPE_CODE (type) = TYPE_CODE_METHOD;
+ type->set_code (TYPE_CODE_METHOD);
TYPE_CHAIN (type) = type;
TYPE_INSTANCE_FLAGS (type) = flags;
if (num_types > 0)
--num_types;
TYPE_VARARGS (type) = 1;
}
- else if (TYPE_CODE (check_typedef (param_types[num_types - 1]))
+ else if (check_typedef (param_types[num_types - 1])->code ()
== TYPE_CODE_VOID)
{
--num_types;
neither an objfile nor a gdbarch. As a result we must manually
allocate memory for auxiliary fields, and free the memory ourselves
when we are done with it. */
- TYPE_NFIELDS (type) = num_types;
- TYPE_FIELDS (type) = (struct field *)
- xzalloc (sizeof (struct field) * num_types);
+ type->set_num_fields (num_types);
+ type->set_fields
+ ((struct field *) xzalloc (sizeof (struct field) * num_types));
while (num_types-- > 0)
TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
fake_method::~fake_method ()
{
- xfree (TYPE_FIELDS (&m_type));
+ xfree (m_type.fields ());
}
/* Helper for evaluating an OP_VAR_VALUE. */
type *ftype = value_type (argvec[0]);
- if (TYPE_CODE (ftype) == TYPE_CODE_INTERNAL_FUNCTION)
+ if (ftype->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
/* We don't know anything about what the internal
function might return, but we have to return
return value_zero (builtin_type (exp->gdbarch)->builtin_int,
not_lval);
}
- else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
+ else if (ftype->code () == TYPE_CODE_XMETHOD)
{
type *return_type
= result_type_of_xmethod (argvec[0],
error (_("Xmethod is missing return type."));
return value_zero (return_type, not_lval);
}
- else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
- || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
+ else if (ftype->code () == TYPE_CODE_FUNC
+ || ftype->code () == TYPE_CODE_METHOD)
{
if (TYPE_GNU_IFUNC (ftype))
{
error (_("Expression of type other than "
"\"Function returning ...\" used as function"));
}
- switch (TYPE_CODE (value_type (argvec[0])))
+ switch (value_type (argvec[0])->code ())
{
case TYPE_CODE_INTERNAL_FUNCTION:
return call_internal_function (exp->gdbarch, exp->language_defn,
if (noside == EVAL_SKIP)
tem = 1; /* Set it to the right arg index so that all
arguments can also be skipped. */
- else if (TYPE_CODE (a1_type) == TYPE_CODE_METHODPTR)
+ else if (a1_type->code () == TYPE_CODE_METHODPTR)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
arg1 = value_zero (TYPE_TARGET_TYPE (a1_type), not_lval);
tem = 2;
argvec[1] = arg2;
}
- else if (TYPE_CODE (a1_type) == TYPE_CODE_MEMBERPTR)
+ else if (a1_type->code () == TYPE_CODE_MEMBERPTR)
{
struct type *type_ptr
= lookup_pointer_type (TYPE_SELF_TYPE (a1_type));
function = NULL;
function_name = NULL;
- if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
+ if (type->code () == TYPE_CODE_NAMESPACE)
{
- function = cp_lookup_symbol_namespace (TYPE_NAME (type),
+ function = cp_lookup_symbol_namespace (type->name (),
name,
get_selected_block (0),
VAR_DOMAIN).symbol;
if (function == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
- name, TYPE_NAME (type));
+ name, type->name ());
tem = 1;
/* arg2 is left as NULL on purpose. */
}
else
{
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION);
+ gdb_assert (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION);
function_name = name;
/* We need a properly typed value for method lookup. For
if (op == OP_VAR_MSYM_VALUE)
{
minimal_symbol *msym = exp->elts[*pos + 2].msymbol;
- var_func_name = MSYMBOL_PRINT_NAME (msym);
+ var_func_name = msym->print_name ();
}
else if (op == OP_VAR_VALUE)
{
symbol *sym = exp->elts[*pos + 2].symbol;
- var_func_name = SYMBOL_PRINT_NAME (sym);
+ var_func_name = sym->print_name ();
}
argvec[0] = evaluate_subexp_with_coercion (exp, pos, noside);
type *type = value_type (argvec[0]);
- if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type && type->code () == TYPE_CODE_PTR)
type = TYPE_TARGET_TYPE (type);
- if (type && TYPE_CODE (type) == TYPE_CODE_FUNC)
+ if (type && type->code () == TYPE_CODE_FUNC)
{
- for (; tem <= nargs && tem <= TYPE_NFIELDS (type); tem++)
+ for (; tem <= nargs && tem <= type->num_fields (); tem++)
{
argvec[tem] = evaluate_subexp (TYPE_FIELD_TYPE (type,
tem - 1),
evaluate_subexp (NULL_TYPE, exp, pos, noside);
}
+/* Return true if type is integral or reference to integral */
+
+static bool
+is_integral_or_integral_reference (struct type *type)
+{
+ if (is_integral_type (type))
+ return true;
+
+ type = check_typedef (type);
+ return (type != nullptr
+ && TYPE_IS_REFERENCE (type)
+ && is_integral_type (TYPE_TARGET_TYPE (type)));
+}
+
struct value *
evaluate_subexp_standard (struct type *expect_type,
struct expression *exp, int *pos,
{
(*pos) += 3;
symbol *var = exp->elts[pc + 2].symbol;
- if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
- error_unknown_type (SYMBOL_PRINT_NAME (var));
+ if (SYMBOL_TYPE (var)->code () == TYPE_CODE_ERROR)
+ error_unknown_type (var->print_name ());
if (noside != EVAL_SKIP)
return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
else
msymbol);
type = value_type (val);
- if (TYPE_CODE (type) == TYPE_CODE_ERROR
+ if (type->code () == TYPE_CODE_ERROR
&& (noside != EVAL_AVOID_SIDE_EFFECTS || pc != 0))
- error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+ error_unknown_type (msymbol->print_name ());
return val;
}
if (SYMBOL_COMPUTED_OPS (sym) == NULL
|| SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
error (_("Symbol \"%s\" does not have any specific entry value"),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
frame = get_selected_frame (NULL);
return SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry (sym, frame);
type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ && type->code () == TYPE_CODE_STRUCT)
{
struct value *rec = allocate_value (expect_type);
}
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ && type->code () == TYPE_CODE_ARRAY)
{
struct type *range_type = TYPE_INDEX_TYPE (type);
struct type *element_type = TYPE_TARGET_TYPE (type);
}
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
- && TYPE_CODE (type) == TYPE_CODE_SET)
+ && type->code () == TYPE_CODE_SET)
{
struct value *set = allocate_value (expect_type);
gdb_byte *valaddr = value_contents_raw (set);
LONGEST low_bound, high_bound;
/* Get targettype of elementtype. */
- while (TYPE_CODE (check_type) == TYPE_CODE_RANGE
- || TYPE_CODE (check_type) == TYPE_CODE_TYPEDEF)
+ while (check_type->code () == TYPE_CODE_RANGE
+ || check_type->code () == TYPE_CODE_TYPEDEF)
check_type = TYPE_TARGET_TYPE (check_type);
if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
/* Check types of elements to avoid mixture of elements from
different types. Also check if type of element is "compatible"
with element type of powerset. */
- if (TYPE_CODE (range_low_type) == TYPE_CODE_RANGE)
+ if (range_low_type->code () == TYPE_CODE_RANGE)
range_low_type = TYPE_TARGET_TYPE (range_low_type);
- if (TYPE_CODE (range_high_type) == TYPE_CODE_RANGE)
+ if (range_high_type->code () == TYPE_CODE_RANGE)
range_high_type = TYPE_TARGET_TYPE (range_high_type);
- if ((TYPE_CODE (range_low_type) != TYPE_CODE (range_high_type))
- || (TYPE_CODE (range_low_type) == TYPE_CODE_ENUM
+ if ((range_low_type->code () != range_high_type->code ())
+ || (range_low_type->code () == TYPE_CODE_ENUM
&& (range_low_type != range_high_type)))
/* different element modes. */
error (_("POWERSET tuple elements of different mode"));
- if ((TYPE_CODE (check_type) != TYPE_CODE (range_low_type))
- || (TYPE_CODE (check_type) == TYPE_CODE_ENUM
+ if ((check_type->code () != range_low_type->code ())
+ || (check_type->code () == TYPE_CODE_ENUM
&& range_low_type != check_type))
error (_("incompatible POWERSET tuple elements"));
if (range_low > range_high)
{
int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
- if (gdbarch_bits_big_endian (exp->gdbarch))
+ if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG)
bit_index = TARGET_CHAR_BIT - 1 - bit_index;
valaddr[(unsigned) range_low / TARGET_CHAR_BIT]
|= 1 << bit_index;
block_for_pc (funaddr);
val_type = check_typedef (val_type);
-
- if ((val_type == NULL)
- || (TYPE_CODE(val_type) == TYPE_CODE_ERROR))
+
+ if ((val_type == NULL)
+ || (val_type->code () == TYPE_CODE_ERROR))
{
if (expect_type != NULL)
val_type = expect_type;
struct_return = using_struct_return (exp->gdbarch, NULL,
check_typedef (expect_type));
}
-
+
/* Found a function symbol. Now we will substitute its
value in place of the message dispatcher (obj_msgSend),
so that we call the method directly instead of thru
if (method)
{
- if (TYPE_CODE (value_type (method)) != TYPE_CODE_FUNC)
+ if (value_type (method)->code () != TYPE_CODE_FUNC)
error (_("method address has symbol information "
"with non-function type; skipping"));
struct type *callee_type = value_type (called_method);
- if (callee_type && TYPE_CODE (callee_type) == TYPE_CODE_PTR)
+ if (callee_type && callee_type->code () == TYPE_CODE_PTR)
callee_type = TYPE_TARGET_TYPE (callee_type);
callee_type = TYPE_TARGET_TYPE (callee_type);
if (callee_type)
{
- if ((TYPE_CODE (callee_type) == TYPE_CODE_ERROR) && expect_type)
+ if ((callee_type->code () == TYPE_CODE_ERROR) && expect_type)
return allocate_value (expect_type);
else
return allocate_value (callee_type);
/* First determine the type code we are dealing with. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
type = check_typedef (value_type (arg1));
- code = TYPE_CODE (type);
+ code = type->code ();
if (code == TYPE_CODE_PTR)
{
to the target value the original one points to. */
struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (target_type) == TYPE_CODE_ARRAY
- || TYPE_CODE (target_type) == TYPE_CODE_STRING
- || TYPE_CODE (target_type) == TYPE_CODE_FUNC)
+ if (target_type->code () == TYPE_CODE_ARRAY
+ || target_type->code () == TYPE_CODE_STRING
+ || target_type->code () == TYPE_CODE_FUNC)
{
arg1 = value_ind (arg1);
type = check_typedef (value_type (arg1));
- code = TYPE_CODE (type);
+ code = type->code ();
}
}
get_user_print_options (&opts);
if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
- && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_STRUCT))
+ && (TYPE_TARGET_TYPE (arg_type)->code () == TYPE_CODE_STRUCT))
{
real_type = value_rtti_indirect_type (arg1, &full, &top,
&using_enc);
return eval_skip_value (exp);
type = check_typedef (value_type (arg2));
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_METHODPTR:
if (noside == EVAL_AVOID_SIDE_EFFECTS)
else
{
arg2 = cplus_method_ptr_to_value (&arg1, arg2);
- gdb_assert (TYPE_CODE (value_type (arg2)) == TYPE_CODE_PTR);
+ gdb_assert (value_type (arg2)->code () == TYPE_CODE_PTR);
return value_ind (arg2);
}
case BINOP_ASSIGN:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
+ /* Special-case assignments where the left-hand-side is a
+ convenience variable -- in these, don't bother setting an
+ expected type. This avoids a weird case where re-assigning a
+ string or array to an internal variable could error with "Too
+ many array elements". */
+ arg2 = evaluate_subexp (VALUE_LVAL (arg1) == lval_internalvar
+ ? NULL_TYPE : value_type (arg1),
+ exp, pos, noside);
if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
return arg1;
if (binop_user_defined_p (op, arg1, arg2))
return value_x_binop (arg1, arg2, op, OP_NULL, noside);
else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ && is_integral_or_integral_reference (value_type (arg2)))
return value_ptradd (arg1, value_as_long (arg2));
else if (ptrmath_type_p (exp->language_defn, value_type (arg2))
- && is_integral_type (value_type (arg1)))
+ && is_integral_or_integral_reference (value_type (arg1)))
return value_ptradd (arg2, value_as_long (arg1));
else
{
return value_from_longest (type, value_ptrdiff (arg1, arg2));
}
else if (ptrmath_type_p (exp->language_defn, value_type (arg1))
- && is_integral_type (value_type (arg2)))
+ && is_integral_or_integral_reference (value_type (arg2)))
return value_ptradd (arg1, - value_as_long (arg2));
else
{
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY
- && TYPE_CODE (type) != TYPE_CODE_PTR)
+ if (type->code () != TYPE_CODE_ARRAY
+ && type->code () != TYPE_CODE_PTR)
{
- if (TYPE_NAME (type))
+ if (type->name ())
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (type));
+ type->name ());
else
error (_("cannot subscript requested type"));
}
else
{
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (value_type (arg1)));
+ value_type (arg1)->name ());
}
}
arg1 = coerce_ref (arg1);
type = check_typedef (value_type (arg1));
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_ARRAY:
break;
default:
- if (TYPE_NAME (type))
+ if (type->name ())
error (_("cannot subscript something of type `%s'"),
- TYPE_NAME (type));
+ type->name ());
else
error (_("cannot subscript requested type"));
}
if (noside == EVAL_SKIP)
return eval_skip_value (exp);
type = check_typedef (value_type (arg2));
- if (TYPE_CODE (type) != TYPE_CODE_INT
- && TYPE_CODE (type) != TYPE_CODE_ENUM)
+ if (type->code () != TYPE_CODE_INT
+ && type->code () != TYPE_CODE_ENUM)
error (_("Non-integral right operand for \"@\" operator."));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
}
case UNOP_IND:
- if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
+ if (expect_type && expect_type->code () == TYPE_CODE_PTR)
expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) == TYPE_CODE_METHODPTR
- || TYPE_CODE (type) == TYPE_CODE_MEMBERPTR)
+ if (type->code () == TYPE_CODE_METHODPTR
+ || type->code () == TYPE_CODE_MEMBERPTR)
error (_("Attempt to dereference pointer "
"to member without an object"));
if (noside == EVAL_SKIP)
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
type = check_typedef (value_type (arg1));
- if (TYPE_CODE (type) == TYPE_CODE_PTR
+ if (type->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (type)
/* In C you can dereference an array to get the 1st elt. */
- || TYPE_CODE (type) == TYPE_CODE_ARRAY
+ || type->code () == TYPE_CODE_ARRAY
)
return value_zero (TYPE_TARGET_TYPE (type),
lval_memory);
- else if (TYPE_CODE (type) == TYPE_CODE_INT)
+ else if (type->code () == TYPE_CODE_INT)
/* GDB allows dereferencing an int. */
return value_zero (builtin_type (exp->gdbarch)->builtin_int,
lval_memory);
This returns an int, which seems like the most C-like thing to
do. "long long" variables are rare enough that
BUILTIN_TYPE_LONGEST would seem to be a mistake. */
- if (TYPE_CODE (type) == TYPE_CODE_INT)
+ if (type->code () == TYPE_CODE_INT)
return value_at_lazy (builtin_type (exp->gdbarch)->builtin_int,
(CORE_ADDR) value_as_address (arg1));
return value_ind (arg1);
case OP_VAR_VALUE:
var = exp->elts[pc + 2].symbol;
type = check_typedef (SYMBOL_TYPE (var));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& !TYPE_VECTOR (type)
&& CAST_IS_CONVERSION (exp->language_defn))
{
(*pos)++;
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
- if (TYPE_CODE (type) != TYPE_CODE_PTR
+ if (type->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type)
- && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ && type->code () != TYPE_CODE_ARRAY)
error (_("Attempt to take contents of a non-pointer value."));
type = TYPE_TARGET_TYPE (type);
if (is_dynamic_type (type))
{
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
type = value_type (val);
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+ if (type->code () == TYPE_CODE_ARRAY
&& is_dynamic_type (TYPE_INDEX_TYPE (type))
&& TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type)))
return allocate_optimized_out_value (size_type);
msymbol);
type = value_type (mval);
- if (TYPE_CODE (type) == TYPE_CODE_ERROR)
- error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
+ if (type->code () == TYPE_CODE_ERROR)
+ error_unknown_type (msymbol->print_name ());
return value_from_longest (size_type, TYPE_LENGTH (type));
}
val = evaluate_subexp (NULL_TYPE, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
type = check_typedef (value_type (val));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
type = check_typedef (TYPE_TARGET_TYPE (type));
- if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+ if (type->code () == TYPE_CODE_ARRAY)
{
type = TYPE_INDEX_TYPE (type);
/* Only re-evaluate the right hand side if the resulting type
int ndimen = 1;
struct type *tmp_type;
- if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))
+ if ((array_type->code () != TYPE_CODE_ARRAY))
error (_("Can't get dimensions for a non-array type"));
tmp_type = array_type;
while ((tmp_type = TYPE_TARGET_TYPE (tmp_type)))
{
- if (TYPE_CODE (tmp_type) == TYPE_CODE_ARRAY)
+ if (tmp_type->code () == TYPE_CODE_ARRAY)
++ndimen;
}
return ndimen;
projects / deliverable / binutils-gdb.git / blobdiff