/* varobj support for Ada.
- Copyright (C) 2012-2017 Free Software Foundation, Inc.
+ Copyright (C) 2012-2020 Free Software Foundation, Inc.
This file is part of GDB.
static std::string
ada_varobj_scalar_image (struct type *type, LONGEST val)
{
- struct ui_file *buf = mem_fileopen ();
- struct cleanup *cleanups = make_cleanup_ui_file_delete (buf);
+ string_file buf;
- ada_print_scalar (type, val, buf);
- std::string result = ui_file_as_string (buf);
- do_cleanups (cleanups);
-
- return result;
+ ada_print_scalar (type, val, &buf);
+ return std::move (buf.string ());
}
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates
ada_get_decoded_value would have transformed our parent_type
into a simple array pointer type. */
gdb_assert (parent_value == NULL);
- gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF);
+ gdb_assert (parent_type->code () == TYPE_CODE_TYPEDEF);
/* Decode parent_type by the equivalent pointer to (decoded)
array. */
- while (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+ while (parent_type->code () == TYPE_CODE_TYPEDEF)
parent_type = TYPE_TARGET_TYPE (parent_type);
parent_type = ada_coerce_to_simple_array_type (parent_type);
parent_type = lookup_pointer_type (parent_type);
one child (the struct), their children are the components of
the struct/union type. We handle this situation by dereferencing
the (value, type) couple. */
- if (TYPE_CODE (*type) == TYPE_CODE_PTR
- && (TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_STRUCT
- || TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_UNION)
+ if ((*type)->code () == TYPE_CODE_PTR
+ && (TYPE_TARGET_TYPE (*type)->code () == TYPE_CODE_STRUCT
+ || TYPE_TARGET_TYPE (*type)->code () == TYPE_CODE_UNION)
&& !ada_is_array_descriptor_type (TYPE_TARGET_TYPE (*type))
&& !ada_is_constrained_packed_array_type (TYPE_TARGET_TYPE (*type)))
ada_varobj_ind (*value, *type, value, type);
int n_children = 0;
int i;
- gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
- || TYPE_CODE (parent_type) == TYPE_CODE_UNION);
+ gdb_assert (parent_type->code () == TYPE_CODE_STRUCT
+ || parent_type->code () == TYPE_CODE_UNION);
- for (i = 0; i < TYPE_NFIELDS (parent_type); i++)
+ for (i = 0; i < parent_type->num_fields (); i++)
{
if (ada_is_ignored_field (parent_type, i))
continue;
/* Pointer to functions and to void do not have a child, since
you cannot print what they point to. */
- if (TYPE_CODE (child_type) == TYPE_CODE_FUNC
- || TYPE_CODE (child_type) == TYPE_CODE_VOID)
+ if (child_type->code () == TYPE_CODE_FUNC
+ || child_type->code () == TYPE_CODE_VOID)
return 0;
/* All other types have 1 child. */
/* A typedef to an array descriptor in fact represents a pointer
to an unconstrained array. These types always have one child
(the unconstrained array). */
- if (ada_is_array_descriptor_type (parent_type)
- && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+ if (ada_is_access_to_unconstrained_array (parent_type))
return 1;
- if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY)
+ if (parent_type->code () == TYPE_CODE_ARRAY)
return ada_varobj_get_array_number_of_children (parent_value,
parent_type);
- 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)
return ada_varobj_get_struct_number_of_children (parent_value,
parent_type);
- if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
+ if (parent_type->code () == TYPE_CODE_PTR)
return ada_varobj_get_ptr_number_of_children (parent_value,
parent_type);
int fieldno;
int childno = 0;
- gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT);
+ gdb_assert (parent_type->code () == TYPE_CODE_STRUCT
+ || parent_type->code () == TYPE_CODE_UNION);
- for (fieldno = 0; fieldno < TYPE_NFIELDS (parent_type); fieldno++)
+ for (fieldno = 0; fieldno < parent_type->num_fields (); fieldno++)
{
if (ada_is_ignored_field (parent_type, fieldno))
continue;
struct type *index_type;
int real_index;
- gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY);
+ gdb_assert (parent_type->code () == TYPE_CODE_ARRAY);
index_type = TYPE_INDEX_TYPE (parent_type);
real_index = child_index + ada_discrete_type_low_bound (index_type);
of the array index type when such type qualification is
needed. */
const char *index_type_name = NULL;
+ std::string decoded;
/* If the index type is a range type, find the base type. */
- while (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
+ while (index_type->code () == TYPE_CODE_RANGE)
index_type = TYPE_TARGET_TYPE (index_type);
- if (TYPE_CODE (index_type) == TYPE_CODE_ENUM
- || TYPE_CODE (index_type) == TYPE_CODE_BOOL)
+ if (index_type->code () == TYPE_CODE_ENUM
+ || index_type->code () == TYPE_CODE_BOOL)
{
index_type_name = ada_type_name (index_type);
if (index_type_name)
- index_type_name = ada_decode (index_type_name);
+ {
+ decoded = ada_decode (index_type_name);
+ index_type_name = decoded.c_str ();
+ }
}
if (index_type_name != NULL)
if (child_path_expr)
*child_path_expr = std::string ();
- if (ada_is_array_descriptor_type (parent_type)
- && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
+ if (ada_is_access_to_unconstrained_array (parent_type))
{
ada_varobj_describe_ptr_child (parent_value, parent_type,
parent_name, parent_path_expr,
return;
}
- if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY)
+ if (parent_type->code () == TYPE_CODE_ARRAY)
{
ada_varobj_describe_simple_array_child
(parent_value, parent_type, parent_name, parent_path_expr,
return;
}
- if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT)
+ if (parent_type->code () == TYPE_CODE_STRUCT
+ || parent_type->code () == TYPE_CODE_UNION)
{
ada_varobj_describe_struct_child (parent_value, parent_type,
parent_name, parent_path_expr,
return;
}
- if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
+ if (parent_type->code () == TYPE_CODE_PTR)
{
ada_varobj_describe_ptr_child (parent_value, parent_type,
parent_name, parent_path_expr,
ada_varobj_get_value_image (struct value *value,
struct value_print_options *opts)
{
- struct ui_file *buffer;
- struct cleanup *old_chain;
+ string_file buffer;
- buffer = mem_fileopen ();
- old_chain = make_cleanup_ui_file_delete (buffer);
-
- common_val_print (value, buffer, 0, opts, current_language);
- std::string result = ui_file_as_string (buffer);
-
- do_cleanups (old_chain);
- return result;
+ common_val_print (value, &buffer, 0, opts, current_language);
+ return std::move (buffer.string ());
}
/* Assuming that the (VALUE, TYPE) pair designates an array varobj,
struct type *type,
struct value_print_options *opts)
{
- char *result;
const int numchild = ada_varobj_get_array_number_of_children (value, type);
/* If we have a string, provide its contents in the "value" field.
{
ada_varobj_decode_var (&value, &type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
static int
ada_number_of_children (const struct varobj *var)
{
- return ada_varobj_get_number_of_children (var->value, var->type);
+ return ada_varobj_get_number_of_children (var->value.get (), var->type);
}
static std::string
static std::string
ada_name_of_child (const struct varobj *parent, int index)
{
- return ada_varobj_get_name_of_child (parent->value, parent->type,
+ return ada_varobj_get_name_of_child (parent->value.get (), parent->type,
parent->name.c_str (), index);
}
const struct varobj *parent = child->parent;
const char *parent_path_expr = varobj_get_path_expr (parent);
- return ada_varobj_get_path_expr_of_child (parent->value,
+ return ada_varobj_get_path_expr_of_child (parent->value.get (),
parent->type,
parent->name.c_str (),
parent_path_expr,
static struct value *
ada_value_of_child (const struct varobj *parent, int index)
{
- return ada_varobj_get_value_of_child (parent->value, parent->type,
+ return ada_varobj_get_value_of_child (parent->value.get (), parent->type,
parent->name.c_str (), index);
}
static struct type *
ada_type_of_child (const struct varobj *parent, int index)
{
- return ada_varobj_get_type_of_child (parent->value, parent->type,
+ return ada_varobj_get_type_of_child (parent->value.get (), parent->type,
index);
}
varobj_formatted_print_options (&opts, format);
- return ada_varobj_get_value_of_variable (var->value, var->type, &opts);
+ return ada_varobj_get_value_of_variable (var->value.get (), var->type,
+ &opts);
}
/* Implement the "value_is_changeable_p" routine for Ada. */
-static int
+static bool
ada_value_is_changeable_p (const struct varobj *var)
{
- struct type *type = var->value ? value_type (var->value) : var->type;
+ struct type *type = (var->value != nullptr
+ ? value_type (var->value.get ()) : var->type);
- if (ada_is_array_descriptor_type (type)
- && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ if (type->code () == TYPE_CODE_REF)
+ type = TYPE_TARGET_TYPE (type);
+
+ if (ada_is_access_to_unconstrained_array (type))
{
/* This is in reality a pointer to an unconstrained array.
its value is changeable. */
- return 1;
+ return true;
}
if (ada_is_string_type (type))
/* We display the contents of the string in the array's
"value" field. The contents can change, so consider
that the array is changeable. */
- return 1;
+ return true;
}
return varobj_default_value_is_changeable_p (var);
/* Implement the "value_has_mutated" routine for Ada. */
-static int
+static bool
ada_value_has_mutated (const struct varobj *var, struct value *new_val,
struct type *new_type)
{
- int i;
int from = -1;
int to = -1;
has mutated. */
if (ada_varobj_get_number_of_children (new_val, new_type)
!= var->num_children)
- return 1;
+ return true;
/* If the number of fields have remained the same, then we need
to check the name of each field. If they remain the same,
has mutated or not. So just assume it hasn't. */
varobj_restrict_range (var->children, &from, &to);
- for (i = from; i < to; i++)
+ for (int i = from; i < to; i++)
if (ada_varobj_get_name_of_child (new_val, new_type,
var->name.c_str (), i)
- != VEC_index (varobj_p, var->children, i)->name)
- return 1;
+ != var->children[i]->name)
+ return true;
- return 0;
+ return false;
}
/* varobj operations for ada. */
projects / deliverable / binutils-gdb.git / blobdiff