t2 = check_typedef (value_type (v2));
/* Check preconditions. */
- gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
- || TYPE_CODE (t1) == TYPE_CODE_UNION)
+ gdb_assert ((t1->code () == TYPE_CODE_STRUCT
+ || t1->code () == TYPE_CODE_UNION)
&& !!"Precondition is that type is of STRUCT or UNION kind.");
- gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
- || TYPE_CODE (t2) == TYPE_CODE_UNION)
+ gdb_assert ((t2->code () == TYPE_CODE_STRUCT
+ || t2->code () == TYPE_CODE_UNION)
&& !!"Precondition is that value is of STRUCT or UNION kind");
if (TYPE_NAME (t1) != NULL
struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
- if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
- && TYPE_CODE (t2) == TYPE_CODE_STRUCT
+ if (t1->code () == TYPE_CODE_STRUCT
+ && t2->code () == TYPE_CODE_STRUCT
&& (subclass_check || !value_logical_not (arg2)))
{
struct value *v2;
v2 = coerce_ref (arg2);
else
v2 = value_ind (arg2);
- gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
+ gdb_assert (check_typedef (value_type (v2))->code ()
== TYPE_CODE_STRUCT && !!"Why did coercion fail?");
v2 = value_cast_structs (t1, v2);
/* At this point we have what we can have, un-dereference if needed. */
struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
struct value *val = value_cast (dereftype, arg2);
- return value_ref (val, TYPE_CODE (t1));
+ return value_ref (val, t1->code ());
}
if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2))))
struct type *to_type = type;
type = check_typedef (type);
- code1 = TYPE_CODE (type);
+ code1 = type->code ();
arg2 = coerce_ref (arg2);
type2 = check_typedef (value_type (arg2));
}
if (current_language->c_style_arrays
- && TYPE_CODE (type2) == TYPE_CODE_ARRAY
+ && type2->code () == TYPE_CODE_ARRAY
&& !TYPE_VECTOR (type2))
arg2 = value_coerce_array (arg2);
- if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
+ if (type2->code () == TYPE_CODE_FUNC)
arg2 = value_coerce_function (arg2);
type2 = check_typedef (value_type (arg2));
- code2 = TYPE_CODE (type2);
+ code2 = type2->code ();
if (code1 == TYPE_CODE_COMPLEX)
return cast_into_complex (to_type, arg2);
arg_type = value_type (arg);
- dest_code = TYPE_CODE (real_type);
- arg_code = TYPE_CODE (arg_type);
+ dest_code = real_type->code ();
+ arg_code = arg_type->code ();
/* We can convert pointer types, or any pointer type to int, or int
type to pointer. */
if (is_ref)
result = value_cast (type, value_ref (value_ind (result),
- TYPE_CODE (type)));
+ type->code ()));
return result;
}
CORE_ADDR addr;
int is_ref = TYPE_IS_REFERENCE (resolved_type);
- if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
+ if (resolved_type->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (resolved_type))
error (_("Argument to dynamic_cast must be a pointer or reference type"));
- if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
- && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT)
+ if (TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_VOID
+ && TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_STRUCT)
error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
- if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
+ if (resolved_type->code () == TYPE_CODE_PTR)
{
- if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
- && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
+ if (arg_type->code () != TYPE_CODE_PTR
+ && ! (arg_type->code () == TYPE_CODE_INT
&& value_as_long (arg) == 0))
error (_("Argument to dynamic_cast does not have pointer type"));
- if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
+ if (arg_type->code () == TYPE_CODE_PTR)
{
arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
- if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
+ if (arg_type->code () != TYPE_CODE_STRUCT)
error (_("Argument to dynamic_cast does "
"not have pointer to class type"));
}
}
else
{
- if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
+ if (arg_type->code () != TYPE_CODE_STRUCT)
error (_("Argument to dynamic_cast does not have class type"));
}
/* dynamic_cast<void *> means to return a pointer to the
most-derived object. */
- if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
- && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
+ if (resolved_type->code () == TYPE_CODE_PTR
+ && TYPE_TARGET_TYPE (resolved_type)->code () == TYPE_CODE_VOID)
return value_at_lazy (type, addr);
tem = value_at (type, addr);
&result) == 1)
return value_cast (type,
is_ref
- ? value_ref (result, TYPE_CODE (resolved_type))
+ ? value_ref (result, resolved_type->code ())
: value_addr (result));
}
rtti_type, &result) == 1)
return value_cast (type,
is_ref
- ? value_ref (result, TYPE_CODE (resolved_type))
+ ? value_ref (result, resolved_type->code ())
: value_addr (result));
- if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
+ if (resolved_type->code () == TYPE_CODE_PTR)
return value_zero (type, not_lval);
error (_("dynamic_cast failed"));
{
val = value_from_longest (type, (LONGEST) 1);
}
- else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+ else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
{
struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
int i;
{
struct value *val;
- if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
+ if (check_typedef (type)->code () == TYPE_CODE_VOID)
error (_("Attempt to dereference a generic pointer."));
val = value_from_contents_and_address (type, NULL, addr);
in the case of pointer types. For object types, the enclosing type
and embedded offset must *not* be copied: the target object refered
to by TOVAL retains its original dynamic type after assignment. */
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ if (type->code () == TYPE_CODE_PTR)
{
set_value_enclosing_type (val, value_enclosing_type (fromval));
set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
type = value_type (val);
if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
- || TYPE_CODE (type) == TYPE_CODE_FUNC)
+ || type->code () == TYPE_CODE_FUNC)
{
CORE_ADDR addr = value_address (val);
valtype = check_typedef (value_type (val));
- switch (TYPE_CODE (valtype))
+ switch (valtype->code ())
{
case TYPE_CODE_ARRAY:
return TYPE_VECTOR (valtype) ? 0 : 1;
return arg2;
}
}
- if (TYPE_CODE (type) == TYPE_CODE_FUNC)
+ if (type->code () == TYPE_CODE_FUNC)
return value_coerce_function (arg1);
/* If this is an array that has not yet been pushed to the target,
gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
- if ((TYPE_CODE (type) == TYPE_CODE_REF
- || TYPE_CODE (type) == TYPE_CODE_RVALUE_REF)
- && TYPE_CODE (type) == refcode)
+ if ((type->code () == TYPE_CODE_REF
+ || type->code () == TYPE_CODE_RVALUE_REF)
+ && type->code () == refcode)
return arg1;
arg2 = value_addr (arg1);
}
}
- if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
+ if (base_type->code () == TYPE_CODE_PTR)
{
struct type *enc_type;
enc_type = check_typedef (value_enclosing_type (arg1));
enc_type = TYPE_TARGET_TYPE (enc_type);
- if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
- || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
+ if (check_typedef (enc_type)->code () == TYPE_CODE_FUNC
+ || check_typedef (enc_type)->code () == TYPE_CODE_METHOD)
/* For functions, go through find_function_addr, which knows
how to handle function descriptors. */
arg2 = value_at_lazy (enc_type,
t2 ++;
for (i = 0;
- (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
+ (i < nargs) && t1[i].type->code () != TYPE_CODE_VOID;
i++)
{
struct type *tt1, *tt2;
if (TYPE_IS_REFERENCE (tt1)
/* We should be doing hairy argument matching, as below. */
- && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
- == TYPE_CODE (tt2)))
+ && (check_typedef (TYPE_TARGET_TYPE (tt1))->code ()
+ == tt2->code ()))
{
- if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
+ if (tt2->code () == TYPE_CODE_ARRAY)
t2[i] = value_coerce_array (t2[i]);
else
- t2[i] = value_ref (t2[i], TYPE_CODE (tt1));
+ t2[i] = value_ref (t2[i], tt1->code ());
continue;
}
char *>, and properly access map["hello"], because the
argument to [] will be a reference to a pointer to a char,
and the argument will be a pointer to a char. */
- while (TYPE_IS_REFERENCE (tt1) || TYPE_CODE (tt1) == TYPE_CODE_PTR)
+ while (TYPE_IS_REFERENCE (tt1) || tt1->code () == TYPE_CODE_PTR)
{
- tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+ tt1 = check_typedef ( TYPE_TARGET_TYPE (tt1) );
}
- while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
- || TYPE_CODE(tt2) == TYPE_CODE_PTR
+ while (tt2->code () == TYPE_CODE_ARRAY
+ || tt2->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (tt2))
{
- tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
+ tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
}
- if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
+ if (tt1->code () == tt2->code ())
continue;
/* Array to pointer is a `trivial conversion' according to the
ARM. */
/* We should be doing much hairier argument matching (see
section 13.2 of the ARM), but as a quick kludge, just check
for the same type code. */
- if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
+ if (t1[i].type->code () != value_type (t2[i])->code ())
return i + 1;
}
if (varargs || t2[i] == NULL)
{
struct type *field_type = TYPE_FIELD_TYPE (type, i);
- if (TYPE_CODE (field_type) == TYPE_CODE_UNION
- || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
+ if (field_type->code () == TYPE_CODE_UNION
+ || field_type->code () == TYPE_CODE_STRUCT)
{
/* Look for a match through the fields of an anonymous
union, or anonymous struct. C++ provides anonymous
from GDB) implementation of variant records, the
bitpos is zero in an anonymous union field, so we
have to add the offset of the union here. */
- if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
+ if (field_type->code () == TYPE_CODE_STRUCT
|| (TYPE_NFIELDS (field_type) > 0
&& TYPE_FIELD_BITPOS (field_type, 0) == 0))
new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
/* Follow pointers until we get to a non-pointer. */
- while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+ while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+ if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
t = check_typedef (value_type (*argp));
}
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Attempt to extract a component of a value that is not a %s."),
err);
t = check_typedef (value_type (*argp));
- while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+ while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
{
*argp = value_ind (*argp);
- if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+ if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
t = check_typedef (value_type (*argp));
}
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Attempt to extract a component of a value that is not a %s."),
err);
t = check_typedef (value_type (*argp));
/* Code snarfed from value_struct_elt. */
- while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+ while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+ if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
*argp = coerce_array (*argp);
t = check_typedef (value_type (*argp));
}
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Attempt to extract a component of a "
"value that is not a struct or union"));
/* OBJ may be a pointer value rather than the object itself. */
obj = coerce_ref (obj);
- while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
+ while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR)
obj = coerce_ref (value_ind (obj));
obj_type_name = TYPE_NAME (value_type (obj));
/* First check whether this is a data member, e.g. a pointer to
a function. */
- if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
+ if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT)
{
*valp = search_struct_field (name, obj,
check_typedef (value_type (obj)), 0);
the function part. Do not try this for non-functions (e.g.
function pointers). */
if (qualified_name
- && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
- == TYPE_CODE_FUNC)
+ && (check_typedef (SYMBOL_TYPE (fsym))->code ()
+ == TYPE_CODE_FUNC))
{
temp_func = cp_func_name (qualified_name);
struct type *temp_type = check_typedef (value_type (temp));
struct type *objtype = check_typedef (obj_type);
- if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
- && (TYPE_CODE (objtype) == TYPE_CODE_PTR
+ if (temp_type->code () != TYPE_CODE_PTR
+ && (objtype->code () == TYPE_CODE_PTR
|| TYPE_IS_REFERENCE (objtype)))
{
temp = value_addr (temp);
int i;
int name_len = strlen (name);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM
+ gdb_assert (type->code () == TYPE_CODE_ENUM
&& TYPE_DECLARED_CLASS (type));
for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
struct type *expect_type, int want_address,
enum noside noside)
{
- switch (TYPE_CODE (curtype))
+ switch (curtype->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
/* Special case: a method taking void. T1 will contain no
non-artificial fields, and T2 will contain TYPE_CODE_VOID. */
if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
- && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
+ && TYPE_FIELD_TYPE (t2, 0)->code () == TYPE_CODE_VOID)
return 1;
if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
int i;
struct value *result;
- if (TYPE_CODE (t) != TYPE_CODE_STRUCT
- && TYPE_CODE (t) != TYPE_CODE_UNION)
+ if (t->code () != TYPE_CODE_STRUCT
+ && t->code () != TYPE_CODE_UNION)
error (_("Internal error: non-aggregate type "
"to value_struct_elt_for_reference"));
ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
type = check_typedef (value_type (ptr));
gdb_assert (type != NULL
- && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
+ && type->code () == TYPE_CODE_MEMBERPTR);
tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
v = value_cast_pointers (tmp, v, 1);
mem_offset = value_as_long (ptr);
as a pointer to a method. */
/* Perform all necessary dereferencing. */
- while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
+ while (intype && intype->code () == TYPE_CODE_PTR)
intype = TYPE_TARGET_TYPE (intype);
for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
type = check_typedef (type);
if (TYPE_IS_REFERENCE (type))
target = coerce_ref (v);
- else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ else if (type->code () == TYPE_CODE_PTR)
{
try
real_type = make_cv_type (TYPE_CONST (target_type),
TYPE_VOLATILE (target_type), real_type, NULL);
if (TYPE_IS_REFERENCE (type))
- real_type = lookup_reference_type (real_type, TYPE_CODE (type));
- else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ real_type = lookup_reference_type (real_type, type->code ());
+ else if (type->code () == TYPE_CODE_PTR)
real_type = lookup_pointer_type (real_type);
else
internal_error (__FILE__, __LINE__, _("Unexpected value type."));
struct type *array_type;
array_type = check_typedef (value_type (array));
- if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
- && TYPE_CODE (array_type) != TYPE_CODE_STRING)
+ if (array_type->code () != TYPE_CODE_ARRAY
+ && array_type->code () != TYPE_CODE_STRING)
error (_("cannot take slice of non-array"));
if (type_not_allocated (array_type))
slice_type = create_array_type (NULL,
element_type,
slice_range_type);
- TYPE_CODE (slice_type) = TYPE_CODE (array_type);
+ slice_type->set_code (array_type->code ());
if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
slice = allocate_value_lazy (slice_type);
struct type *type = check_typedef (value_type (value));
struct type *ttype = TYPE_TARGET_TYPE (type);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX);
+ gdb_assert (type->code () == TYPE_CODE_COMPLEX);
return value_from_component (value, ttype, 0);
}
struct type *type = check_typedef (value_type (value));
struct type *ttype = TYPE_TARGET_TYPE (type);
- gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX);
+ gdb_assert (type->code () == TYPE_CODE_COMPLEX);
return value_from_component (value, ttype,
TYPE_LENGTH (check_typedef (ttype)));
}
{
struct type *real_type = TYPE_TARGET_TYPE (type);
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
+ if (value_type (val)->code () == TYPE_CODE_COMPLEX)
{
struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
struct value *re_val = allocate_value (val_real_type);
return value_literal_complex (re_val, im_val, type);
}
- else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
- || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
+ else if (value_type (val)->code () == TYPE_CODE_FLT
+ || value_type (val)->code () == TYPE_CODE_INT)
return value_literal_complex (val,
value_zero (real_type, not_lval),
type);
projects / deliverable / binutils-gdb.git / blobdiff