Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010 Free Software Foundation, Inc.
+ 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
static void jump_command (char *, int);
static void step_1 (int, int, char *);
-static void step_once (int skip_subroutines, int single_inst, int count, int thread);
+static void step_once (int skip_subroutines, int single_inst,
+ int count, int thread);
static void next_command (char *, int);
#define ERROR_NO_INFERIOR \
if (!target_has_execution) error (_("The program is not being run."));
-/* Scratch area where string containing arguments to give to the program will be
- stored by 'set args'. As soon as anything is stored, notice_args_set will
- move it into per-inferior storage. Arguments are separated by spaces. Empty
- string (pointer to '\0') means no args. */
+/* Scratch area where string containing arguments to give to the
+ program will be stored by 'set args'. As soon as anything is
+ stored, notice_args_set will move it into per-inferior storage.
+ Arguments are separated by spaces. Empty string (pointer to '\0')
+ means no args. */
static char *inferior_args_scratch;
int stopped_by_random_signal;
\f
-/* Accessor routines. */
+/* Accessor routines. */
/* Set the io terminal for the current inferior. Ownership of
TERMINAL_NAME is not transferred. */
if (cp == NULL)
cp = strchr (argv[i], '\n');
if (cp != NULL)
- error (_("can't handle command-line argument containing whitespace"));
+ error (_("can't handle command-line "
+ "argument containing whitespace"));
length += strlen (argv[i]) + 1;
}
/* This function detects whether or not a '&' character (indicating
background execution) has been added as *the last* of the arguments ARGS
- of a command. If it has, it removes it and returns 1. Otherwise it
- does nothing and returns 0. */
+ of a command. If it has, it removes it and returns 1. Otherwise it
+ does nothing and returns 0. */
static int
strip_bg_char (char **args)
{
}
}
-/* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
+/* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
a temporary breakpoint at the begining of the main program before
running the program. */
int async_exec = strip_bg_char (&args);
/* If we get a request for running in the bg but the target
- doesn't support it, error out. */
+ doesn't support it, error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
/* If we don't get a request of running in the bg, then we need
- to simulate synchronous (fg) execution. */
+ to simulate synchronous (fg) execution. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
- /* If there were other args, beside '&', process them. */
+ /* If there were other args, beside '&', process them. */
if (args)
set_inferior_args (args);
}
/* We call get_inferior_args() because we might need to compute
the value now. */
target_create_inferior (exec_file, get_inferior_args (),
- environ_vector (current_inferior ()->environment), from_tty);
+ environ_vector (current_inferior ()->environment),
+ from_tty);
/* We're starting off a new process. When we get out of here, in
non-stop mode, finish the state of all threads of that process,
{
if (ptid_equal (inferior_ptid, null_ptid)
|| is_exited (inferior_ptid))
- error (_("\
-Cannot execute this command without a live selected thread."));
+ error (_("Cannot execute this command without a live selected thread."));
}
/* If the user is looking at trace frames, any resumption of execution
- is likely to mix up recorded and live target data. So simply
+ is likely to mix up recorded and live target data. So simply
disallow those commands. */
void
ensure_not_tfind_mode (void)
{
if (get_traceframe_number () >= 0)
- error (_("\
-Cannot execute this command while looking at trace frames."));
+ error (_("Cannot execute this command while looking at trace frames."));
}
void
int all_threads = 0;
ERROR_NO_INFERIOR;
- /* Find out whether we must run in the background. */
+ /* Find out whether we must run in the background. */
if (args != NULL)
async_exec = strip_bg_char (&args);
/* If we must run in the background, but the target can't do it,
- error out. */
+ error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
/* If we are not asked to run in the bg, then prepare to run in the
- foreground, synchronously. */
+ foreground, synchronously. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
error (_("`-a' is meaningless in all-stop mode."));
if (args != NULL && all_threads)
- error (_("\
-Can't resume all threads and specify proceed count simultaneously."));
+ error (_("Can't resume all threads and specify "
+ "proceed count simultaneously."));
/* If we have an argument left, set proceed count of breakpoint we
stopped at. */
tp = find_thread_ptid (last_ptid);
}
if (tp != NULL)
- bs = tp->stop_bpstat;
+ bs = tp->control.stop_bpstat;
while ((stat = bpstat_num (&bs, &num)) != 0)
if (stat > 0)
step_1 (1, 1, count_string);
}
-static void
+void
delete_longjmp_breakpoint_cleanup (void *arg)
{
int thread = * (int *) arg;
async_exec = strip_bg_char (&count_string);
/* If we get a request for running in the bg but the target
- doesn't support it, error out. */
+ doesn't support it, error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
/* If we don't get a request of running in the bg, then we need
- to simulate synchronous (fg) execution. */
+ to simulate synchronous (fg) execution. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
count = count_string ? parse_and_eval_long (count_string) : 1;
- if (!single_inst || skip_subroutines) /* leave si command alone */
+ if (!single_inst || skip_subroutines) /* Leave si command alone. */
{
+ struct thread_info *tp = inferior_thread ();
+
if (in_thread_list (inferior_ptid))
thread = pid_to_thread_id (inferior_ptid);
- set_longjmp_breakpoint (thread);
+ set_longjmp_breakpoint (tp, get_frame_id (get_current_frame ()));
make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
}
else
tp = NULL;
- if (!tp || !tp->stop_step || !tp->step_multi)
+ if (!tp || !tp->control.stop_step || !tp->step_multi)
{
/* If we stopped for some reason that is not stepping
there are no further steps to make. */
/* Called after we are done with one step operation, to check whether
we need to step again, before we print the prompt and return control
- to the user. If count is > 1, we will need to do one more call to
- proceed(), via step_once(). Basically it is like step_once and
- step_1_continuation are co-recursive. */
+ to the user. If count is > 1, we will need to do one more call to
+ proceed(), via step_once(). Basically it is like step_once and
+ step_1_continuation are co-recursive. */
static void
step_1_continuation (void *args)
{
struct thread_info *tp;
tp = inferior_thread ();
- if (tp->step_multi && tp->stop_step)
+ if (tp->step_multi && tp->control.stop_step)
{
/* There are more steps to make, and we did stop due to
ending a stepping range. Do another step. */
pc = get_frame_pc (frame);
find_pc_line_pc_range (pc,
- &tp->step_range_start, &tp->step_range_end);
+ &tp->control.step_range_start,
+ &tp->control.step_range_end);
/* If we have no line info, switch to stepi mode. */
- if (tp->step_range_end == 0 && step_stop_if_no_debug)
- tp->step_range_start = tp->step_range_end = 1;
- else if (tp->step_range_end == 0)
+ if (tp->control.step_range_end == 0 && step_stop_if_no_debug)
+ tp->control.step_range_start = tp->control.step_range_end = 1;
+ else if (tp->control.step_range_end == 0)
{
char *name;
if (find_pc_partial_function (pc, &name,
- &tp->step_range_start,
- &tp->step_range_end) == 0)
+ &tp->control.step_range_start,
+ &tp->control.step_range_end) == 0)
error (_("Cannot find bounds of current function"));
target_terminal_ours ();
- printf_filtered (_("\
-Single stepping until exit from function %s,\n\
-which has no line number information.\n"), name);
+ printf_filtered (_("Single stepping until exit from function %s,"
+ "\nwhich has no line number information.\n"),
+ name);
}
}
else
{
/* Say we are stepping, but stop after one insn whatever it does. */
- tp->step_range_start = tp->step_range_end = 1;
+ tp->control.step_range_start = tp->control.step_range_end = 1;
if (!skip_subroutines)
/* It is stepi.
Don't step over function calls, not even to functions lacking
line numbers. */
- tp->step_over_calls = STEP_OVER_NONE;
+ tp->control.step_over_calls = STEP_OVER_NONE;
}
if (skip_subroutines)
- tp->step_over_calls = STEP_OVER_ALL;
+ tp->control.step_over_calls = STEP_OVER_ALL;
tp->step_multi = (count > 1);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
ensure_valid_thread ();
ensure_not_running ();
- /* Find out whether we must run in the background. */
+ /* Find out whether we must run in the background. */
if (arg != NULL)
async_exec = strip_bg_char (&arg);
/* If we must run in the background, but the target can't do it,
- error out. */
+ error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
if (sal.symtab == 0 && sal.pc == 0)
error (_("No source file has been specified."));
- resolve_sal_pc (&sal); /* May error out */
+ resolve_sal_pc (&sal); /* May error out. */
- /* See if we are trying to jump to another function. */
+ /* See if we are trying to jump to another function. */
fn = get_frame_function (get_current_frame ());
sfn = find_pc_function (sal.pc);
if (fn != NULL && sfn != fn)
if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn)) &&
!section_is_mapped (SYMBOL_OBJ_SECTION (sfn)))
{
- if (!query (_("WARNING!!! Destination is in unmapped overlay! Jump anyway? ")))
+ if (!query (_("WARNING!!! Destination is in "
+ "unmapped overlay! Jump anyway? ")))
{
error (_("Not confirmed."));
/* NOTREACHED */
}
/* If we are not asked to run in the bg, then prepare to run in the
- foreground, synchronously. */
+ foreground, synchronously. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
}
\f
-/* Go to line or address in current procedure */
+/* Go to line or address in current procedure. */
static void
go_command (char *line_no, int from_tty)
{
proceed ((CORE_ADDR) -1, oursig, 0);
}
+/* A continuation callback for until_next_command. */
+
+static void
+until_next_continuation (void *arg)
+{
+ struct thread_info *tp = arg;
+
+ delete_longjmp_breakpoint (tp->num);
+}
+
/* Proceed until we reach a different source line with pc greater than
our current one or exit the function. We skip calls in both cases.
struct symbol *func;
struct symtab_and_line sal;
struct thread_info *tp = inferior_thread ();
+ int thread = tp->num;
+ struct cleanup *old_chain;
clear_proceed_status ();
set_step_frame ();
/* Step until either exited from this function or greater
than the current line (if in symbolic section) or pc (if
- not). */
+ not). */
pc = get_frame_pc (frame);
func = find_pc_function (pc);
if (msymbol == NULL)
error (_("Execution is not within a known function."));
- tp->step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
- tp->step_range_end = pc;
+ tp->control.step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
+ tp->control.step_range_end = pc;
}
else
{
sal = find_pc_line (pc, 0);
- tp->step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
- tp->step_range_end = sal.end;
+ tp->control.step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
+ tp->control.step_range_end = sal.end;
}
- tp->step_over_calls = STEP_OVER_ALL;
+ tp->control.step_over_calls = STEP_OVER_ALL;
tp->step_multi = 0; /* Only one call to proceed */
+ set_longjmp_breakpoint (tp, get_frame_id (frame));
+ old_chain = make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
+
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
+
+ if (target_can_async_p () && is_running (inferior_ptid))
+ {
+ discard_cleanups (old_chain);
+ add_continuation (tp, until_next_continuation, tp, NULL);
+ }
+ else
+ do_cleanups (old_chain);
}
static void
ensure_valid_thread ();
ensure_not_running ();
- /* Find out whether we must run in the background. */
+ /* Find out whether we must run in the background. */
if (arg != NULL)
async_exec = strip_bg_char (&arg);
/* If we must run in the background, but the target can't do it,
- error out. */
+ error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
/* If we are not asked to run in the bg, then prepare to run in the
- foreground, synchronously. */
+ foreground, synchronously. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
impossible to do all the stuff as part of the finish_command
function itself. The only chance we have to complete this command
is in fetch_inferior_event, which is called by the event loop as
- soon as it detects that the target has stopped. This function is
+ soon as it detects that the target has stopped. This function is
called via the cmd_continuation pointer. */
struct finish_command_continuation_args
&& is_stopped (inferior_ptid))
{
tp = inferior_thread ();
- bs = tp->stop_bpstat;
+ bs = tp->control.stop_bpstat;
}
if (bpstat_find_breakpoint (bs, a->breakpoint) != NULL
/* We suppress normal call of normal_stop observer and do it here so
that the *stopped notification includes the return value. */
- if (bs != NULL && tp->proceed_to_finish)
+ if (bs != NULL && tp->control.proceed_to_finish)
observer_notify_normal_stop (bs, 1 /* print frame */);
delete_breakpoint (a->breakpoint);
+ delete_longjmp_breakpoint (inferior_thread ()->num);
}
static void
sal = find_pc_line (func_addr, 0);
/* We don't need a return value. */
- tp->proceed_to_finish = 0;
+ tp->control.proceed_to_finish = 0;
/* Special case: if we're sitting at the function entry point,
then all we need to do is take a reverse singlestep. We
don't need to set a breakpoint, and indeed it would do us
old_chain = make_cleanup_delete_breakpoint (breakpoint);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
/* We will be stopped when proceed returns. */
- back_up = bpstat_find_breakpoint (tp->stop_bpstat, breakpoint) != NULL;
+ back_up = (bpstat_find_breakpoint (tp->control.stop_bpstat, breakpoint)
+ != NULL);
do_cleanups (old_chain);
}
else
/* If in fact we hit the step-resume breakpoint (and not
some other breakpoint), then we're almost there --
we just need to back up by one more single-step. */
- tp->step_range_start = tp->step_range_end = 1;
+ tp->control.step_range_start = tp->control.step_range_end = 1;
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
}
return;
struct breakpoint *breakpoint;
struct cleanup *old_chain;
struct finish_command_continuation_args *cargs;
+ int thread = tp->num;
sal = find_pc_line (get_frame_pc (frame), 0);
sal.pc = get_frame_pc (frame);
old_chain = make_cleanup_delete_breakpoint (breakpoint);
- tp->proceed_to_finish = 1; /* We want stop_registers, please... */
+ set_longjmp_breakpoint (tp, get_frame_id (frame));
+ make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
+
+ /* We want stop_registers, please... */
+ tp->control.proceed_to_finish = 1;
cargs = xmalloc (sizeof (*cargs));
cargs->breakpoint = breakpoint;
init_sal (&empty_sal);
set_step_info (frame, empty_sal);
- tp->step_range_start = tp->step_range_end = get_frame_pc (frame);
- tp->step_over_calls = STEP_OVER_ALL;
+ tp->control.step_range_start = get_frame_pc (frame);
+ tp->control.step_range_end = tp->control.step_range_start;
+ tp->control.step_over_calls = STEP_OVER_ALL;
/* Print info on the selected frame, including level number but not
source. */
error (_("Selected thread is running."));
tp = find_thread_ptid (ptid);
- bs = tp->stop_bpstat;
+ bs = tp->control.stop_bpstat;
stat = bpstat_num (&bs, &num);
target_files_info ();
printf_filtered (_("Program stopped at %s.\n"),
paddress (target_gdbarch, stop_pc));
- if (tp->stop_step)
+ if (tp->control.stop_step)
printf_filtered (_("It stopped after being stepped.\n"));
else if (stat != 0)
{
{
if (stat < 0)
{
- printf_filtered (_("\
-It stopped at a breakpoint that has since been deleted.\n"));
+ printf_filtered (_("It stopped at a breakpoint "
+ "that has since been deleted.\n"));
}
else
printf_filtered (_("It stopped at breakpoint %d.\n"), num);
stat = bpstat_num (&bs, &num);
}
}
- else if (tp->stop_signal != TARGET_SIGNAL_0)
+ else if (tp->suspend.stop_signal != TARGET_SIGNAL_0)
{
printf_filtered (_("It stopped with signal %s, %s.\n"),
- target_signal_to_name (tp->stop_signal),
- target_signal_to_string (tp->stop_signal));
+ target_signal_to_name (tp->suspend.stop_signal),
+ target_signal_to_string (tp->suspend.stop_signal));
}
if (!from_tty)
{
- printf_filtered (_("\
-Type \"info stack\" or \"info registers\" for more information.\n"));
+ printf_filtered (_("Type \"info stack\" or \"info "
+ "registers\" for more information.\n"));
}
}
\f
if (arg == 0)
error_no_arg (_("environment variable and value"));
- /* Find seperation between variable name and value */
+ /* Find seperation between variable name and value. */
p = (char *) strchr (arg, '=');
val = (char *) strchr (arg, ' ');
{
/* We have both a space and an equals. If the space is before the
equals, walk forward over the spaces til we see a nonspace
- (possibly the equals). */
+ (possibly the equals). */
if (p > val)
while (*val == ' ')
val++;
{
nullset = 1;
if (p == 0)
- p = arg + strlen (arg); /* So that savestring below will work */
+ p = arg + strlen (arg); /* So that savestring below will work. */
}
else
{
- /* Not setting variable value to null */
+ /* Not setting variable value to null. */
val = p + 1;
while (*val == ' ' || *val == '\t')
val++;
var = savestring (arg, p - arg);
if (nullset)
{
- printf_filtered (_("\
-Setting environment variable \"%s\" to null value.\n"),
+ printf_filtered (_("Setting environment variable "
+ "\"%s\" to null value.\n"),
var);
set_in_environ (current_inferior ()->environment, var, "");
}
unset_in_environ (current_inferior ()->environment, var);
}
-/* Handle the execution path (PATH variable) */
+/* Handle the execution path (PATH variable). */
static const char path_var_name[] = "PATH";
path_info (char *args, int from_tty)
{
puts_filtered ("Executable and object file path: ");
- puts_filtered (get_in_environ (current_inferior ()->environment, path_var_name));
+ puts_filtered (get_in_environ (current_inferior ()->environment,
+ path_var_name));
puts_filtered ("\n");
}
dont_repeat ();
env = get_in_environ (current_inferior ()->environment, path_var_name);
- /* Can be null if path is not set */
+ /* Can be null if path is not set. */
if (!env)
env = "";
exec_path = xstrdup (env);
}
\f
-/* Print out the machine register regnum. If regnum is -1, print all
+/* Print out the machine register regnum. If regnum is -1, print all
registers (print_all == 1) or all non-float and non-vector
registers (print_all == 0).
{
/* FIXME: This should not really be inferior_ptid (or target_has_execution).
It should be a distinct flag that indicates that a target is active, cuz
- some targets don't have processes! */
+ some targets don't have processes! */
if (ptid_equal (inferior_ptid, null_ptid))
error (_("The program is not being run."));
with their threads. */
if (!have_inferiors ())
{
- init_thread_list (); /* Destroy thread info */
+ init_thread_list (); /* Destroy thread info. */
/* Killing off the inferior can leave us with a core file. If
so, print the state we are left in. */
&& !is_exited (thread->ptid)
&& !is_executing (thread->ptid)
&& !thread->stop_requested
- && thread->stop_signal == TARGET_SIGNAL_0)
+ && thread->suspend.stop_signal == TARGET_SIGNAL_0)
{
switch_to_thread (thread->ptid);
clear_proceed_status ();
* This only needs to be done if we are attaching to a process.
*/
-/*
- attach_command --
+/* attach_command --
takes a program started up outside of gdb and ``attaches'' to it.
This stops it cold in its tracks and allows us to start debugging it.
and wait for the trace-trap that results from attaching. */
struct inferior *inferior;
inferior = current_inferior ();
- inferior->stop_soon = NO_STOP_QUIETLY;
+ inferior->control.stop_soon = NO_STOP_QUIETLY;
/* If no exec file is yet known, try to determine it from the
process itself. */
Attempt to qualify the filename against the source path.
(If that fails, we'll just fall back on the original
- filename. Not much more we can do...)
- */
+ filename. Not much more we can do...) */
+
if (!source_full_path_of (exec_file, &full_exec_path))
full_exec_path = xstrdup (exec_file);
proceed_after_attach (inferior->pid);
else
{
- if (inferior_thread ()->stop_signal == TARGET_SIGNAL_0)
+ if (inferior_thread ()->suspend.stop_signal == TARGET_SIGNAL_0)
{
clear_proceed_status ();
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
async_exec = strip_bg_char (&args);
/* If we get a request for running in the bg but the target
- doesn't support it, error out. */
+ doesn't support it, error out. */
if (async_exec && !target_can_async_p ())
error (_("Asynchronous execution not supported on this target."));
}
to simulate synchronous (fg) execution. */
if (!async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
make_cleanup ((make_cleanup_ftype *)async_enable_stdin, NULL);
}
{
struct inferior *inferior = current_inferior ();
- /* Careful here. See comments in inferior.h. Basically some
+ /* Careful here. See comments in inferior.h. Basically some
OSes don't ignore SIGSTOPs on continue requests anymore. We
need a way for handle_inferior_event to reset the stop_signal
variable after an attach, and this is what
STOP_QUIETLY_NO_SIGSTOP is for. */
- inferior->stop_soon = STOP_QUIETLY_NO_SIGSTOP;
+ inferior->control.stop_soon = STOP_QUIETLY_NO_SIGSTOP;
if (target_can_async_p ())
{
that. */
target_stop (inferior_ptid);
- inferior->stop_soon = STOP_QUIETLY_REMOTE;
+ inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
/* Wait for stop before proceeding. */
if (target_can_async_p ())
static void
disconnect_command (char *args, int from_tty)
{
- dont_repeat (); /* Not for the faint of heart */
+ dont_repeat (); /* Not for the faint of heart. */
target_disconnect (args, from_tty);
no_shared_libraries (NULL, from_tty);
init_thread_list ();
{
int all_threads = 0;
- dont_repeat (); /* Not for the faint of heart */
+ dont_repeat (); /* Not for the faint of heart. */
if (args != NULL
&& strncmp (args, "-a", sizeof ("-a") - 1) == 0)
}
}
if (!printed_something)
- fprintf_filtered (file, "\
-No floating-point info available for this processor.\n");
+ fprintf_filtered (file, "No floating-point info "
+ "available for this processor.\n");
}
}
static void
unset_command (char *args, int from_tty)
{
- printf_filtered (_("\
-\"unset\" must be followed by the name of an unset subcommand.\n"));
+ printf_filtered (_("\"unset\" must be followed by the "
+ "name of an unset subcommand.\n"));
help_list (unsetlist, "unset ", -1, gdb_stdout);
}
{
struct cmd_list_element *c = NULL;
- /* add the filename of the terminal connected to inferior I/O */
+ /* Add the filename of the terminal connected to inferior I/O. */
add_setshow_filename_cmd ("inferior-tty", class_run,
&inferior_io_terminal_scratch, _("\
Set terminal for future runs of program being debugged."), _("\
$cwd in the path means the current working directory.\n\
This path is equivalent to the $PATH shell variable. It is a list of\n\
directories, separated by colons. These directories are searched to find\n\
-fully linked executable files and separately compiled object files as needed."));
+fully linked executable files and separately compiled object files as \
+needed."));
set_cmd_completer (c, filename_completer);
c = add_cmd ("paths", no_class, path_info, _("\
$cwd in the path means the current working directory.\n\
This path is equivalent to the $PATH shell variable. It is a list of\n\
directories, separated by colons. These directories are searched to find\n\
-fully linked executable files and separately compiled object files as needed."),
+fully linked executable files and separately compiled object files as \
+needed."),
&showlist);
set_cmd_completer (c, noop_completer);
add_com ("stepi", class_run, stepi_command, _("\
Step one instruction exactly.\n\
-Argument N means do this N times (or till program stops for another reason)."));
+Argument N means do this N times (or till program stops for another \
+reason)."));
add_com_alias ("si", "stepi", class_alias, 0);
add_com ("nexti", class_run, nexti_command, _("\
Step one instruction, but proceed through subroutine calls.\n\
-Argument N means do this N times (or till program stops for another reason)."));
+Argument N means do this N times (or till program stops for another \
+reason)."));
add_com_alias ("ni", "nexti", class_alias, 0);
add_com ("finish", class_run, finish_command, _("\
Step program, proceeding through subroutine calls.\n\
Like the \"step\" command as long as subroutine calls do not happen;\n\
when they do, the call is treated as one instruction.\n\
-Argument N means do this N times (or till program stops for another reason)."));
+Argument N means do this N times (or till program stops for another \
+reason)."));
add_com_alias ("n", "next", class_run, 1);
if (xdb_commands)
add_com_alias ("S", "next", class_run, 1);
add_com ("step", class_run, step_command, _("\
Step program until it reaches a different source line.\n\
-Argument N means do this N times (or till program stops for another reason)."));
+Argument N means do this N times (or till program stops for another \
+reason)."));
add_com_alias ("s", "step", class_run, 1);
c = add_com ("until", class_run, until_command, _("\
Execute until the program reaches a source line greater than the current\n\
-or a specified location (same args as break command) within the current frame."));
+or a specified location (same args as break command) within the current \
+frame."));
set_cmd_completer (c, location_completer);
add_com_alias ("u", "until", class_run, 1);
c = add_com ("advance", class_run, advance_command, _("\
-Continue the program up to the given location (same form as args for break command).\n\
+Continue the program up to the given location (same form as args for break \
+command).\n\
Execution will also stop upon exit from the current stack frame."));
set_cmd_completer (c, location_completer);
c = add_com ("run", class_run, run_command, _("\
Start debugged program. You may specify arguments to give it.\n\
Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
-Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
-With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
+Input and output redirection with \">\", \"<\", or \">>\" are also \
+allowed.\n\n\
+With no arguments, uses arguments last specified (with \"run\" \
+or \"set args\").\n\
To cancel previous arguments and run with no arguments,\n\
use \"set args\" without arguments."));
set_cmd_completer (c, filename_completer);
projects / deliverable / binutils-gdb.git / blobdiff