/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "target-float.h"
#include "extension.h"
#include "ada-lang.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "charset.h"
#include "typeprint.h"
#include <ctype.h>
#include "c-lang.h"
#include "cp-abi.h"
#include "inferior.h"
+#include "gdbsupport/selftest.h"
+#include "selftest-arch.h"
/* Maximum number of wchars returned from wchar_iterate. */
#define MAX_WCHARS 4
show_print_max (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Limit on string chars or array "
- "elements to print is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Limit on string chars or array "
+ "elements to print is %s.\n"),
+ value);
}
show_input_radix (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Default input radix for entering numbers is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Default input radix for entering numbers is %s.\n"),
+ value);
}
unsigned output_radix = 10;
show_output_radix (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Default output radix for printing of values is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Default output radix for printing of values is %s.\n"),
+ value);
}
/* By default we print arrays without printing the index of each element in
show_print_array_indexes (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
+ gdb_printf (file, _("Printing of array indexes is %s.\n"), value);
}
/* Print repeat counts if there are more than this many repetitions of an
show_repeat_count_threshold (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
- value);
+ gdb_printf (file, _("Threshold for repeated print elements is %s.\n"),
+ value);
}
/* If nonzero, prints memory tag violations for pointers. */
show_memory_tag_violations (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Printing of memory tag violations is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of memory tag violations is %s.\n"),
+ value);
}
/* If nonzero, stops printing of char arrays at first null. */
show_stop_print_at_null (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Printing of char arrays to stop "
- "at first null char is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of char arrays to stop "
+ "at first null char is %s.\n"),
+ value);
}
/* Controls pretty printing of structures. */
show_prettyformat_structs (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Pretty formatting of structures is %s.\n"), value);
+ gdb_printf (file, _("Pretty formatting of structures is %s.\n"), value);
}
/* Controls pretty printing of arrays. */
show_prettyformat_arrays (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Pretty formatting of arrays is %s.\n"), value);
+ gdb_printf (file, _("Pretty formatting of arrays is %s.\n"), value);
}
/* If nonzero, causes unions inside structures or other unions to be
show_unionprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Printing of unions interior to structures is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of unions interior to structures is %s.\n"),
+ value);
}
/* If nonzero, causes machine addresses to be printed in certain contexts. */
show_addressprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
+ gdb_printf (file, _("Printing of addresses is %s.\n"), value);
}
static void
show_symbol_print (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file,
- _("Printing of symbols when printing pointers is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of symbols when printing pointers is %s.\n"),
+ value);
}
\f
if (options->symbol_print)
print_address_demangle (options, gdbarch, address, stream, demangle);
else if (options->addressprint)
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* generic_val_print helper for TYPE_CODE_ARRAY. */
if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the array high bound"));
- fputs_filtered (decorations->array_start, stream);
+ gdb_puts (decorations->array_start, stream);
value_print_array_elements (val, stream, recurse, options, 0);
- fputs_filtered (decorations->array_end, stream);
+ gdb_puts (decorations->array_end, stream);
}
else
{
{
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);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
CORE_ADDR addr = unpack_pointer (type, valaddr);
print_unpacked_pointer (type, elttype, addr, stream, options);
CORE_ADDR address
= extract_typed_address (address_buffer + embedded_offset, type);
- fprintf_filtered (stream, "@");
- fputs_filtered (paddress (gdbarch, address), stream);
+ gdb_printf (stream, "@");
+ gdb_puts (paddress (gdbarch, address), stream);
}
/* Else: we have a non-addressable value, such as a DW_AT_const_value. */
}
gdb_assert (deref_val != NULL);
if (value_lval_const (deref_val) == lval_memory)
- return value_contents_for_printing_const (value_addr (deref_val));
+ return value_contents_for_printing_const (value_addr (deref_val)).data ();
else
{
/* We have a non-addressable value, such as a DW_AT_const_value. */
const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
|| options->deref_ref);
const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
if (must_coerce_ref && type_is_defined)
{
print_ref_address (type, address, embedded_offset, stream);
if (options->deref_ref)
- fputs_filtered (": ", stream);
+ gdb_puts (": ", stream);
}
if (options->deref_ref)
common_val_print (deref_val, stream, recurse, options,
current_language);
else
- fputs_filtered ("???", stream);
+ gdb_puts ("???", stream);
}
}
for (i = 0; i < len; i++)
{
QUIT;
- if (val == TYPE_FIELD_ENUMVAL (type, i))
+ if (val == type->field (i).loc_enumval ())
{
break;
}
}
if (i < len)
{
- fputs_styled (TYPE_FIELD_NAME (type, i), variable_name_style.style (),
+ fputs_styled (type->field (i).name (), variable_name_style.style (),
stream);
}
- else if (TYPE_FLAG_ENUM (type))
+ else if (type->is_flag_enum ())
{
int first = 1;
{
QUIT;
- ULONGEST enumval = TYPE_FIELD_ENUMVAL (type, i);
+ ULONGEST enumval = type->field (i).loc_enumval ();
int nbits = count_one_bits_ll (enumval);
gdb_assert (nbits == 0 || nbits == 1);
{
if (first)
{
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
first = 0;
}
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", stream);
- val &= ~TYPE_FIELD_ENUMVAL (type, i);
- fputs_styled (TYPE_FIELD_NAME (type, i),
+ val &= ~type->field (i).loc_enumval ();
+ fputs_styled (type->field (i).name (),
variable_name_style.style (), stream);
}
}
{
/* There are leftover bits, print them. */
if (first)
- fputs_filtered ("(", stream);
+ gdb_puts ("(", stream);
else
- fputs_filtered (" | ", stream);
+ gdb_puts (" | ", stream);
- fputs_filtered ("unknown: 0x", stream);
+ gdb_puts ("unknown: 0x", stream);
print_longest (stream, 'x', 0, val);
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
else if (first)
{
/* Nothing has been printed and the value is 0, the enum value must
have been 0. */
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
}
else
{
/* Something has been printed, close the parenthesis. */
- fputs_filtered (")", stream);
+ gdb_puts (")", stream);
}
}
else
gdb_assert (!options->format);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
val = unpack_long (type, valaddr + embedded_offset * unit_size);
/* FIXME, we should consider, at least for ANSI C language,
eliminating the distinction made between FUNCs and POINTERs to
FUNCs. */
- fprintf_filtered (stream, "{");
+ gdb_printf (stream, "{");
type_print (type, "", stream, -1);
- fprintf_filtered (stream, "} ");
+ gdb_printf (stream, "} ");
/* Try to print what function it points to, and its address. */
print_address_demangle (options, gdbarch, address, stream, demangle);
}
}
else
{
- const gdb_byte *valaddr = value_contents_for_printing (value);
+ const gdb_byte *valaddr = value_contents_for_printing (value).data ();
struct type *type = check_typedef (value_type (value));
LONGEST val = unpack_long (type, valaddr);
if (val == 0)
- fputs_filtered (decorations->false_name, stream);
+ gdb_puts (decorations->false_name, stream);
else if (val == 1)
- fputs_filtered (decorations->true_name, stream);
+ gdb_puts (decorations->true_name, stream);
else
print_longest (stream, 'd', 0, val);
}
{
struct type *unresolved_type = value_type (value);
struct type *type = check_typedef (unresolved_type);
- const gdb_byte *valaddr = value_contents_for_printing (value);
+ const gdb_byte *valaddr = value_contents_for_printing (value).data ();
LONGEST val = unpack_long (type, valaddr);
if (type->is_unsigned ())
- fprintf_filtered (stream, "%u", (unsigned int) val);
+ gdb_printf (stream, "%u", (unsigned int) val);
else
- fprintf_filtered (stream, "%d", (int) val);
- fputs_filtered (" ", stream);
- LA_PRINT_CHAR (val, unresolved_type, stream);
+ gdb_printf (stream, "%d", (int) val);
+ gdb_puts (" ", stream);
+ current_language->printchar (val, unresolved_type, stream);
}
}
{
gdb_assert (!options->format);
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
+ const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();
print_floating (valaddr, type, stream);
}
{
struct type *type = value_type (val);
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
gdb_mpf f;
f.read_fixed_point (gdb::make_array_view (valaddr, TYPE_LENGTH (type)),
const char *fmt = TYPE_LENGTH (type) < 4 ? "%.11Fg" : "%.17Fg";
std::string str = gmp_string_printf (fmt, f.val);
- fprintf_filtered (stream, "%s", str.c_str ());
+ gdb_printf (stream, "%s", str.c_str ());
}
}
const struct generic_val_print_decorations
*decorations)
{
- fprintf_filtered (stream, "%s", decorations->complex_prefix);
+ gdb_printf (stream, "%s", decorations->complex_prefix);
struct value *real_part = value_real_part (val);
value_print_scalar_formatted (real_part, options, 0, stream);
- fprintf_filtered (stream, "%s", decorations->complex_infix);
+ gdb_printf (stream, "%s", decorations->complex_infix);
struct value *imag_part = value_imaginary_part (val);
value_print_scalar_formatted (imag_part, options, 0, stream);
- fprintf_filtered (stream, "%s", decorations->complex_suffix);
+ gdb_printf (stream, "%s", decorations->complex_suffix);
}
/* generic_value_print helper for TYPE_CODE_MEMBERPTR. */
/* Member pointers are essentially specific to C++, and so if we
encounter one, we should print it according to C++ rules. */
struct type *type = check_typedef (value_type (val));
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
cp_print_class_member (valaddr, type, stream, "&");
}
else
if (is_fixed_point_type (type))
type = type->fixed_point_type_base_type ();
+ /* Widen a subrange to its target type, then use that type's
+ printer. */
+ while (type->code () == TYPE_CODE_RANGE)
+ {
+ type = check_typedef (TYPE_TARGET_TYPE (type));
+ val = value_cast (type, val);
+ }
+
switch (type->code ())
{
case TYPE_CODE_ARRAY:
generic_value_print_bool (val, stream, options, decorations);
break;
- case TYPE_CODE_RANGE:
case TYPE_CODE_INT:
generic_value_print_int (val, stream, options);
break;
break;
case TYPE_CODE_VOID:
- fputs_filtered (decorations->void_name, stream);
+ gdb_puts (decorations->void_name, stream);
break;
case TYPE_CODE_ERROR:
- fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
+ gdb_printf (stream, "%s", TYPE_ERROR_NAME (type));
break;
case TYPE_CODE_UNDEF:
break;
case TYPE_CODE_METHODPTR:
- cplus_print_method_ptr (value_contents_for_printing (val), type,
+ cplus_print_method_ptr (value_contents_for_printing (val).data (), type,
stream);
break;
}
}
-/* 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. */
+/* Print using the given LANGUAGE the value VAL onto stream STREAM according
+ to OPTIONS.
-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)
+ This is a preferable interface to val_print, above, because it uses
+ GDB's value mechanism. */
+
+void
+common_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;
+ 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
+ size is determined from the type size which is unknown). So
+ get a fixed representation of our value. */
+ value = ada_to_fixed_value (value);
+
+ if (value_lazy (value))
+ value_fetch_lazy (value);
+
struct value_print_options local_opts = *options;
struct type *type = value_type (value);
struct type *real_type = check_typedef (type);
if (!options->raw)
{
- ret = apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
- language);
- if (ret)
+ if (apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
+ language))
return;
}
otherwise, print an ellipsis. */
if (options->summary && !val_print_scalar_type_p (type))
{
- fprintf_filtered (stream, "...");
+ gdb_printf (stream, "...");
return;
}
catch (const gdb_exception_error &except)
{
fprintf_styled (stream, metadata_style.style (),
- _("<error reading variable>"));
+ _("<error reading variable: %s>"), except.what ());
}
}
if (options->max_depth > -1 && recurse >= options->max_depth)
{
gdb_assert (language->struct_too_deep_ellipsis () != NULL);
- fputs_filtered (language->struct_too_deep_ellipsis (), stream);
+ gdb_puts (language->struct_too_deep_ellipsis (), stream);
return true;
}
if (value_entirely_optimized_out (val))
{
if (options->summary && !val_print_scalar_type_p (value_type (val)))
- fprintf_filtered (stream, "...");
+ gdb_printf (stream, "...");
else
val_print_optimized_out (val, stream);
return 0;
if (value_entirely_unavailable (val))
{
if (options->summary && !val_print_scalar_type_p (value_type (val)))
- fprintf_filtered (stream, "...");
+ gdb_printf (stream, "...");
else
val_print_unavailable (stream);
return 0;
return 1;
}
-/* Print using the given LANGUAGE the value VAL onto stream STREAM according
- to OPTIONS.
-
- This is a preferable interface to val_print, above, because it uses
- GDB's value mechanism. */
-
-void
-common_val_print (struct value *val, struct ui_file *stream, int recurse,
- const struct value_print_options *options,
- const struct language_defn *language)
-{
- 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
- size is determined from the type size which is unknown). So
- get a fixed representation of our value. */
- val = ada_to_fixed_value (val);
-
- if (value_lazy (val))
- value_fetch_lazy (val);
-
- do_val_print (val, stream, recurse, options, language);
-}
-
/* See valprint.h. */
void
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)
+ const gdb_byte *valaddr = (value_contents_for_printing (original_value).data ()
+ embedded_offset);
ULONGEST val = unpack_long (type, valaddr);
int field, nfields = type->num_fields ();
struct gdbarch *gdbarch = type->arch ();
struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
- fputs_filtered ("[", stream);
+ gdb_puts ("[", stream);
for (field = 0; field < nfields; field++)
{
- if (TYPE_FIELD_NAME (type, field)[0] != '\0')
+ if (type->field (field).name ()[0] != '\0')
{
struct type *field_type = type->field (field).type ();
int. */
&& TYPE_FIELD_BITSIZE (type, field) == 1)
{
- if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
- fprintf_filtered
+ if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ()))
+ gdb_printf
(stream, " %ps",
styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (type, field)));
+ type->field (field).name ()));
}
else
{
unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
- ULONGEST field_val
- = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1);
+ ULONGEST field_val = val >> type->field (field).loc_bitpos ();
if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
field_val &= ((ULONGEST) 1 << field_len) - 1;
- fprintf_filtered (stream, " %ps=",
- styled_string (variable_name_style.style (),
- TYPE_FIELD_NAME (type, field)));
+ gdb_printf (stream, " %ps=",
+ styled_string (variable_name_style.style (),
+ type->field (field).name ()));
if (field_type->code () == TYPE_CODE_ENUM)
generic_val_print_enum_1 (field_type, field_val, stream);
else
}
}
}
- fputs_filtered (" ]", stream);
+ gdb_puts (" ]", stream);
}
/* See valprint.h. */
/* value_contents_for_printing fetches all VAL's contents. They are
needed to check whether VAL is optimized-out or unavailable
below. */
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
/* A scalar object that does not have all bits available can't be
printed, because all bits contribute to its representation. */
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
}
- fputs_filtered (val, stream);
+ gdb_puts (val, stream);
}
/* This used to be a macro, but I don't think it is called often enough
struct ui_file *stream)
{
std::string str = target_float_to_string (valaddr, type);
- fputs_filtered (str.c_str (), stream);
+ gdb_puts (str.c_str (), stream);
}
void
b = '0';
if (zero_pad || seen_a_one || b == '1')
- fputc_filtered (b, stream);
+ gdb_putc (b, stream);
if (b == '1')
seen_a_one = true;
}
b = '0';
if (zero_pad || seen_a_one || b == '1')
- fputc_filtered (b, stream);
+ gdb_putc (b, stream);
if (b == '1')
seen_a_one = true;
}
/* When not zero-padding, ensure that something is printed when the
input is 0. */
if (!zero_pad && !seen_a_one)
- fputc_filtered ('0', stream);
+ gdb_putc ('0', stream);
}
/* A helper for print_octal_chars that emits a single octal digit,
emit_octal_digit (struct ui_file *stream, bool *seen_a_one, int digit)
{
if (*seen_a_one || digit != 0)
- fprintf_filtered (stream, "%o", digit);
+ gdb_printf (stream, "%o", digit);
if (digit != 0)
*seen_a_one = true;
}
cycle = (len * HOST_CHAR_BIT) % BITS_IN_OCTAL;
carry = 0;
- fputs_filtered ("0", stream);
+ gdb_puts ("0", stream);
bool seen_a_one = false;
if (byte_order == BFD_ENDIAN_BIG)
{
if (is_signed
&& maybe_negate_by_bytes (valaddr, len, byte_order, &negated_bytes))
{
- fputs_filtered ("-", stream);
+ gdb_puts ("-", stream);
valaddr = negated_bytes.data ();
}
for (; i >= 0; i--)
{
- fprintf_filtered (stream, "%1d", digits[i]);
+ gdb_printf (stream, "%1d", digits[i]);
}
}
{
const gdb_byte *p;
- fputs_filtered ("0x", stream);
+ gdb_puts ("0x", stream);
if (byte_order == BFD_ENDIAN_BIG)
{
p = valaddr;
/* When not zero-padding, use a different format for the
very first byte printed. */
if (!zero_pad && p == first)
- fprintf_filtered (stream, "%x", *p);
+ gdb_printf (stream, "%x", *p);
else
- fprintf_filtered (stream, "%02x", *p);
+ gdb_printf (stream, "%02x", *p);
}
}
else
/* When not zero-padding, use a different format for the
very first byte printed. */
if (!zero_pad && p == first)
- fprintf_filtered (stream, "%x", *p);
+ gdb_printf (stream, "%x", *p);
else
- fprintf_filtered (stream, "%02x", *p);
+ gdb_printf (stream, "%02x", *p);
}
}
}
the address of the description. */
if (options->addressprint && func_addr != address)
{
- fputs_filtered ("@", stream);
- fputs_filtered (paddress (gdbarch, address), stream);
- fputs_filtered (": ", stream);
+ gdb_puts ("@", stream);
+ gdb_puts (paddress (gdbarch, address), stream);
+ gdb_puts (": ", stream);
}
print_address_demangle (options, gdbarch, func_addr, stream, demangle);
}
{
if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, ",\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
+ gdb_printf (stream, ",\n");
+ print_spaces (2 + 2 * recurse, stream);
}
else
- fprintf_filtered (stream, ", ");
+ gdb_printf (stream, ", ");
}
else if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, "\n");
- print_spaces_filtered (2 + 2 * recurse, stream);
+ gdb_printf (stream, "\n");
+ print_spaces (2 + 2 * recurse, stream);
}
- wrap_here (n_spaces (2 + 2 * recurse));
+ stream->wrap_here (2 + 2 * recurse);
maybe_print_array_index (index_type, i + low_bound,
stream, options);
if (reps > options->repeat_count_threshold)
{
annotate_elt_rep (reps);
- fprintf_filtered (stream, " %p[<repeats %u times>%p]",
- metadata_style.style ().ptr (), reps, nullptr);
+ gdb_printf (stream, " %p[<repeats %u times>%p]",
+ metadata_style.style ().ptr (), reps, nullptr);
annotate_elt_rep_end ();
i = rep1 - 1;
}
annotate_array_section_end ();
if (i < len)
- fprintf_filtered (stream, "...");
+ gdb_printf (stream, "...");
if (options->prettyformat_arrays)
{
- fprintf_filtered (stream, "\n");
- print_spaces_filtered (2 * recurse, stream);
+ gdb_printf (stream, "\n");
+ print_spaces (2 * recurse, stream);
}
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Return the repeat count of the next character/byte in ITER,
if (length == 0)
{
- fputs_filtered ("\"\"", stream);
+ gdb_puts ("\"\"", stream);
return;
}
sizeof (gdb_wchar_t), &output, translit_char);
obstack_1grow (&output, '\0');
- fputs_filtered ((const char *) obstack_base (&output), stream);
+ gdb_puts ((const char *) obstack_base (&output), stream);
}
/* Print a string from the inferior, starting at ADDR and printing up to LEN
But if we fetch something and then get an error, print the string
and then the error message. */
if (err == 0 || bytes_read > 0)
- {
- LA_PRINT_STRING (stream, elttype, buffer.get (), bytes_read / width,
- encoding, force_ellipsis, options);
- }
+ current_language->printstr (stream, elttype, buffer.get (),
+ bytes_read / width,
+ encoding, force_ellipsis, options);
if (err != 0)
{
std::string str = memory_error_message (TARGET_XFER_E_IO, gdbarch, addr);
- fprintf_filtered (stream, _("<error: %ps>"),
- styled_string (metadata_style.style (),
- str.c_str ()));
+ gdb_printf (stream, _("<error: %ps>"),
+ styled_string (metadata_style.style (),
+ str.c_str ()));
}
return (bytes_read / width);
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);
+ gdb_printf (file, _("Maximum print depth is %s.\n"), value);
}
\f
input_radix_1 = input_radix = radix;
if (from_tty)
{
- printf_filtered (_("Input radix now set to "
- "decimal %u, hex %x, octal %o.\n"),
- radix, radix, radix);
+ gdb_printf (_("Input radix now set to "
+ "decimal %u, hex %x, octal %o.\n"),
+ radix, radix, radix);
}
}
output_radix_1 = output_radix = radix;
if (from_tty)
{
- printf_filtered (_("Output radix now set to "
- "decimal %u, hex %x, octal %o.\n"),
- radix, radix, radix);
+ gdb_printf (_("Output radix now set to "
+ "decimal %u, hex %x, octal %o.\n"),
+ radix, radix, radix);
}
}
set_input_radix_1 (0, radix);
if (from_tty)
{
- printf_filtered (_("Input and output radices now set to "
- "decimal %u, hex %x, octal %o.\n"),
- radix, radix, radix);
+ gdb_printf (_("Input and output radices now set to "
+ "decimal %u, hex %x, octal %o.\n"),
+ radix, radix, radix);
}
}
{
if (input_radix == output_radix)
{
- printf_filtered (_("Input and output radices set to "
- "decimal %u, hex %x, octal %o.\n"),
- input_radix, input_radix, input_radix);
+ gdb_printf (_("Input and output radices set to "
+ "decimal %u, hex %x, octal %o.\n"),
+ input_radix, input_radix, input_radix);
}
else
{
- printf_filtered (_("Input radix set to decimal "
- "%u, hex %x, octal %o.\n"),
- input_radix, input_radix, input_radix);
- printf_filtered (_("Output radix set to decimal "
- "%u, hex %x, octal %o.\n"),
- output_radix, output_radix, output_radix);
+ gdb_printf (_("Input radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
+ input_radix, input_radix, input_radix);
+ gdb_printf (_("Output radix set to decimal "
+ "%u, hex %x, octal %o.\n"),
+ output_radix, output_radix, output_radix);
}
}
}
show_vtblprint (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
+ gdb_printf (file, _("\
Printing of C++ virtual function tables is %s.\n"),
- value);
+ value);
}
/* Controls looking up an object's derived type using what we find in
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file, _("\
+ gdb_printf (file, _("\
Printing of object's derived type based on vtable info is %s.\n"),
- value);
+ value);
}
static void
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file,
- _("Printing of C++ static members is %s.\n"),
- value);
+ gdb_printf (file,
+ _("Printing of C++ static members is %s.\n"),
+ value);
}
\f
return {{value_print_option_defs}, opts};
}
+#if GDB_SELF_TEST
+
+/* Test printing of TYPE_CODE_FLAGS values. */
+
+static void
+test_print_flags (gdbarch *arch)
+{
+ type *flags_type = arch_flags_type (arch, "test_type", 32);
+ type *field_type = builtin_type (arch)->builtin_uint32;
+
+ /* Value: 1010 1010
+ Fields: CCCB BAAA */
+ append_flags_type_field (flags_type, 0, 3, field_type, "A");
+ append_flags_type_field (flags_type, 3, 2, field_type, "B");
+ append_flags_type_field (flags_type, 5, 3, field_type, "C");
+
+ value *val = allocate_value (flags_type);
+ gdb_byte *contents = value_contents_writeable (val).data ();
+ store_unsigned_integer (contents, 4, gdbarch_byte_order (arch), 0xaa);
+
+ string_file out;
+ val_print_type_code_flags (flags_type, val, 0, &out);
+ SELF_CHECK (out.string () == "[ A=2 B=1 C=5 ]");
+}
+
+#endif
+
void _initialize_valprint ();
void
_initialize_valprint ()
{
- 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);
+#if GDB_SELF_TEST
+ selftests::register_test_foreach_arch ("print-flags", test_print_flags);
+#endif
+
+ set_show_commands setshow_print_cmds
+ = add_setshow_prefix_cmd ("print", no_class,
+ _("Generic command for setting how things print."),
+ _("Generic command for showing print settings."),
+ &setprintlist, &showprintlist,
+ &setlist, &showlist);
+ add_alias_cmd ("p", setshow_print_cmds.set, no_class, 1, &setlist);
/* Prefer set print to set prompt. */
- add_alias_cmd ("pr", "print", no_class, 1, &setlist);
-
- 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_basic_prefix_cmd ("raw", no_class,
- _("\
-Generic command for setting what things to print in \"raw\" mode."),
- &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);
+ add_alias_cmd ("pr", setshow_print_cmds.set, no_class, 1, &setlist);
+ add_alias_cmd ("p", setshow_print_cmds.show, no_class, 1, &showlist);
+ add_alias_cmd ("pr", setshow_print_cmds.show, no_class, 1, &showlist);
+
+ set_show_commands setshow_print_raw_cmds
+ = add_setshow_prefix_cmd
+ ("raw", no_class,
+ _("Generic command for setting what things to print in \"raw\" mode."),
+ _("Generic command for showing \"print raw\" settings."),
+ &setprintrawlist, &showprintrawlist, &setprintlist, &showprintlist);
+ deprecate_cmd (setshow_print_raw_cmds.set, nullptr);
+ deprecate_cmd (setshow_print_raw_cmds.show, nullptr);
gdb::option::add_setshow_cmds_for_options
(class_support, &user_print_options, value_print_option_defs,