along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
+#include "defs.h"
#include <signal.h>
#include <sys/param.h>
#include <string.h>
-#include "defs.h"
#include "symtab.h"
+#include "gdbtypes.h"
#include "frame.h"
#include "inferior.h"
#include "environ.h"
#include "gdbcore.h"
#include "target.h"
-extern char *sys_siglist[];
+static void
+continue_command PARAMS ((char *, int));
+
+static void
+until_next_command PARAMS ((int));
+
+static void
+until_command PARAMS ((char *, int));
+
+static void
+path_info PARAMS ((char *, int));
+
+static void
+path_command PARAMS ((char *, int));
+
+static void
+unset_command PARAMS ((char *, int));
+
+static void
+float_info PARAMS ((char *, int));
+
+static void
+detach_command PARAMS ((char *, int));
+
+static void
+nofp_registers_info PARAMS ((char *, int));
+
+static void
+all_registers_info PARAMS ((char *, int));
+
+static void
+registers_info PARAMS ((char *, int));
+
+static void
+do_registers_info PARAMS ((int, int));
+
+static void
+unset_environment_command PARAMS ((char *, int));
+
+static void
+set_environment_command PARAMS ((char *, int));
+
+static void
+environment_info PARAMS ((char *, int));
+
+static void
+program_info PARAMS ((char *, int));
+
+static void
+finish_command PARAMS ((char *, int));
+
+static void
+signal_command PARAMS ((char *, int));
+
+static void
+jump_command PARAMS ((char *, int));
+
+static void
+step_1 PARAMS ((int, int, char *));
+
+static void
+nexti_command PARAMS ((char *, int));
+
+static void
+stepi_command PARAMS ((char *, int));
+
+static void
+next_command PARAMS ((char *, int));
-extern void until_break_command (); /* breakpoint.c */
+static void
+step_command PARAMS ((char *, int));
+
+static void
+run_command PARAMS ((char *, int));
#define ERROR_NO_INFERIOR \
if (!target_has_execution) error ("The program is not being run.");
FRAME_ADDR step_frame_address;
/* 1 means step over all subroutine calls.
+ 0 means don't step over calls (used by stepi).
-1 means step over calls to undebuggable functions. */
int step_over_calls;
struct environ *inferior_environ;
-CORE_ADDR read_pc ();
-void breakpoint_clear_ignore_counts ();
-
\f
/* ARGSUSED */
void
exec_file = (char *) get_exec_file (0);
- /* The exec file is re-read every time we do an inferior_died, so
+ /* The exec file is re-read every time we do a generic_mourn_inferior, so
we just have to worry about the symbol file. */
reread_symbols ();
if (from_tty)
{
- printf ("Starting program: %s %s\n",
- exec_file? exec_file: "", inferior_args);
+ puts_filtered("Starting program: ");
+ if (exec_file)
+ puts_filtered(exec_file);
+ puts_filtered(" ");
+ puts_filtered(inferior_args);
+ puts_filtered("\n");
fflush (stdout);
}
environ_vector (inferior_environ));
}
\f
-void
+static void
continue_command (proc_count_exp, from_tty)
char *proc_count_exp;
int from_tty;
/* set_ignore_count prints a message ending with a period.
So print two spaces before "Continuing.". */
if (from_tty)
- printf (" ");
+ printf_filtered (" ");
num = bpstat_num (&bs);
}
}
if (from_tty)
- printf ("Continuing.\n");
+ printf_filtered ("Continuing.\n");
clear_proceed_status ();
}
\f
/* Step until outside of current statement. */
-static void step_1 ();
/* ARGSUSED */
static void
step_command (count_string, from_tty)
- char * count_string;
+ char *count_string;
int from_tty;
{
step_1 (0, 0, count_string);
/* ARGSUSED */
static void
next_command (count_string, from_tty)
- char * count_string;
+ char *count_string;
int from_tty;
{
step_1 (1, 0, count_string);
/* ARGSUSED */
static void
stepi_command (count_string, from_tty)
- char * count_string;
+ char *count_string;
int from_tty;
{
step_1 (0, 1, count_string);
/* ARGSUSED */
static void
nexti_command (count_string, from_tty)
- char * count_string;
+ char *count_string;
int from_tty;
{
step_1 (1, 1, count_string);
{
register int count = 1;
FRAME fr;
+ struct cleanup *cleanups = 0;
ERROR_NO_INFERIOR;
count = count_string ? parse_and_eval_address (count_string) : 1;
+ if (!single_inst || skip_subroutines) /* leave si command alone */
+ {
+ enable_longjmp_breakpoint();
+ cleanups = make_cleanup(disable_longjmp_breakpoint, 0);
+ }
+
for (; count > 0; count--)
{
clear_proceed_status ();
-
fr = get_current_frame ();
if (!fr) /* Avoid coredump here. Why tho? */
error ("No current frame");
find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
if (step_range_end == 0)
{
- int misc;
+ struct minimal_symbol *msymbol;
- misc = find_pc_misc_function (stop_pc);
+ /* FIXME: This should be using containing_function_bounds or a
+ cleaned-up version thereof, to deal with things like the
+ end of the text segment. */
+
+ msymbol = lookup_minimal_symbol_by_pc (stop_pc);
target_terminal_ours ();
- printf ("Current function has no line number information.\n");
+ printf_filtered ("Current function has no line number information.\n");
fflush (stdout);
- /* No info or after _etext ("Can't happen") */
- if (misc == -1 || misc == misc_function_count - 1)
- error ("No data available on pc function.");
-
- printf ("Single stepping until function exit.\n");
+ if (msymbol == NULL || SYMBOL_NAME (msymbol + 1) == NULL)
+ {
+ /* If sigtramp is in the u area, check for it. */
+#if defined SIGTRAMP_START
+ if (IN_SIGTRAMP (stop_pc, (char *)NULL))
+ {
+ step_range_start = SIGTRAMP_START;
+ step_range_end = SIGTRAMP_END;
+ }
+ else
+#endif
+ error ("Cannot find bounds of current function.");
+ }
+ else
+ {
+ step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
+ step_range_end = SYMBOL_VALUE_ADDRESS (msymbol + 1);
+ }
+
+ printf_filtered ("Single stepping until function exit.\n");
fflush (stdout);
-
- step_range_start = misc_function_vector[misc].address;
- step_range_end = misc_function_vector[misc + 1].address;
}
}
else
write_register (NPC_REGNUM, read_register (PC_REGNUM));
#endif
}
+
+ if (!single_inst || skip_subroutines)
+ do_cleanups(cleanups);
}
\f
/* Continue program at specified address. */
register CORE_ADDR addr;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
+ struct symbol *fn;
+ struct symbol *sfn;
ERROR_NO_INFERIOR;
}
sal = sals.sals[0];
- free (sals.sals);
+ free ((PTR)sals.sals);
if (sal.symtab == 0 && sal.pc == 0)
error ("No source file has been specified.");
resolve_sal_pc (&sal); /* May error out */
- {
- struct symbol *fn = get_frame_function (get_current_frame ());
- struct symbol *sfn = find_pc_function (sal.pc);
- if (fn != 0 && sfn != fn
- && ! query ("Line %d is not in `%s'. Jump anyway? ",
- sal.line, SYMBOL_NAME (fn)))
- error ("Not confirmed.");
- }
+ /* 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 (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line,
+ SYMBOL_SOURCE_NAME (fn)))
+ {
+ error ("Not confirmed.");
+ /* NOTREACHED */
+ }
+ }
addr = ADDR_BITS_SET (sal.pc);
if (from_tty)
- printf ("Continuing at %s.\n", local_hex_string(addr));
+ printf_filtered ("Continuing at %s.\n", local_hex_string(addr));
clear_proceed_status ();
proceed (addr, 0, 0);
if (!signum_exp)
error_no_arg ("signal number");
- signum = parse_and_eval_address (signum_exp);
+ /* It would be even slicker to make signal names be valid expressions,
+ (the type could be "enum $signal" or some such), then the user could
+ assign them to convenience variables. */
+ signum = strtosigno (signum_exp);
+
+ if (signum == 0)
+ /* Not found as a name, try it as an expression. */
+ signum = parse_and_eval_address (signum_exp);
if (from_tty)
- printf ("Continuing with signal %d.\n", signum);
+ {
+ char *signame = strsigno (signum);
+ printf_filtered ("Continuing with signal ");
+ if (signame == NULL || signum == 0)
+ printf_filtered ("%d.\n", signum);
+ else
+ /* Do we need to print the number as well as the name? */
+ printf_filtered ("%s (%d).\n", signame, signum);
+ }
clear_proceed_status ();
proceed (stop_pc, signum, 0);
The dummy's frame is automatically popped whenever that break is hit.
If that is the first time the program stops, run_stack_dummy
returns to its caller with that frame already gone.
- Otherwise, the caller never gets returned to. */
+ Otherwise, the caller never gets returned to.
+
+ NAME is a string to print to identify the function which we are calling.
+ It is not guaranteed to be the name of a function, it could be something
+ like "at 0x4370" if a name can't be found for the function. */
/* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
static int stack_dummy_testing = 0;
void
-run_stack_dummy (addr, buffer)
+run_stack_dummy (name, addr, buffer)
+ char *name;
CORE_ADDR addr;
char buffer[REGISTER_BYTES];
{
if (!stop_stack_dummy)
/* This used to say
- "Cannot continue previously requested operation". */
+ "The expression which contained the function call has been discarded."
+ It is a hard concept to explain in a few words. Ideally, GDB would
+ be able to resume evaluation of the expression when the function
+ finally is done executing. Perhaps someday this will be implemented
+ (it would not be easy). */
error ("\
The program being debugged stopped while in a function called from GDB.\n\
-The expression which contained the function call has been discarded.");
+When the function (%s) is done executing, GDB will silently\n\
+stop (instead of continuing to evaluate the expression containing\n\
+the function call).", name);
/* On return, the stack dummy has been popped already. */
- bcopy (stop_registers, buffer, sizeof stop_registers);
+ memcpy (buffer, stop_registers, sizeof stop_registers);
}
\f
/* Proceed until we reach a different source line with pc greater than
of wait_for_inferior and the proceed status code. -- randy */
/* ARGSUSED */
-void
+static void
until_next_command (from_tty)
int from_tty;
{
if (!func)
{
- int misc_func = find_pc_misc_function (pc);
+ struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
- if (misc_func != -1)
+ if (msymbol == NULL)
error ("Execution is not within a known function.");
- step_range_start = misc_function_vector[misc_func].address;
+ step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
step_range_end = pc;
}
else
proceed ((CORE_ADDR) -1, -1, 1);
}
-void
+static void
until_command (arg, from_tty)
char *arg;
int from_tty;
register FRAME frame;
struct frame_info *fi;
register struct symbol *function;
+ struct breakpoint *breakpoint;
+ struct cleanup *old_chain;
if (arg)
error ("The \"finish\" command does not take any arguments.");
fi = get_frame_info (frame);
sal = find_pc_line (fi->pc, 0);
sal.pc = fi->pc;
- set_momentary_breakpoint (sal, frame);
+
+ breakpoint = set_momentary_breakpoint (sal, frame, bp_finish);
+
+ old_chain = make_cleanup(delete_breakpoint, breakpoint);
/* Find the function we will return from. */
proceed_to_finish = 1; /* We want stop_registers, please... */
proceed ((CORE_ADDR) -1, -1, 0);
- if (bpstat_momentary_breakpoint (stop_bpstat) && function != 0)
+ /* Did we stop at our breakpoint? */
+ if (bpstat_find_breakpoint(stop_bpstat, breakpoint) != NULL
+ && function != 0)
{
struct type *value_type;
register value val;
value_print (val, stdout, 0, Val_no_prettyprint);
printf_filtered ("\n");
}
+ do_cleanups(old_chain);
}
\f
/* ARGSUSED */
if (!target_has_execution)
{
- printf ("The program being debugged is not being run.\n");
+ printf_filtered ("The program being debugged is not being run.\n");
return;
}
target_files_info ();
- printf ("Program stopped at %s.\n", local_hex_string(stop_pc));
+ printf_filtered ("Program stopped at %s.\n", local_hex_string(stop_pc));
if (stop_step)
- printf ("It stopped after being stepped.\n");
+ printf_filtered ("It stopped after being stepped.\n");
else if (num != 0)
{
/* There may be several breakpoints in the same place, so this
while (num != 0)
{
if (num < 0)
- printf ("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 ("It stopped at breakpoint %d.\n", num);
+ printf_filtered ("It stopped at breakpoint %d.\n", num);
num = bpstat_num (&bs);
}
}
- else if (stop_signal) {
+ else if (stop_signal)
+ {
#ifdef PRINT_RANDOM_SIGNAL
- PRINT_RANDOM_SIGNAL (stop_signal);
+ PRINT_RANDOM_SIGNAL (stop_signal);
#else
- printf ("It stopped with signal %d (%s).\n",
- stop_signal,
- (stop_signal > NSIG)? "unknown": sys_siglist[stop_signal]);
+ char *signame = strsigno (stop_signal);
+ printf_filtered ("It stopped with signal ");
+ if (signame == NULL)
+ printf_filtered ("%d", stop_signal);
+ else
+ /* Do we need to print the number as well as the name? */
+ printf_filtered ("%s (%d)", signame, stop_signal);
+ printf_filtered (", %s.\n", safe_strsignal (stop_signal));
#endif
}
if (!from_tty)
- printf ("Type \"info stack\" or \"info registers\" for more information.\n");
+ printf_filtered ("Type \"info stack\" or \"info registers\" for more information.\n");
}
\f
static void
-environment_info (var)
+environment_info (var, from_tty)
char *var;
+ int from_tty;
{
if (var)
{
register char *val = get_in_environ (inferior_environ, var);
if (val)
- printf ("%s = %s\n", var, val);
+ {
+ puts_filtered (var);
+ puts_filtered (" = ");
+ puts_filtered (val);
+ puts_filtered ("\n");
+ }
else
- printf ("Environment variable \"%s\" not defined.\n", var);
+ {
+ puts_filtered ("Environment variable \"");
+ puts_filtered (var);
+ puts_filtered ("\" not defined.\n");
+ }
}
else
{
register char **vector = environ_vector (inferior_environ);
while (*vector)
- printf ("%s\n", *vector++);
+ {
+ puts_filtered (*vector++);
+ puts_filtered ("\n");
+ }
}
}
static void
-set_environment_command (arg)
+set_environment_command (arg, from_tty)
char *arg;
+ int from_tty;
{
register char *p, *val, *var;
int nullset = 0;
if (p != 0 && val != 0)
{
/* We have both a space and an equals. If the space is before the
- equals and the only thing between the two is more space, use
- the equals */
+ equals, walk forward over the spaces til we see a nonspace
+ (possibly the equals). */
if (p > val)
while (*val == ' ')
val++;
- /* Take the smaller of the two. If there was space before the
- "=", they will be the same right now. */
- p = arg + min (p - arg, val - arg);
+ /* Now if the = is after the char following the spaces,
+ take the char following the spaces. */
+ if (p > val)
+ p = val - 1;
}
else if (val != 0 && p == 0)
p = val;
var = savestring (arg, p - arg);
if (nullset)
{
- printf ("Setting environment variable \"%s\" to null value.\n", var);
+ printf_filtered ("Setting environment variable \"%s\" to null value.\n", var);
set_in_environ (inferior_environ, var, "");
}
else
/* Handle the execution path (PATH variable) */
-const static char path_var_name[] = "PATH";
+static const char path_var_name[] = "PATH";
/* ARGSUSED */
-void
+static void
path_info (args, from_tty)
char *args;
int from_tty;
{
- printf ("Executable and object file path: %s\n",
- get_in_environ (inferior_environ, path_var_name));
+ puts_filtered ("Executable and object file path: ");
+ puts_filtered (get_in_environ (inferior_environ, path_var_name));
+ puts_filtered ("\n");
}
/* Add zero or more directories to the front of the execution path. */
-void
+static void
path_command (dirname, from_tty)
char *dirname;
int from_tty;
path_info ((char *)NULL, from_tty);
}
\f
+/* This routine is getting awfully cluttered with #if's. It's probably
+ time to turn this into READ_PC and define it in the tm.h file.
+ Ditto for write_pc. */
+
CORE_ADDR
read_pc ()
{
+#ifdef GDB_TARGET_IS_HPPA
+ int flags = read_register(FLAGS_REGNUM);
+
+ if (flags & 2)
+ return read_register(31) & ~0x3; /* User PC is here when in sys call */
+ return read_register (PC_REGNUM) & ~0x3;
+#else
+#ifdef TARGET_READ_PC
+ return TARGET_READ_PC ();
+#else
return ADDR_BITS_REMOVE ((CORE_ADDR) read_register (PC_REGNUM));
+#endif
+#endif
}
void
write_pc (val)
CORE_ADDR val;
{
+#ifdef TARGET_WRITE_PC
+ TARGET_WRITE_PC (val);
+#else
write_register (PC_REGNUM, (long) val);
#ifdef NPC_REGNUM
- write_register (NPC_REGNUM, (long) val+4);
+ write_register (NPC_REGNUM, (long) val + 4);
+#ifdef NNPC_REGNUM
+ write_register (NNPC_REGNUM, (long) val + 8);
+#endif
+#endif
#endif
pc_changed = 0;
}
-char *reg_names[] = REGISTER_NAMES;
+/* Cope with strage ways of getting to the stack and frame pointers */
+
+CORE_ADDR
+read_sp ()
+{
+#ifdef TARGET_READ_SP
+ return TARGET_READ_SP ();
+#else
+ return read_register (SP_REGNUM);
+#endif
+}
+
+void
+write_sp (val)
+ CORE_ADDR val;
+{
+#ifdef TARGET_WRITE_SP
+ TARGET_WRITE_SP (val);
+#else
+ write_register (SP_REGNUM, val);
+#endif
+}
+
+
+CORE_ADDR
+read_fp ()
+{
+#ifdef TARGET_READ_FP
+ return TARGET_READ_FP ();
+#else
+ return read_register (FP_REGNUM);
+#endif
+}
+
+void
+write_fp (val)
+ CORE_ADDR val;
+{
+#ifdef TARGET_WRITE_FP
+ TARGET_WRITE_FP (val);
+#else
+ write_register (FP_REGNUM, val);
+#endif
+}
+
+const char * const reg_names[] = REGISTER_NAMES;
/* Print out the machine register regnum. If regnum is -1,
print all registers (fpregs == 1) or all non-float registers
continue;
}
- target_convert_to_virtual (i, raw_buffer, virtual_buffer);
+ REGISTER_CONVERT_TO_VIRTUAL (i, raw_buffer, virtual_buffer);
/* If virtual format is floating, print it that way, and in raw hex. */
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
int fpregs;
{
int regnum;
+ register char *end;
if (!target_has_registers)
error ("The program has no registers now.");
- if (addr_exp)
+ if (!addr_exp)
{
- if (*addr_exp >= '0' && *addr_exp <= '9')
- regnum = atoi (addr_exp);
- else
- {
- register char *p = addr_exp;
- if (p[0] == '$')
- p++;
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (!strcmp (p, reg_names[regnum]))
- break;
- if (regnum == NUM_REGS)
- error ("%s: invalid register name.", addr_exp);
- }
+ DO_REGISTERS_INFO(-1, fpregs);
+ return;
}
- else
- regnum = -1;
- DO_REGISTERS_INFO(regnum, fpregs);
+ do
+ {
+ if (addr_exp[0] == '$')
+ addr_exp++;
+ end = addr_exp;
+ while (*end != '\0' && *end != ' ' && *end != '\t')
+ ++end;
+ for (regnum = 0; regnum < NUM_REGS; regnum++)
+ if (!strncmp (addr_exp, reg_names[regnum], end - addr_exp)
+ && strlen (reg_names[regnum]) == end - addr_exp)
+ goto found;
+ if (*addr_exp >= '0' && *addr_exp <= '9')
+ regnum = atoi (addr_exp); /* Take a number */
+ if (regnum >= NUM_REGS) /* Bad name, or bad number */
+ error ("%.*s: invalid register", end - addr_exp, addr_exp);
+
+found:
+ DO_REGISTERS_INFO(regnum, fpregs);
+
+ addr_exp = end;
+ while (*addr_exp == ' ' || *addr_exp == '\t')
+ ++addr_exp;
+ } while (*addr_exp != '\0');
}
static void
-all_registers_info (addr_exp)
+all_registers_info (addr_exp, from_tty)
char *addr_exp;
+ int from_tty;
{
registers_info (addr_exp, 1);
}
static void
-nofp_registers_info (addr_exp)
+nofp_registers_info (addr_exp, from_tty)
char *addr_exp;
+ int from_tty;
{
registers_info (addr_exp, 0);
}
*/
/*
- * 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 tracing it.
- * For this to work, we must be able to send the process a
- * signal and we must have the same effective uid as the program.
- */
+ 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. */
+
void
attach_command (args, from_tty)
char *args;
int from_tty;
{
dont_repeat (); /* Not for the faint of heart */
+
+ if (target_has_execution)
+ {
+ if (query ("A program is being debugged already. Kill it? "))
+ target_kill ();
+ else
+ error ("Not killed.");
+ }
+
target_attach (args, from_tty);
+
+ /* Set up the "saved terminal modes" of the inferior
+ based on what modes we are starting it with. */
+ target_terminal_init ();
+
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
+
+ /* Set up execution context to know that we should return from
+ wait_for_inferior as soon as the target reports a stop. */
+ init_wait_for_inferior ();
+ clear_proceed_status ();
+ stop_soon_quietly = 1;
+
+ wait_for_inferior ();
+
+#ifdef SOLIB_ADD
+ /* Add shared library symbols from the newly attached process, if any. */
+ SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0);
+#endif
+
+ normal_stop ();
}
/*
/* ARGSUSED */
static void
-float_info (addr_exp)
+float_info (addr_exp, from_tty)
char *addr_exp;
+ int from_tty;
{
#ifdef FLOAT_INFO
FLOAT_INFO;
#else
- printf ("No floating point info available for this processor.\n");
+ printf_filtered ("No floating point info available for this processor.\n");
#endif
}
\f
-struct cmd_list_element *unsetlist = NULL;
-
/* ARGSUSED */
static void
unset_command (args, from_tty)
char *args;
int from_tty;
{
- printf ("\"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, stdout);
}
add_com ("continue", class_run, continue_command,
"Continue program being debugged, after signal or breakpoint.\n\
-If proceeding from breakpoint, a number N may be used as an argument:\n\
-then the same breakpoint won't break until the Nth time it is reached.");
+If proceeding from breakpoint, a number N may be used as an argument,\n\
+which means to set the ignore count of that breakpoint to N - 1 (so that\n\
+the breakpoint won't break until the Nth time it is reached).");
add_com_alias ("c", "cont", class_run, 1);
add_com_alias ("fg", "cont", class_run, 1);
"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\
+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.");
add_com_alias ("r", "run", class_run, 1);