/* varobj support for C and C++.
- Copyright (C) 1999-2016 Free Software Foundation, Inc.
+ Copyright (C) 1999-2020 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#define ANONYMOUS_UNION_NAME _("<anonymous union>")
/* Does CHILD represent a child with no name? This happens when
- the child is an anonmous struct or union and it has no field name
+ the child is an anonymous struct or union and it has no field name
in its parent variable.
This has already been determined by *_describe_child. The easiest
thing to do is to compare the child's name with ANONYMOUS_*_NAME. */
-int
+bool
varobj_is_anonymous_child (const struct varobj *child)
{
return (child->name == ANONYMOUS_STRUCT_NAME
to us, is already supposed to be
reference-stripped. */
- gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
+ gdb_assert (!TYPE_IS_REFERENCE (*type));
/* Pointers to structures are treated just like
structures when accessing children. Don't
- dererences pointers to other types. */
- if (TYPE_CODE (*type) == TYPE_CODE_PTR)
+ dereference pointers to other types. */
+ if ((*type)->code () == TYPE_CODE_PTR)
{
struct type *target_type = get_target_type (*type);
- if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (target_type) == TYPE_CODE_UNION)
+ if (target_type->code () == TYPE_CODE_STRUCT
+ || target_type->code () == TYPE_CODE_UNION)
{
if (value && *value)
{
- TRY
+ try
{
*value = value_ind (*value);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
*value = NULL;
}
- END_CATCH
}
*type = target_type;
if (was_ptr)
/* Is VAR a path expression parent, i.e., can it be used to construct
a valid path expression? */
-static int
+static bool
c_is_path_expr_parent (const struct varobj *var)
{
struct type *type;
/* "Fake" children are not path_expr parents. */
if (CPLUS_FAKE_CHILD (var))
- return 0;
+ return false;
type = varobj_get_gdb_type (var);
/* Anonymous unions and structs are also not path_expr parents. */
- if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION)
- && TYPE_NAME (type) == NULL
- && TYPE_TAG_NAME (type) == NULL)
+ if ((type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION)
+ && type->name () == NULL)
{
const struct varobj *parent = var->parent;
parent_type = varobj_get_value_type (parent);
adjust_value_for_child_access (NULL, &parent_type, &was_ptr, 0);
- if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (parent_type) == TYPE_CODE_UNION)
+ if (parent_type->code () == TYPE_CODE_STRUCT
+ || parent_type->code () == TYPE_CODE_UNION)
{
const char *field_name;
- gdb_assert (var->index < TYPE_NFIELDS (parent_type));
+ gdb_assert (var->index < parent_type->num_fields ());
field_name = TYPE_FIELD_NAME (parent_type, var->index);
return !(field_name == NULL || *field_name == '\0');
}
}
- return 0;
+ return false;
}
- return 1;
+ return true;
}
/* C */
adjust_value_for_child_access (NULL, &type, NULL, 0);
target = get_target_type (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- children = TYPE_NFIELDS (type);
+ children = type->num_fields ();
break;
case TYPE_CODE_PTR:
to test for it, please mind that a little magic is necessary to
properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
TYPE_NAME == "char". */
- if (TYPE_CODE (target) == TYPE_CODE_FUNC
- || TYPE_CODE (target) == TYPE_CODE_VOID)
+ if (target->code () == TYPE_CODE_FUNC
+ || target->code () == TYPE_CODE_VOID)
children = 0;
else
children = 1;
type = check_typedef (type);
- 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);
- TRY
+ try
{
- if (field_is_static (&TYPE_FIELD (type, type_index)))
+ if (field_is_static (&type->field (type_index)))
result = value_static_field (type, type_index);
else
result = value_primitive_field (value, 0, type_index, type);
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
return NULL;
}
- END_CATCH
return result;
}
std::string *cname, struct value **cvalue,
struct type **ctype, std::string *cfull_expression)
{
- struct value *value = parent->value;
+ struct value *value = parent->value.get ();
struct type *type = varobj_get_value_type (parent);
std::string parent_expression;
int was_ptr;
}
adjust_value_for_child_access (&value, &type, &was_ptr, 0);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
if (cname)
{
int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
- TRY
+ try
{
*cvalue = value_subscript (value, real_index);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
}
- END_CATCH
}
if (ctype)
{
if (cname)
{
- if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
+ if (TYPE_FIELD_TYPE (type, index)->code ()
== TYPE_CODE_STRUCT)
*cname = ANONYMOUS_STRUCT_NAME;
else
if (cvalue && value)
{
- TRY
+ try
{
*cvalue = value_ind (value);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
*cvalue = NULL;
}
- END_CATCH
}
/* Don't use get_target_type because it calls
struct type *type = get_type (var);
/* Strip top-level references. */
- while (TYPE_CODE (type) == TYPE_CODE_REF)
+ while (TYPE_IS_REFERENCE (type))
type = check_typedef (TYPE_TARGET_TYPE (type));
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
}
else
{
- if (var->not_fetched && value_lazy (var->value))
+ if (var->not_fetched && value_lazy (var->value.get ()))
/* Frozen variable and no value yet. We don't
implicitly fetch the value. MI response will
use empty string for the value, which is OK. */
return std::string ();
gdb_assert (varobj_value_is_changeable_p (var));
- gdb_assert (!value_lazy (var->value));
+ gdb_assert (!value_lazy (var->value.get ()));
/* If the specified format is the current one,
we can reuse print_value. */
if (format == var->format)
return var->print_value;
else
- return varobj_value_get_print_value (var->value, format, var);
+ return varobj_value_get_print_value (var->value.get (), format,
+ var);
}
}
}
/* It is necessary to access a real type (via RTTI). */
if (opts.objectprint)
{
- value = var->value;
- lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
- || TYPE_CODE (var->type) == TYPE_CODE_PTR);
+ value = var->value.get ();
+ lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
+ || var->type->code () == TYPE_CODE_PTR);
}
adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
- if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT)
- || ((TYPE_CODE (type)) == TYPE_CODE_UNION))
+ if (((type->code ()) == TYPE_CODE_STRUCT)
+ || ((type->code ()) == TYPE_CODE_UNION))
{
int kids[3];
{
const struct varobj *parent = var->parent;
- value = parent->value;
- lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
- || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
+ value = parent->value.get ();
+ lookup_actual_type = (TYPE_IS_REFERENCE (parent->type)
+ || parent->type->code () == TYPE_CODE_PTR);
}
adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
children[v_protected] = 0;
vptr_fieldno = get_vptr_fieldno (type, &basetype);
- for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
+ for (i = TYPE_N_BASECLASSES (type); i < type->num_fields (); i++)
{
/* If we have a virtual table pointer, omit it. Even if virtual
table pointers are not specifically marked in the debug info,
var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
if (opts.objectprint)
- lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
- || TYPE_CODE (var->type) == TYPE_CODE_PTR);
- value = var->value;
+ lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
+ || var->type->code () == TYPE_CODE_PTR);
+ value = var->value.get ();
type = varobj_get_value_type (var);
if (cfull_expression)
parent_expression
adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION)
+ if (type->code () == TYPE_CODE_STRUCT
+ || type->code () == TYPE_CODE_UNION)
{
const char *join = was_ptr ? "->" : ".";
--type_index;
/* If the type is anonymous and the field has no name,
- set an appopriate name. */
+ set an appropriate name. */
field_name = TYPE_FIELD_NAME (type, type_index);
if (field_name == NULL || *field_name == '\0')
{
if (cname)
{
- if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
+ if (TYPE_FIELD_TYPE (type, type_index)->code ()
== TYPE_CODE_STRUCT)
*cname = ANONYMOUS_STRUCT_NAME;
- else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
+ else if (TYPE_FIELD_TYPE (type, type_index)->code ()
== TYPE_CODE_UNION)
*cname = ANONYMOUS_UNION_NAME;
}
}
else
{
- char *access = NULL;
+ const char *access = NULL;
int children[3];
cplus_class_num_children (type, children);
projects / deliverable / binutils-gdb.git / blobdiff