2012-03-28 23:31:18 +02:00
|
|
|
/* varobj support for Ada.
|
|
|
|
|
2015-01-01 10:32:14 +01:00
|
|
|
Copyright (C) 2012-2015 Free Software Foundation, Inc.
|
2012-03-28 23:31:18 +02:00
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
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
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "ada-lang.h"
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
#include "varobj.h"
|
2012-03-28 23:31:18 +02:00
|
|
|
#include "language.h"
|
|
|
|
#include "valprint.h"
|
|
|
|
|
|
|
|
/* Implementation principle used in this unit:
|
|
|
|
|
|
|
|
For our purposes, the meat of the varobj object is made of two
|
|
|
|
elements: The varobj's (struct) value, and the varobj's (struct)
|
|
|
|
type. In most situations, the varobj has a non-NULL value, and
|
|
|
|
the type becomes redundant, as it can be directly derived from
|
|
|
|
the value. In the initial implementation of this unit, most
|
|
|
|
routines would only take a value, and return a value.
|
|
|
|
|
|
|
|
But there are many situations where it is possible for a varobj
|
|
|
|
to have a NULL value. For instance, if the varobj becomes out of
|
|
|
|
scope. Or better yet, when the varobj is the child of another
|
|
|
|
NULL pointer varobj. In that situation, we must rely on the type
|
|
|
|
instead of the value to create the child varobj.
|
|
|
|
|
|
|
|
That's why most functions below work with a (value, type) pair.
|
|
|
|
The value may or may not be NULL. But the type is always expected
|
|
|
|
to be set. When the value is NULL, then we work with the type
|
|
|
|
alone, and keep the value NULL. But when the value is not NULL,
|
|
|
|
then we work using the value, because it provides more information.
|
|
|
|
But we still always set the type as well, even if that type could
|
|
|
|
easily be derived from the value. The reason behind this is that
|
|
|
|
it allows the code to use the type without having to worry about
|
|
|
|
it being set or not. It makes the code clearer. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static int ada_varobj_get_number_of_children (struct value *parent_value,
|
|
|
|
struct type *parent_type);
|
|
|
|
|
2012-03-28 23:31:18 +02:00
|
|
|
/* A convenience function that decodes the VALUE_PTR/TYPE_PTR couple:
|
|
|
|
If there is a value (*VALUE_PTR not NULL), then perform the decoding
|
|
|
|
using it, and compute the associated type from the resulting value.
|
|
|
|
Otherwise, compute a static approximation of *TYPE_PTR, leaving
|
|
|
|
*VALUE_PTR unchanged.
|
|
|
|
|
|
|
|
The results are written in place. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr)
|
|
|
|
{
|
|
|
|
if (*value_ptr)
|
|
|
|
{
|
|
|
|
*value_ptr = ada_get_decoded_value (*value_ptr);
|
|
|
|
*type_ptr = ada_check_typedef (value_type (*value_ptr));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*type_ptr = ada_get_decoded_type (*type_ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return a string containing an image of the given scalar value.
|
|
|
|
VAL is the numeric value, while TYPE is the value's type.
|
|
|
|
This is useful for plain integers, of course, but even more
|
|
|
|
so for enumerated types.
|
|
|
|
|
|
|
|
The result should be deallocated by xfree after use. */
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ada_varobj_scalar_image (struct type *type, LONGEST val)
|
|
|
|
{
|
|
|
|
struct ui_file *buf = mem_fileopen ();
|
|
|
|
struct cleanup *cleanups = make_cleanup_ui_file_delete (buf);
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
ada_print_scalar (type, val, buf);
|
|
|
|
result = ui_file_xstrdup (buf, NULL);
|
|
|
|
do_cleanups (cleanups);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates
|
|
|
|
a struct or union, compute the (CHILD_VALUE, CHILD_TYPE) couple
|
|
|
|
corresponding to the field number FIELDNO. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_struct_elt (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
int fieldno,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type)
|
|
|
|
{
|
|
|
|
struct value *value = NULL;
|
|
|
|
struct type *type = NULL;
|
|
|
|
|
|
|
|
if (parent_value)
|
|
|
|
{
|
|
|
|
value = value_field (parent_value, fieldno);
|
|
|
|
type = value_type (value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
type = TYPE_FIELD_TYPE (parent_type, fieldno);
|
|
|
|
|
|
|
|
if (child_value)
|
|
|
|
*child_value = value;
|
|
|
|
if (child_type)
|
|
|
|
*child_type = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a pointer or
|
|
|
|
reference, return a (CHILD_VALUE, CHILD_TYPE) couple corresponding
|
|
|
|
to the dereferenced value. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_ind (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type)
|
|
|
|
{
|
|
|
|
struct value *value = NULL;
|
|
|
|
struct type *type = NULL;
|
|
|
|
|
|
|
|
if (ada_is_array_descriptor_type (parent_type))
|
|
|
|
{
|
|
|
|
/* This can only happen when PARENT_VALUE is NULL. Otherwise,
|
|
|
|
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);
|
|
|
|
|
|
|
|
/* Decode parent_type by the equivalent pointer to (decoded)
|
|
|
|
array. */
|
|
|
|
while (TYPE_CODE (parent_type) == 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If parent_value is a null pointer, then only perform static
|
|
|
|
dereferencing. We cannot dereference null pointers. */
|
|
|
|
if (parent_value && value_as_address (parent_value) == 0)
|
|
|
|
parent_value = NULL;
|
|
|
|
|
|
|
|
if (parent_value)
|
|
|
|
{
|
|
|
|
value = ada_value_ind (parent_value);
|
|
|
|
type = value_type (value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
type = TYPE_TARGET_TYPE (parent_type);
|
|
|
|
|
|
|
|
if (child_value)
|
|
|
|
*child_value = value;
|
|
|
|
if (child_type)
|
|
|
|
*child_type = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a simple
|
|
|
|
array (TYPE_CODE_ARRAY), return the (CHILD_VALUE, CHILD_TYPE)
|
|
|
|
pair corresponding to the element at ELT_INDEX. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_simple_array_elt (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
int elt_index,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type)
|
|
|
|
{
|
|
|
|
struct value *value = NULL;
|
|
|
|
struct type *type = NULL;
|
|
|
|
|
|
|
|
if (parent_value)
|
|
|
|
{
|
|
|
|
struct value *index_value =
|
|
|
|
value_from_longest (TYPE_INDEX_TYPE (parent_type), elt_index);
|
|
|
|
|
|
|
|
value = ada_value_subscript (parent_value, 1, &index_value);
|
|
|
|
type = value_type (value);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
type = TYPE_TARGET_TYPE (parent_type);
|
|
|
|
|
|
|
|
if (child_value)
|
|
|
|
*child_value = value;
|
|
|
|
if (child_type)
|
|
|
|
*child_type = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given the decoded value and decoded type of a variable object,
|
|
|
|
adjust the value and type to those necessary for getting children
|
|
|
|
of the variable object.
|
|
|
|
|
|
|
|
The replacement is performed in place. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_adjust_for_child_access (struct value **value,
|
|
|
|
struct type **type)
|
|
|
|
{
|
|
|
|
/* Pointers to struct/union types are special: Instead of having
|
|
|
|
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)
|
|
|
|
&& !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);
|
2014-01-04 03:31:11 +01:00
|
|
|
|
|
|
|
/* If this is a tagged type, we need to transform it a bit in order
|
|
|
|
to be able to fetch its full view. As always with tagged types,
|
|
|
|
we can only do that if we have a value. */
|
|
|
|
if (*value != NULL && ada_is_tagged_type (*type, 1))
|
|
|
|
{
|
|
|
|
*value = ada_tag_value_at_base_address (*value);
|
|
|
|
*type = value_type (*value);
|
|
|
|
}
|
2012-03-28 23:31:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is an array
|
|
|
|
(any type of array, "simple" or not), return the number of children
|
|
|
|
that this array contains. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
ada_varobj_get_array_number_of_children (struct value *parent_value,
|
|
|
|
struct type *parent_type)
|
|
|
|
{
|
|
|
|
LONGEST lo, hi;
|
|
|
|
|
[Ada/varobj] number of children of null pointer to dynamic array.
This is preparation work to avoid a regression in the Ada/varobj.
An upcoming patch is going to add support for types in DWARF
which have dynamic properties whose value is a reference to another
DIE.
Consider for instance the following declaration:
type Variant_Type (N : Int := 0) is record
F : String(1 .. N) := (others => 'x');
end record;
type Variant_Type_Access is access all Variant_Type;
VTA : Variant_Type_Access := null;
This declares a variable "VTA" which is an access (=pointer)
to a variant record Variant_Type. This record contains two
components, the first being "N" (the discriminant), and the
second being "F", an array whose lower bound is 1, and whose
upper bound depends on the value of "N" (the discriminant).
Of interest to us, here, is that second component ("F"), and
in particular its bounds. The debugging info, and in particular
the info for the array looks like the following...
.uleb128 0x9 # (DIE (0x91) DW_TAG_array_type)
.long .LASF16 # DW_AT_name: "bar__variant_type__T2b"
.long 0xac # DW_AT_GNAT_descriptive_type
.long 0x2cb # DW_AT_type
.long 0xac # DW_AT_sibling
.uleb128 0xa # (DIE (0xa2) DW_TAG_subrange_type)
.long 0xc4 # DW_AT_type
.long 0x87 # DW_AT_upper_bound
.byte 0 # end of children of DIE 0x91
... where the upper bound of the array's subrange type is a reference
to "n"'s DIE (0x87):
.uleb128 0x8 # (DIE (0x87) DW_TAG_member)
.ascii "n\0" # DW_AT_name
[...]
Once the patch to handle this dynamic property gets applied,
this is what happens when creating a varobj for variable "VTA"
(whose value is null), and then trying to list its children:
(gdb)
-var-create vta * vta
^done,name="vta",numchild="2",value="0x0",
type="bar.variant_type_access",has_more="0"
(gdb)
-var-list-children 1 vta
^done,numchild="2",
children=[child={name="vta.n",[...]},
child={name="vta.f",exp="f",
numchild="43877616", <<<<-----
value="[43877616]", <<<<-----
type="array (1 .. n) of character"}],
has_more="0"
It has an odd number of children.
In this case, we cannot really determine the number of children,
since that number depends on the value of a field in a record
for which we do not have a value. Up to now, the value we've been
displaying is zero - meaning we have an empty array.
What happens in this case, is that, because the VTA is a null pointer,
we're not able to resolve the pointer's target type, and therefore
end up asking ada_varobj_get_array_number_of_children to return
the number of elements in that array; for that, it relies blindly
on get_array_bounds, which assumes the type is no longer dynamic,
and therefore the reads the bound without seeing that it's value
is actually a reference rather than a resolved constant.
This patch prevents the issue by explicitly handling the case of
dynamic arrays, and returning zero child in that case.
gdb/ChangeLog:
* ada-varobj.c (ada_varobj_get_array_number_of_children):
Return zero if PARENT_VALUE is NULL and parent_type's
range type is dynamic.
gdb/testsuite/ChangeLog:
* gdb.ada/mi_var_array: New testcase.
Tested on x86_64-linux.
2015-01-14 15:39:24 +01:00
|
|
|
if (parent_value == NULL
|
|
|
|
&& is_dynamic_type (TYPE_INDEX_TYPE (parent_type)))
|
|
|
|
{
|
|
|
|
/* This happens when listing the children of an object
|
|
|
|
which does not exist in memory (Eg: when requesting
|
|
|
|
the children of a null pointer, which is allowed by
|
|
|
|
varobj). The array index type being dynamic, we cannot
|
|
|
|
determine how many elements this array has. Just assume
|
|
|
|
it has none. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-03-28 23:31:18 +02:00
|
|
|
if (!get_array_bounds (parent_type, &lo, &hi))
|
|
|
|
{
|
|
|
|
/* Could not get the array bounds. Pretend this is an empty array. */
|
|
|
|
warning (_("unable to get bounds of array, assuming null array"));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ada allows the upper bound to be less than the lower bound,
|
|
|
|
in order to specify empty arrays... */
|
|
|
|
if (hi < lo)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return hi - lo + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a struct or
|
|
|
|
union, return the number of children this struct contains. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
ada_varobj_get_struct_number_of_children (struct value *parent_value,
|
|
|
|
struct type *parent_type)
|
|
|
|
{
|
|
|
|
int n_children = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
|
|
|
|
|| TYPE_CODE (parent_type) == TYPE_CODE_UNION);
|
|
|
|
|
|
|
|
for (i = 0; i < TYPE_NFIELDS (parent_type); i++)
|
|
|
|
{
|
|
|
|
if (ada_is_ignored_field (parent_type, i))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ada_is_wrapper_field (parent_type, i))
|
|
|
|
{
|
|
|
|
struct value *elt_value;
|
|
|
|
struct type *elt_type;
|
|
|
|
|
|
|
|
ada_varobj_struct_elt (parent_value, parent_type, i,
|
|
|
|
&elt_value, &elt_type);
|
|
|
|
if (ada_is_tagged_type (elt_type, 0))
|
|
|
|
{
|
|
|
|
/* We must not use ada_varobj_get_number_of_children
|
|
|
|
to determine is element's number of children, because
|
|
|
|
this function first calls ada_varobj_decode_var,
|
|
|
|
which "fixes" the element. For tagged types, this
|
|
|
|
includes reading the object's tag to determine its
|
|
|
|
real type, which happens to be the parent_type, and
|
|
|
|
leads to an infinite loop (because the element gets
|
|
|
|
fixed back into the parent). */
|
|
|
|
n_children += ada_varobj_get_struct_number_of_children
|
|
|
|
(elt_value, elt_type);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n_children += ada_varobj_get_number_of_children (elt_value, elt_type);
|
|
|
|
}
|
|
|
|
else if (ada_is_variant_part (parent_type, i))
|
|
|
|
{
|
|
|
|
/* In normal situations, the variant part of the record should
|
|
|
|
have been "fixed". Or, in other words, it should have been
|
|
|
|
replaced by the branch of the variant part that is relevant
|
|
|
|
for our value. But there are still situations where this
|
|
|
|
can happen, however (Eg. when our parent is a NULL pointer).
|
|
|
|
We do not support showing this part of the record for now,
|
|
|
|
so just pretend this field does not exist. */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
n_children++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return n_children;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates
|
|
|
|
a pointer, return the number of children this pointer has. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
ada_varobj_get_ptr_number_of_children (struct value *parent_value,
|
|
|
|
struct type *parent_type)
|
|
|
|
{
|
|
|
|
struct type *child_type = TYPE_TARGET_TYPE (parent_type);
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* All other types have 1 child. */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the number of children for the (PARENT_VALUE, PARENT_TYPE)
|
|
|
|
pair. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static int
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_number_of_children (struct value *parent_value,
|
|
|
|
struct type *parent_type)
|
|
|
|
{
|
|
|
|
ada_varobj_decode_var (&parent_value, &parent_type);
|
|
|
|
ada_varobj_adjust_for_child_access (&parent_value, &parent_type);
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (TYPE_CODE (parent_type) == 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)
|
|
|
|
return ada_varobj_get_struct_number_of_children (parent_value,
|
|
|
|
parent_type);
|
|
|
|
|
|
|
|
if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
|
|
|
|
return ada_varobj_get_ptr_number_of_children (parent_value,
|
|
|
|
parent_type);
|
|
|
|
|
|
|
|
/* All other types have no child. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Describe the child of the (PARENT_VALUE, PARENT_TYPE) pair
|
|
|
|
whose index is CHILD_INDEX:
|
|
|
|
|
|
|
|
- If CHILD_NAME is not NULL, then a copy of the child's name
|
|
|
|
is saved in *CHILD_NAME. This copy must be deallocated
|
|
|
|
with xfree after use.
|
|
|
|
|
|
|
|
- If CHILD_VALUE is not NULL, then save the child's value
|
|
|
|
in *CHILD_VALUE. Same thing for the child's type with
|
|
|
|
CHILD_TYPE if not NULL.
|
|
|
|
|
|
|
|
- If CHILD_PATH_EXPR is not NULL, then compute the child's
|
|
|
|
path expression. The resulting string must be deallocated
|
|
|
|
after use with xfree.
|
|
|
|
|
|
|
|
Computing the child's path expression requires the PARENT_PATH_EXPR
|
|
|
|
to be non-NULL. Otherwise, PARENT_PATH_EXPR may be null if
|
|
|
|
CHILD_PATH_EXPR is NULL.
|
|
|
|
|
|
|
|
PARENT_NAME is the name of the parent, and should never be NULL. */
|
|
|
|
|
|
|
|
static void ada_varobj_describe_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index,
|
|
|
|
char **child_name,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type,
|
|
|
|
char **child_path_expr);
|
|
|
|
|
|
|
|
/* Same as ada_varobj_describe_child, but limited to struct/union
|
|
|
|
objects. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_describe_struct_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index,
|
|
|
|
char **child_name,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type,
|
|
|
|
char **child_path_expr)
|
|
|
|
{
|
|
|
|
int fieldno;
|
|
|
|
int childno = 0;
|
|
|
|
|
|
|
|
gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT);
|
|
|
|
|
|
|
|
for (fieldno = 0; fieldno < TYPE_NFIELDS (parent_type); fieldno++)
|
|
|
|
{
|
|
|
|
if (ada_is_ignored_field (parent_type, fieldno))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ada_is_wrapper_field (parent_type, fieldno))
|
|
|
|
{
|
|
|
|
struct value *elt_value;
|
|
|
|
struct type *elt_type;
|
|
|
|
int elt_n_children;
|
|
|
|
|
|
|
|
ada_varobj_struct_elt (parent_value, parent_type, fieldno,
|
|
|
|
&elt_value, &elt_type);
|
|
|
|
if (ada_is_tagged_type (elt_type, 0))
|
|
|
|
{
|
|
|
|
/* Same as in ada_varobj_get_struct_number_of_children:
|
|
|
|
For tagged types, we must be careful to not call
|
|
|
|
ada_varobj_get_number_of_children, to prevent our
|
|
|
|
element from being fixed back into the parent. */
|
|
|
|
elt_n_children = ada_varobj_get_struct_number_of_children
|
|
|
|
(elt_value, elt_type);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
elt_n_children =
|
|
|
|
ada_varobj_get_number_of_children (elt_value, elt_type);
|
|
|
|
|
|
|
|
/* Is the child we're looking for one of the children
|
|
|
|
of this wrapper field? */
|
|
|
|
if (child_index - childno < elt_n_children)
|
|
|
|
{
|
|
|
|
if (ada_is_tagged_type (elt_type, 0))
|
|
|
|
{
|
|
|
|
/* Same as in ada_varobj_get_struct_number_of_children:
|
|
|
|
For tagged types, we must be careful to not call
|
|
|
|
ada_varobj_describe_child, to prevent our element
|
|
|
|
from being fixed back into the parent. */
|
|
|
|
ada_varobj_describe_struct_child
|
|
|
|
(elt_value, elt_type, parent_name, parent_path_expr,
|
|
|
|
child_index - childno, child_name, child_value,
|
|
|
|
child_type, child_path_expr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ada_varobj_describe_child (elt_value, elt_type,
|
|
|
|
parent_name, parent_path_expr,
|
|
|
|
child_index - childno,
|
|
|
|
child_name, child_value,
|
|
|
|
child_type, child_path_expr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The child we're looking for is beyond this wrapper
|
|
|
|
field, so skip all its children. */
|
|
|
|
childno += elt_n_children;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else if (ada_is_variant_part (parent_type, fieldno))
|
|
|
|
{
|
|
|
|
/* In normal situations, the variant part of the record should
|
|
|
|
have been "fixed". Or, in other words, it should have been
|
|
|
|
replaced by the branch of the variant part that is relevant
|
|
|
|
for our value. But there are still situations where this
|
|
|
|
can happen, however (Eg. when our parent is a NULL pointer).
|
|
|
|
We do not support showing this part of the record for now,
|
|
|
|
so just pretend this field does not exist. */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (childno == child_index)
|
|
|
|
{
|
|
|
|
if (child_name)
|
|
|
|
{
|
|
|
|
/* The name of the child is none other than the field's
|
|
|
|
name, except that we need to strip suffixes from it.
|
|
|
|
For instance, fields with alignment constraints will
|
|
|
|
have an __XVA suffix added to them. */
|
|
|
|
const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno);
|
|
|
|
int child_name_len = ada_name_prefix_len (field_name);
|
|
|
|
|
|
|
|
*child_name = xstrprintf ("%.*s", child_name_len, field_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (child_value && parent_value)
|
|
|
|
ada_varobj_struct_elt (parent_value, parent_type, fieldno,
|
|
|
|
child_value, NULL);
|
|
|
|
|
|
|
|
if (child_type)
|
|
|
|
ada_varobj_struct_elt (parent_value, parent_type, fieldno,
|
|
|
|
NULL, child_type);
|
|
|
|
|
|
|
|
if (child_path_expr)
|
|
|
|
{
|
|
|
|
/* The name of the child is none other than the field's
|
|
|
|
name, except that we need to strip suffixes from it.
|
|
|
|
For instance, fields with alignment constraints will
|
|
|
|
have an __XVA suffix added to them. */
|
|
|
|
const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno);
|
|
|
|
int child_name_len = ada_name_prefix_len (field_name);
|
|
|
|
|
|
|
|
*child_path_expr =
|
|
|
|
xstrprintf ("(%s).%.*s", parent_path_expr,
|
|
|
|
child_name_len, field_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
childno++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Something went wrong. Either we miscounted the number of
|
|
|
|
children, or CHILD_INDEX was too high. But we should never
|
|
|
|
reach here. We don't have enough information to recover
|
|
|
|
nicely, so just raise an assertion failure. */
|
|
|
|
gdb_assert_not_reached ("unexpected code path");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Same as ada_varobj_describe_child, but limited to pointer objects.
|
|
|
|
|
|
|
|
Note that CHILD_INDEX is unused in this situation, but still provided
|
|
|
|
for consistency of interface with other routines describing an object's
|
|
|
|
child. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_describe_ptr_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index,
|
|
|
|
char **child_name,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type,
|
|
|
|
char **child_path_expr)
|
|
|
|
{
|
|
|
|
if (child_name)
|
|
|
|
*child_name = xstrprintf ("%s.all", parent_name);
|
|
|
|
|
|
|
|
if (child_value && parent_value)
|
|
|
|
ada_varobj_ind (parent_value, parent_type, child_value, NULL);
|
|
|
|
|
|
|
|
if (child_type)
|
|
|
|
ada_varobj_ind (parent_value, parent_type, NULL, child_type);
|
|
|
|
|
|
|
|
if (child_path_expr)
|
|
|
|
*child_path_expr = xstrprintf ("(%s).all", parent_path_expr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Same as ada_varobj_describe_child, limited to simple array objects
|
|
|
|
(TYPE_CODE_ARRAY only).
|
|
|
|
|
|
|
|
Assumes that the (PARENT_VALUE, PARENT_TYPE) pair is properly decoded.
|
|
|
|
This is done by ada_varobj_describe_child before calling us. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_describe_simple_array_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index,
|
|
|
|
char **child_name,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type,
|
|
|
|
char **child_path_expr)
|
|
|
|
{
|
|
|
|
struct type *index_type;
|
|
|
|
int real_index;
|
|
|
|
|
|
|
|
gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY);
|
|
|
|
|
2014-04-24 18:09:11 +02:00
|
|
|
index_type = TYPE_INDEX_TYPE (parent_type);
|
2012-03-28 23:31:18 +02:00
|
|
|
real_index = child_index + ada_discrete_type_low_bound (index_type);
|
|
|
|
|
|
|
|
if (child_name)
|
|
|
|
*child_name = ada_varobj_scalar_image (index_type, real_index);
|
|
|
|
|
|
|
|
if (child_value && parent_value)
|
|
|
|
ada_varobj_simple_array_elt (parent_value, parent_type, real_index,
|
|
|
|
child_value, NULL);
|
|
|
|
|
|
|
|
if (child_type)
|
|
|
|
ada_varobj_simple_array_elt (parent_value, parent_type, real_index,
|
|
|
|
NULL, child_type);
|
|
|
|
|
|
|
|
if (child_path_expr)
|
|
|
|
{
|
|
|
|
char *index_img = ada_varobj_scalar_image (index_type, real_index);
|
|
|
|
struct cleanup *cleanups = make_cleanup (xfree, index_img);
|
|
|
|
|
|
|
|
/* Enumeration litterals by themselves are potentially ambiguous.
|
|
|
|
For instance, consider the following package spec:
|
|
|
|
|
|
|
|
package Pck is
|
|
|
|
type Color is (Red, Green, Blue, White);
|
|
|
|
type Blood_Cells is (White, Red);
|
|
|
|
end Pck;
|
|
|
|
|
|
|
|
In this case, the litteral "red" for instance, or even
|
|
|
|
the fully-qualified litteral "pck.red" cannot be resolved
|
|
|
|
by itself. Type qualification is needed to determine which
|
|
|
|
enumeration litterals should be used.
|
|
|
|
|
|
|
|
The following variable will be used to contain the name
|
|
|
|
of the array index type when such type qualification is
|
|
|
|
needed. */
|
|
|
|
const char *index_type_name = NULL;
|
|
|
|
|
|
|
|
/* If the index type is a range type, find the base type. */
|
|
|
|
while (TYPE_CODE (index_type) == 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)
|
|
|
|
{
|
|
|
|
index_type_name = ada_type_name (index_type);
|
|
|
|
if (index_type_name)
|
|
|
|
index_type_name = ada_decode (index_type_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index_type_name != NULL)
|
|
|
|
*child_path_expr =
|
|
|
|
xstrprintf ("(%s)(%.*s'(%s))", parent_path_expr,
|
|
|
|
ada_name_prefix_len (index_type_name),
|
|
|
|
index_type_name, index_img);
|
|
|
|
else
|
|
|
|
*child_path_expr =
|
|
|
|
xstrprintf ("(%s)(%s)", parent_path_expr, index_img);
|
|
|
|
do_cleanups (cleanups);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See description at declaration above. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
ada_varobj_describe_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index,
|
|
|
|
char **child_name,
|
|
|
|
struct value **child_value,
|
|
|
|
struct type **child_type,
|
|
|
|
char **child_path_expr)
|
|
|
|
{
|
|
|
|
/* We cannot compute the child's path expression without
|
|
|
|
the parent's path expression. This is a pre-condition
|
|
|
|
for calling this function. */
|
|
|
|
if (child_path_expr)
|
|
|
|
gdb_assert (parent_path_expr != NULL);
|
|
|
|
|
|
|
|
ada_varobj_decode_var (&parent_value, &parent_type);
|
|
|
|
ada_varobj_adjust_for_child_access (&parent_value, &parent_type);
|
|
|
|
|
|
|
|
if (child_name)
|
|
|
|
*child_name = NULL;
|
|
|
|
if (child_value)
|
|
|
|
*child_value = NULL;
|
|
|
|
if (child_type)
|
|
|
|
*child_type = NULL;
|
|
|
|
if (child_path_expr)
|
|
|
|
*child_path_expr = NULL;
|
|
|
|
|
|
|
|
if (ada_is_array_descriptor_type (parent_type)
|
|
|
|
&& TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF)
|
|
|
|
{
|
|
|
|
ada_varobj_describe_ptr_child (parent_value, parent_type,
|
|
|
|
parent_name, parent_path_expr,
|
|
|
|
child_index, child_name,
|
|
|
|
child_value, child_type,
|
|
|
|
child_path_expr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY)
|
|
|
|
{
|
|
|
|
ada_varobj_describe_simple_array_child
|
|
|
|
(parent_value, parent_type, parent_name, parent_path_expr,
|
|
|
|
child_index, child_name, child_value, child_type,
|
|
|
|
child_path_expr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT)
|
|
|
|
{
|
|
|
|
ada_varobj_describe_struct_child (parent_value, parent_type,
|
|
|
|
parent_name, parent_path_expr,
|
|
|
|
child_index, child_name,
|
|
|
|
child_value, child_type,
|
|
|
|
child_path_expr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TYPE_CODE (parent_type) == TYPE_CODE_PTR)
|
|
|
|
{
|
|
|
|
ada_varobj_describe_ptr_child (parent_value, parent_type,
|
|
|
|
parent_name, parent_path_expr,
|
|
|
|
child_index, child_name,
|
|
|
|
child_value, child_type,
|
|
|
|
child_path_expr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* It should never happen. But rather than crash, report dummy names
|
|
|
|
and return a NULL child_value. */
|
|
|
|
if (child_name)
|
|
|
|
*child_name = xstrdup ("???");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the name of the child number CHILD_INDEX of the (PARENT_VALUE,
|
|
|
|
PARENT_TYPE) pair. PARENT_NAME is the name of the PARENT.
|
|
|
|
|
|
|
|
The result should be deallocated after use with xfree. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static char *
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_name_of_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name, int child_index)
|
|
|
|
{
|
|
|
|
char *child_name;
|
|
|
|
|
|
|
|
ada_varobj_describe_child (parent_value, parent_type, parent_name,
|
|
|
|
NULL, child_index, &child_name, NULL,
|
|
|
|
NULL, NULL);
|
|
|
|
return child_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the path expression of the child number CHILD_INDEX of
|
|
|
|
the (PARENT_VALUE, PARENT_TYPE) pair. PARENT_NAME is the name
|
|
|
|
of the parent, and PARENT_PATH_EXPR is the parent's path expression.
|
|
|
|
Both must be non-NULL.
|
|
|
|
|
|
|
|
The result must be deallocated after use with xfree. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static char *
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_path_expr_of_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name,
|
|
|
|
const char *parent_path_expr,
|
|
|
|
int child_index)
|
|
|
|
{
|
|
|
|
char *child_path_expr;
|
|
|
|
|
|
|
|
ada_varobj_describe_child (parent_value, parent_type, parent_name,
|
|
|
|
parent_path_expr, child_index, NULL,
|
|
|
|
NULL, NULL, &child_path_expr);
|
|
|
|
|
|
|
|
return child_path_expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the value of child number CHILD_INDEX of the (PARENT_VALUE,
|
|
|
|
PARENT_TYPE) pair. PARENT_NAME is the name of the parent. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static struct value *
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_value_of_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
const char *parent_name, int child_index)
|
|
|
|
{
|
|
|
|
struct value *child_value;
|
|
|
|
|
|
|
|
ada_varobj_describe_child (parent_value, parent_type, parent_name,
|
|
|
|
NULL, child_index, NULL, &child_value,
|
|
|
|
NULL, NULL);
|
|
|
|
|
|
|
|
return child_value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the type of child number CHILD_INDEX of the (PARENT_VALUE,
|
|
|
|
PARENT_TYPE) pair. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static struct type *
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_type_of_child (struct value *parent_value,
|
|
|
|
struct type *parent_type,
|
|
|
|
int child_index)
|
|
|
|
{
|
|
|
|
struct type *child_type;
|
|
|
|
|
|
|
|
ada_varobj_describe_child (parent_value, parent_type, NULL, NULL,
|
|
|
|
child_index, NULL, NULL, &child_type, NULL);
|
|
|
|
|
|
|
|
return child_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return a string that contains the image of the given VALUE, using
|
|
|
|
the print options OPTS as the options for formatting the result.
|
|
|
|
|
|
|
|
The resulting string must be deallocated after use with xfree. */
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ada_varobj_get_value_image (struct value *value,
|
|
|
|
struct value_print_options *opts)
|
|
|
|
{
|
|
|
|
char *result;
|
|
|
|
struct ui_file *buffer;
|
|
|
|
struct cleanup *old_chain;
|
|
|
|
|
|
|
|
buffer = mem_fileopen ();
|
|
|
|
old_chain = make_cleanup_ui_file_delete (buffer);
|
|
|
|
|
|
|
|
common_val_print (value, buffer, 0, opts, current_language);
|
|
|
|
result = ui_file_xstrdup (buffer, NULL);
|
|
|
|
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Assuming that the (VALUE, TYPE) pair designates an array varobj,
|
|
|
|
return a string that is suitable for use in the "value" field of
|
|
|
|
the varobj output. Most of the time, this is the number of elements
|
|
|
|
in the array inside square brackets, but there are situations where
|
|
|
|
it's useful to add more info.
|
|
|
|
|
|
|
|
OPTS are the print options used when formatting the result.
|
|
|
|
|
|
|
|
The result should be deallocated after use using xfree. */
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ada_varobj_get_value_of_array_variable (struct value *value,
|
|
|
|
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.
|
|
|
|
Otherwise, the only other way to inspect the contents of the string
|
|
|
|
is by looking at the value of each element, as in any other array,
|
|
|
|
which is not very convenient... */
|
|
|
|
if (value
|
|
|
|
&& ada_is_string_type (type)
|
|
|
|
&& (opts->format == 0 || opts->format == 's'))
|
|
|
|
{
|
|
|
|
char *str;
|
|
|
|
struct cleanup *old_chain;
|
|
|
|
|
|
|
|
str = ada_varobj_get_value_image (value, opts);
|
|
|
|
old_chain = make_cleanup (xfree, str);
|
|
|
|
result = xstrprintf ("[%d] %s", numchild, str);
|
|
|
|
do_cleanups (old_chain);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
result = xstrprintf ("[%d]", numchild);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return a string representation of the (VALUE, TYPE) pair, using
|
|
|
|
the given print options OPTS as our formatting options. */
|
|
|
|
|
2013-10-17 15:31:33 +02:00
|
|
|
static char *
|
2012-03-28 23:31:18 +02:00
|
|
|
ada_varobj_get_value_of_variable (struct value *value,
|
|
|
|
struct type *type,
|
|
|
|
struct value_print_options *opts)
|
|
|
|
{
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
ada_varobj_decode_var (&value, &type);
|
|
|
|
|
|
|
|
switch (TYPE_CODE (type))
|
|
|
|
{
|
|
|
|
case TYPE_CODE_STRUCT:
|
|
|
|
case TYPE_CODE_UNION:
|
|
|
|
result = xstrdup ("{...}");
|
|
|
|
break;
|
|
|
|
case TYPE_CODE_ARRAY:
|
|
|
|
result = ada_varobj_get_value_of_array_variable (value, type, opts);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!value)
|
|
|
|
result = xstrdup ("");
|
|
|
|
else
|
|
|
|
result = ada_varobj_get_value_image (value, opts);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
/* Ada specific callbacks for VAROBJs. */
|
2012-03-28 23:31:18 +02:00
|
|
|
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
static int
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_number_of_children (const struct varobj *var)
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
{
|
|
|
|
return ada_varobj_get_number_of_children (var->value, var->type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_name_of_variable (const struct varobj *parent)
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
{
|
|
|
|
return c_varobj_ops.name_of_variable (parent);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ada_name_of_child (struct varobj *parent, int index)
|
|
|
|
{
|
|
|
|
return ada_varobj_get_name_of_child (parent->value, parent->type,
|
|
|
|
parent->name, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char*
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_path_expr_of_child (const struct varobj *child)
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
{
|
|
|
|
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,
|
|
|
|
parent->type,
|
|
|
|
parent->name,
|
|
|
|
parent_path_expr,
|
|
|
|
child->index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct value *
|
|
|
|
ada_value_of_child (struct varobj *parent, int index)
|
|
|
|
{
|
|
|
|
return ada_varobj_get_value_of_child (parent->value, parent->type,
|
|
|
|
parent->name, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct type *
|
|
|
|
ada_type_of_child (struct varobj *parent, int index)
|
|
|
|
{
|
|
|
|
return ada_varobj_get_type_of_child (parent->value, parent->type,
|
|
|
|
index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_value_of_variable (const struct varobj *var,
|
|
|
|
enum varobj_display_formats format)
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
{
|
|
|
|
struct value_print_options opts;
|
|
|
|
|
|
|
|
varobj_formatted_print_options (&opts, format);
|
|
|
|
|
|
|
|
return ada_varobj_get_value_of_variable (var->value, var->type, &opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "value_is_changeable_p" routine for Ada. */
|
|
|
|
|
|
|
|
static int
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_value_is_changeable_p (const struct varobj *var)
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
{
|
|
|
|
struct type *type = var->value ? value_type (var->value) : var->type;
|
|
|
|
|
|
|
|
if (ada_is_array_descriptor_type (type)
|
|
|
|
&& TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
|
|
|
|
{
|
|
|
|
/* This is in reality a pointer to an unconstrained array.
|
|
|
|
its value is changeable. */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 varobj_default_value_is_changeable_p (var);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Implement the "value_has_mutated" routine for Ada. */
|
|
|
|
|
|
|
|
static int
|
2015-01-30 21:07:15 +01:00
|
|
|
ada_value_has_mutated (const struct varobj *var, struct value *new_val,
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
struct type *new_type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int from = -1;
|
|
|
|
int to = -1;
|
|
|
|
|
|
|
|
/* If the number of fields have changed, then for sure the type
|
|
|
|
has mutated. */
|
|
|
|
if (ada_varobj_get_number_of_children (new_val, new_type)
|
|
|
|
!= var->num_children)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* If the number of fields have remained the same, then we need
|
|
|
|
to check the name of each field. If they remain the same,
|
|
|
|
then chances are the type hasn't mutated. This is technically
|
|
|
|
an incomplete test, as the child's type might have changed
|
|
|
|
despite the fact that the name remains the same. But we'll
|
|
|
|
handle this situation by saying that the child has mutated,
|
|
|
|
not this value.
|
|
|
|
|
|
|
|
If only part (or none!) of the children have been fetched,
|
|
|
|
then only check the ones we fetched. It does not matter
|
|
|
|
to the frontend whether a child that it has not fetched yet
|
|
|
|
has mutated or not. So just assume it hasn't. */
|
|
|
|
|
|
|
|
varobj_restrict_range (var->children, &from, &to);
|
|
|
|
for (i = from; i < to; i++)
|
|
|
|
if (strcmp (ada_varobj_get_name_of_child (new_val, new_type,
|
|
|
|
var->name, i),
|
|
|
|
VEC_index (varobj_p, var->children, i)->name) != 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* varobj operations for ada. */
|
|
|
|
|
|
|
|
const struct lang_varobj_ops ada_varobj_ops =
|
|
|
|
{
|
|
|
|
ada_number_of_children,
|
|
|
|
ada_name_of_variable,
|
|
|
|
ada_name_of_child,
|
|
|
|
ada_path_expr_of_child,
|
|
|
|
ada_value_of_child,
|
|
|
|
ada_type_of_child,
|
|
|
|
ada_value_of_variable,
|
|
|
|
ada_value_is_changeable_p,
|
Improve MI -var-info-path-expression for nested struct/union case.
https://sourceware.org/ml/gdb-patches/2014-05/msg00383.html
The MI command -var-info-path-expression currently does not handle
non-anonymous structs / unions nested within other structs / unions,
it will skip parts of the expression. Consider this example:
## START EXAMPLE ##
$ cat ex.c
#include <string.h>
int
main ()
{
struct s1
{
int a;
};
struct ss
{
struct s1 x;
};
struct ss an_ss;
memset (&an_ss, 0, sizeof (an_ss));
return 0;
}
$ gcc -g -o ex.x ex.c
$ gdb ex.x
(gdb) break 18
Breakpoint 1 at 0x80483ba: file ex.c, line 18.
(gdb) run
Starting program: /home/user/ex.x
Breakpoint 1, main () at ex.c:18
18 return 0;
(gdb) interpreter-exec mi "-var-create an_ss * an_ss"
(gdb) interpreter-exec mi "-var-list-children an_ss"
^done,numchild="1",children=[child={name="an_ss.x",exp="x",numchild="1",type="struct s1",thread-id="1"}],has_more="0"
(gdb) interpreter-exec mi "-var-list-children an_ss.x"
^done,numchild="1",children=[child={name="an_ss.x.a",exp="a",numchild="0",type="int",thread-id="1"}],has_more="0"
(gdb) interpreter-exec mi "-var-list-children an_ss.x.a"
^done,numchild="0",has_more="0"
(gdb) interpreter-exec mi "-var-info-path-expression an_ss.x.a"
^done,path_expr="(an_ss).a"
(gdb) print (an_ss).a
There is no member named a.
## END EXAMPLE ##
Notice that the path expression returned is wrong, and as a result
the print command fails.
This patch adds a new method to the varobj_ops structure called
is_path_expr_parent, to allow language specific control over finding
the parent varobj, the current logic becomes the C/C++ version and is
extended to handle the nested cases. No other language currently uses
this code, so all other languages just get a default method.
With this patch, the above example now finishes like this:
## START EXAMPLE ##
$ gdb ex.x
(gdb) break 18
Breakpoint 1 at 0x80483ba: file ex.c, line 18.
(gdb) run
Starting program: /home/user/ex.x
Breakpoint 1, main () at ex.c:18
18 return 0;
(gdb) interpreter-exec mi "-var-list-children an_ss"
^done,numchild="1",children=[child={name="an_ss.x",exp="x",numchild="1",type="struct s1",thread-id="1"}],has_more="0"
(gdb) interpreter-exec mi "-var-list-children an_ss.x"
^done,numchild="1",children=[child={name="an_ss.x.a",exp="a",numchild="0",type="int",thread-id="1"}],has_more="0"
(gdb) interpreter-exec mi "-var-list-children an_ss.x.a"
^done,numchild="0",has_more="0"
(gdb) interpreter-exec mi "-var-info-path-expression an_ss.x.a"
^done,path_expr="((an_ss).x).a"
(gdb) print ((an_ss).x).a
$1 = 0
## END EXAMPLE ##
Notice that the path expression is now correct, and the print is a
success.
gdb/ChangeLog:
* ada-varobj.c (ada_varobj_ops): Fill in is_path_expr_parent
field.
* c-varobj.c (c_is_path_expr_parent): New function, moved core
from varobj.c, with additional checks.
(c_varobj_ops): Fill in is_path_expr_parent field.
(cplus_varobj_ops): Fill in is_path_expr_parent field.
* jv-varobj.c (java_varobj_ops): Fill in is_path_expr_parent
field.
* varobj.c (is_path_expr_parent): Call is_path_expr_parent varobj
ops method.
(varobj_default_is_path_expr_parent): New function.
* varobj.h (lang_varobj_ops): Add is_path_expr_parent field.
(varobj_default_is_path_expr_parent): Declare new function.
gdb/testsuite/ChangeLog:
* gdb.mi/var-cmd.c (do_nested_struct_union_tests): New function
setting up test structures.
(main): Call new test function.
* gdb.mi/mi2-var-child.exp: Create additional breakpoint in new
test function, continue into test function and walk test
structures.
2014-07-07 20:22:36 +02:00
|
|
|
ada_value_has_mutated,
|
|
|
|
varobj_default_is_path_expr_parent
|
gdb/
* Makefile.in (SFILES): Add c-varobj.c and jv-varobj.c.
(COMMON_OBS): Add c-varobj.o and jv-varobj.o.
* ada-varobj.c: Include "varobj.h".
(ada_number_of_children): New. Moved from varobj.c.
(ada_name_of_variable, ada_name_of_child): Likewise.
(ada_path_expr_of_child, ada_value_of_child): Likewise.
(ada_type_of_child, ada_value_of_variable): Likewise.
(ada_value_is_changeable_p, ada_value_has_mutated): Likewise.
(ada_varobj_ops): New.
* c-varobj.c, jv-varobj.c: New file. Moved from varobj.c.
* gdbtypes.c (get_target_type): New. Moved from varobj.c.
* gdbtypes.h (get_target_type): Declare.
* varobj.c: Remove the inclusion of "ada-varobj.h" and
"ada-lang.h".
(ANONYMOUS_STRUCT_NAME): Move it to c-varobj.c.
(ANONYMOUS_UNION_NAME): Likewise.
(get_type, get_value_type, get_target_type): Remove declarations.
(value_get_print_value, varobj_value_get_print_value): Likewise.
(c_number_of_children, c_name_of_variable): Likewise.
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable, java_number_of_children): Likewise.
(java_name_of_variable, java_name_of_child): Likewise.
(java_path_expr_of_child, java_value_of_child): Likewise.
(java_type_of_child, java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Likewise.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
(struct language_specific): Move it to varobj.h.
(CPLUS_FAKE_CHILD): Move it to varobj.h.
(restrict_range): Rename it varobj_restrict_range. Make it extern.
Callers update.
(get_path_expr_parent): Rename it to varobj_get_path_expr_parent.
Make it extern.
(is_anonymous_child): Move it to c-varobj.c and rename to
varobj_is_anonymous_child. Caller update.
(get_type): Move it to c-varobj.c.
(get_value_type): Rename it varobj_get_value_type. Make it
extern.
(get_target_type): Move it gdbtypes.c.
(varobj_formatted_print_options): New function.
(value_get_print_value): Rename it to
varobj_value_get_print_value and make it extern.
(varobj_value_is_changeable_p): Make it extern.
(adjust_value_for_child_access): Move it to c-varobj.c.
(default_value_is_changeable_p): Rename it to
varobj_default_value_is_changeable_p. Make it extern.
(c_number_of_children, c_name_of_variable): Move it to c-varobj.c
(c_name_of_child, c_path_expr_of_child): Likewise.
(c_value_of_child, c_type_of_child): Likewise.
(c_value_of_variable, cplus_number_of_children): Likewise.
(cplus_class_num_children, cplus_name_of_variable): Likewise.
(cplus_name_of_child, cplus_path_expr_of_child): Likewise.
(cplus_value_of_child, cplus_type_of_child): Likewise.
(cplus_value_of_variable): Likewise.
(java_number_of_children, java_name_of_variable): Move it to jv-varobj.c.
(java_name_of_child, java_path_expr_of_child): Likewise.
(java_value_of_child, java_type_of_child): Likewise.
(java_value_of_variable): Likewise.
(ada_number_of_children, ada_name_of_variable): Move it to ada-varobj.c.
(ada_name_of_child, ada_path_expr_of_child): Likewise.
(ada_value_of_child, ada_type_of_child): Likewise.
(ada_value_of_variable, ada_value_is_changeable_p): Likewise.
(ada_value_has_mutated): Likewise.
* varobj.h (CPLUS_FAKE_CHILD): New macro, moved from varobj.c.
(struct lang_varobj_ops): New. Renamed by 'struct language_specific'.
(c_varobj_ops, cplus_varobj_ops): Declare.
(java_varobj_ops, ada_varobj_ops): Declare.
(varobj_default_value_is_changeable_p): Declare.
(varobj_value_is_changeable_p): Declare.
(varobj_get_value_type, varobj_is_anonymous_child): Declare.
(varobj_get_path_expr_parent): Declare.
(varobj_value_get_print_value): Declare.
(varobj_formatted_print_options): Declare.
(varobj_restrict_range): Declare.
2013-10-17 15:28:37 +02:00
|
|
|
};
|