/* Print values for GNU debugger GDB.
- Copyright (C) 1986-2016 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "charset.h"
#include "arch-utils.h"
#include "cli/cli-utils.h"
+#include "cli/cli-script.h"
#include "format.h"
#include "source.h"
char *exp_string;
/* Expression to be evaluated and displayed. */
- struct expression *exp;
+ expression_up exp;
/* Item number of this auto-display item. */
int number;
/* User specified format, so don't look to the type to tell us
what to do. */
val_print_scalar_formatted (type,
- value_contents_for_printing (val),
value_embedded_offset (val),
val,
options, size, stream);
int
print_address_symbolic (struct gdbarch *gdbarch, CORE_ADDR addr,
struct ui_file *stream,
- int do_demangle, char *leadin)
+ int do_demangle, const char *leadin)
{
char *name = NULL;
char *filename = NULL;
/* The vector PCS is used to store instruction addresses within
a pc range. */
CORE_ADDR loop_start, loop_end, p;
- VEC (CORE_ADDR) *pcs = NULL;
+ std::vector<CORE_ADDR> pcs;
struct symtab_and_line sal;
- struct cleanup *cleanup = make_cleanup (VEC_cleanup (CORE_ADDR), &pcs);
*inst_read = 0;
loop_start = loop_end = addr;
instructions from INST_COUNT, and go to the next iteration. */
do
{
- VEC_truncate (CORE_ADDR, pcs, 0);
+ pcs.clear ();
sal = find_pc_sect_line (loop_start, NULL, 1);
if (sal.line <= 0)
{
LOOP_START to LOOP_END. */
for (p = loop_start; p < loop_end;)
{
- VEC_safe_push (CORE_ADDR, pcs, p);
+ pcs.push_back (p);
p += gdb_insn_length (gdbarch, p);
}
- inst_count -= VEC_length (CORE_ADDR, pcs);
- *inst_read += VEC_length (CORE_ADDR, pcs);
+ inst_count -= pcs.size ();
+ *inst_read += pcs.size ();
}
while (inst_count > 0);
The case when the length of PCS is 0 means that we reached an area for
which line info is not available. In such case, we return LOOP_START,
which was the lowest instruction address that had line info. */
- p = VEC_length (CORE_ADDR, pcs) > 0
- ? VEC_index (CORE_ADDR, pcs, -inst_count)
- : loop_start;
+ p = pcs.size () > 0 ? pcs[-inst_count] : loop_start;
/* INST_READ includes all instruction addresses in a pc range. Need to
exclude the beginning part up to the address we're returning. That
if (inst_count < 0)
*inst_read += inst_count;
- do_cleanups (cleanup);
return p;
}
static void
print_command_1 (const char *exp, int voidprint)
{
- struct expression *expr;
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
struct value *val;
struct format_data fmt;
if (exp && *exp)
{
- expr = parse_expression (exp);
- make_cleanup (free_current_contents, &expr);
- val = evaluate_expression (expr);
+ expression_up expr = parse_expression (exp);
+ val = evaluate_expression (expr.get ());
}
else
val = access_value_history (0);
if (voidprint || (val && value_type (val) &&
TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
print_value (val, &fmt);
-
- do_cleanups (old_chain);
}
static void
void
output_command_const (const char *exp, int from_tty)
{
- struct expression *expr;
- struct cleanup *old_chain;
char format = 0;
struct value *val;
struct format_data fmt;
format = fmt.format;
}
- expr = parse_expression (exp);
- old_chain = make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (exp);
- val = evaluate_expression (expr);
+ val = evaluate_expression (expr.get ());
annotate_value_begin (value_type (val));
wrap_here ("");
gdb_flush (gdb_stdout);
-
- do_cleanups (old_chain);
}
static void
set_command (char *exp, int from_tty)
{
- struct expression *expr = parse_expression (exp);
- struct cleanup *old_chain =
- make_cleanup (free_current_contents, &expr);
+ expression_up expr = parse_expression (exp);
if (expr->nelts >= 1)
switch (expr->elts[0].opcode)
(_("Expression is not an assignment (and might have no effect)"));
}
- evaluate_expression (expr);
- do_cleanups (old_chain);
+ evaluate_expression (expr.get ());
}
static void
static void
x_command (char *exp, int from_tty)
{
- struct expression *expr;
struct format_data fmt;
struct cleanup *old_chain;
struct value *val;
if (exp != 0 && *exp != 0)
{
- expr = parse_expression (exp);
+ expression_up expr = parse_expression (exp);
/* Cause expression not to be there any more if this command is
repeated with Newline. But don't clobber a user-defined
command's definition. */
if (from_tty)
*exp = 0;
- old_chain = make_cleanup (free_current_contents, &expr);
- val = evaluate_expression (expr);
- if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
+ val = evaluate_expression (expr.get ());
+ if (TYPE_IS_REFERENCE (value_type (val)))
val = coerce_ref (val);
/* In rvalue contexts, such as this, functions are coerced into
pointers to functions. This makes "x/i main" work. */
next_address = value_as_address (val);
next_gdbarch = expr->gdbarch;
- do_cleanups (old_chain);
}
if (!next_gdbarch)
display_command (char *arg, int from_tty)
{
struct format_data fmt;
- struct expression *expr;
struct display *newobj;
const char *exp = arg;
}
innermost_block = NULL;
- expr = parse_expression (exp);
+ expression_up expr = parse_expression (exp);
- newobj = XNEW (struct display);
+ newobj = new display ();
newobj->exp_string = xstrdup (exp);
- newobj->exp = expr;
+ newobj->exp = std::move (expr);
newobj->block = innermost_block;
newobj->pspace = current_program_space;
newobj->number = ++display_number;
free_display (struct display *d)
{
xfree (d->exp_string);
- xfree (d->exp);
- xfree (d);
+ delete d;
}
/* Clear out the display_chain. Done when new symtabs are loaded,
static void
do_one_display (struct display *d)
{
- struct cleanup *old_chain;
int within_current_scope;
if (d->enabled_p == 0)
expression if the current architecture has changed. */
if (d->exp != NULL && d->exp->gdbarch != get_current_arch ())
{
- xfree (d->exp);
- d->exp = NULL;
+ d->exp.reset ();
d->block = NULL;
}
if (!within_current_scope)
return;
- old_chain = make_cleanup_restore_integer (¤t_display_number);
- current_display_number = d->number;
+ scoped_restore save_display_number
+ = make_scoped_restore (¤t_display_number, d->number);
annotate_display_begin ();
printf_filtered ("%d", d->number);
struct value *val;
CORE_ADDR addr;
- val = evaluate_expression (d->exp);
+ val = evaluate_expression (d->exp.get ());
addr = value_as_address (val);
if (d->format.format == 'i')
addr = gdbarch_addr_bits_remove (d->exp->gdbarch, addr);
{
struct value *val;
- val = evaluate_expression (d->exp);
+ val = evaluate_expression (d->exp.get ());
print_formatted (val, d->format.size, &opts, gdb_stdout);
}
CATCH (ex, RETURN_MASK_ERROR)
annotate_display_end ();
gdb_flush (gdb_stdout);
- do_cleanups (old_chain);
}
/* Display all of the values on the auto-display chain which can be
continue;
if (lookup_objfile_from_block (d->block) == objfile
- || (d->exp && exp_uses_objfile (d->exp, objfile)))
+ || (d->exp != NULL && exp_uses_objfile (d->exp.get (), objfile)))
{
- xfree (d->exp);
- d->exp = NULL;
+ d->exp.reset ();
d->block = NULL;
}
}
static void
eval_command (char *arg, int from_tty)
{
- struct ui_file *ui_out = mem_fileopen ();
- struct cleanup *cleanups = make_cleanup_ui_file_delete (ui_out);
- char *expanded;
-
- ui_printf (arg, ui_out);
+ string_file stb;
- expanded = ui_file_xstrdup (ui_out, NULL);
- make_cleanup (xfree, expanded);
+ ui_printf (arg, &stb);
- execute_command (expanded, from_tty);
+ std::string expanded = insert_user_defined_cmd_args (stb.c_str ());
- do_cleanups (cleanups);
+ execute_command (&expanded[0], from_tty);
}
void
projects / deliverable / binutils-gdb.git / blobdiff