/* Print values for GDB, the GNU debugger.
- Copyright (C) 1986-2017 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "language.h"
#include "annotate.h"
#include "valprint.h"
-#include "floatformat.h"
-#include "doublest.h"
-#include "dfp.h"
+#include "target-float.h"
#include "extension.h"
#include "ada-lang.h"
#include "gdb_obstack.h"
#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"
/* Maximum number of wchars returned from wchar_iterate. */
#define MAX_WCHARS 4
int repeat_count;
};
-typedef struct converted_character converted_character_d;
-DEF_VEC_O (converted_character_d);
-
/* Command lists for set/show print raw. */
struct cmd_list_element *setprintrawlist;
struct cmd_list_element *showprintrawlist;
static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
int len, int *errptr);
-static void show_print (char *, int);
-
-static void set_print (char *, int);
-
-static void set_radix (char *, int);
-
-static void show_radix (char *, int);
-
-static void set_input_radix (char *, int, struct cmd_list_element *);
-
static void set_input_radix_1 (int, unsigned);
-static void set_output_radix (char *, int, struct cmd_list_element *);
-
static void set_output_radix_1 (int, unsigned);
static void val_print_type_code_flags (struct type *type,
const gdb_byte *valaddr,
struct ui_file *stream);
-void _initialize_valprint (void);
-
#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. */
}
}
+/* 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
}
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.
}
}
-/* generic_val_print helper for TYPE_CODE_FLT. */
+/* generic_val_print helper for TYPE_CODE_FLT and TYPE_CODE_DECFLOAT. */
static void
generic_val_print_float (struct type *type,
}
}
-/* generic_val_print helper for TYPE_CODE_DECFLOAT. */
-
-static void
-generic_val_print_decfloat (struct type *type,
- int embedded_offset, struct ui_file *stream,
- struct value *original_value,
- 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)
- val_print_scalar_formatted (type, embedded_offset, original_value,
- options, 0, stream);
- else
- {
- const gdb_byte *valaddr = value_contents_for_printing (original_value);
-
- print_decimal_floating (valaddr + embedded_offset * unit_size, type,
- stream);
- }
-}
-
/* generic_val_print helper for TYPE_CODE_COMPLEX. */
static void
break;
case TYPE_CODE_FLT:
+ case TYPE_CODE_DECFLOAT:
generic_val_print_float (type, embedded_offset, stream,
original_value, options);
break;
- case TYPE_CODE_DECFLOAT:
- generic_val_print_decfloat (type, embedded_offset, stream,
- original_value, options);
- break;
-
case TYPE_CODE_VOID:
fputs_filtered (decorations->void_name, stream);
break;
/* 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:
error (_("Unhandled type code %d in symbol table."),
TYPE_CODE (type));
}
- gdb_flush (stream);
}
/* Print using the given LANGUAGE the data of type TYPE located at
if (TYPE_STUB (real_type))
{
- fprintf_filtered (stream, _("<incomplete type>"));
- gdb_flush (stream);
+ fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
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);
}
- CATCH (except, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &except)
+ {
+ fprintf_styled (stream, metadata_style.style (),
+ _("<error reading variable>"));
+ }
+}
+
+/* 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)
{
- fprintf_filtered (stream, _("<error reading variable>"));
+ gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
+ fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
+ return true;
}
- END_CATCH
+
+ 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;
}
if (TYPE_CODE (value_type (val)) == 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;
}
(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
return (rtnval);
}
-/* Print a floating point value of type TYPE (not always a
- TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
+/* Print a floating point value of floating-point type TYPE,
+ pointed to in GDB by VALADDR, on STREAM. */
void
print_floating (const gdb_byte *valaddr, struct type *type,
struct ui_file *stream)
{
- DOUBLEST doub;
- int inv;
- const struct floatformat *fmt = NULL;
- unsigned len = TYPE_LENGTH (type);
- enum float_kind kind;
-
- /* If it is a floating-point, check for obvious problems. */
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- fmt = floatformat_from_type (type);
- if (fmt != NULL)
- {
- kind = floatformat_classify (fmt, valaddr);
- if (kind == float_nan)
- {
- if (floatformat_is_negative (fmt, valaddr))
- fprintf_filtered (stream, "-");
- fprintf_filtered (stream, "nan(");
- fputs_filtered ("0x", stream);
- fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
- fprintf_filtered (stream, ")");
- return;
- }
- else if (kind == float_infinite)
- {
- if (floatformat_is_negative (fmt, valaddr))
- fputs_filtered ("-", stream);
- fputs_filtered ("inf", stream);
- return;
- }
- }
-
- /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
- isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
- needs to be used as that takes care of any necessary type
- conversions. Such conversions are of course direct to DOUBLEST
- and disregard any possible target floating point limitations.
- For instance, a u64 would be converted and displayed exactly on a
- host with 80 bit DOUBLEST but with loss of information on a host
- with 64 bit DOUBLEST. */
-
- doub = unpack_double (type, valaddr, &inv);
- if (inv)
- {
- fprintf_filtered (stream, "<invalid float value>");
- return;
- }
-
- /* FIXME: kettenis/2001-01-20: The following code makes too much
- assumptions about the host and target floating point format. */
-
- /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
- not necessarily be a TYPE_CODE_FLT, the below ignores that and
- instead uses the type's length to determine the precision of the
- floating-point value being printed. */
-
- if (len < sizeof (double))
- fprintf_filtered (stream, "%.9g", (double) doub);
- else if (len == sizeof (double))
- fprintf_filtered (stream, "%.17g", (double) doub);
- else
-#ifdef PRINTF_HAS_LONG_DOUBLE
- fprintf_filtered (stream, "%.35Lg", doub);
-#else
- /* This at least wins with values that are representable as
- doubles. */
- fprintf_filtered (stream, "%.17g", (double) doub);
-#endif
-}
-
-void
-print_decimal_floating (const gdb_byte *valaddr, struct type *type,
- struct ui_file *stream)
-{
- enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
- char decstr[MAX_DECIMAL_STRING];
- unsigned len = TYPE_LENGTH (type);
-
- decimal_to_string (valaddr, len, byte_order, decstr);
- fputs_filtered (decstr, stream);
- return;
+ std::string str = target_float_to_string (valaddr, type);
+ fputs_filtered (str.c_str (), stream);
}
void
gdb::byte_vector *out_vec)
{
gdb_byte sign_byte;
+ gdb_assert (len > 0);
if (byte_order == BFD_ENDIAN_BIG)
sign_byte = bytes[0];
else
* 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
{
CORE_ADDR func_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch, address,
- ¤t_target);
+ current_top_target ());
/* If the function pointer is represented by a description, print
the address of the description. */
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;
return (nread);
}
-/* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
- each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
- allocated buffer containing the string, which the caller is responsible to
- free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
+/* Read a string from the inferior, at ADDR, with LEN characters of
+ WIDTH bytes each. Fetch at most FETCHLIMIT characters. BUFFER
+ will be set to a newly allocated buffer containing the string, and
+ BYTES_READ will be set to the number of bytes read. Returns 0 on
success, or a target_xfer_status on failure.
If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
int
read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
- enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
+ enum bfd_endian byte_order, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
+ int *bytes_read)
{
int errcode; /* Errno returned from bad reads. */
unsigned int nfetch; /* Chars to fetch / chars fetched. */
gdb_byte *bufptr; /* Pointer to next available byte in
buffer. */
- struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
/* Loop until we either have all the characters, or we encounter
some error, such as bumping into the end of the address space. */
- *buffer = NULL;
-
- old_chain = make_cleanup (free_current_contents, buffer);
+ buffer->reset (nullptr);
if (len > 0)
{
one operation. */
unsigned int fetchlen = std::min ((unsigned) len, fetchlimit);
- *buffer = (gdb_byte *) xmalloc (fetchlen * width);
- bufptr = *buffer;
+ buffer->reset ((gdb_byte *) xmalloc (fetchlen * width));
+ bufptr = buffer->get ();
nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
/ width;
nfetch = std::min ((unsigned long) chunksize, fetchlimit - bufsize);
if (*buffer == NULL)
- *buffer = (gdb_byte *) xmalloc (nfetch * width);
+ buffer->reset ((gdb_byte *) xmalloc (nfetch * width));
else
- *buffer = (gdb_byte *) xrealloc (*buffer,
- (nfetch + bufsize) * width);
+ buffer->reset ((gdb_byte *) xrealloc (buffer->release (),
+ (nfetch + bufsize) * width));
- bufptr = *buffer + bufsize * width;
+ bufptr = buffer->get () + bufsize * width;
bufsize += nfetch;
/* Read as much as we can. */
}
}
while (errcode == 0 /* no error */
- && bufptr - *buffer < fetchlimit * width /* no overrun */
+ && bufptr - buffer->get () < fetchlimit * width /* no overrun */
&& !found_nul); /* haven't found NUL yet */
}
else
{ /* Length of string is really 0! */
/* We always allocate *buffer. */
- *buffer = bufptr = (gdb_byte *) xmalloc (1);
+ buffer->reset ((gdb_byte *) xmalloc (1));
+ bufptr = buffer->get ();
errcode = 0;
}
/* bufptr and addr now point immediately beyond the last byte which we
consider part of the string (including a '\0' which ends the string). */
- *bytes_read = bufptr - *buffer;
+ *bytes_read = bufptr - buffer->get ();
QUIT;
- discard_cleanups (old_chain);
-
return errcode;
}
int quoter, const char *encoding)
{
enum bfd_endian byte_order
- = gdbarch_byte_order (get_type_arch (type));
- gdb_byte *buf;
+ = type_byte_order (type);
+ gdb_byte *c_buf;
int need_escape = 0;
- buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
- pack_long (buf, type, c);
+ c_buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
+ pack_long (c_buf, type, c);
- wchar_iterator iter (buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type));
+ wchar_iterator iter (c_buf, TYPE_LENGTH (type), encoding, TYPE_LENGTH (type));
/* This holds the printable form of the wchar_t data. */
auto_obstack wchar_buf;
static int
count_next_character (wchar_iterator *iter,
- VEC (converted_character_d) **vec)
+ std::vector<converted_character> *vec)
{
struct converted_character *current;
- if (VEC_empty (converted_character_d, *vec))
+ if (vec->empty ())
{
struct converted_character tmp;
gdb_wchar_t *chars;
gdb_assert (tmp.num_chars < MAX_WCHARS);
memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t));
}
- VEC_safe_push (converted_character_d, *vec, &tmp);
+ vec->push_back (tmp);
}
- current = VEC_last (converted_character_d, *vec);
+ current = &vec->back ();
/* Count repeated characters or bytes. */
current->repeat_count = 1;
/* Push this next converted character onto the result vector. */
repeat = current->repeat_count;
- VEC_safe_push (converted_character_d, *vec, &d);
+ vec->push_back (d);
return repeat;
}
}
/* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
character to use with string output. WIDTH is the size of the output
- character type. BYTE_ORDER is the the target byte order. OPTIONS
+ character type. BYTE_ORDER is the target byte order. OPTIONS
is the user's print options. */
static void
print_converted_chars_to_obstack (struct obstack *obstack,
- VEC (converted_character_d) *chars,
+ const std::vector<converted_character> &chars,
int quote_char, int width,
enum bfd_endian byte_order,
const struct value_print_options *options)
{
unsigned int idx;
- struct converted_character *elem;
+ const converted_character *elem;
enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
int need_escape = 0;
case REPEAT:
{
int j;
- char *s;
/* We are outputting a character with a repeat count
greater than options->repeat_count_threshold. */
print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
byte_order, obstack, quote_char, &need_escape);
obstack_grow_wstr (obstack, LCST ("'"));
- s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count);
+ std::string s = string_printf (_(" <repeats %u times>"),
+ elem->repeat_count);
for (j = 0; s[j]; ++j)
{
gdb_wchar_t w = gdb_btowc (s[j]);
obstack_grow (obstack, &w, sizeof (gdb_wchar_t));
}
- xfree (s);
}
break;
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;
last = state;
if (state != FINISH)
{
- elem = VEC_index (converted_character_d, chars, idx++);
+ elem = &chars[idx++];
switch (elem->result)
{
case wchar_iterate_ok:
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);
- struct cleanup *cleanup;
int finished = 0;
struct converted_character *last;
- VEC (converted_character_d) *converted_chars;
if (length == -1)
{
/* Arrange to iterate over the characters, in wchar_t form. */
wchar_iterator iter (string, length * width, encoding, width);
- converted_chars = NULL;
- cleanup = make_cleanup (VEC_cleanup (converted_character_d),
- &converted_chars);
+ std::vector<converted_character> converted_chars;
/* Convert characters until the string is over or the maximum
number of printed characters has been reached. */
/* Get the last element and determine if the entire string was
processed. */
- last = VEC_last (converted_character_d, converted_chars);
+ last = &converted_chars.back ();
finished = (last->result == wchar_iterate_eof);
/* Ensure that CONVERTED_CHARS is terminated. */
obstack_1grow (&output, '\0');
fputs_filtered ((const char *) obstack_base (&output), stream);
-
- do_cleanups (cleanup);
}
/* Print a string from the inferior, starting at ADDR and printing up to LEN
int found_nul; /* Non-zero if we found the nul char. */
unsigned int fetchlimit; /* Maximum number of chars to print. */
int bytes_read;
- gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
- struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
+ 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
err = read_string (addr, len, width, fetchlimit, byte_order,
&buffer, &bytes_read);
- old_chain = make_cleanup (xfree, buffer);
addr += bytes_read;
/* Determine found_nul by looking at the last character read. */
found_nul = 0;
if (bytes_read >= width)
- found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
- byte_order) == 0;
+ found_nul = extract_unsigned_integer (buffer.get () + bytes_read - width,
+ width, byte_order) == 0;
if (len == -1 && !found_nul)
{
gdb_byte *peekbuf;
and then the error message. */
if (err == 0 || bytes_read > 0)
{
- LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
+ LA_PRINT_STRING (stream, elttype, buffer.get (), bytes_read / width,
encoding, force_ellipsis, options);
}
{
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);
- do_cleanups (old_chain);
-
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.
setting the input radix to "10" never changes it! */
static void
-set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
+set_input_radix (const char *args, int from_tty, struct cmd_list_element *c)
{
set_input_radix_1 (from_tty, input_radix_1);
}
static unsigned output_radix_1 = 10;
static void
-set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
+set_output_radix (const char *args, int from_tty, struct cmd_list_element *c)
{
set_output_radix_1 (from_tty, output_radix_1);
}
the 'set input-radix' command. */
static void
-set_radix (char *arg, int from_tty)
+set_radix (const char *arg, int from_tty)
{
unsigned radix;
/* Show both the input and output radices. */
static void
-show_radix (char *arg, int from_tty)
+show_radix (const char *arg, int from_tty)
{
if (from_tty)
{
\f
static void
-set_print (char *arg, int from_tty)
+set_print (const char *arg, int from_tty)
{
printf_unfiltered (
"\"set print\" must be followed by the name of a print subcommand.\n");
}
static void
-show_print (char *args, int from_tty)
+show_print (const char *args, int from_tty)
{
cmd_show_list (showprintlist, from_tty, "");
}
static void
-set_print_raw (char *arg, int from_tty)
+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");
}
static void
-show_print_raw (char *args, int from_tty)
+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,
+ struct cmd_list_element *c, const char *value)
+{
+ 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_objectprint (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file, _("\
+Printing of object's derived type based on vtable info is %s.\n"),
+ value);
+}
+
+static void
+show_static_field_print (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c,
+ const char *value)
+{
+ fprintf_filtered (file,
+ _("Printing of C++ static members is %s.\n"),
+ value);
+}
+
\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)
+{
+ return {{value_print_option_defs}, opts};
+}
+
void
_initialize_valprint (void)
{
+ 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_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_prefix_cmd ("raw", no_class, set_print_raw,
+ _("\
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_prefix_cmd ("raw", no_class, show_print_raw,
+ _("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