/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "typeprint.h"
#include <ctype.h>
#include <algorithm>
-#include "common/byte-vector.h"
+#include "gdbsupport/byte-vector.h"
+#include "cli/cli-option.h"
+#include "gdbarch.h"
+#include "cli/cli-style.h"
+#include "count-one-bits.h"
/* Maximum number of wchars returned from wchar_iterate. */
#define MAX_WCHARS 4
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. */
+#define PRINT_MAX_DEPTH_DEFAULT 20 /* Start print_max_depth off at this value. */
struct value_print_options user_print_options =
{
1, /* pascal_static_field_print */
0, /* raw */
0, /* summary */
- 1 /* symbol_print */
+ 1, /* symbol_print */
+ PRINT_MAX_DEPTH_DEFAULT, /* max_depth */
+ 1 /* finish_print */
};
/* Initialize *OPTS to be a copy of the user print options. */
type = TYPE_TARGET_TYPE (type);
type = check_typedef (type);
}
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
case TYPE_CODE_ARRAY:
case TYPE_CODE_STRUCT:
}
}
+/* A helper function for val_print. When printing with limited depth we
+ want to print string and scalar arguments, but not aggregate arguments.
+ This function distinguishes between the two. */
+
+static bool
+val_print_scalar_or_string_type_p (struct type *type,
+ const struct language_defn *language)
+{
+ return (val_print_scalar_type_p (type)
+ || language->la_is_string_type_p (type));
+}
+
/* See its definition in value.h. */
int
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)
}
if (!is_ref || !ref_is_addressable)
- fputs_filtered (_("<synthetic pointer>"), stream);
+ fputs_styled (_("<synthetic pointer>"), metadata_style.style (),
+ stream);
/* C++ references should be valid even if they're synthetic. */
return is_ref;
if (val != NULL && value_lval_const (val) == lval_register)
val_print_not_saved (stream);
else
- fprintf_filtered (stream, _("<optimized out>"));
+ fprintf_styled (stream, metadata_style.style (), _("<optimized out>"));
}
void
val_print_not_saved (struct ui_file *stream)
{
- fprintf_filtered (stream, _("<not saved>"));
+ fprintf_styled (stream, metadata_style.style (), _("<not saved>"));
}
void
val_print_unavailable (struct ui_file *stream)
{
- fprintf_filtered (stream, _("<unavailable>"));
+ fprintf_styled (stream, metadata_style.style (), _("<unavailable>"));
}
void
val_print_invalid_address (struct ui_file *stream)
{
- fprintf_filtered (stream, _("<invalid address>"));
+ fprintf_styled (stream, metadata_style.style (), _("<invalid address>"));
}
/* Print a pointer based on the type of its target.
{
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))
{
int first = 1;
- /* We have a "flag" enum, so we try to decompose it into
- pieces as appropriate. A flag enum has disjoint
- constants by definition. */
- fputs_filtered ("(", stream);
+ /* We have a "flag" enum, so we try to decompose it into pieces as
+ appropriate. The enum may have multiple enumerators representing
+ the same bit, in which case we choose to only print the first one
+ we find. */
for (i = 0; i < len; ++i)
{
QUIT;
- if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0)
+ ULONGEST enumval = TYPE_FIELD_ENUMVAL (type, i);
+ int nbits = count_one_bits_ll (enumval);
+
+ gdb_assert (nbits == 0 || nbits == 1);
+
+ 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: ", stream);
- print_longest (stream, 'd', 0, val);
- }
- 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);
+ }
}
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);
-
- val = unpack_long (type, valaddr + embedded_offset * unit_size);
+ gdb_assert (!options->format);
- 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:
/* This happens (without TYPE_STUB set) on systems which don't use
dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
and no complete type for struct foo in that file. */
- fprintf_filtered (stream, _("<incomplete type>"));
+ fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
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 ());
}
- gdb_flush (stream);
}
-/* 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.
+/* 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. */
- 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. */
-
-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)
if (TYPE_STUB (real_type))
{
- fprintf_filtered (stream, _("<incomplete type>"));
- gdb_flush (stream);
+ fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
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;
}
return;
}
- TRY
+ /* If this value is too deep then don't print it. */
+ if (!val_print_scalar_or_string_type_p (type, language)
+ && val_print_check_max_depth (stream, recurse, options, language))
+ 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 (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
{
- fprintf_filtered (stream, _("<error reading variable>"));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<error reading variable>"));
}
- END_CATCH
+}
+
+/* See valprint.h. */
+
+bool
+val_print_check_max_depth (struct ui_file *stream, int recurse,
+ const struct value_print_options *options,
+ const struct language_defn *language)
+{
+ if (options->max_depth > -1 && recurse >= options->max_depth)
+ {
+ gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
+ fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
+ return true;
+ }
+
+ return false;
}
/* Check whether the value VAL is printable. Return 1 if it is;
{
if (val == 0)
{
- fprintf_filtered (stream, _("<address of value unknown>"));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<address of value unknown>"));
return 0;
}
return 0;
}
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
+ if (value_type (val)->code () == TYPE_CODE_INTERNAL_FUNCTION)
{
- fprintf_filtered (stream, _("<internal function %s>"),
- value_internal_function_name (val));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<internal function %s>"),
+ value_internal_function_name (val));
return 0;
}
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.
(leading 0 or 0x).
Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
- and was intended to request formating according to the current
+ and was intended to request formatting according to the current
language and would be used for most integers that GDB prints. The
exceptional cases were things like protocols where the format of
the integer is a protocol thing, not a user-visible thing). The
* decimal.
*
* Given a hex number (in nibbles) as XYZ, we start by taking X and
- * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
+ * decimalizing it as "x1 x2" in two decimal nibbles. Then we multiply
* the nibbles by 16, add Y and re-decimalize. Repeat with Z.
*
* The trick is that "digits" holds a base-10 number, but sometimes
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, " <repeats %u times>", reps);
+ fprintf_filtered (stream, " %p[<repeats %u times>%p]",
+ metadata_style.style ().ptr (), reps, nullptr);
annotate_elt_rep_end ();
i = rep1 - 1;
}
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);
}
}
int quoter, const char *encoding)
{
enum bfd_endian byte_order
- = gdbarch_byte_order (get_type_arch (type));
+ = type_byte_order (type);
gdb_byte *c_buf;
int need_escape = 0;
obstack, 0, &need_escape);
obstack_grow_wstr (obstack, LCST (">"));
- /* We do not attempt to outupt anything after this. */
+ /* We do not attempt to output anything after this. */
state = FINISH;
break;
int quote_char, int c_style_terminator,
const struct value_print_options *options)
{
- enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
+ enum bfd_endian byte_order = type_byte_order (type);
unsigned int i;
int width = TYPE_LENGTH (type);
int finished = 0;
int bytes_read;
gdb::unique_xmalloc_ptr<gdb_byte> buffer; /* Dynamically growable fetch buffer. */
struct gdbarch *gdbarch = get_type_arch (elttype);
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum bfd_endian byte_order = type_byte_order (elttype);
int width = TYPE_LENGTH (elttype);
/* First we need to figure out the limit on the number of characters we are
{
std::string str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr);
- fprintf_filtered (stream, "<error: ");
- fputs_filtered (str.c_str (), stream);
- fprintf_filtered (stream, ">");
+ fprintf_filtered (stream, _("<error: %ps>"),
+ styled_string (metadata_style.style (),
+ str.c_str ()));
}
- gdb_flush (stream);
-
return (bytes_read / width);
}
+
+/* Handle 'show print max-depth'. */
+
+static void
+show_print_max_depth (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Maximum print depth is %s.\n"), value);
+}
\f
/* The 'set input-radix' command writes to this auxiliary variable.
}
\f
+/* Controls printing of vtbl's. */
static void
-set_print (const char *arg, int from_tty)
+show_vtblprint (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
{
- printf_unfiltered (
- "\"set print\" must be followed by the name of a print subcommand.\n");
- help_list (setprintlist, "set print ", all_commands, gdb_stdout);
+ fprintf_filtered (file, _("\
+Printing of C++ virtual function tables is %s.\n"),
+ value);
}
+/* Controls looking up an object's derived type using what we find in
+ its vtables. */
static void
-show_print (const char *args, int from_tty)
+show_objectprint (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
{
- cmd_show_list (showprintlist, from_tty, "");
+ fprintf_filtered (file, _("\
+Printing of object's derived type based on vtable info is %s.\n"),
+ value);
}
static void
-set_print_raw (const char *arg, int from_tty)
+show_static_field_print (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
{
- 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);
+ fprintf_filtered (file,
+ _("Printing of C++ static members is %s.\n"),
+ value);
}
-static void
-show_print_raw (const char *args, int from_tty)
+\f
+
+/* A couple typedefs to make writing the options a bit more
+ convenient. */
+using boolean_option_def
+ = gdb::option::boolean_option_def<value_print_options>;
+using uinteger_option_def
+ = gdb::option::uinteger_option_def<value_print_options>;
+using zuinteger_unlimited_option_def
+ = gdb::option::zuinteger_unlimited_option_def<value_print_options>;
+
+/* Definitions of options for the "print" and "compile print"
+ commands. */
+static const gdb::option::option_def value_print_option_defs[] = {
+
+ boolean_option_def {
+ "address",
+ [] (value_print_options *opt) { return &opt->addressprint; },
+ show_addressprint, /* show_cmd_cb */
+ N_("Set printing of addresses."),
+ N_("Show printing of addresses."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "array",
+ [] (value_print_options *opt) { return &opt->prettyformat_arrays; },
+ show_prettyformat_arrays, /* show_cmd_cb */
+ N_("Set pretty formatting of arrays."),
+ N_("Show pretty formatting of arrays."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "array-indexes",
+ [] (value_print_options *opt) { return &opt->print_array_indexes; },
+ show_print_array_indexes, /* show_cmd_cb */
+ N_("Set printing of array indexes."),
+ N_("Show printing of array indexes."),
+ NULL, /* help_doc */
+ },
+
+ uinteger_option_def {
+ "elements",
+ [] (value_print_options *opt) { return &opt->print_max; },
+ show_print_max, /* show_cmd_cb */
+ N_("Set limit on string chars or array elements to print."),
+ N_("Show limit on string chars or array elements to print."),
+ N_("\"unlimited\" causes there to be no limit."),
+ },
+
+ zuinteger_unlimited_option_def {
+ "max-depth",
+ [] (value_print_options *opt) { return &opt->max_depth; },
+ show_print_max_depth, /* show_cmd_cb */
+ N_("Set maximum print depth for nested structures, unions and arrays."),
+ N_("Show maximum print depth for nested structures, unions, and arrays."),
+ N_("When structures, unions, or arrays are nested beyond this depth then they\n\
+will be replaced with either '{...}' or '(...)' depending on the language.\n\
+Use \"unlimited\" to print the complete structure.")
+ },
+
+ boolean_option_def {
+ "null-stop",
+ [] (value_print_options *opt) { return &opt->stop_print_at_null; },
+ show_stop_print_at_null, /* show_cmd_cb */
+ N_("Set printing of char arrays to stop at first null char."),
+ N_("Show printing of char arrays to stop at first null char."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "object",
+ [] (value_print_options *opt) { return &opt->objectprint; },
+ show_objectprint, /* show_cmd_cb */
+ _("Set printing of C++ virtual function tables."),
+ _("Show printing of C++ virtual function tables."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "pretty",
+ [] (value_print_options *opt) { return &opt->prettyformat_structs; },
+ show_prettyformat_structs, /* show_cmd_cb */
+ N_("Set pretty formatting of structures."),
+ N_("Show pretty formatting of structures."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "raw-values",
+ [] (value_print_options *opt) { return &opt->raw; },
+ NULL, /* show_cmd_cb */
+ N_("Set whether to print values in raw form."),
+ N_("Show whether to print values in raw form."),
+ N_("If set, values are printed in raw form, bypassing any\n\
+pretty-printers for that value.")
+ },
+
+ uinteger_option_def {
+ "repeats",
+ [] (value_print_options *opt) { return &opt->repeat_count_threshold; },
+ show_repeat_count_threshold, /* show_cmd_cb */
+ N_("Set threshold for repeated print elements."),
+ N_("Show threshold for repeated print elements."),
+ N_("\"unlimited\" causes all elements to be individually printed."),
+ },
+
+ boolean_option_def {
+ "static-members",
+ [] (value_print_options *opt) { return &opt->static_field_print; },
+ show_static_field_print, /* show_cmd_cb */
+ N_("Set printing of C++ static members."),
+ N_("Show printing of C++ static members."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "symbol",
+ [] (value_print_options *opt) { return &opt->symbol_print; },
+ show_symbol_print, /* show_cmd_cb */
+ N_("Set printing of symbol names when printing pointers."),
+ N_("Show printing of symbol names when printing pointers."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "union",
+ [] (value_print_options *opt) { return &opt->unionprint; },
+ show_unionprint, /* show_cmd_cb */
+ N_("Set printing of unions interior to structures."),
+ N_("Show printing of unions interior to structures."),
+ NULL, /* help_doc */
+ },
+
+ boolean_option_def {
+ "vtbl",
+ [] (value_print_options *opt) { return &opt->vtblprint; },
+ show_vtblprint, /* show_cmd_cb */
+ N_("Set printing of C++ virtual function tables."),
+ N_("Show printing of C++ virtual function tables."),
+ NULL, /* help_doc */
+ },
+};
+
+/* See valprint.h. */
+
+gdb::option::option_def_group
+make_value_print_options_def_group (value_print_options *opts)
{
- cmd_show_list (showprintrawlist, from_tty, "");
+ return {{value_print_option_defs}, opts};
}
-\f
+void _initialize_valprint ();
void
-_initialize_valprint (void)
+_initialize_valprint ()
{
- add_prefix_cmd ("print", no_class, set_print,
- _("Generic command for setting how things print."),
- &setprintlist, "set print ", 0, &setlist);
+ cmd_list_element *cmd;
+
+ 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);
- 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);
- add_prefix_cmd ("raw", no_class, show_print_raw,
- _("Generic command for showing \"print raw\" settings."),
- &showprintrawlist, "show print raw ", 0, &showprintlist);
-
- add_setshow_uinteger_cmd ("elements", no_class,
- &user_print_options.print_max, _("\
-Set limit on string chars or array elements to print."), _("\
-Show limit on string chars or array elements to print."), _("\
-\"set print elements unlimited\" causes there to be no limit."),
- NULL,
- show_print_max,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("null-stop", no_class,
- &user_print_options.stop_print_at_null, _("\
-Set printing of char arrays to stop at first null char."), _("\
-Show printing of char arrays to stop at first null char."), NULL,
- NULL,
- show_stop_print_at_null,
- &setprintlist, &showprintlist);
-
- add_setshow_uinteger_cmd ("repeats", no_class,
- &user_print_options.repeat_count_threshold, _("\
-Set threshold for repeated print elements."), _("\
-Show threshold for repeated print elements."), _("\
-\"set print repeats unlimited\" causes all elements to be individually printed."),
- NULL,
- show_repeat_count_threshold,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("pretty", class_support,
- &user_print_options.prettyformat_structs, _("\
-Set pretty formatting of structures."), _("\
-Show pretty formatting of structures."), NULL,
- NULL,
- show_prettyformat_structs,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("union", class_support,
- &user_print_options.unionprint, _("\
-Set printing of unions interior to structures."), _("\
-Show printing of unions interior to structures."), NULL,
- NULL,
- show_unionprint,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("array", class_support,
- &user_print_options.prettyformat_arrays, _("\
-Set pretty formatting of arrays."), _("\
-Show pretty formatting of arrays."), NULL,
- NULL,
- show_prettyformat_arrays,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("address", class_support,
- &user_print_options.addressprint, _("\
-Set printing of addresses."), _("\
-Show printing of addresses."), NULL,
- NULL,
- show_addressprint,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("symbol", class_support,
- &user_print_options.symbol_print, _("\
-Set printing of symbol names when printing pointers."), _("\
-Show printing of symbol names when printing pointers."),
- NULL, NULL,
- show_symbol_print,
- &setprintlist, &showprintlist);
+ &setprintrawlist, "set print raw ", 0,
+ &setprintlist);
+ deprecate_cmd (cmd, nullptr);
+
+ 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
+ (class_support, &user_print_options, value_print_option_defs,
+ &setprintlist, &showprintlist);
add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
_("\
Show the default input and output number radices.\n\
Use 'show input-radix' or 'show output-radix' to independently show each."),
&showlist);
-
- add_setshow_boolean_cmd ("array-indexes", class_support,
- &user_print_options.print_array_indexes, _("\
-Set printing of array indexes."), _("\
-Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
- &setprintlist, &showprintlist);
}
projects / deliverable / binutils-gdb.git / blobdiff