/* GDB CLI commands.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
- 2011 Free Software Foundation, Inc.
+ Copyright (C) 2000-2005, 2007-2012 Free Software Foundation, Inc.
This file is part of GDB.
#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"
/* Prototypes for local utility functions */
static void ambiguous_line_spec (struct symtabs_and_lines *);
+
+static void filter_sals (struct symtabs_and_lines *);
+
\f
/* Limit the call depth of user-defined commands */
-int max_user_call_depth;
+unsigned int max_user_call_depth;
/* Define all cmd_list_elements. */
struct cmd_list_element *killlist;
-/* Chain containing all defined "enable breakpoint" subcommands. */
-
-struct cmd_list_element *enablebreaklist;
-
/* Chain containing all defined set subcommands */
struct cmd_list_element *setlist;
static const char script_ext_soft[] = "soft";
static const char script_ext_strict[] = "strict";
-static const char *script_ext_enums[] = {
+static const char *const script_ext_enums[] = {
script_ext_off,
script_ext_soft,
script_ext_strict,
help_cmd (command, gdb_stdout);
}
\f
-/* String compare function for qsort. */
-static int
-compare_strings (const void *arg1, const void *arg2)
-{
- const char **s1 = (const char **) arg1;
- const char **s2 = (const char **) arg2;
-
- return strcmp (*s1, *s2);
-}
-
/* The "complete" command is used by Emacs to implement completion. */
static void
complete_command (char *arg, int from_tty)
{
int argpoint;
- char **completions, *point, *arg_prefix;
+ char *point, *arg_prefix;
+ VEC (char_ptr) *completions;
dont_repeat ();
if (completions)
{
- int item, size;
+ int ix, size = VEC_length (char_ptr, completions);
+ char *item, *prev = NULL;
- for (size = 0; completions[size]; ++size)
- ;
- qsort (completions, size, sizeof (char *), compare_strings);
+ qsort (VEC_address (char_ptr, completions), size,
+ sizeof (char *), compare_strings);
/* We do extra processing here since we only want to print each
unique item once. */
- item = 0;
- while (item < size)
+ for (ix = 0; VEC_iterate (char_ptr, completions, ix, item); ++ix)
{
int next_item;
- printf_unfiltered ("%s%s\n", arg_prefix, completions[item]);
- next_item = item + 1;
- while (next_item < size
- && ! strcmp (completions[item], completions[next_item]))
+ if (prev == NULL || strcmp (item, prev) != 0)
{
- xfree (completions[next_item]);
- ++next_item;
+ printf_unfiltered ("%s%s\n", arg_prefix, item);
+ xfree (prev);
+ prev = item;
}
-
- xfree (completions[item]);
- item = next_item;
+ else
+ xfree (item);
}
- xfree (completions);
+ xfree (prev);
+ VEC_free (char_ptr, completions);
}
}
static void
show_version (char *args, int from_tty)
{
- immediate_quit++;
print_gdb_version (gdb_stdout);
printf_filtered ("\n");
- immediate_quit--;
}
/* Handle the quit command. */
dont_repeat ();
if (dir == 0)
- error_no_arg (_("new working directory"));
+ dir = "~";
dir = tilde_expand (dir);
make_cleanup (xfree, dir);
{
if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.'
&& (p[2] == 0 || IS_DIR_SEPARATOR (p[2])))
- strcpy (p, p + 2);
+ memmove (p, p + 2, strlen (p + 2) + 1);
else if (IS_DIR_SEPARATOR (p[0]) && p[1] == '.' && p[2] == '.'
&& (p[3] == 0 || IS_DIR_SEPARATOR (p[3])))
{
++p;
else
{
- strcpy (q - 1, p + 3);
+ memmove (q - 1, p + 3, strlen (p + 3) + 1);
p = q - 1;
}
}
do_cleanups (old_cleanups);
*streamp = fdopen (fd, FOPEN_RT);
+ if (*streamp == NULL)
+ {
+ int save_errno = errno;
+
+ close (fd);
+ if (full_pathp)
+ xfree (*full_pathp);
+ errno = save_errno;
+ return 0;
+ }
+
return 1;
}
-/* Load script FILE, which has already been opened as STREAM.
- STREAM is closed before we return. */
+/* Load script FILE, which has already been opened as STREAM. */
static void
source_script_from_stream (FILE *stream, const char *file)
else
{
/* Nope, just punt. */
- fclose (stream);
throw_exception (e);
}
}
- else
- fclose (stream);
}
else
script_from_file (stream, file);
if (!find_and_open_script (file, search_path, &stream, &full_path))
{
- /* The script wasn't found, or was otherwise inaccessible.
+ /* The script wasn't found, or was otherwise inaccessible.
If the source command was invoked interactively, throw an
error. Otherwise (e.g. if it was invoked by a script),
silently ignore the error. */
}
old_cleanups = make_cleanup (xfree, full_path);
- source_script_from_stream (stream, file);
+ make_cleanup_fclose (stream);
+ /* The python support reopens the file, so we need to pass full_path here
+ in case the file was found on the search path. It's useful to do this
+ 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);
do_cleanups (old_cleanups);
}
chdir (current_directory);
#endif
#else /* Can fork. */
- int rc, status, pid;
+ int status, pid;
if ((pid = vfork ()) == 0)
{
}
if (pid != -1)
- while ((rc = wait (&status)) != pid && rc != -1)
- ;
+ waitpid (pid, &status, 0);
else
error (_("Fork failed"));
#endif /* Can fork. */
struct symbol *sym;
char *arg1;
char *editor;
- char *p, *fn;
+ char *p;
+ const char *fn;
/* Pull in the current default source line if necessary. */
if (arg == 0)
/* Now should only be one argument -- decode it in SAL. */
arg1 = arg;
- sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
+ sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+ filter_sals (&sals);
if (! sals.nelts)
{
/* C++ */
dummy_beg = 1;
else
{
- sals = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
+ sals = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
+ filter_sals (&sals);
if (!sals.nelts)
return; /* C++ */
if (sals.nelts > 1)
else
{
if (dummy_beg)
- sals_end = decode_line_1 (&arg1, 0, 0, 0, 0, 0);
+ sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE, 0, 0);
else
- sals_end = decode_line_1 (&arg1, 0, sal.symtab, sal.line, 0, 0);
+ sals_end = decode_line_1 (&arg1, DECODE_LINE_LIST_MODE,
+ sal.symtab, sal.line);
+ filter_sals (&sals_end);
if (sals_end.nelts == 0)
return;
if (sals_end.nelts > 1)
paddress (gdbarch, low), paddress (gdbarch, high));
/* Dump the specified range. */
- gdb_disassembly (gdbarch, uiout, 0, flags, -1, low, high);
+ gdb_disassembly (gdbarch, current_uiout, 0, flags, -1, low, high);
printf_filtered ("End of assembler dump.\n");
gdb_flush (gdb_stdout);
struct frame_info *frame;
struct gdbarch *gdbarch;
CORE_ADDR low, high, pc;
- char *name;
+ const char *name;
frame = get_selected_frame (_("No frame selected."));
gdbarch = get_frame_arch (frame);
- pc = get_frame_pc (frame);
+ pc = get_frame_address_in_block (frame);
if (find_pc_partial_function (pc, &name, &low, &high) == 0)
error (_("No function contains program counter for selected frame."));
#if defined(TUI)
{
struct gdbarch *gdbarch = get_current_arch ();
CORE_ADDR low, high;
- char *name;
+ const char *name;
CORE_ADDR pc;
int flags;
char *comname = args;
c = lookup_cmd (&comname, cmdlist, "", 0, 1);
- if (c->class != class_user)
+ /* c->user_commands would be NULL if it's a python command. */
+ if (c->class != class_user || !c->user_commands)
error (_("Not a user command."));
show_user_1 (c, "", args, gdb_stdout);
}
error (_("Error in regular expression: %s"), err);
}
}
+
+/* Subroutine of alias_command to simplify it.
+ Return the first N elements of ARGV flattened back to a string
+ with a space separating each element.
+ ARGV may not be NULL.
+ 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)
+{
+ int i;
+ dyn_string_t result = dyn_string_new (10);
+
+ 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]);
+ }
+
+ return result;
+}
+
+/* Subroutine of alias_command to simplify it.
+ Return TRUE if COMMAND exists, unambiguously. Otherwise FALSE. */
+
+static int
+valid_command_p (char *command)
+{
+ struct cmd_list_element *c;
+
+ c = lookup_cmd_1 (& command, cmdlist, NULL, 1);
+
+ if (c == NULL || c == (struct cmd_list_element *) -1)
+ return FALSE;
+
+ /* This is the slightly tricky part.
+ lookup_cmd_1 will return a pointer to the last part of COMMAND
+ to match, leaving COMMAND pointing at the remainder. */
+ while (*command == ' ' || *command == '\t')
+ ++command;
+ return *command == '\0';
+}
+
+/* Make an alias of an existing command. */
+
+static void
+alias_command (char *args, int from_tty)
+{
+ int i, alias_argc, command_argc;
+ int abbrev_flag = 0;
+ char *args2, *equals, *alias, *command;
+ char **alias_argv, **command_argv;
+ dyn_string_t alias_dyn_string, command_dyn_string;
+ struct cmd_list_element *c;
+ static const char usage[] = N_("Usage: alias [-a] [--] ALIAS = COMMAND");
+
+ if (args == NULL || strchr (args, '=') == NULL)
+ error (_(usage));
+
+ args2 = xstrdup (args);
+ make_cleanup (xfree, args2);
+ equals = strchr (args2, '=');
+ *equals = '\0';
+ alias_argv = gdb_buildargv (args2);
+ make_cleanup_freeargv (alias_argv);
+ command_argv = gdb_buildargv (equals + 1);
+ make_cleanup_freeargv (command_argv);
+
+ for (i = 0; alias_argv[i] != NULL; )
+ {
+ if (strcmp (alias_argv[i], "-a") == 0)
+ {
+ ++alias_argv;
+ abbrev_flag = 1;
+ }
+ else if (strcmp (alias_argv[i], "--") == 0)
+ {
+ ++alias_argv;
+ break;
+ }
+ else
+ break;
+ }
+
+ if (alias_argv[0] == NULL || command_argv[0] == NULL
+ || *alias_argv[0] == '\0' || *command_argv[0] == '\0')
+ error (_(usage));
+
+ for (i = 0; alias_argv[i] != NULL; ++i)
+ {
+ if (! valid_user_defined_cmd_name_p (alias_argv[i]))
+ {
+ if (i == 0)
+ error (_("Invalid command name: %s"), alias_argv[i]);
+ else
+ error (_("Invalid command element name: %s"), alias_argv[i]);
+ }
+ }
+
+ alias_argc = countargv (alias_argv);
+ command_argc = countargv (command_argv);
+
+ /* 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);
+ 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);
+ if (valid_command_p (alias))
+ error (_("Alias already exists: %s"), alias);
+
+ /* If ALIAS is one word, it is an alias for the entire COMMAND.
+ Example: alias spe = set print elements
+
+ Otherwise ALIAS and COMMAND must have the same number of words,
+ and every word except the last must match; and the last word of
+ ALIAS is made an alias of the last word of COMMAND.
+ Example: alias set print elms = set pr elem
+ Note that unambiguous abbreviations are allowed. */
+
+ if (alias_argc == 1)
+ {
+ /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
+ add_com_alias (xstrdup (alias_argv[0]), command, class_alias,
+ abbrev_flag);
+ }
+ else
+ {
+ dyn_string_t alias_prefix_dyn_string, command_prefix_dyn_string;
+ char *alias_prefix, *command_prefix;
+ struct cmd_list_element *c_alias, *c_command;
+
+ if (alias_argc != command_argc)
+ error (_("Mismatched command length between ALIAS and 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);
+
+ c_command = lookup_cmd_1 (& command_prefix, cmdlist, NULL, 1);
+ /* We've already tried to look up COMMAND. */
+ gdb_assert (c_command != NULL
+ && c_command != (struct cmd_list_element *) -1);
+ gdb_assert (c_command->prefixlist != NULL);
+ c_alias = lookup_cmd_1 (& alias_prefix, cmdlist, NULL, 1);
+ if (c_alias != c_command)
+ error (_("ALIAS and COMMAND prefixes do not match."));
+
+ /* add_cmd requires *we* allocate space for name, hence the xstrdup. */
+ add_alias_cmd (xstrdup (alias_argv[alias_argc - 1]),
+ command_argv[command_argc - 1],
+ class_alias, abbrev_flag, c_command->prefixlist);
+ }
+}
\f
/* Print a list of files and line numbers which a user may choose from
in order to list a function which was specified ambiguously (as
sals->sals[i].symtab->filename, sals->sals[i].line);
}
+/* Sort function for filter_sals. */
+
+static int
+compare_symtabs (const void *a, const void *b)
+{
+ const struct symtab_and_line *sala = a;
+ const struct symtab_and_line *salb = b;
+ int r;
+
+ if (!sala->symtab->dirname)
+ {
+ if (salb->symtab->dirname)
+ return -1;
+ }
+ else if (!salb->symtab->dirname)
+ {
+ if (sala->symtab->dirname)
+ return 1;
+ }
+ else
+ {
+ r = filename_cmp (sala->symtab->dirname, salb->symtab->dirname);
+ if (r)
+ return r;
+ }
+
+ r = filename_cmp (sala->symtab->filename, salb->symtab->filename);
+ if (r)
+ return r;
+
+ if (sala->line < salb->line)
+ return -1;
+ return sala->line == salb->line ? 0 : 1;
+}
+
+/* Remove any SALs that do not match the current program space, or
+ which appear to be "file:line" duplicates. */
+
+static void
+filter_sals (struct symtabs_and_lines *sals)
+{
+ int i, out, prev;
+
+ out = 0;
+ for (i = 0; i < sals->nelts; ++i)
+ {
+ if (sals->sals[i].pspace == current_program_space
+ && sals->sals[i].symtab != NULL)
+ {
+ sals->sals[out] = sals->sals[i];
+ ++out;
+ }
+ }
+ sals->nelts = out;
+
+ qsort (sals->sals, sals->nelts, sizeof (struct symtab_and_line),
+ compare_symtabs);
+
+ out = 1;
+ prev = 0;
+ for (i = 1; i < sals->nelts; ++i)
+ {
+ if (compare_symtabs (&sals->sals[prev], &sals->sals[i]))
+ {
+ /* Symtabs differ. */
+ sals->sals[out] = sals->sals[i];
+ prev = out;
+ ++out;
+ }
+ }
+
+ if (sals->nelts == 0)
+ {
+ xfree (sals->sals);
+ sals->sals = NULL;
+ }
+ else
+ sals->nelts = out;
+}
+
static void
set_debug (char *arg, int from_tty)
{
stoplist = NULL;
deletelist = NULL;
detachlist = NULL;
- enablebreaklist = NULL;
setlist = NULL;
unsetlist = NULL;
showlist = NULL;
}
\f
+
+initialize_file_ftype _initialize_cli_cmds;
+
void
-init_cli_cmds (void)
+_initialize_cli_cmds (void)
{
struct cmd_list_element *c;
- char *source_help_text;
/* Define the classes of commands.
- They will appear in the help list in the reverse of this order. */
+ They will appear in the help list in alphabetical order. */
add_cmd ("internals", class_maintenance, NULL, _("\
Maintenance commands.\n\
Use the \"document\" command to give documentation for the new command.\n\
Commands defined in this way may have up to ten arguments."));
- source_help_text = xstrprintf (_("\
-Read commands from a file named FILE.\n\
-\n\
-Usage: source [-s] [-v] FILE\n\
--s: search for the script in the source search path,\n\
- even if FILE contains directories.\n\
--v: each command in FILE is echoed as it is executed.\n\
-\n\
-Note that the file \"%s\" is read automatically in this way\n\
-when GDB is started."), gdbinit);
- c = add_cmd ("source", class_support, source_command,
- source_help_text, &cmdlist);
- set_cmd_completer (c, filename_completer);
-
add_setshow_enum_cmd ("script-extension", class_support,
script_ext_enums, &script_ext_mode, _("\
Set mode for script filename extension recognition."), _("\
show_remote_debug,
&setdebuglist, &showdebuglist);
- add_setshow_integer_cmd ("remotetimeout", no_class, &remote_timeout, _("\
+ add_setshow_zuinteger_unlimited_cmd ("remotetimeout", no_class,
+ &remote_timeout, _("\
Set timeout limit to wait for target to respond."), _("\
Show timeout limit to wait for target to respond."), _("\
This value is used to set the time limit for gdb to wait for a response\n\
from the target."),
- NULL,
- show_remote_timeout,
- &setlist, &showlist);
+ NULL,
+ show_remote_timeout,
+ &setlist, &showlist);
add_prefix_cmd ("debug", no_class, set_debug,
_("Generic command for setting gdb debugging flags"),
if (xdb_commands)
add_com_alias ("va", "disassemble", class_xdb, 0);
- /* NOTE: cagney/2000-03-20: Being able to enter ``(gdb) !ls'' would
- be a really useful feature. Unfortunately, the below wont do
- this. Instead it adds support for the form ``(gdb) ! ls''
- (i.e. the space is required). If the ``!'' command below is
- added the complains about no ``!'' command would be replaced by
- complains about how the ``!'' command is broken :-) */
- if (xdb_commands)
- add_com_alias ("!", "shell", class_support, 0);
+ add_com_alias ("!", "shell", class_support, 0);
c = add_com ("make", class_support, make_command, _("\
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 user defined commands.\n\
+Show definitions of non-python 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,
_("Search for commands matching a REGEXP"));
- add_setshow_integer_cmd ("max-user-call-depth", no_class,
+ add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
&max_user_call_depth, _("\
-Set the max call depth for user-defined commands."), _("\
-Show the max call depth for user-defined commands."), NULL,
- NULL,
- show_max_user_call_depth,
- &setlist, &showlist);
+Set the max call depth for non-python user-defined commands."), _("\
+Show the max call depth for non-python user-defined commands."), NULL,
+ NULL,
+ show_max_user_call_depth,
+ &setlist, &showlist);
add_setshow_boolean_cmd ("trace-commands", no_class, &trace_commands, _("\
Set tracing of GDB CLI commands."), _("\
NULL,
NULL,
&setlist, &showlist);
+
+ c = add_com ("alias", class_support, alias_command, _("\
+Define a new command that is an alias of an existing command.\n\
+Usage: alias [-a] [--] ALIAS = COMMAND\n\
+ALIAS is the name of the alias command to create.\n\
+COMMAND is the command being aliased to.\n\
+If \"-a\" is specified, the command is an abbreviation,\n\
+and will not appear in help command list output.\n\
+\n\
+Examples:\n\
+Make \"spe\" an alias of \"set print elements\":\n\
+ alias spe = set print elements\n\
+Make \"elms\" an alias of \"elements\" in the \"set print\" command:\n\
+ alias -a set print elms = set print elements"));
+}
+
+void
+init_cli_cmds (void)
+{
+ struct cmd_list_element *c;
+ char *source_help_text;
+
+ source_help_text = xstrprintf (_("\
+Read commands from a file named FILE.\n\
+\n\
+Usage: source [-s] [-v] FILE\n\
+-s: search for the script in the source search path,\n\
+ even if FILE contains directories.\n\
+-v: each command in FILE is echoed as it is executed.\n\
+\n\
+Note that the file \"%s\" is read automatically in this way\n\
+when GDB is started."), gdbinit);
+ c = add_cmd ("source", class_support, source_command,
+ source_help_text, &cmdlist);
+ set_cmd_completer (c, filename_completer);
}