type = check_typedef (type);
- for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
+ for (i = type->num_fields () - 1; i >= nbases; i--)
{
- if (field_is_static (&TYPE_FIELD (type, i)))
+ if (field_is_static (&type->field (i)))
{
gen_static_field (ax, &value, type, i);
if (value.optimized_out)
{
int string_trace = 0;
if (ax->trace_string
- && TYPE_CODE (value->type) == TYPE_CODE_PTR
+ && value->type->code () == TYPE_CODE_PTR
&& c_textual_element_type (check_typedef (TYPE_TARGET_TYPE (value->type)),
's'))
string_trace = 1;
/* To trace C++ classes with static fields stored elsewhere. */
if (ax->tracing
- && (TYPE_CODE (value->type) == TYPE_CODE_STRUCT
- || TYPE_CODE (value->type) == TYPE_CODE_UNION))
+ && (value->type->code () == TYPE_CODE_STRUCT
+ || value->type->code () == TYPE_CODE_UNION))
gen_trace_static_fields (ax, value->type);
}
\f
ax_trace_quick (ax, TYPE_LENGTH (type));
}
- if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+ if (type->code () == TYPE_CODE_RANGE)
type = TYPE_TARGET_TYPE (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
type. Error out and give callers a chance to handle the failure
gracefully. */
error (_("gen_fetch: Unsupported type code `%s'."),
- TYPE_NAME (type));
+ type->name ());
}
}
/* Only deal with scalars, structs and such may be too large
to fit in a stack entry. */
value->type = check_typedef (value->type);
- if (TYPE_CODE (value->type) == TYPE_CODE_ARRAY
- || TYPE_CODE (value->type) == TYPE_CODE_STRUCT
- || TYPE_CODE (value->type) == TYPE_CODE_UNION
- || TYPE_CODE (value->type) == TYPE_CODE_FUNC)
+ if (value->type->code () == TYPE_CODE_ARRAY
+ || value->type->code () == TYPE_CODE_STRUCT
+ || value->type->code () == TYPE_CODE_UNION
+ || value->type->code () == TYPE_CODE_FUNC)
error (_("Value not scalar: cannot be an rvalue."));
switch (value->kind)
the stack. Should we tweak the type? */
/* Some types require special handling. */
- switch (TYPE_CODE (value->type))
+ switch (value->type->code ())
{
/* Functions get converted to a pointer to the function. */
case TYPE_CODE_FUNC:
struct axs_value *value2)
{
/* Do the usual binary conversions. */
- if (TYPE_CODE (value1->type) == TYPE_CODE_INT
- && TYPE_CODE (value2->type) == TYPE_CODE_INT)
+ if (value1->type->code () == TYPE_CODE_INT
+ && value2->type->code () == TYPE_CODE_INT)
{
/* The ANSI integral promotions seem to work this way: Order the
integer types by size, and then by signedness: an n-bit
/* Dereference typedefs. */
type = check_typedef (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_PTR:
case TYPE_CODE_REF:
struct axs_value *value1, struct axs_value *value2)
{
gdb_assert (pointer_type (value1->type));
- gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
+ gdb_assert (value2->type->code () == TYPE_CODE_INT);
gen_scale (ax, aop_mul, value1->type);
ax_simple (ax, aop_add);
struct axs_value *value1, struct axs_value *value2)
{
gdb_assert (pointer_type (value1->type));
- gdb_assert (TYPE_CODE (value2->type) == TYPE_CODE_INT);
+ gdb_assert (value2->type->code () == TYPE_CODE_INT);
gen_scale (ax, aop_mul, value1->type);
ax_simple (ax, aop_sub);
int may_carry, const char *name)
{
/* We only handle INT op INT. */
- if ((TYPE_CODE (value1->type) != TYPE_CODE_INT)
- || (TYPE_CODE (value2->type) != TYPE_CODE_INT))
+ if ((value1->type->code () != TYPE_CODE_INT)
+ || (value2->type->code () != TYPE_CODE_INT))
error (_("Invalid combination of types in %s."), name);
ax_simple (ax,
gen_logical_not (struct agent_expr *ax, struct axs_value *value,
struct type *result_type)
{
- if (TYPE_CODE (value->type) != TYPE_CODE_INT
- && TYPE_CODE (value->type) != TYPE_CODE_PTR)
+ if (value->type->code () != TYPE_CODE_INT
+ && value->type->code () != TYPE_CODE_PTR)
error (_("Invalid type of operand to `!'."));
ax_simple (ax, aop_log_not);
static void
gen_complement (struct agent_expr *ax, struct axs_value *value)
{
- if (TYPE_CODE (value->type) != TYPE_CODE_INT)
+ if (value->type->code () != TYPE_CODE_INT)
error (_("Invalid type of operand to `~'."));
ax_simple (ax, aop_bit_not);
T" to "T", and mark the value as an lvalue in memory. Leave it
to the consumer to actually dereference it. */
value->type = check_typedef (TYPE_TARGET_TYPE (value->type));
- if (TYPE_CODE (value->type) == TYPE_CODE_VOID)
+ if (value->type->code () == TYPE_CODE_VOID)
error (_("Attempt to dereference a generic pointer."));
- value->kind = ((TYPE_CODE (value->type) == TYPE_CODE_FUNC)
+ value->kind = ((value->type->code () == TYPE_CODE_FUNC)
? axs_rvalue : axs_lvalue_memory);
}
/* Special case for taking the address of a function. The ANSI
standard describes this as a special case, too, so this
arrangement is not without motivation. */
- if (TYPE_CODE (value->type) == TYPE_CODE_FUNC)
+ if (value->type->code () == TYPE_CODE_FUNC)
/* The value's already an rvalue on the stack, so we just need to
change the type. */
value->type = lookup_pointer_type (value->type);
type = check_typedef (type);
- for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
+ for (i = type->num_fields () - 1; i >= nbases; i--)
{
const char *this_name = TYPE_FIELD_NAME (type, i);
"this") will have been generated already, which will
be unnecessary but not harmful if the static field is
being handled as a global. */
- if (field_is_static (&TYPE_FIELD (type, i)))
+ if (field_is_static (&type->field (i)))
{
gen_static_field (ax, value, type, i);
if (value->optimized_out)
type = check_typedef (value->type);
/* This must yield a structure or a union. */
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION)
+ if (type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_UNION)
error (_("The left operand of `%s' is not a %s."),
operator_name, operand_name);
if (!found)
error (_("Couldn't find member named `%s' in struct/union/class `%s'"),
- field, TYPE_NAME (type));
+ field, type->name ());
}
static int
struct type *t = type;
int i;
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
internal_error (__FILE__, __LINE__,
_("non-aggregate type to gen_struct_elt_for_reference"));
- for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
+ for (i = t->num_fields () - 1; i >= TYPE_N_BASECLASSES (t); i--)
{
const char *t_field_name = TYPE_FIELD_NAME (t, i);
if (t_field_name && strcmp (t_field_name, fieldname) == 0)
{
- if (field_is_static (&TYPE_FIELD (t, i)))
+ if (field_is_static (&t->field (i)))
{
gen_static_field (ax, value, t, i);
if (value->optimized_out)
if (!found)
error (_("No symbol \"%s\" in namespace \"%s\"."),
- name, TYPE_NAME (curtype));
+ name, curtype->name ());
return found;
}
gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value,
const struct type *curtype, char *name)
{
- const char *namespace_name = TYPE_NAME (curtype);
+ const char *namespace_name = curtype->name ();
struct block_symbol sym;
sym = cp_lookup_symbol_namespace (namespace_name, name,
gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value,
struct type *type, char *field)
{
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
if (!v)
error (_("Right operand of `@' must be a "
"constant, in agent expressions."));
- if (TYPE_CODE (value_type (v)) != TYPE_CODE_INT)
+ if (value_type (v)->code () != TYPE_CODE_INT)
error (_("Right operand of `@' must be an integer."));
length = value_as_long (v);
if (length <= 0)
}
else
gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile);
- if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
+ if (value->type->code () == TYPE_CODE_ERROR)
value->type = to_type;
(*pc) += 4;
}
error (_("`%s' has been optimized out, cannot use"),
(*pc)[2].symbol->print_name ());
- if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
+ if (value->type->code () == TYPE_CODE_ERROR)
error_unknown_type ((*pc)[2].symbol->print_name ());
(*pc) += 4;
case OP_VAR_MSYM_VALUE:
gen_msym_var_ref (ax, value, (*pc)[2].msymbol, (*pc)[1].objfile);
- if (TYPE_CODE (value->type) == TYPE_CODE_ERROR)
+ if (value->type->code () == TYPE_CODE_ERROR)
error_unknown_type ((*pc)[2].msymbol->linkage_name ());
(*pc) += 4;
switch (op)
{
case BINOP_ADD:
- if (TYPE_CODE (value1->type) == TYPE_CODE_INT
+ if (value1->type->code () == TYPE_CODE_INT
&& pointer_type (value2->type))
{
/* Swap the values and proceed normally. */
gen_ptradd (ax, value, value2, value1);
}
else if (pointer_type (value1->type)
- && TYPE_CODE (value2->type) == TYPE_CODE_INT)
+ && value2->type->code () == TYPE_CODE_INT)
gen_ptradd (ax, value, value1, value2);
else
gen_binop (ax, value, value1, value2,
break;
case BINOP_SUB:
if (pointer_type (value1->type)
- && TYPE_CODE (value2->type) == TYPE_CODE_INT)
+ && value2->type->code () == TYPE_CODE_INT)
gen_ptrsub (ax,value, value1, value2);
else if (pointer_type (value1->type)
&& pointer_type (value2->type))
an array or pointer type (like a plain int variable for
example), then report this as an error. */
type = check_typedef (value1->type);
- 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"));
}