#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
}
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.
/* 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:
if (TYPE_STUB (real_type))
{
- fprintf_filtered (stream, _("<incomplete type>"));
+ fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
return;
}
}
catch (const gdb_exception_error &except)
{
- fprintf_filtered (stream, _("<error reading variable>"));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<error reading variable>"));
}
}
{
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
* 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
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;
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 ()));
}
return (bytes_read / width);
using zuinteger_unlimited_option_def
= gdb::option::zuinteger_unlimited_option_def<value_print_options>;
-/* Definions of options for the "print" and "compile print"
+/* Definitions of options for the "print" and "compile print"
commands. */
static const gdb::option::option_def value_print_option_defs[] = {
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; },
projects / deliverable / binutils-gdb.git / blobdiff