#include "block.h"
#include "disasm.h"
#include "target-float.h"
-#include "observer.h"
+#include "observable.h"
#include "solist.h"
#include "parser-defs.h"
#include "charset.h"
#include "source.h"
#include "common/byte-vector.h"
-#ifdef TUI
-#include "tui/tui.h" /* For tui_active et al. */
-#endif
-
/* Last specified output format. */
static char last_format = 0;
static char last_size = 'w';
+/* Last specified count for the 'x' command. */
+
+static int last_count;
+
/* Default address to examine next, and associated architecture. */
static struct gdbarch *next_gdbarch;
/* Contents of last address examined.
This is not valid past the end of the `x' command! */
-static struct value *last_examine_value;
+static value_ref_ptr last_examine_value;
/* Largest offset between a symbolic value and an address, that will be
printed as `0x1234 <symbol+offset>'. */
break;
}
- while (*p == ' ' || *p == '\t')
- p++;
- *string_ptr = p;
+ *string_ptr = skip_spaces (p);
/* Set defaults for format and size if not specified. */
if (val.format == '?')
struct ui_file *stream,
int do_demangle, const char *leadin)
{
- char *name = NULL;
- char *filename = NULL;
+ std::string name, filename;
int unmapped = 0;
int offset = 0;
int line = 0;
- /* Throw away both name and filename. */
- struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
- make_cleanup (free_current_contents, &filename);
-
if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
&filename, &line, &unmapped))
- {
- do_cleanups (cleanup_chain);
- return 0;
- }
+ return 0;
fputs_filtered (leadin, stream);
if (unmapped)
fputs_filtered ("<*", stream);
else
fputs_filtered ("<", stream);
- fputs_filtered (name, stream);
+ fputs_filtered (name.c_str (), stream);
if (offset != 0)
fprintf_filtered (stream, "+%u", (unsigned int) offset);
/* Append source filename and line number if desired. Give specific
line # of this addr, if we have it; else line # of the nearest symbol. */
- if (print_symbol_filename && filename != NULL)
+ if (print_symbol_filename && !filename.empty ())
{
if (line != -1)
- fprintf_filtered (stream, " at %s:%d", filename, line);
+ fprintf_filtered (stream, " at %s:%d", filename.c_str (), line);
else
- fprintf_filtered (stream, " in %s", filename);
+ fprintf_filtered (stream, " in %s", filename.c_str ());
}
if (unmapped)
fputs_filtered ("*>", stream);
else
fputs_filtered (">", stream);
- do_cleanups (cleanup_chain);
return 1;
}
-/* Given an address ADDR return all the elements needed to print the
- address in a symbolic form. NAME can be mangled or not depending
- on DO_DEMANGLE (and also on the asm_demangle global variable,
- manipulated via ''set print asm-demangle''). Return 0 in case of
- success, when all the info in the OUT paramters is valid. Return 1
- otherwise. */
+/* See valprint.h. */
+
int
build_address_symbolic (struct gdbarch *gdbarch,
CORE_ADDR addr, /* IN */
int do_demangle, /* IN */
- char **name, /* OUT */
+ std::string *name, /* OUT */
int *offset, /* OUT */
- char **filename, /* OUT */
+ std::string *filename, /* OUT */
int *line, /* OUT */
int *unmapped) /* OUT */
{
*offset = addr - name_location;
- *name = xstrdup (name_temp);
+ *name = name_temp;
if (print_symbol_filename)
{
if (sal.symtab)
{
- *filename = xstrdup (symtab_to_filename_for_display (sal.symtab));
+ *filename = symtab_to_filename_for_display (sal.symtab);
*line = sal.line;
}
}
object. */
last_examine_address = next_address;
- if (last_examine_value)
- value_free (last_examine_value);
-
/* The value to be displayed is not fetched greedily.
Instead, to avoid the possibility of a fetched value not
being used, its retrieval is delayed until the print code
the disassembler be modified so that LAST_EXAMINE_VALUE
is left with the byte sequence from the last complete
instruction fetched from memory? */
- last_examine_value = value_at_lazy (val_type, next_address);
-
- if (last_examine_value)
- release_value (last_examine_value);
+ last_examine_value
+ = release_value (value_at_lazy (val_type, next_address));
- print_formatted (last_examine_value, size, &opts, gdb_stdout);
+ print_formatted (last_examine_value.get (), size, &opts, gdb_stdout);
/* Display any branch delay slots following the final insn. */
if (format == 'i' && count == 1)
/* Implementation of the "output" command. */
-static void
-output_command (const char *exp, int from_tty)
-{
- output_command_const (exp, from_tty);
-}
-
-/* Like output_command, but takes a const string as argument. */
-
void
-output_command_const (const char *exp, int from_tty)
+output_command (const char *exp, int from_tty)
{
char format = 0;
struct value *val;
{
const char *obj_name, *mapped, *sec_name, *msym_name;
const char *loc_string;
- struct cleanup *old_chain;
matches = 1;
offset = sect_addr - MSYMBOL_VALUE_ADDRESS (objfile, msymbol);
{
struct bound_minimal_symbol msym;
- msym = lookup_minimal_symbol_and_objfile (SYMBOL_LINKAGE_NAME (sym));
+ msym = lookup_bound_minimal_symbol (SYMBOL_LINKAGE_NAME (sym));
if (msym.minsym == NULL)
printf_filtered ("unresolved");
else
fmt.count = 1;
fmt.raw = 0;
+ /* If there is no expression and no format, use the most recent
+ count. */
+ if (exp == nullptr && last_count > 0)
+ fmt.count = last_count;
+
if (exp && *exp == '/')
{
const char *tmp = exp + 1;
exp = (char *) tmp;
}
+ last_count = fmt.count;
+
/* If we have an expression, evaluate it and use it as the address. */
if (exp != 0 && *exp != 0)
last_format = fmt.format;
/* Set a couple of internal variables if appropriate. */
- if (last_examine_value)
+ if (last_examine_value != nullptr)
{
/* Make last address examined available to the user as $_. Use
the correct pointer type. */
struct type *pointer_type
- = lookup_pointer_type (value_type (last_examine_value));
+ = lookup_pointer_type (value_type (last_examine_value.get ()));
set_internalvar (lookup_internalvar ("_"),
value_from_pointer (pointer_type,
last_examine_address));
as $__. If the last value has not been fetched from memory
then don't fetch it now; instead mark it by voiding the $__
variable. */
- if (value_lazy (last_examine_value))
+ if (value_lazy (last_examine_value.get ()))
clear_internalvar (lookup_internalvar ("__"));
else
- set_internalvar (lookup_internalvar ("__"), last_examine_value);
+ set_internalvar (lookup_internalvar ("__"), last_examine_value.get ());
}
}
\f
int j;
tem = value_as_address (value);
+ if (tem == 0)
+ {
+ fprintf_filtered (stream, format, "(null)");
+ return;
+ }
/* This is a %s argument. Find the length of the string. */
for (j = 0;; j++)
gdb_byte *buf = (gdb_byte *) alloca (wcwidth);
tem = value_as_address (value);
+ if (tem == 0)
+ {
+ fprintf_filtered (stream, format, "(null)");
+ return;
+ }
/* This is a %s argument. Find the length of the string. */
for (j = 0;; j += wcwidth)
/* Parameter data. */
struct type *param_type = value_type (value);
struct gdbarch *gdbarch = get_type_arch (param_type);
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
/* Determine target type corresponding to the format string. */
struct type *fmt_type;
if (val != 0)
*fmt_p++ = '#';
- /* Copy any width. */
- while (*p >= '0' && *p < '9')
+ /* Copy any width or flags. Only the "-" flag is valid for pointers
+ -- see the format_pieces constructor. */
+ while (*p == '-' || (*p >= '0' && *p < '9'))
*fmt_p++ = *p++;
gdb_assert (*p == 'p' && *(p + 1) == '\0');
current_display_number = -1;
- observer_attach_free_objfile (clear_dangling_display_expressions);
+ gdb::observers::free_objfile.attach (clear_dangling_display_expressions);
add_info ("address", info_address_command,
_("Describe where symbol SYM is stored."));
variable in the program being debugged. EXP is any valid expression.\n\
This may usually be abbreviated to simply \"set\"."),
&setlist);
+ add_alias_cmd ("var", "variable", class_vars, 0, &setlist);
c = add_com ("print", class_vars, print_command, _("\
Print value of expression EXP.\n\