static void set_output_radix_1 (int, unsigned);
static void val_print_type_code_flags (struct type *type,
- const gdb_byte *valaddr,
+ struct value *original_value,
+ int embedded_offset,
struct ui_file *stream);
#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
type = TYPE_TARGET_TYPE (type);
type = check_typedef (type);
}
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
return 0;
}
- if (TYPE_CODE (type) != TYPE_CODE_UNION
- && TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_ARRAY)
+ if (type->code () != TYPE_CODE_UNION
+ && type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_ARRAY)
{
if (value_bits_any_optimized_out (val,
TARGET_CHAR_BIT * embedded_offset,
if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
{
- const int is_ref = TYPE_CODE (type) == TYPE_CODE_REF;
+ const int is_ref = type->code () == TYPE_CODE_REF;
int ref_is_addressable = 0;
if (is_ref)
{
struct gdbarch *gdbarch = get_type_arch (type);
- if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
+ if (elttype->code () == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
print_function_pointer_address (options, gdbarch, address, stream);
/* generic_val_print helper for TYPE_CODE_ARRAY. */
static void
-generic_val_print_array (struct type *type,
- int embedded_offset, CORE_ADDR address,
+generic_val_print_array (struct value *val,
struct ui_file *stream, int recurse,
- struct value *original_value,
const struct value_print_options *options,
const struct
generic_val_print_decorations *decorations)
{
+ struct type *type = check_typedef (value_type (val));
struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
struct type *elttype = check_typedef (unresolved_elttype);
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
- if (options->prettyformat_arrays)
- {
- print_spaces_filtered (2 + 2 * recurse, stream);
- }
-
fputs_filtered (decorations->array_start, stream);
- val_print_array_elements (type, embedded_offset,
- address, stream,
- recurse, original_value, options, 0);
+ value_print_array_elements (val, stream, recurse, options, 0);
fputs_filtered (decorations->array_end, stream);
}
else
{
/* Array of unspecified length: treat like pointer to first elt. */
- print_unpacked_pointer (type, elttype, address + embedded_offset, stream,
- options);
+ print_unpacked_pointer (type, elttype, value_address (val),
+ stream, options);
}
}
-/* generic_val_print helper for TYPE_CODE_PTR. */
+/* generic_value_print helper for TYPE_CODE_PTR. */
static void
-generic_val_print_ptr (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+generic_value_print_ptr (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
- struct gdbarch *gdbarch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
if (options->format && options->format != 's')
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
+ value_print_scalar_formatted (val, options, 0, stream);
else
{
- struct type *unresolved_elttype = TYPE_TARGET_TYPE(type);
- struct type *elttype = check_typedef (unresolved_elttype);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
- CORE_ADDR addr = unpack_pointer (type,
- valaddr + embedded_offset * unit_size);
+ struct type *type = check_typedef (value_type (val));
+ struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+ const gdb_byte *valaddr = value_contents_for_printing (val);
+ CORE_ADDR addr = unpack_pointer (type, valaddr);
print_unpacked_pointer (type, elttype, addr, stream, options);
}
}
-/* generic_val_print helper for TYPE_CODE_MEMBERPTR. */
-
-static void
-generic_val_print_memberptr (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
-{
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
-}
-
/* Print '@' followed by the address contained in ADDRESS_BUFFER. */
static void
TARGET_CHAR_BIT * TYPE_LENGTH (type));
const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
|| options->deref_ref);
- const int type_is_defined = TYPE_CODE (elttype) != TYPE_CODE_UNDEF;
+ const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;
const gdb_byte *valaddr = value_contents_for_printing (original_value);
if (must_coerce_ref && type_is_defined)
unsigned int i;
unsigned int len;
- len = TYPE_NFIELDS (type);
+ len = type->num_fields ();
for (i = 0; i < len; i++)
{
QUIT;
}
if (i < len)
{
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fputs_styled (TYPE_FIELD_NAME (type, i), variable_name_style.style (),
+ stream);
}
else if (TYPE_FLAG_ENUM (type))
{
appropriate. The enum may have multiple enumerators representing
the same bit, in which case we choose to only print the first one
we find. */
- fputs_filtered ("(", stream);
for (i = 0; i < len; ++i)
{
QUIT;
if ((val & enumval) != 0)
{
- if (!first)
+ if (first)
+ {
+ fputs_filtered ("(", stream);
+ first = 0;
+ }
+ else
fputs_filtered (" | ", stream);
- first = 0;
val &= ~TYPE_FIELD_ENUMVAL (type, i);
- fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
+ fputs_styled (TYPE_FIELD_NAME (type, i),
+ variable_name_style.style (), stream);
}
}
- if (first || val != 0)
+ if (val != 0)
{
- if (!first)
+ /* There are leftover bits, print them. */
+ if (first)
+ fputs_filtered ("(", stream);
+ else
fputs_filtered (" | ", stream);
+
fputs_filtered ("unknown: 0x", stream);
print_longest (stream, 'x', 0, val);
+ fputs_filtered (")", stream);
+ }
+ else if (first)
+ {
+ /* Nothing has been printed and the value is 0, the enum value must
+ have been 0. */
+ fputs_filtered ("0", stream);
+ }
+ else
+ {
+ /* Something has been printed, close the parenthesis. */
+ fputs_filtered (")", stream);
}
-
- fputs_filtered (")", stream);
}
else
print_longest (stream, 'd', 0, val);
struct gdbarch *gdbarch = get_type_arch (type);
int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ gdb_assert (!options->format);
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
-
- generic_val_print_enum_1 (type, val, stream);
- }
-}
-
-/* generic_val_print helper for TYPE_CODE_FLAGS. */
-
-static void
-generic_val_print_flags (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+ const gdb_byte *valaddr = value_contents_for_printing (original_value);
-{
- if (options->format)
- val_print_scalar_formatted (type, embedded_offset, original_value,
- options, 0, stream);
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ val = unpack_long (type, valaddr + embedded_offset * unit_size);
- val_print_type_code_flags (type, valaddr + embedded_offset, stream);
- }
+ generic_val_print_enum_1 (type, val, stream);
}
/* generic_val_print helper for TYPE_CODE_FUNC and TYPE_CODE_METHOD. */
{
struct gdbarch *gdbarch = get_type_arch (type);
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- /* FIXME, we should consider, at least for ANSI C language,
- eliminating the distinction made between FUNCs and POINTERs
- to FUNCs. */
- fprintf_filtered (stream, "{");
- type_print (type, "", stream, -1);
- fprintf_filtered (stream, "} ");
- /* Try to print what function it points to, and its address. */
- print_address_demangle (options, gdbarch, address, stream, demangle);
- }
+ gdb_assert (!options->format);
+
+ /* FIXME, we should consider, at least for ANSI C language,
+ eliminating the distinction made between FUNCs and POINTERs to
+ FUNCs. */
+ fprintf_filtered (stream, "{");
+ type_print (type, "", stream, -1);
+ fprintf_filtered (stream, "} ");
+ /* Try to print what function it points to, and its address. */
+ print_address_demangle (options, gdbarch, address, stream, demangle);
}
-/* generic_val_print helper for TYPE_CODE_BOOL. */
+/* generic_value_print helper for TYPE_CODE_BOOL. */
static void
-generic_val_print_bool (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations *decorations)
+generic_value_print_bool
+ (struct value *value, struct ui_file *stream,
+ const struct value_print_options *options,
+ const struct generic_val_print_decorations *decorations)
{
- LONGEST val;
- struct gdbarch *gdbarch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
-
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (value, &opts, 0, stream);
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
+ const gdb_byte *valaddr = value_contents_for_printing (value);
+ struct type *type = check_typedef (value_type (value));
+ LONGEST val = unpack_long (type, valaddr);
if (val == 0)
fputs_filtered (decorations->false_name, stream);
else if (val == 1)
}
}
-/* generic_val_print helper for TYPE_CODE_INT. */
+/* generic_value_print helper for TYPE_CODE_INT. */
static void
-generic_val_print_int (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+generic_value_print_int (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (val, &opts, 0, stream);
}
-/* generic_val_print helper for TYPE_CODE_CHAR. */
+/* generic_value_print helper for TYPE_CODE_CHAR. */
static void
-generic_val_print_char (struct type *type, struct type *unresolved_type,
- int embedded_offset,
- struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options)
+generic_value_print_char (struct value *value, struct ui_file *stream,
+ const struct value_print_options *options)
{
- LONGEST val;
- struct gdbarch *gdbarch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
-
if (options->format || options->output_format)
{
struct value_print_options opts = *options;
opts.format = (options->format ? options->format
: options->output_format);
- val_print_scalar_formatted (type, embedded_offset,
- original_value, &opts, 0, stream);
+ value_print_scalar_formatted (value, &opts, 0, stream);
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ struct type *unresolved_type = value_type (value);
+ struct type *type = check_typedef (unresolved_type);
+ const gdb_byte *valaddr = value_contents_for_printing (value);
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
+ LONGEST val = unpack_long (type, valaddr);
if (TYPE_UNSIGNED (type))
fprintf_filtered (stream, "%u", (unsigned int) val);
else
struct gdbarch *gdbarch = get_type_arch (type);
int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
- if (options->format)
- {
- val_print_scalar_formatted (type, embedded_offset,
- original_value, options, 0, stream);
- }
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ gdb_assert (!options->format);
- print_floating (valaddr + embedded_offset * unit_size, type, stream);
- }
+ const gdb_byte *valaddr = value_contents_for_printing (original_value);
+
+ print_floating (valaddr + embedded_offset * unit_size, type, stream);
}
-/* generic_val_print helper for TYPE_CODE_COMPLEX. */
+/* generic_value_print helper for TYPE_CODE_COMPLEX. */
static void
-generic_val_print_complex (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations
- *decorations)
+generic_value_print_complex (struct value *val, struct ui_file *stream,
+ const struct value_print_options *options,
+ const struct generic_val_print_decorations
+ *decorations)
{
- struct gdbarch *gdbarch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
fprintf_filtered (stream, "%s", decorations->complex_prefix);
- if (options->format)
- val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
- embedded_offset, original_value, options, 0,
- stream);
- else
- print_floating (valaddr + embedded_offset * unit_size,
- TYPE_TARGET_TYPE (type), stream);
+
+ struct value *real_part = value_real_part (val);
+ value_print_scalar_formatted (real_part, options, 0, stream);
fprintf_filtered (stream, "%s", decorations->complex_infix);
- if (options->format)
- val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
- embedded_offset
- + type_length_units (TYPE_TARGET_TYPE (type)),
- original_value, options, 0, stream);
- else
- print_floating (valaddr + embedded_offset * unit_size
- + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
- TYPE_TARGET_TYPE (type), stream);
+
+ struct value *imag_part = value_imaginary_part (val);
+ value_print_scalar_formatted (imag_part, options, 0, stream);
fprintf_filtered (stream, "%s", decorations->complex_suffix);
}
-/* A generic val_print that is suitable for use by language
- implementations of the la_val_print method. This function can
- handle most type codes, though not all, notably exception
- TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
- the caller.
-
- Most arguments are as to val_print.
-
- The additional DECORATIONS argument can be used to customize the
- output in some small, language-specific ways. */
+/* See valprint.h. */
void
-generic_val_print (struct type *type,
- int embedded_offset, CORE_ADDR address,
- struct ui_file *stream, int recurse,
- struct value *original_value,
- const struct value_print_options *options,
- const struct generic_val_print_decorations *decorations)
+generic_value_print (struct value *val, struct ui_file *stream, int recurse,
+ const struct value_print_options *options,
+ const struct generic_val_print_decorations *decorations)
{
- struct type *unresolved_type = type;
+ struct type *type = value_type (val);
type = check_typedef (type);
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
- generic_val_print_array (type, embedded_offset, address, stream,
- recurse, original_value, options, decorations);
+ generic_val_print_array (val, stream, recurse, options, decorations);
break;
case TYPE_CODE_MEMBERPTR:
- generic_val_print_memberptr (type, embedded_offset, stream,
- original_value, options);
+ value_print_scalar_formatted (val, options, 0, stream);
break;
case TYPE_CODE_PTR:
- generic_val_print_ptr (type, embedded_offset, stream,
- original_value, options);
+ generic_value_print_ptr (val, stream, options);
break;
case TYPE_CODE_REF:
case TYPE_CODE_RVALUE_REF:
- generic_val_print_ref (type, embedded_offset, stream, recurse,
- original_value, options);
+ generic_val_print_ref (type, 0, stream, recurse,
+ val, options);
break;
case TYPE_CODE_ENUM:
- generic_val_print_enum (type, embedded_offset, stream,
- original_value, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_enum (type, 0, stream, val, options);
break;
case TYPE_CODE_FLAGS:
- generic_val_print_flags (type, embedded_offset, stream,
- original_value, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ val_print_type_code_flags (type, val, 0, stream);
break;
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
- generic_val_print_func (type, embedded_offset, address, stream,
- original_value, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_func (type, 0, value_address (val), stream,
+ val, options);
break;
case TYPE_CODE_BOOL:
- generic_val_print_bool (type, embedded_offset, stream,
- original_value, options, decorations);
+ generic_value_print_bool (val, stream, options, decorations);
break;
case TYPE_CODE_RANGE:
/* FALLTHROUGH */
case TYPE_CODE_INT:
- generic_val_print_int (type, embedded_offset, stream,
- original_value, options);
+ generic_value_print_int (val, stream, options);
break;
case TYPE_CODE_CHAR:
- generic_val_print_char (type, unresolved_type, embedded_offset,
- stream, original_value, options);
+ generic_value_print_char (val, stream, options);
break;
case TYPE_CODE_FLT:
case TYPE_CODE_DECFLOAT:
- generic_val_print_float (type, embedded_offset, stream,
- original_value, options);
+ if (options->format)
+ value_print_scalar_formatted (val, options, 0, stream);
+ else
+ generic_val_print_float (type, 0, stream,
+ val, options);
break;
case TYPE_CODE_VOID:
break;
case TYPE_CODE_COMPLEX:
- generic_val_print_complex (type, embedded_offset, stream,
- original_value, options, decorations);
+ generic_value_print_complex (val, stream, options, decorations);
break;
case TYPE_CODE_UNION:
case TYPE_CODE_METHODPTR:
default:
error (_("Unhandled type code %d in symbol table."),
- TYPE_CODE (type));
+ type->code ());
}
}
-/* Print using the given LANGUAGE the data of type TYPE located at
- VAL's contents buffer + EMBEDDED_OFFSET (within GDB), which came
- from the inferior at address ADDRESS + EMBEDDED_OFFSET, onto
- stdio stream STREAM according to OPTIONS. VAL is the whole object
- that came from ADDRESS.
-
- The language printers will pass down an adjusted EMBEDDED_OFFSET to
- further helper subroutines as subfields of TYPE are printed. In
- such cases, VAL is passed down unadjusted, so
- that VAL can be queried for metadata about the contents data being
- printed, using EMBEDDED_OFFSET as an offset into VAL's contents
- buffer. For example: "has this field been optimized out", or "I'm
- printing an object while inspecting a traceframe; has this
- particular piece of data been collected?".
-
- RECURSE indicates the amount of indentation to supply before
- continuation lines; this amount is roughly twice the value of
- RECURSE. */
+/* Helper function for val_print and common_val_print that does the
+ work. Arguments are as to val_print, but FULL_VALUE, if given, is
+ the value to be printed. */
-void
-val_print (struct type *type, LONGEST embedded_offset,
- CORE_ADDR address, struct ui_file *stream, int recurse,
- struct value *val,
- const struct value_print_options *options,
- const struct language_defn *language)
+static void
+do_val_print (struct value *value, struct ui_file *stream, int recurse,
+ const struct value_print_options *options,
+ const struct language_defn *language)
{
int ret = 0;
struct value_print_options local_opts = *options;
+ struct type *type = value_type (value);
struct type *real_type = check_typedef (type);
if (local_opts.prettyformat == Val_prettyformat_default)
return;
}
- if (!valprint_check_validity (stream, real_type, embedded_offset, val))
+ if (!valprint_check_validity (stream, real_type, 0, value))
return;
if (!options->raw)
{
- ret = apply_ext_lang_val_pretty_printer (type, embedded_offset,
- address, stream, recurse,
- val, options, language);
+ ret = apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
+ language);
if (ret)
return;
}
try
{
- language->la_val_print (type, embedded_offset, address,
- stream, recurse, val,
- &local_opts);
+ language->la_value_print_inner (value, stream, recurse, &local_opts);
}
catch (const gdb_exception_error &except)
{
return 0;
}
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
+ if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
fprintf_styled (stream, metadata_style.style (),
_("<internal function %s>"),
const struct value_print_options *options,
const struct language_defn *language)
{
- if (!value_check_printable (val, stream, options))
- return;
-
if (language->la_language == language_ada)
/* The value might have a dynamic type, which would cause trouble
below when trying to extract the value contents (since the value
if (value_lazy (val))
value_fetch_lazy (val);
- val_print (value_type (val),
- value_embedded_offset (val), value_address (val),
- stream, recurse,
- val, options, language);
+ do_val_print (val, stream, recurse, options, language);
+}
+
+/* See valprint.h. */
+
+void
+common_val_print_checked (struct value *val, struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options,
+ const struct language_defn *language)
+{
+ if (!value_check_printable (val, stream, options))
+ return;
+ common_val_print (val, stream, recurse, options, language);
}
/* Print on stream STREAM the value VAL according to OPTIONS. The value
value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options)
{
+ scoped_value_mark free_values;
+
if (!value_check_printable (val, stream, options))
return;
if (!options->raw)
{
int r
- = apply_ext_lang_val_pretty_printer (value_type (val),
- value_embedded_offset (val),
- value_address (val),
- stream, 0,
- val, options, current_language);
+ = apply_ext_lang_val_pretty_printer (val, stream, 0, options,
+ current_language);
if (r)
return;
}
static void
-val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
- struct ui_file *stream)
+val_print_type_code_flags (struct type *type, struct value *original_value,
+ int embedded_offset, struct ui_file *stream)
{
+ const gdb_byte *valaddr = (value_contents_for_printing (original_value)
+ + embedded_offset);
ULONGEST val = unpack_long (type, valaddr);
- int field, nfields = TYPE_NFIELDS (type);
+ int field, nfields = type->num_fields ();
struct gdbarch *gdbarch = get_type_arch (type);
struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
&& TYPE_FIELD_BITSIZE (type, field) == 1)
{
if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
- fprintf_filtered (stream, " %s",
- TYPE_FIELD_NAME (type, field));
+ fprintf_filtered
+ (stream, " %ps",
+ styled_string (variable_name_style.style (),
+ TYPE_FIELD_NAME (type, field)));
}
else
{
if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
field_val &= ((ULONGEST) 1 << field_len) - 1;
- fprintf_filtered (stream, " %s=",
- TYPE_FIELD_NAME (type, field));
- if (TYPE_CODE (field_type) == TYPE_CODE_ENUM)
+ fprintf_filtered (stream, " %ps=",
+ styled_string (variable_name_style.style (),
+ TYPE_FIELD_NAME (type, field)));
+ if (field_type->code () == TYPE_CODE_ENUM)
generic_val_print_enum_1 (field_type, field_val, stream);
else
print_longest (stream, 'd', 0, field_val);
fputs_filtered (" ]", stream);
}
-/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
- according to OPTIONS and SIZE on STREAM. Format i is not supported
- at this level.
-
- This is how the elements of an array or structure are printed
- with a format. */
+/* See valprint.h. */
void
-val_print_scalar_formatted (struct type *type,
- LONGEST embedded_offset,
- struct value *val,
- const struct value_print_options *options,
- int size,
- struct ui_file *stream)
+value_print_scalar_formatted (struct value *val,
+ const struct value_print_options *options,
+ int size,
+ struct ui_file *stream)
{
- struct gdbarch *arch = get_type_arch (type);
- int unit_size = gdbarch_addressable_memory_unit_size (arch);
+ struct type *type = check_typedef (value_type (val));
gdb_assert (val != NULL);
struct value_print_options opts = *options;
opts.format = 0;
opts.deref_ref = 0;
- val_print (type, embedded_offset, 0, stream, 0, val, &opts,
- current_language);
+ common_val_print (val, stream, 0, &opts, current_language);
return;
}
/* A scalar object that does not have all bits available can't be
printed, because all bits contribute to its representation. */
- if (value_bits_any_optimized_out (val,
- TARGET_CHAR_BIT * embedded_offset,
+ if (value_bits_any_optimized_out (val, 0,
TARGET_CHAR_BIT * TYPE_LENGTH (type)))
val_print_optimized_out (val, stream);
- else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
+ else if (!value_bytes_available (val, 0, TYPE_LENGTH (type)))
val_print_unavailable (stream);
else
- print_scalar_formatted (valaddr + embedded_offset * unit_size, type,
- options, size, stream);
+ print_scalar_formatted (valaddr, type, options, size, stream);
}
/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
struct ui_file *stream,
const struct value_print_options *options)
{
- struct value *index_value;
-
if (!options->print_array_indexes)
return;
- index_value = value_from_longest (index_type, index);
-
- LA_PRINT_ARRAY_INDEX (index_value, stream, options);
+ LA_PRINT_ARRAY_INDEX (index_type, index, stream, options);
}
-/* Called by various <lang>_val_print routines to print elements of an
- array in the form "<elem1>, <elem2>, <elem3>, ...".
-
- (FIXME?) Assumes array element separator is a comma, which is correct
- for all languages currently handled.
- (FIXME?) Some languages have a notation for repeated array elements,
- perhaps we should try to use that notation when appropriate. */
+/* See valprint.h. */
void
-val_print_array_elements (struct type *type,
- LONGEST embedded_offset,
- CORE_ADDR address, struct ui_file *stream,
- int recurse,
- struct value *val,
- const struct value_print_options *options,
- unsigned int i)
+value_print_array_elements (struct value *val, struct ui_file *stream,
+ int recurse,
+ const struct value_print_options *options,
+ unsigned int i)
{
unsigned int things_printed = 0;
unsigned len;
- struct type *elttype, *index_type, *base_index_type;
+ struct type *elttype, *index_type;
unsigned eltlen;
/* Position of the array element we are examining to see
whether it is repeated. */
/* Number of repetitions we have detected so far. */
unsigned int reps;
LONGEST low_bound, high_bound;
- LONGEST low_pos, high_pos;
+
+ struct type *type = check_typedef (value_type (val));
elttype = TYPE_TARGET_TYPE (type);
eltlen = type_length_units (check_typedef (elttype));
index_type = TYPE_INDEX_TYPE (type);
+ if (index_type->code () == TYPE_CODE_RANGE)
+ index_type = TYPE_TARGET_TYPE (index_type);
if (get_array_bounds (type, &low_bound, &high_bound))
{
- if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
- base_index_type = TYPE_TARGET_TYPE (index_type);
- else
- base_index_type = index_type;
-
- /* Non-contiguous enumerations types can by used as index types
- in some languages (e.g. Ada). In this case, the array length
- shall be computed from the positions of the first and last
- literal in the enumeration type, and not from the values
- of these literals. */
- if (!discrete_position (base_index_type, low_bound, &low_pos)
- || !discrete_position (base_index_type, high_bound, &high_pos))
- {
- warning (_("unable to get positions in array, use bounds instead"));
- low_pos = low_bound;
- high_pos = high_bound;
- }
-
- /* The array length should normally be HIGH_POS - LOW_POS + 1.
- But we have to be a little extra careful, because some languages
- such as Ada allow LOW_POS to be greater than HIGH_POS for
- empty arrays. In that situation, the array length is just zero,
- not negative! */
- if (low_pos > high_pos)
+ /* The array length should normally be HIGH_BOUND - LOW_BOUND +
+ 1. But we have to be a little extra careful, because some
+ languages such as Ada allow LOW_BOUND to be greater than
+ HIGH_BOUND for empty arrays. In that situation, the array
+ length is just zero, not negative! */
+ if (low_bound > high_bound)
len = 0;
else
- len = high_pos - low_pos + 1;
+ len = high_bound - low_bound + 1;
}
else
{
for (; i < len && things_printed < options->print_max; i++)
{
+ scoped_value_mark free_values;
+
if (i != 0)
{
if (options->prettyformat_arrays)
print_spaces_filtered (2 + 2 * recurse, stream);
}
else
- {
- fprintf_filtered (stream, ", ");
- }
+ fprintf_filtered (stream, ", ");
+ }
+ else if (options->prettyformat_arrays)
+ {
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 + 2 * recurse, stream);
}
wrap_here (n_spaces (2 + 2 * recurse));
maybe_print_array_index (index_type, i + low_bound,
if (options->repeat_count_threshold < UINT_MAX)
{
while (rep1 < len
- && value_contents_eq (val,
- embedded_offset + i * eltlen,
- val,
- (embedded_offset
- + rep1 * eltlen),
+ && value_contents_eq (val, i * eltlen,
+ val, rep1 * eltlen,
eltlen))
{
++reps;
}
}
+ struct value *element = value_from_component (val, elttype, eltlen * i);
+ common_val_print (element, stream, recurse + 1, options,
+ current_language);
+
if (reps > options->repeat_count_threshold)
{
- val_print (elttype, embedded_offset + i * eltlen,
- address, stream, recurse + 1, val, options,
- current_language);
annotate_elt_rep (reps);
fprintf_filtered (stream, " %p[<repeats %u times>%p]",
metadata_style.style ().ptr (), reps, nullptr);
}
else
{
- val_print (elttype, embedded_offset + i * eltlen,
- address,
- stream, recurse + 1, val, options, current_language);
annotate_elt ();
things_printed++;
}
}
annotate_array_section_end ();
if (i < len)
+ fprintf_filtered (stream, "...");
+ if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, "...");
+ fprintf_filtered (stream, "\n");
+ print_spaces_filtered (2 * recurse, stream);
}
}
}
\f
-static void
-set_print (const char *arg, int from_tty)
-{
- printf_unfiltered (
- "\"set print\" must be followed by the name of a print subcommand.\n");
- help_list (setprintlist, "set print ", all_commands, gdb_stdout);
-}
-
-static void
-show_print (const char *args, int from_tty)
-{
- cmd_show_list (showprintlist, from_tty, "");
-}
-
-static void
-set_print_raw (const char *arg, int from_tty)
-{
- printf_unfiltered (
- "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
- help_list (setprintrawlist, "set print raw ", all_commands, gdb_stdout);
-}
-
-static void
-show_print_raw (const char *args, int from_tty)
-{
- cmd_show_list (showprintrawlist, from_tty, "");
-}
-
/* Controls printing of vtbl's. */
static void
show_vtblprint (struct ui_file *file, int from_tty,
{
cmd_list_element *cmd;
- add_prefix_cmd ("print", no_class, set_print,
- _("Generic command for setting how things print."),
- &setprintlist, "set print ", 0, &setlist);
+ add_basic_prefix_cmd ("print", no_class,
+ _("Generic command for setting how things print."),
+ &setprintlist, "set print ", 0, &setlist);
add_alias_cmd ("p", "print", no_class, 1, &setlist);
/* Prefer set print to set prompt. */
add_alias_cmd ("pr", "print", no_class, 1, &setlist);
- add_prefix_cmd ("print", no_class, show_print,
- _("Generic command for showing print settings."),
- &showprintlist, "show print ", 0, &showlist);
+ add_show_prefix_cmd ("print", no_class,
+ _("Generic command for showing print settings."),
+ &showprintlist, "show print ", 0, &showlist);
add_alias_cmd ("p", "print", no_class, 1, &showlist);
add_alias_cmd ("pr", "print", no_class, 1, &showlist);
- cmd = add_prefix_cmd ("raw", no_class, set_print_raw,
- _("\
+ cmd = add_basic_prefix_cmd ("raw", no_class,
+ _("\
Generic command for setting what things to print in \"raw\" mode."),
- &setprintrawlist, "set print raw ", 0,
- &setprintlist);
+ &setprintrawlist, "set print raw ", 0,
+ &setprintlist);
deprecate_cmd (cmd, nullptr);
- cmd = add_prefix_cmd ("raw", no_class, show_print_raw,
- _("Generic command for showing \"print raw\" settings."),
- &showprintrawlist, "show print raw ", 0,
- &showprintlist);
+ cmd = add_show_prefix_cmd ("raw", no_class,
+ _("Generic command for showing \"print raw\" settings."),
+ &showprintrawlist, "show print raw ", 0,
+ &showprintlist);
deprecate_cmd (cmd, nullptr);
gdb::option::add_setshow_cmds_for_options
projects / deliverable / binutils-gdb.git / blobdiff