/* GDB CLI commands.
- Copyright (C) 2000-2014 Free Software Foundation, Inc.
+ Copyright (C) 2000-2017 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "exceptions.h"
#include "arch-utils.h"
-#include "dyn-string.h"
#include "readline/readline.h"
#include "readline/tilde.h"
#include "completer.h"
#include "target.h" /* For baud_rate, remote_debug and remote_timeout. */
#include "gdb_wait.h" /* For shell escape implementation. */
#include "gdb_regex.h" /* Used by apropos_command. */
-#include <string.h>
#include "gdb_vfork.h"
#include "linespec.h"
#include "expression.h"
#include "disasm.h"
#include "tracepoint.h"
#include "filestuff.h"
+#include "location.h"
#include "ui-out.h"
#endif
#include <fcntl.h>
+#include <algorithm>
+#include <string>
/* Prototypes for local command functions */
static void make_command (char *, int);
-static void shell_escape (char *, int);
+static void shell_escape (const char *, int);
static void edit_command (char *, int);
none is supplied. */
void
-error_no_arg (char *why)
+error_no_arg (const char *why)
{
error (_("Argument required (%s)."), why);
}
{
printf_unfiltered (_("\"info\" must be followed by "
"the name of an info command.\n"));
- help_list (infolist, "info ", -1, gdb_stdout);
+ help_list (infolist, "info ", all_commands, gdb_stdout);
}
/* The "show" command with no arguments shows all the settings. */
help_cmd (command, gdb_stdout);
}
\f
-/* The "complete" command is used by Emacs to implement completion. */
+/* Note: The "complete" command is used by Emacs to implement completion.
+ [Is that why this function writes output with *_unfiltered?] */
static void
-complete_command (char *arg, int from_tty)
+complete_command (char *arg_entry, int from_tty)
{
+ const char *arg = arg_entry;
int argpoint;
- char *point, *arg_prefix;
+ char *arg_prefix;
VEC (char_ptr) *completions;
dont_repeat ();
+ if (max_completions == 0)
+ {
+ /* Only print this for non-mi frontends. An MI frontend may not
+ be able to handle this. */
+ if (!current_uiout->is_mi_like_p ())
+ {
+ printf_unfiltered (_("max-completions is zero,"
+ " completion is disabled.\n"));
+ }
+ return;
+ }
+
if (arg == NULL)
arg = "";
argpoint = strlen (arg);
within, and except for filenames at the beginning of, the word to
be completed. The following crude imitation of readline's
word-breaking tries to accomodate this. */
- point = arg + argpoint;
+ const char *point = arg + argpoint;
while (point > arg)
{
if (strchr (rl_completer_word_break_characters, point[-1]) != 0)
point--;
}
- arg_prefix = alloca (point - arg + 1);
+ arg_prefix = (char *) alloca (point - arg + 1);
memcpy (arg_prefix, arg, point - arg);
arg_prefix[point - arg] = 0;
xfree (prev);
VEC_free (char_ptr, completions);
+
+ if (size == max_completions)
+ {
+ /* ARG_PREFIX and POINT are included in the output so that emacs
+ will include the message in the output. */
+ printf_unfiltered (_("%s%s %s\n"),
+ arg_prefix, point,
+ get_max_completions_reached_message ());
+ }
}
}
void
quit_command (char *args, int from_tty)
{
+ int exit_code = 0;
+
+ /* An optional expression may be used to cause gdb to terminate with
+ the value of that expression. */
+ if (args)
+ {
+ struct value *val = parse_and_eval (args);
+
+ exit_code = (int) value_as_long (val);
+ }
+
if (!quit_confirm ())
error (_("Not confirmed."));
query_if_trace_running (from_tty);
- quit_force (args, from_tty);
+ quit_force (args ? &exit_code : NULL, from_tty);
}
static void
repeat might be useful but is more likely to be a mistake. */
dont_repeat ();
- if (dir == 0)
- dir = "~";
-
- dir = tilde_expand (dir);
+ dir = tilde_expand (dir != NULL ? dir : "~");
cleanup = make_cleanup (xfree, dir);
if (chdir (dir) < 0)
return 1;
}
-/* Load script FILE, which has already been opened as STREAM. */
+/* Load script FILE, which has already been opened as STREAM.
+ FILE_TO_OPEN is the form of FILE to use if one needs to open the file.
+ This is provided as FILE may have been found via the source search path.
+ An important thing to note here is that FILE may be a symlink to a file
+ with a different or non-existing suffix, and thus one cannot infer the
+ extension language from FILE_TO_OPEN. */
static void
-source_script_from_stream (FILE *stream, const char *file)
+source_script_from_stream (FILE *stream, const char *file,
+ const char *file_to_open)
{
if (script_ext_mode != script_ext_off)
{
= ext_lang_script_sourcer (extlang);
gdb_assert (sourcer != NULL);
- sourcer (extlang, stream, file);
+ sourcer (extlang, stream, file_to_open);
return;
}
else if (script_ext_mode == script_ext_soft)
anyway so that error messages show the actual file used. But only do
this if we (may have) used search_path, as printing the full path in
errors for the non-search case can be more noise than signal. */
- source_script_from_stream (stream, search_path ? full_path : file);
+ source_script_from_stream (stream, file, search_path ? full_path : file);
do_cleanups (old_cleanups);
}
{
struct cleanup *old_cleanups;
char *file = args;
- int *old_source_verbose = xmalloc (sizeof(int));
+ int *old_source_verbose = XNEW (int);
int search_path = 0;
*old_source_verbose = source_verbose;
}
static void
-shell_escape (char *arg, int from_tty)
+shell_escape (const char *arg, int from_tty)
{
#if defined(CANT_FORK) || \
(!defined(HAVE_WORKING_VFORK) && !defined(HAVE_WORKING_FORK))
#endif /* Can fork. */
}
+/* Implementation of the "shell" command. */
+
+static void
+shell_command (char *arg, int from_tty)
+{
+ shell_escape (arg, from_tty);
+}
+
static void
edit_command (char *arg, int from_tty)
{
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct symbol *sym;
- char *arg1;
- char *editor;
+ const char *editor;
char *p;
const char *fn;
}
else
{
- /* Now should only be one argument -- decode it in SAL. */
+ char *arg1;
+ /* Now should only be one argument -- decode it in SAL. */
arg1 = arg;
- sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+ event_location_up location = string_to_event_location (&arg1,
+ current_language);
+ sals = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
+ NULL, NULL, 0);
filter_sals (&sals);
if (! sals.nelts)
error (_("No source file for address %s."),
paddress (get_current_arch (), sal.pc));
- gdbarch = get_objfile_arch (sal.symtab->objfile);
+ gdbarch = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
sym = find_pc_function (sal.pc);
if (sym)
printf_filtered ("%s is in %s (%s:%d).\n",
char *p;
/* Pull in the current default source line if necessary. */
- if (arg == 0 || arg[0] == '+' || arg[0] == '-')
+ if (arg == NULL || ((arg[0] == '+' || arg[0] == '-') && arg[1] == '\0'))
{
set_default_source_symtab_and_line ();
cursal = get_current_source_symtab_and_line ();
- }
- /* "l" or "l +" lists next ten lines. */
+ /* If this is the first "list" since we've set the current
+ source line, center the listing around that line. */
+ if (get_first_line_listed () == 0)
+ {
+ int first;
- if (arg == 0 || strcmp (arg, "+") == 0)
- {
- print_source_lines (cursal.symtab, cursal.line,
- cursal.line + get_lines_to_list (), 0);
- return;
- }
+ first = std::max (cursal.line - get_lines_to_list () / 2, 1);
+
+ /* A small special case --- if listing backwards, and we
+ should list only one line, list the preceding line,
+ instead of the exact line we've just shown after e.g.,
+ stopping for a breakpoint. */
+ if (arg != NULL && arg[0] == '-'
+ && get_lines_to_list () == 1 && first > 1)
+ first -= 1;
+
+ print_source_lines (cursal.symtab, first,
+ first + get_lines_to_list (), 0);
+ }
+
+ /* "l" or "l +" lists next ten lines. */
+ else if (arg == NULL || arg[0] == '+')
+ print_source_lines (cursal.symtab, cursal.line,
+ cursal.line + get_lines_to_list (), 0);
+
+ /* "l -" lists previous ten lines, the ones before the ten just
+ listed. */
+ else if (arg[0] == '-')
+ {
+ if (get_first_line_listed () == 1)
+ error (_("Already at the start of %s."),
+ symtab_to_filename_for_display (cursal.symtab));
+ print_source_lines (cursal.symtab,
+ std::max (get_first_line_listed ()
+ - get_lines_to_list (), 1),
+ get_first_line_listed (), 0);
+ }
- /* "l -" lists previous ten lines, the ones before the ten just
- listed. */
- if (strcmp (arg, "-") == 0)
- {
- print_source_lines (cursal.symtab,
- max (get_first_line_listed ()
- - get_lines_to_list (), 1),
- get_first_line_listed (), 0);
return;
}
dummy_beg = 1;
else
{
- sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+ event_location_up location = string_to_event_location (&arg1,
+ current_language);
+ sals = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
+ NULL, NULL, 0);
filter_sals (&sals);
if (!sals.nelts)
- return; /* C++ */
+ {
+ /* C++ */
+ return;
+ }
if (sals.nelts > 1)
{
ambiguous_line_spec (&sals);
dummy_end = 1;
else
{
+ event_location_up location
+ = string_to_event_location (&arg1, current_language);
if (dummy_beg)
- sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+ sals_end = decode_line_1 (location.get (),
+ DECODE_LINE_LIST_MODE, NULL, NULL, 0);
else
- sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE,
- sal.symtab, sal.line);
+ sals_end = decode_line_1 (location.get (), DECODE_LINE_LIST_MODE,
+ NULL, sal.symtab, sal.line);
+
filter_sals (&sals_end);
if (sals_end.nelts == 0)
return;
error (_("No source file for address %s."),
paddress (get_current_arch (), sal.pc));
- gdbarch = get_objfile_arch (sal.symtab->objfile);
+ gdbarch = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
sym = find_pc_function (sal.pc);
if (sym)
printf_filtered ("%s is in %s (%s:%d).\n",
error (_("No default source file yet. Do \"help list\"."));
if (dummy_beg)
print_source_lines (sal_end.symtab,
- max (sal_end.line - (get_lines_to_list () - 1), 1),
+ std::max (sal_end.line - (get_lines_to_list () - 1), 1),
sal_end.line + 1, 0);
else if (sal.symtab == 0)
error (_("No default source file yet. Do \"help list\"."));
paddress (gdbarch, low), paddress (gdbarch, high));
/* Dump the specified range. */
- gdb_disassembly (gdbarch, current_uiout, 0, flags, -1, low, high);
+ gdb_disassembly (gdbarch, current_uiout, flags, -1, low, high);
printf_filtered ("End of assembler dump.\n");
gdb_flush (gdb_stdout);
/* Dump a specified section of assembly code.
Usage:
- disassemble [/mr]
+ disassemble [/mrs]
- dump the assembly code for the function of the current pc
- disassemble [/mr] addr
+ disassemble [/mrs] addr
- dump the assembly code for the function at ADDR
- disassemble [/mr] low,high
- disassemble [/mr] low,+length
+ disassemble [/mrs] low,high
+ disassemble [/mrs] low,+length
- dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length)
- A /m modifier will include source code with the assembly.
- A /r modifier will include raw instructions in hex with the assembly. */
+ A /m modifier will include source code with the assembly in a
+ "source centric" view. This view lists only the file of the first insn,
+ even if other source files are involved (e.g., inlined functions), and
+ the output is in source order, even with optimized code. This view is
+ considered deprecated as it hasn't been useful in practice.
+
+ A /r modifier will include raw instructions in hex with the assembly.
+
+ A /s modifier will include source code with the assembly, like /m, with
+ two important differences:
+ 1) The output is still in pc address order.
+ 2) File names and contents for all relevant source files are displayed. */
static void
disassemble_command (char *arg, int from_tty)
switch (*p++)
{
case 'm':
- flags |= DISASSEMBLY_SOURCE;
+ flags |= DISASSEMBLY_SOURCE_DEPRECATED;
break;
case 'r':
flags |= DISASSEMBLY_RAW_INSN;
break;
+ case 's':
+ flags |= DISASSEMBLY_SOURCE;
+ break;
default:
error (_("Invalid disassembly modifier."));
}
p = skip_spaces_const (p);
}
+ if ((flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
+ == (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
+ error (_("Cannot specify both /m and /s."));
+
if (! p || ! *p)
{
flags |= DISASSEMBLY_OMIT_FNAME;
static void
make_command (char *arg, int from_tty)
{
- char *p;
-
if (arg == 0)
- p = "make";
+ shell_escape ("make", from_tty);
else
{
- p = xmalloc (sizeof ("make ") + strlen (arg));
- strcpy (p, "make ");
- strcpy (p + sizeof ("make ") - 1, arg);
- }
+ std::string cmd = std::string ("make ") + arg;
- shell_escape (p, from_tty);
+ shell_escape (cmd.c_str (), from_tty);
+ }
}
static void
const char *comname = args;
c = lookup_cmd (&comname, cmdlist, "", 0, 1);
- /* c->user_commands would be NULL if it's a python command. */
- if (c->class != class_user || !c->user_commands)
+ if (!cli_user_command_p (c))
error (_("Not a user command."));
show_user_1 (c, "", args, gdb_stdout);
}
{
for (c = cmdlist; c; c = c->next)
{
- if (c->class == class_user || c->prefixlist != NULL)
+ if (cli_user_command_p (c) || c->prefixlist != NULL)
show_user_1 (c, "", c->name, gdb_stdout);
}
}
static void
apropos_command (char *searchstr, int from_tty)
{
- regex_t pattern;
- int code;
-
if (searchstr == NULL)
error (_("REGEXP string is empty"));
- code = regcomp (&pattern, searchstr, REG_ICASE);
- if (code == 0)
- {
- struct cleanup *cleanups;
-
- cleanups = make_regfree_cleanup (&pattern);
- apropos_cmd (gdb_stdout, cmdlist, &pattern, "");
- do_cleanups (cleanups);
- }
- else
- {
- char *err = get_regcomp_error (code, &pattern);
+ compiled_regex pattern (searchstr, REG_ICASE,
+ _("Error in regular expression"));
- make_cleanup (xfree, err);
- error (_("Error in regular expression: %s"), err);
- }
+ apropos_cmd (gdb_stdout, cmdlist, pattern, "");
}
/* Subroutine of alias_command to simplify it.
This does not take care of quoting elements in case they contain spaces
on purpose. */
-static dyn_string_t
-argv_to_dyn_string (char **argv, int n)
+static std::string
+argv_to_string (char **argv, int n)
{
int i;
- dyn_string_t result = dyn_string_new (10);
+ std::string result;
gdb_assert (argv != NULL);
gdb_assert (n >= 0 && n <= countargv (argv));
for (i = 0; i < n; ++i)
{
if (i > 0)
- dyn_string_append_char (result, ' ');
- dyn_string_append_cstr (result, argv[i]);
+ result += " ";
+ result += argv[i];
}
return result;
return *command == '\0';
}
+/* Called when "alias" was incorrectly used. */
+
+static void
+alias_usage_error (void)
+{
+ error (_("Usage: alias [-a] [--] ALIAS = COMMAND"));
+}
+
/* Make an alias of an existing command. */
static void
{
int i, alias_argc, command_argc;
int abbrev_flag = 0;
- char *args2, *equals, *alias, *command;
+ char *args2, *equals;
+ const char *alias, *command;
char **alias_argv, **command_argv;
- dyn_string_t alias_dyn_string, command_dyn_string;
struct cleanup *cleanup;
- static const char usage[] = N_("Usage: alias [-a] [--] ALIAS = COMMAND");
if (args == NULL || strchr (args, '=') == NULL)
- error (_(usage));
+ alias_usage_error ();
args2 = xstrdup (args);
cleanup = make_cleanup (xfree, args2);
if (alias_argv[0] == NULL || command_argv[0] == NULL
|| *alias_argv[0] == '\0' || *command_argv[0] == '\0')
- error (_(usage));
+ alias_usage_error ();
for (i = 0; alias_argv[i] != NULL; ++i)
{
/* COMMAND must exist.
Reconstruct the command to remove any extraneous spaces,
for better error messages. */
- command_dyn_string = argv_to_dyn_string (command_argv, command_argc);
- make_cleanup_dyn_string_delete (command_dyn_string);
- command = dyn_string_buf (command_dyn_string);
+ std::string command_string (argv_to_string (command_argv, command_argc));
+ command = command_string.c_str ();
if (! valid_command_p (command))
error (_("Invalid command to alias to: %s"), command);
/* ALIAS must not exist. */
- alias_dyn_string = argv_to_dyn_string (alias_argv, alias_argc);
- make_cleanup_dyn_string_delete (alias_dyn_string);
- alias = dyn_string_buf (alias_dyn_string);
+ std::string alias_string (argv_to_string (alias_argv, alias_argc));
+ alias = alias_string.c_str ();
if (valid_command_p (alias))
error (_("Alias already exists: %s"), alias);
}
else
{
- dyn_string_t alias_prefix_dyn_string, command_prefix_dyn_string;
const char *alias_prefix, *command_prefix;
struct cmd_list_element *c_alias, *c_command;
/* Create copies of ALIAS and COMMAND without the last word,
and use that to verify the leading elements match. */
- alias_prefix_dyn_string =
- argv_to_dyn_string (alias_argv, alias_argc - 1);
- make_cleanup_dyn_string_delete (alias_prefix_dyn_string);
- command_prefix_dyn_string =
- argv_to_dyn_string (alias_argv, command_argc - 1);
- make_cleanup_dyn_string_delete (command_prefix_dyn_string);
- alias_prefix = dyn_string_buf (alias_prefix_dyn_string);
- command_prefix = dyn_string_buf (command_prefix_dyn_string);
+ std::string alias_prefix_string (argv_to_string (alias_argv,
+ alias_argc - 1));
+ std::string command_prefix_string (argv_to_string (alias_argv,
+ command_argc - 1));
+ alias_prefix = alias_prefix_string.c_str ();
+ command_prefix = command_prefix_string.c_str ();
c_command = lookup_cmd_1 (& command_prefix, cmdlist, NULL, 1);
/* We've already tried to look up COMMAND. */
static int
compare_symtabs (const void *a, const void *b)
{
- const struct symtab_and_line *sala = a;
- const struct symtab_and_line *salb = b;
+ const struct symtab_and_line *sala = (const struct symtab_and_line *) a;
+ const struct symtab_and_line *salb = (const struct symtab_and_line *) b;
+ const char *dira = SYMTAB_DIRNAME (sala->symtab);
+ const char *dirb = SYMTAB_DIRNAME (salb->symtab);
int r;
- if (!sala->symtab->dirname)
+ if (dira == NULL)
{
- if (salb->symtab->dirname)
+ if (dirb != NULL)
return -1;
}
- else if (!salb->symtab->dirname)
+ else if (dirb == NULL)
{
- if (sala->symtab->dirname)
+ if (dira != NULL)
return 1;
}
else
{
- r = filename_cmp (sala->symtab->dirname, salb->symtab->dirname);
+ r = filename_cmp (dira, dirb);
if (r)
return r;
}
{
printf_unfiltered (_("\"set debug\" must be followed by "
"the name of a debug subcommand.\n"));
- help_list (setdebuglist, "set debug ", -1, gdb_stdout);
+ help_list (setdebuglist, "set debug ", all_commands, gdb_stdout);
}
static void
show_script_ext_mode,
&setlist, &showlist);
- add_com ("quit", class_support, quit_command, _("Exit gdb."));
+ add_com ("quit", class_support, quit_command, _("\
+Exit gdb.\n\
+Usage: quit [EXPR]\n\
+The optional expression EXPR, if present, is evaluated and the result\n\
+used as GDB's exit code. The default is zero."));
c = add_com ("help", class_support, help_command,
_("Print list of commands."));
set_cmd_completer (c, command_completer);
_("Generic command for showing gdb debugging flags"),
&showdebuglist, "show debug ", 0, &showlist);
- c = add_com ("shell", class_support, shell_escape, _("\
+ c = add_com ("shell", class_support, shell_command, _("\
Execute the rest of the line as a shell command.\n\
With no arguments, run an inferior shell."));
set_cmd_completer (c, filename_completer);
FUNCTION, to list around beginning of that function,\n\
FILE:FUNCTION, to distinguish among like-named static functions.\n\
*ADDRESS, to list around the line containing that address.\n\
-With two args if one is empty it stands for ten lines away from \
-the other arg."));
+With two args, if one is empty, it stands for ten lines away from\n\
+the other arg.\n\
+\n\
+By default, when a single location is given, display ten lines.\n\
+This can be changed using \"set listsize\", and the current value\n\
+can be shown using \"show listsize\"."));
- if (!xdb_commands)
- add_com_alias ("l", "list", class_files, 1);
- else
- add_com_alias ("v", "list", class_files, 1);
+ add_com_alias ("l", "list", class_files, 1);
if (dbx_commands)
add_com_alias ("file", "list", class_files, 1);
c = add_com ("disassemble", class_vars, disassemble_command, _("\
Disassemble a specified section of memory.\n\
Default is the function surrounding the pc of the selected frame.\n\
+\n\
With a /m modifier, source lines are included (if available).\n\
+This view is \"source centric\": the output is in source line order,\n\
+regardless of any optimization that is present. Only the main source file\n\
+is displayed, not those of, e.g., any inlined functions.\n\
+This modifier hasn't proved useful in practice and is deprecated\n\
+in favor of /s.\n\
+\n\
+With a /s modifier, source lines are included (if available).\n\
+This differs from /m in two important respects:\n\
+- the output is still in pc address order, and\n\
+- file names and contents for all relevant source files are displayed.\n\
+\n\
With a /r modifier, raw instructions in hex are included.\n\
+\n\
With a single argument, the function surrounding that address is dumped.\n\
Two arguments (separated by a comma) are taken as a range of memory to dump,\n\
in the form of \"start,end\", or \"start,+length\".\n\
So, for example, if you want to disassemble function bar in file foo.c\n\
you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
set_cmd_completer (c, location_completer);
- if (xdb_commands)
- add_com_alias ("va", "disassemble", class_xdb, 0);
add_com_alias ("!", "shell", class_support, 0);
Run the ``make'' program using the rest of the line as arguments."));
set_cmd_completer (c, filename_completer);
add_cmd ("user", no_class, show_user, _("\
-Show definitions of non-python user defined commands.\n\
+Show definitions of non-python/scheme user defined commands.\n\
Argument is the name of the user defined command.\n\
With no argument, show definitions of all user defined commands."), &showlist);
add_com ("apropos", class_support, apropos_command,
add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
&max_user_call_depth, _("\
-Set the max call depth for non-python user-defined commands."), _("\
-Show the max call depth for non-python user-defined commands."), NULL,
+Set the max call depth for non-python/scheme user-defined commands."), _("\
+Show the max call depth for non-python/scheme user-defined commands."), NULL,
NULL,
show_max_user_call_depth,
&setlist, &showlist);