if (msymbol.minsym != NULL)
{
struct objfile *objfile = msymbol.objfile;
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct type *type;
CORE_ADDR maddr;
{
struct objfile *objf;
struct value *val = find_function_in_inferior ("malloc", &objf);
- struct gdbarch *gdbarch = get_objfile_arch (objf);
+ struct gdbarch *gdbarch = objf->arch ();
struct value *blocklen;
blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
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
- && TYPE_NAME (t2) != NULL
- && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
+ if (t1->name () != NULL
+ && t2->name () != NULL
+ && !strcmp (t1->name (), t2->name ()))
return NULL;
/* Upcasting: look in the type of the source to see if it contains the
type of the target as a superclass. If so, we'll need to
offset the pointer rather than just change its type. */
- if (TYPE_NAME (t1) != NULL)
+ if (t1->name () != NULL)
{
- v = search_struct_field (TYPE_NAME (t1),
+ v = search_struct_field (t1->name (),
v2, t2, 1);
if (v)
return v;
/* Downcasting: look in the type of the target to see if it contains the
type of the source as a superclass. If so, we'll need to
offset the pointer rather than just change its type. */
- if (TYPE_NAME (t2) != NULL)
+ if (t2->name () != NULL)
{
/* Try downcasting using the run-time type of the value. */
int full, using_enc;
/* We might be trying to cast to the outermost enclosing
type, in which case search_struct_field won't work. */
- if (TYPE_NAME (real_type) != NULL
- && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
+ if (real_type->name () != NULL
+ && !strcmp (real_type->name (), t1->name ()))
return v;
- v = search_struct_field (TYPE_NAME (t2), v, real_type, 1);
+ v = search_struct_field (t2->name (), v, real_type, 1);
if (v)
return v;
}
/* Try downcasting using information from the destination type
T2. This wouldn't work properly for classes with virtual
bases, but those were handled above. */
- v = search_struct_field (TYPE_NAME (t2),
+ v = search_struct_field (t2->name (),
value_zero (t1, not_lval), t1, 1);
if (v)
{
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);
if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
&& (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
- && TYPE_NAME (type) != 0)
+ && type->name () != 0)
{
struct value *v = value_cast_structs (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)
nbases = TYPE_N_BASECLASSES (type);
if (!looking_for_baseclass)
- for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
+ for (i = type->num_fields () - 1; i >= nbases; i--)
{
const char *t_field_name = TYPE_FIELD_NAME (type, i);
{
struct value *v;
- if (field_is_static (&TYPE_FIELD (type, i)))
+ if (field_is_static (&type->field (i)))
v = value_static_field (type, i);
else
v = value_primitive_field (arg1, offset, i, type);
{
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
- || (TYPE_NFIELDS (field_type) > 0
+ if (field_type->code () == TYPE_CODE_STRUCT
+ || (field_type->num_fields () > 0
&& TYPE_FIELD_BITPOS (field_type, 0) == 0))
new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
{
if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
- TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
+ TYPE_FN_FIELD_TYPE (f, j)->num_fields (),
TYPE_FN_FIELD_ARGS (f, j), args))
{
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
/* 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);
- for (i = TYPE_N_BASECLASSES (t); i < TYPE_NFIELDS (t); i++)
+ for (i = TYPE_N_BASECLASSES (t); i < t->num_fields (); i++)
{
- if (!field_is_static (&TYPE_FIELD (t, i))
+ if (!field_is_static (&t->field (i))
&& bitpos == TYPE_FIELD_BITPOS (t, i)
&& types_equal (ftype, TYPE_FIELD_TYPE (t, i)))
return value_primitive_field (*argp, 0, i, t);
return NULL;
}
-/* See value.h. */
-
-int
-value_union_variant (struct type *union_type, const gdb_byte *contents)
-{
- gdb_assert (TYPE_CODE (union_type) == TYPE_CODE_UNION
- && TYPE_FLAG_DISCRIMINATED_UNION (union_type));
-
- struct dynamic_prop *discriminant_prop
- = get_dyn_prop (DYN_PROP_DISCRIMINATED, union_type);
- gdb_assert (discriminant_prop != nullptr);
-
- struct discriminant_info *info
- = (struct discriminant_info *) discriminant_prop->data.baton;
- gdb_assert (info != nullptr);
-
- /* If this is a univariant union, just return the sole field. */
- if (TYPE_NFIELDS (union_type) == 1)
- return 0;
- /* This should only happen for univariants, which we already dealt
- with. */
- gdb_assert (info->discriminant_index != -1);
-
- /* Compute the discriminant. Note that unpack_field_as_long handles
- sign extension when necessary, as does the DWARF reader -- so
- signed discriminants will be handled correctly despite the use of
- an unsigned type here. */
- ULONGEST discriminant = unpack_field_as_long (union_type, contents,
- info->discriminant_index);
-
- for (int i = 0; i < TYPE_NFIELDS (union_type); ++i)
- {
- if (i != info->default_index
- && i != info->discriminant_index
- && discriminant == info->discriminants[i])
- return i;
- }
-
- if (info->default_index == -1)
- error (_("Could not find variant corresponding to discriminant %s"),
- pulongest (discriminant));
- return info->default_index;
-}
-
/* Search through the methods of an object (and its bases) to find a
specified method. Return a reference to the fn_field list METHODS of
overloaded instances defined in the source language. If available
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));
+ obj_type_name = value_type (obj)->name ();
/* 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);
if (methods != NULL)
{
- nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (methods, ix));
+ nparms = TYPE_FN_FIELD_TYPE (methods, ix)->num_fields ();
static_offset = oload_method_static_p (methods, ix);
}
else
- nparms = TYPE_NFIELDS (SYMBOL_TYPE (functions[ix]));
+ nparms = SYMBOL_TYPE (functions[ix])->num_fields ();
parm_types.reserve (nparms);
for (jj = 0; jj < nparms; jj++)
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)
+ for (i = TYPE_N_BASECLASSES (type); i < type->num_fields (); ++i)
{
const char *fname = TYPE_FIELD_NAME (type, i);
int len;
}
error (_("no constant named \"%s\" in enum \"%s\""),
- name, TYPE_NAME (type));
+ name, type->name ());
}
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
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:
{
int start = 0;
- if (TYPE_NFIELDS (t1) > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
+ if (t1->num_fields () > 0 && TYPE_FIELD_ARTIFICIAL (t1, 0))
++start;
/* If skipping artificial fields, find the first real field
in T1. */
if (skip_artificial)
{
- while (start < TYPE_NFIELDS (t1)
+ while (start < t1->num_fields ()
&& TYPE_FIELD_ARTIFICIAL (t1, start))
++start;
}
/* 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)
+ if ((t1->num_fields () - start) == 0 && t2->num_fields () == 1
+ && TYPE_FIELD_TYPE (t2, 0)->code () == TYPE_CODE_VOID)
return 1;
- if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
+ if ((t1->num_fields () - start) == t2->num_fields ())
{
int i;
- for (i = 0; i < TYPE_NFIELDS (t2); ++i)
+ for (i = 0; i < t2->num_fields (); ++i)
{
if (compare_ranks (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
TYPE_FIELD_TYPE (t2, i), NULL),
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"));
- 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, name) == 0)
{
- if (field_is_static (&TYPE_FIELD (t, i)))
+ if (field_is_static (&t->field (i)))
{
struct value *v = value_static_field (t, i);
if (want_address)
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)
if (retval == NULL)
error (_("No symbol \"%s\" in namespace \"%s\"."),
- name, TYPE_NAME (curtype));
+ name, curtype->name ());
return retval;
}
const char *name, int want_address,
enum noside noside)
{
- const char *namespace_name = TYPE_NAME (curtype);
+ const char *namespace_name = curtype->name ();
struct block_symbol sym;
struct value *result;
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."));
{
warning (_("Couldn't retrieve complete object of RTTI "
"type %s; object may be in register(s)."),
- TYPE_NAME (real_type));
+ real_type->name ());
return argp;
}
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);
return slice;
}
-/* Create a value for a FORTRAN complex number. Currently most of the
- time values are coerced to COMPLEX*16 (i.e. a complex number
- composed of 2 doubles. This really should be a smarter routine
- that figures out precision intelligently as opposed to assuming
- doubles. FIXME: fmb */
+/* See value.h. */
struct value *
-value_literal_complex (struct value *arg1,
+value_literal_complex (struct value *arg1,
struct value *arg2,
struct type *type)
{
return val;
}
+/* See value.h. */
+
+struct value *
+value_real_part (struct value *value)
+{
+ struct type *type = check_typedef (value_type (value));
+ struct type *ttype = TYPE_TARGET_TYPE (type);
+
+ gdb_assert (type->code () == TYPE_CODE_COMPLEX);
+ return value_from_component (value, ttype, 0);
+}
+
+/* See value.h. */
+
+struct value *
+value_imaginary_part (struct value *value)
+{
+ struct type *type = check_typedef (value_type (value));
+ struct type *ttype = TYPE_TARGET_TYPE (type);
+
+ gdb_assert (type->code () == TYPE_CODE_COMPLEX);
+ return value_from_component (value, ttype,
+ TYPE_LENGTH (check_typedef (ttype)));
+}
+
/* Cast a value into the appropriate complex data type. */
static struct value *
{
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);
error (_("cannot cast non-number to complex"));
}
+void _initialize_valops ();
void
-_initialize_valops (void)
+_initialize_valops ()
{
add_setshow_boolean_cmd ("overload-resolution", class_support,
&overload_resolution, _("\
projects / deliverable / binutils-gdb.git / blobdiff