#include "stack.h"
#include "gdb_assert.h"
#include "dictionary.h"
+#include "exceptions.h"
#include "reggroups.h"
#include "regcache.h"
int print_args,
struct symtab_and_line sal);
+static void set_current_sal_from_frame (struct frame_info *, int);
+
static void backtrace_command (char *, int);
static void frame_info (char *, int);
static int
print_stack_frame_stub (void *args)
{
- struct print_stack_frame_args *p = (struct print_stack_frame_args *) args;
+ struct print_stack_frame_args *p = args;
+ int center = (p->print_what == SRC_LINE
+ || p->print_what == SRC_AND_LOC);
print_frame_info (p->fi, p->print_level, p->print_what, p->print_args);
+ set_current_sal_from_frame (p->fi, center);
return 0;
}
2 for each recurse. */
val = read_var_value (sym, fi);
- annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
+ annotate_arg_value (val == NULL ? NULL : value_type (val));
if (val)
{
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
+ val_print (value_type (val), VALUE_CONTENTS (val), 0,
VALUE_ADDRESS (val),
stb->stream, 0, 0, 2, Val_no_prettyprint);
ui_out_field_stream (uiout, "value", stb);
return 0;
}
+/* Set the current source and line to the location of the given
+ frame, if possible. When CENTER is true, adjust so the
+ relevant line is in the center of the next 'list'. */
+
+static void
+set_current_sal_from_frame (struct frame_info *fi, int center)
+{
+ struct symtab_and_line sal;
+
+ find_frame_sal (fi, &sal);
+ if (sal.symtab)
+ {
+ if (center)
+ sal.line = max (sal.line - get_lines_to_list () / 2, 1);
+ set_current_source_symtab_and_line (&sal);
+ }
+}
+
/* Print information about a frame for frame "fi" at level "level".
Used in "where" output, also used to emit breakpoint or step
messages.
source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
- if (sal.symtab)
- set_current_source_symtab_and_line (&sal);
-
if (source_print && sal.symtab)
{
- struct symtab_and_line cursal;
int done = 0;
int mid_statement = ((print_what == SRC_LINE)
&& (get_frame_pc (fi) != sal.pc));
if (!done)
{
if (deprecated_print_frame_info_listing_hook)
- deprecated_print_frame_info_listing_hook (sal.symtab, sal.line, sal.line + 1, 0);
+ deprecated_print_frame_info_listing_hook (sal.symtab,
+ sal.line,
+ sal.line + 1, 0);
else
{
/* We used to do this earlier, but that is clearly
when we stepi/nexti into the middle of a source
line. Only the command line really wants this
behavior. Other UIs probably would like the
- ability to decide for themselves if it is desired. */
+ ability to decide for themselves if it is desired. */
if (addressprint && mid_statement)
{
ui_out_field_core_addr (uiout, "addr", get_frame_pc (fi));
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
}
}
- /* Make sure we have at least a default source file */
- set_default_source_symtab_and_line ();
- cursal = get_current_source_symtab_and_line ();
- cursal.line = max (sal.line - get_lines_to_list () / 2, 1);
- set_current_source_symtab_and_line (&cursal);
}
if (print_what != LOCATION)
/* None of the remaining use the selected frame. */
if (selected_frame_p != NULL)
- (*selected_frame_p) = 1;
+ (*selected_frame_p) = 0;
/* Assume the single arg[0] is an integer, and try using that to
select a frame relative to current. */
/* We couldn't identify the frame as an existing frame, but
perhaps we can create one with a single argument. */
-#ifdef SETUP_ARBITRARY_FRAME
- return SETUP_ARBITRARY_FRAME (numargs, addrs);
-#else
- /* Usual case. Do it here rather than have everyone supply a
- SETUP_ARBITRARY_FRAME that does this. */
if (numargs == 1)
return create_new_frame (addrs[0], 0);
- error ("Too many args in frame specification");
-#endif
+ else if (numargs == 2)
+ return create_new_frame (addrs[0], addrs[1]);
+ else
+ error ("Too many args in frame specification");
}
struct frame_info *
printf_filtered ("(More stack frames follow...)\n");
}
+struct backtrace_command_args
+ {
+ char *count_exp;
+ int show_locals;
+ int from_tty;
+ };
+
+/* Stub to call backtrace_command_1 by way of an error catcher. */
+static int
+backtrace_command_stub (void *data)
+{
+ struct backtrace_command_args *args = (struct backtrace_command_args *)data;
+ backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
+ return 0;
+}
+
static void
backtrace_command (char *arg, int from_tty)
{
char **argv = (char **) NULL;
int argIndicatingFullTrace = (-1), totArgLen = 0, argc = 0;
char *argPtr = arg;
+ struct backtrace_command_args btargs;
if (arg != (char *) NULL)
{
}
}
- backtrace_command_1 (argPtr, (argIndicatingFullTrace >= 0), from_tty);
+ btargs.count_exp = argPtr;
+ btargs.show_locals = (argIndicatingFullTrace >= 0);
+ btargs.from_tty = from_tty;
+ catch_errors (backtrace_command_stub, (char *)&btargs, "", RETURN_MASK_ERROR);
if (argIndicatingFullTrace >= 0 && totArgLen > 0)
xfree (argPtr);
static void
backtrace_full_command (char *arg, int from_tty)
{
- backtrace_command_1 (arg, 1, from_tty);
+ struct backtrace_command_args btargs;
+ btargs.count_exp = arg;
+ btargs.show_locals = 1;
+ btargs.from_tty = from_tty;
+ catch_errors (backtrace_command_stub, (char *)&btargs, "", RETURN_MASK_ERROR);
}
\f
/* Make sure the value is fully evaluated. It may live in the
stack frame we're about to pop. */
- if (VALUE_LAZY (return_value))
+ if (value_lazy (return_value))
value_fetch_lazy (return_value);
if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
/* Store RETURN_VAUE in the just-returned register set. */
if (return_value != NULL)
{
- struct type *return_type = VALUE_TYPE (return_value);
+ struct type *return_type = value_type (return_value);
gdb_assert (gdbarch_return_value (current_gdbarch, return_type,
NULL, NULL, NULL)
== RETURN_VALUE_REGISTER_CONVENTION);