mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-12-27 17:40:49 +00:00
* ada-lang.c: run through gdb_indent.sh
* ada-lang.h: run through gdb_indent.sh
* ada-tasks.c: run through gdb_indent.sh
* ada-typeprint.c: run through gdb_indent.sh
* ada-valprint.c: run through gdb_indent.sh
This commit is contained in:
Aidan Skinner
@@ -32,9 +32,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
#include "c-lang.h"
|
||||
|
||||
/* Encapsulates arguments to ada_val_print. */
|
||||
struct ada_val_print_args {
|
||||
struct type* type;
|
||||
char* valaddr0;
|
||||
struct ada_val_print_args
|
||||
{
|
||||
struct type *type;
|
||||
char *valaddr0;
|
||||
int embedded_offset;
|
||||
CORE_ADDR address;
|
||||
struct ui_file *stream;
|
||||
@@ -47,45 +48,47 @@ struct ada_val_print_args {
|
||||
extern int inspect_it;
|
||||
extern unsigned int repeat_count_threshold;
|
||||
|
||||
static void print_record (struct type*, char*, struct ui_file*, int,
|
||||
static void print_record (struct type *, char *, struct ui_file *, int,
|
||||
int, enum val_prettyprint);
|
||||
|
||||
static int print_field_values (struct type*, char*, struct ui_file*,
|
||||
static int print_field_values (struct type *, char *, struct ui_file *,
|
||||
int, int, enum val_prettyprint,
|
||||
int, struct type*, char*);
|
||||
int, struct type *, char *);
|
||||
|
||||
static int print_variant_part (struct type*, int, char*,
|
||||
struct ui_file*, int, int, enum val_prettyprint,
|
||||
int, struct type*, char*);
|
||||
static int print_variant_part (struct type *, int, char *,
|
||||
struct ui_file *, int, int,
|
||||
enum val_prettyprint, int, struct type *,
|
||||
char *);
|
||||
|
||||
static void val_print_packed_array_elements (struct type*, char *valaddr, int,
|
||||
struct ui_file*, int, int,
|
||||
static void val_print_packed_array_elements (struct type *, char *valaddr,
|
||||
int, struct ui_file *, int, int,
|
||||
enum val_prettyprint);
|
||||
|
||||
static void adjust_type_signedness (struct type*);
|
||||
static void adjust_type_signedness (struct type *);
|
||||
|
||||
static int ada_val_print_stub (PTR args0);
|
||||
|
||||
static int ada_val_print_1 (struct type*, char*, int, CORE_ADDR, struct ui_file*,
|
||||
int, int, int, enum val_prettyprint);
|
||||
static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR,
|
||||
struct ui_file *, int, int, int,
|
||||
enum val_prettyprint);
|
||||
|
||||
|
||||
/* Make TYPE unsigned if its range of values includes no negatives. */
|
||||
static void
|
||||
static void
|
||||
adjust_type_signedness (type)
|
||||
struct type* type;
|
||||
struct type *type;
|
||||
{
|
||||
if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
|
||||
if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
|
||||
&& TYPE_LOW_BOUND (type) >= 0)
|
||||
TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
|
||||
}
|
||||
}
|
||||
|
||||
/* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
|
||||
if non-standard (i.e., other than 1 for numbers, other than lower bound
|
||||
of index type for enumerated type). Returns 1 if something printed,
|
||||
otherwise 0. */
|
||||
|
||||
static int
|
||||
static int
|
||||
print_optional_low_bound (struct ui_file *stream, struct type *type)
|
||||
{
|
||||
struct type *index_type;
|
||||
@@ -96,27 +99,28 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
|
||||
|
||||
if (index_type == NULL)
|
||||
return 0;
|
||||
if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
|
||||
if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
|
||||
{
|
||||
low_bound = TYPE_LOW_BOUND (index_type);
|
||||
index_type = TYPE_TARGET_TYPE (index_type);
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
|
||||
switch (TYPE_CODE (index_type)) {
|
||||
case TYPE_CODE_ENUM:
|
||||
if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
|
||||
return 0;
|
||||
break;
|
||||
case TYPE_CODE_UNDEF:
|
||||
index_type = builtin_type_long;
|
||||
/* FALL THROUGH */
|
||||
default:
|
||||
if (low_bound == 1)
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (TYPE_CODE (index_type))
|
||||
{
|
||||
case TYPE_CODE_ENUM:
|
||||
if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
|
||||
return 0;
|
||||
break;
|
||||
case TYPE_CODE_UNDEF:
|
||||
index_type = builtin_type_long;
|
||||
/* FALL THROUGH */
|
||||
default:
|
||||
if (low_bound == 1)
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
|
||||
ada_print_scalar (index_type, (LONGEST) low_bound, stream);
|
||||
fprintf_filtered (stream, " => ");
|
||||
@@ -128,7 +132,7 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
|
||||
BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
|
||||
separates with commas. RECURSE is the recursion (nesting) level.
|
||||
If PRETTY, uses "prettier" format. TYPE must have been decoded (as
|
||||
by ada_coerce_to_simple_array). */
|
||||
by ada_coerce_to_simple_array). */
|
||||
|
||||
static void
|
||||
val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
@@ -147,8 +151,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
/* Number of repetitions we have detected so far. */
|
||||
unsigned int reps;
|
||||
unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
|
||||
struct value* mark = value_mark ();
|
||||
|
||||
struct value *mark = value_mark ();
|
||||
|
||||
elttype = TYPE_TARGET_TYPE (type);
|
||||
eltlen = TYPE_LENGTH (check_typedef (elttype));
|
||||
|
||||
@@ -183,7 +187,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
wrap_here (n_spaces (2 + 2 * recurse));
|
||||
|
||||
i0 = i;
|
||||
v0 = ada_value_primitive_packed_val (NULL, valaddr,
|
||||
v0 = ada_value_primitive_packed_val (NULL, valaddr,
|
||||
(i0 * bitsize) / HOST_CHAR_BIT,
|
||||
(i0 * bitsize) % HOST_CHAR_BIT,
|
||||
bitsize, elttype);
|
||||
@@ -192,12 +196,11 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
i += 1;
|
||||
if (i >= len)
|
||||
break;
|
||||
v1 = ada_value_primitive_packed_val (NULL, valaddr,
|
||||
v1 = ada_value_primitive_packed_val (NULL, valaddr,
|
||||
(i * bitsize) / HOST_CHAR_BIT,
|
||||
(i * bitsize) % HOST_CHAR_BIT,
|
||||
bitsize, elttype);
|
||||
if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen)
|
||||
!= 0)
|
||||
if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0)
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -215,7 +218,7 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
int j;
|
||||
for (j = i0; j < i; j += 1)
|
||||
{
|
||||
if (j > i0)
|
||||
if (j > i0)
|
||||
{
|
||||
if (prettyprint_arrays)
|
||||
{
|
||||
@@ -244,8 +247,8 @@ val_print_packed_array_elements (struct type *type, char *valaddr,
|
||||
value_free_to_mark (mark);
|
||||
}
|
||||
|
||||
static struct type*
|
||||
printable_val_type (struct type* type, char* valaddr)
|
||||
static struct type *
|
||||
printable_val_type (struct type *type, char *valaddr)
|
||||
{
|
||||
return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
|
||||
}
|
||||
@@ -270,19 +273,19 @@ ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
|
||||
fprintf_filtered (stream, "%c", c);
|
||||
}
|
||||
else
|
||||
fprintf_filtered (stream, "[\"%0*x\"]", type_len*2, c);
|
||||
fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
|
||||
}
|
||||
|
||||
/* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
|
||||
or 2) of a character. */
|
||||
|
||||
static int
|
||||
char_at (char* string, int i, int type_len)
|
||||
char_at (char *string, int i, int type_len)
|
||||
{
|
||||
if (type_len == 1)
|
||||
return string[i];
|
||||
else
|
||||
return (int) extract_unsigned_integer (string + 2*i, 2);
|
||||
else
|
||||
return (int) extract_unsigned_integer (string + 2 * i, 2);
|
||||
}
|
||||
|
||||
void
|
||||
@@ -390,7 +393,7 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
|
||||
for (i = 0; i < length && things_printed < print_max; i += 1)
|
||||
{
|
||||
/* Position of the character we are examining
|
||||
to see whether it is repeated. */
|
||||
to see whether it is repeated. */
|
||||
unsigned int rep1;
|
||||
/* Number of repetitions we have detected so far. */
|
||||
unsigned int reps;
|
||||
@@ -405,8 +408,9 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
|
||||
|
||||
rep1 = i + 1;
|
||||
reps = 1;
|
||||
while (rep1 < length &&
|
||||
char_at(string, rep1, type_len) == char_at (string, i, type_len))
|
||||
while (rep1 < length &&
|
||||
char_at (string, rep1, type_len) == char_at (string, i,
|
||||
type_len))
|
||||
{
|
||||
rep1 += 1;
|
||||
reps += 1;
|
||||
@@ -423,7 +427,8 @@ printstr (struct ui_file *stream, char *string, unsigned int length,
|
||||
in_quotes = 0;
|
||||
}
|
||||
fputs_filtered ("'", stream);
|
||||
ada_emit_char (char_at (string, i, type_len), stream, '\'', type_len);
|
||||
ada_emit_char (char_at (string, i, type_len), stream, '\'',
|
||||
type_len);
|
||||
fputs_filtered ("'", stream);
|
||||
fprintf_filtered (stream, " <repeats %u times>", reps);
|
||||
i = rep1 - 1;
|
||||
@@ -487,12 +492,13 @@ ada_printstr (struct ui_file *stream, char *string, unsigned int length,
|
||||
arrays.) */
|
||||
|
||||
int
|
||||
ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
|
||||
ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
|
||||
CORE_ADDR address, struct ui_file *stream, int format,
|
||||
int deref_ref, int recurse, enum val_prettyprint pretty)
|
||||
{
|
||||
struct ada_val_print_args args;
|
||||
args.type = type; args.valaddr0 = valaddr0;
|
||||
args.type = type;
|
||||
args.valaddr0 = valaddr0;
|
||||
args.embedded_offset = embedded_offset;
|
||||
args.address = address;
|
||||
args.stream = stream;
|
||||
@@ -509,18 +515,18 @@ ada_val_print (struct type* type, char* valaddr0, int embedded_offset,
|
||||
static int
|
||||
ada_val_print_stub (PTR args0)
|
||||
{
|
||||
struct ada_val_print_args* argsp = (struct ada_val_print_args*) args0;
|
||||
return ada_val_print_1 (argsp->type, argsp->valaddr0, argsp->embedded_offset,
|
||||
argsp->address, argsp->stream, argsp->format,
|
||||
argsp->deref_ref, argsp->recurse,
|
||||
argsp->pretty);
|
||||
struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
|
||||
return ada_val_print_1 (argsp->type, argsp->valaddr0,
|
||||
argsp->embedded_offset, argsp->address,
|
||||
argsp->stream, argsp->format, argsp->deref_ref,
|
||||
argsp->recurse, argsp->pretty);
|
||||
}
|
||||
|
||||
/* See the comment on ada_val_print. This function differs in that it
|
||||
* does not catch evaluation errors (leaving that to ada_val_print). */
|
||||
|
||||
static int
|
||||
ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
|
||||
CORE_ADDR address, struct ui_file *stream, int format,
|
||||
int deref_ref, int recurse, enum val_prettyprint pretty)
|
||||
{
|
||||
@@ -530,15 +536,15 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
unsigned int eltlen;
|
||||
LONGEST val;
|
||||
CORE_ADDR addr;
|
||||
char* valaddr = valaddr0 + embedded_offset;
|
||||
char *valaddr = valaddr0 + embedded_offset;
|
||||
|
||||
CHECK_TYPEDEF (type);
|
||||
|
||||
if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type))
|
||||
{
|
||||
int retn;
|
||||
struct value* mark = value_mark ();
|
||||
struct value* val;
|
||||
struct value *mark = value_mark ();
|
||||
struct value *val;
|
||||
val = value_from_contents_and_address (type, valaddr, address);
|
||||
val = ada_coerce_to_simple_array_ptr (val);
|
||||
if (val == NULL)
|
||||
@@ -548,7 +554,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
}
|
||||
else
|
||||
retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
|
||||
VALUE_ADDRESS (val), stream, format,
|
||||
VALUE_ADDRESS (val), stream, format,
|
||||
deref_ref, recurse, pretty);
|
||||
value_free_to_mark (mark);
|
||||
return retn;
|
||||
@@ -561,7 +567,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
default:
|
||||
return c_val_print (type, valaddr0, embedded_offset, address, stream,
|
||||
return c_val_print (type, valaddr0, embedded_offset, address, stream,
|
||||
format, deref_ref, recurse, pretty);
|
||||
|
||||
case TYPE_CODE_INT:
|
||||
@@ -577,26 +583,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
}
|
||||
else if (ada_is_vax_floating_type (type))
|
||||
{
|
||||
struct value* val =
|
||||
struct value *val =
|
||||
value_from_contents_and_address (type, valaddr, address);
|
||||
struct value* func = ada_vax_float_print_function (type);
|
||||
struct value *func = ada_vax_float_print_function (type);
|
||||
if (func != 0)
|
||||
{
|
||||
static struct type* parray_of_char = NULL;
|
||||
struct value* printable_val;
|
||||
static struct type *parray_of_char = NULL;
|
||||
struct value *printable_val;
|
||||
|
||||
if (parray_of_char == NULL)
|
||||
parray_of_char =
|
||||
make_pointer_type
|
||||
(create_array_type
|
||||
(NULL, builtin_type_char,
|
||||
create_range_type (NULL, builtin_type_int, 0, 32)),
|
||||
NULL);
|
||||
if (parray_of_char == NULL)
|
||||
parray_of_char =
|
||||
make_pointer_type
|
||||
(create_array_type
|
||||
(NULL, builtin_type_char,
|
||||
create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
|
||||
|
||||
printable_val =
|
||||
printable_val =
|
||||
value_ind (value_cast (parray_of_char,
|
||||
call_function_by_hand (func, 1, &val)));
|
||||
|
||||
call_function_by_hand (func, 1,
|
||||
&val)));
|
||||
|
||||
fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
|
||||
return 0;
|
||||
}
|
||||
@@ -604,26 +610,26 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
}
|
||||
else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
|
||||
{
|
||||
struct type* target_type = TYPE_TARGET_TYPE (type);
|
||||
struct type *target_type = TYPE_TARGET_TYPE (type);
|
||||
if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
|
||||
{
|
||||
/* Obscure case of range type that has different length from
|
||||
its base type. Perform a conversion, or we will get a
|
||||
nonsense value. Actually, we could use the same
|
||||
code regardless of lengths; I'm just avoiding a cast. */
|
||||
struct value* v =
|
||||
value_cast (target_type,
|
||||
value_from_contents_and_address (type, valaddr, 0));
|
||||
its base type. Perform a conversion, or we will get a
|
||||
nonsense value. Actually, we could use the same
|
||||
code regardless of lengths; I'm just avoiding a cast. */
|
||||
struct value *v = value_cast (target_type,
|
||||
value_from_contents_and_address
|
||||
(type, valaddr, 0));
|
||||
return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0,
|
||||
stream, format, 0, recurse + 1, pretty);
|
||||
}
|
||||
else
|
||||
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
|
||||
return ada_val_print_1 (TYPE_TARGET_TYPE (type),
|
||||
valaddr0, embedded_offset,
|
||||
address, stream, format, deref_ref,
|
||||
address, stream, format, deref_ref,
|
||||
recurse, pretty);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
format = format ? format : output_format;
|
||||
if (format)
|
||||
@@ -661,8 +667,8 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
}
|
||||
if (i < len)
|
||||
{
|
||||
const char* name = ada_enum_name (TYPE_FIELD_NAME (type, i));
|
||||
if (name[0] == '\'')
|
||||
const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
|
||||
if (name[0] == '\'')
|
||||
fprintf_filtered (stream, "%ld %s", (long) val, name);
|
||||
else
|
||||
fputs_filtered (name, stream);
|
||||
@@ -672,18 +678,17 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
print_longest (stream, 'd', 0, val);
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case TYPE_CODE_UNION:
|
||||
case TYPE_CODE_STRUCT:
|
||||
if (ada_is_bogus_array_descriptor (type))
|
||||
{
|
||||
fprintf_filtered (stream, "(...?)");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
print_record (type, valaddr, stream, format,
|
||||
recurse, pretty);
|
||||
print_record (type, valaddr, stream, format, recurse, pretty);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -693,21 +698,20 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
elttype = TYPE_TARGET_TYPE (type);
|
||||
eltlen = TYPE_LENGTH (elttype);
|
||||
len = TYPE_LENGTH (type) / eltlen;
|
||||
|
||||
|
||||
/* For an array of chars, print with string syntax. */
|
||||
if (ada_is_string_type (type)
|
||||
&& (format == 0 || format == 's'))
|
||||
if (ada_is_string_type (type) && (format == 0 || format == 's'))
|
||||
{
|
||||
if (prettyprint_arrays)
|
||||
{
|
||||
print_spaces_filtered (2 + 2 * recurse, stream);
|
||||
}
|
||||
/* If requested, look for the first null char and only print
|
||||
elements up to it. */
|
||||
elements up to it. */
|
||||
if (stop_print_at_null)
|
||||
{
|
||||
int temp_len;
|
||||
|
||||
|
||||
/* Look for a NULL char. */
|
||||
for (temp_len = 0;
|
||||
temp_len < len && temp_len < print_max
|
||||
@@ -715,7 +719,7 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
temp_len += 1);
|
||||
len = temp_len;
|
||||
}
|
||||
|
||||
|
||||
printstr (stream, valaddr, len, 0, eltlen);
|
||||
}
|
||||
else
|
||||
@@ -723,10 +727,9 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
len = 0;
|
||||
fprintf_filtered (stream, "(");
|
||||
print_optional_low_bound (stream, type);
|
||||
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
|
||||
if (TYPE_FIELD_BITSIZE (type, 0) > 0)
|
||||
val_print_packed_array_elements (type, valaddr, 0, stream,
|
||||
format, recurse,
|
||||
pretty);
|
||||
format, recurse, pretty);
|
||||
else
|
||||
val_print_array_elements (type, valaddr, address, stream,
|
||||
format, deref_ref, recurse,
|
||||
@@ -740,27 +743,27 @@ ada_val_print_1 (struct type* type, char* valaddr0, int embedded_offset,
|
||||
case TYPE_CODE_REF:
|
||||
elttype = check_typedef (TYPE_TARGET_TYPE (type));
|
||||
if (addressprint)
|
||||
{
|
||||
{
|
||||
fprintf_filtered (stream, "@");
|
||||
print_address_numeric
|
||||
(extract_address (valaddr,
|
||||
TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream);
|
||||
if (deref_ref)
|
||||
fputs_filtered (": ", stream);
|
||||
}
|
||||
}
|
||||
/* De-reference the reference */
|
||||
if (deref_ref)
|
||||
{
|
||||
if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
|
||||
{
|
||||
LONGEST deref_val_int = (LONGEST)
|
||||
unpack_pointer (lookup_pointer_type (builtin_type_void),
|
||||
LONGEST deref_val_int = (LONGEST)
|
||||
unpack_pointer (lookup_pointer_type (builtin_type_void),
|
||||
valaddr);
|
||||
if (deref_val_int != 0)
|
||||
if (deref_val_int != 0)
|
||||
{
|
||||
struct value* deref_val =
|
||||
ada_value_ind (value_from_longest
|
||||
(lookup_pointer_type (elttype),
|
||||
struct value *deref_val =
|
||||
ada_value_ind (value_from_longest
|
||||
(lookup_pointer_type (elttype),
|
||||
deref_val_int));
|
||||
val_print (VALUE_TYPE (deref_val),
|
||||
VALUE_CONTENTS (deref_val), 0,
|
||||
@@ -785,13 +788,12 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
|
||||
struct type *outer_type, char *outer_valaddr)
|
||||
{
|
||||
struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
|
||||
int which =
|
||||
ada_which_variant_applies (var_type, outer_type, outer_valaddr);
|
||||
int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
|
||||
|
||||
if (which < 0)
|
||||
return 0;
|
||||
else
|
||||
return print_field_values
|
||||
return print_field_values
|
||||
(TYPE_FIELD_TYPE (var_type, which),
|
||||
valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
|
||||
+ TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
|
||||
@@ -800,23 +802,23 @@ print_variant_part (struct type *type, int field_num, char *valaddr,
|
||||
}
|
||||
|
||||
int
|
||||
ada_value_print (struct value* val0, struct ui_file *stream, int format,
|
||||
ada_value_print (struct value *val0, struct ui_file *stream, int format,
|
||||
enum val_prettyprint pretty)
|
||||
{
|
||||
char* valaddr = VALUE_CONTENTS (val0);
|
||||
char *valaddr = VALUE_CONTENTS (val0);
|
||||
CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0);
|
||||
struct type* type =
|
||||
struct type *type =
|
||||
ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL);
|
||||
struct value* val = value_from_contents_and_address (type, valaddr, address);
|
||||
struct value *val =
|
||||
value_from_contents_and_address (type, valaddr, address);
|
||||
|
||||
/* If it is a pointer, indicate what it points to. */
|
||||
if (TYPE_CODE (type) == TYPE_CODE_PTR ||
|
||||
TYPE_CODE (type) == TYPE_CODE_REF)
|
||||
if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF)
|
||||
{
|
||||
/* Hack: remove (char *) for char strings. Their
|
||||
type is indicated by the quoted string anyway. */
|
||||
type is indicated by the quoted string anyway. */
|
||||
if (TYPE_CODE (type) == TYPE_CODE_PTR &&
|
||||
TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char) &&
|
||||
TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) &&
|
||||
TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT &&
|
||||
!TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
|
||||
{
|
||||
@@ -829,7 +831,7 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
|
||||
fprintf_filtered (stream, ") ");
|
||||
}
|
||||
}
|
||||
else if (ada_is_array_descriptor (type))
|
||||
else if (ada_is_array_descriptor (type))
|
||||
{
|
||||
fprintf_filtered (stream, "(");
|
||||
type_print (type, "", stream, -1);
|
||||
@@ -842,10 +844,10 @@ ada_value_print (struct value* val0, struct ui_file *stream, int format,
|
||||
fprintf_filtered (stream, ") (...?)");
|
||||
return 0;
|
||||
}
|
||||
return (val_print (type, VALUE_CONTENTS (val), 0, address,
|
||||
return (val_print (type, VALUE_CONTENTS (val), 0, address,
|
||||
stream, format, 1, 0, pretty));
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
print_record (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
int format, int recurse, enum val_prettyprint pretty)
|
||||
@@ -855,8 +857,7 @@ print_record (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
fprintf_filtered (stream, "(");
|
||||
|
||||
if (print_field_values (type, valaddr, stream, format, recurse, pretty,
|
||||
0, type, valaddr) != 0
|
||||
&& pretty)
|
||||
0, type, valaddr) != 0 && pretty)
|
||||
{
|
||||
fprintf_filtered (stream, "\n");
|
||||
print_spaces_filtered (2 * recurse, stream);
|
||||
@@ -892,13 +893,13 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
for (i = 0; i < len; i += 1)
|
||||
{
|
||||
if (ada_is_ignored_field (type, i))
|
||||
continue;
|
||||
continue;
|
||||
|
||||
if (ada_is_wrapper_field (type, i))
|
||||
{
|
||||
comma_needed =
|
||||
comma_needed =
|
||||
print_field_values (TYPE_FIELD_TYPE (type, i),
|
||||
valaddr
|
||||
valaddr
|
||||
+ TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
|
||||
stream, format, recurse, pretty,
|
||||
comma_needed, type, valaddr);
|
||||
@@ -922,7 +923,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
fprintf_filtered (stream, "\n");
|
||||
print_spaces_filtered (2 + 2 * recurse, stream);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
wrap_here (n_spaces (2 + 2 * recurse));
|
||||
}
|
||||
@@ -942,7 +943,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
else
|
||||
{
|
||||
annotate_field_begin (TYPE_FIELD_TYPE (type, i));
|
||||
fprintf_filtered (stream, "%.*s",
|
||||
fprintf_filtered (stream, "%.*s",
|
||||
ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
|
||||
TYPE_FIELD_NAME (type, i));
|
||||
annotate_field_name_end ();
|
||||
@@ -952,7 +953,7 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
|
||||
if (TYPE_FIELD_PACKED (type, i))
|
||||
{
|
||||
struct value* v;
|
||||
struct value *v;
|
||||
|
||||
/* Bitfields require special handling, especially due to byte
|
||||
order problems. */
|
||||
@@ -965,21 +966,21 @@ print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
|
||||
{
|
||||
int bit_pos = TYPE_FIELD_BITPOS (type, i);
|
||||
int bit_size = TYPE_FIELD_BITSIZE (type, i);
|
||||
|
||||
|
||||
adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
|
||||
v = ada_value_primitive_packed_val (NULL, valaddr,
|
||||
bit_pos / HOST_CHAR_BIT,
|
||||
bit_pos % HOST_CHAR_BIT,
|
||||
bit_size,
|
||||
bit_size,
|
||||
TYPE_FIELD_TYPE (type, i));
|
||||
val_print (TYPE_FIELD_TYPE(type, i), VALUE_CONTENTS (v), 0, 0,
|
||||
val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
|
||||
stream, format, 0, recurse + 1, pretty);
|
||||
}
|
||||
}
|
||||
else
|
||||
ada_val_print (TYPE_FIELD_TYPE (type, i),
|
||||
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
|
||||
0, 0, stream, format, 0, recurse + 1, pretty);
|
||||
ada_val_print (TYPE_FIELD_TYPE (type, i),
|
||||
valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
|
||||
0, 0, stream, format, 0, recurse + 1, pretty);
|
||||
annotate_field_end ();
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user