/* GDB CLI commands.
- Copyright (C) 2000-2017 Free Software Foundation, Inc.
+ Copyright (C) 2000-2019 Free Software Foundation, Inc.
This file is part of GDB.
#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 "common/gdb_wait.h" /* For shell escape implementation. */
+#include "gdbcmd.h"
#include "gdb_regex.h" /* Used by apropos_command. */
#include "gdb_vfork.h"
#include "linespec.h"
#include "source.h"
#include "disasm.h"
#include "tracepoint.h"
-#include "filestuff.h"
+#include "common/filestuff.h"
#include "location.h"
+#include "block.h"
#include "ui-out.h"
+#include "interps.h"
#include "top.h"
#include "cli/cli-decode.h"
#include "cli/cli-utils.h"
#include "extension.h"
+#include "common/pathstuff.h"
#ifdef TUI
#include "tui/tui.h" /* For tui_active et.al. */
#include <algorithm>
#include <string>
-/* Prototypes for local command functions */
-
-static void complete_command (char *, int);
-
-static void echo_command (char *, int);
-
-static void pwd_command (char *, int);
-
-static void help_command (char *, int);
-
-static void make_command (char *, int);
-
-static void shell_escape (const char *, int);
-
-static void edit_command (char *, int);
-
-static void list_command (char *, int);
-
/* Prototypes for local utility functions */
static void print_sal_location (const symtab_and_line &sal);
cmd_show_list (showlist, from_tty, "");
}
-/* A temporary non-const overload of show_command. */
-
-static void
-show_command (char *arg, int from_tty)
-{
- cmd_show_list (showlist, from_tty, "");
-}
-
\f
/* Provide documentation on command or list given by COMMAND. FROM_TTY
is ignored. */
static void
-help_command (char *command, int from_tty)
+help_command (const char *command, int from_tty)
{
help_cmd (command, gdb_stdout);
}
[Is that why this function writes output with *_unfiltered?] */
static void
-complete_command (char *arg_entry, int from_tty)
+complete_command (const char *arg, int from_tty)
{
- const char *arg = arg_entry;
-
dont_repeat ();
if (max_completions == 0)
if (arg == NULL)
arg = "";
- completion_tracker tracker_handle_brkchars;
- completion_tracker tracker_handle_completions;
- completion_tracker *tracker;
-
int quote_char = '\0';
const char *word;
- TRY
- {
- word = completion_find_completion_word (tracker_handle_brkchars,
- arg, "e_char);
-
- /* Completers that provide a custom word point in the
- handle_brkchars phase also compute their completions then.
- Completers that leave the completion word handling to readline
- must be called twice. */
- if (tracker_handle_brkchars.use_custom_word_point ())
- tracker = &tracker_handle_brkchars;
- else
- {
- complete_line (tracker_handle_completions, word, arg, strlen (arg));
- tracker = &tracker_handle_completions;
- }
- }
- CATCH (ex, RETURN_MASK_ALL)
- {
- return;
- }
- END_CATCH
-
- std::string arg_prefix (arg, word - arg);
-
- completion_result result
- = tracker->build_completion_result (word, word - arg, strlen (arg));
+ completion_result result = complete (arg, &word, "e_char);
if (result.number_matches != 0)
{
+ std::string arg_prefix (arg, word - arg);
+
if (result.number_matches == 1)
printf_unfiltered ("%s%s\n", arg_prefix.c_str (), result.match_list[0]);
else
static void
show_version (const char *args, int from_tty)
{
- print_gdb_version (gdb_stdout);
+ print_gdb_version (gdb_stdout, true);
printf_filtered ("\n");
}
/* Handle the quit command. */
void
-quit_command (char *args, int from_tty)
+quit_command (const char *args, int from_tty)
{
int exit_code = 0;
}
static void
-pwd_command (char *args, int from_tty)
+pwd_command (const char *args, int from_tty)
{
if (args)
error (_("The \"pwd\" command does not take an argument: %s"), args);
find_and_open_script (const char *script_file, int search_path)
{
int fd;
- int search_flags = OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH;
+ openp_flags search_flags = OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH;
gdb::optional<open_script> opened;
gdb::unique_xmalloc_ptr<char> file (tilde_expand (script_file));
/* Search for and open 'file' on the search path used for source
files. Put the full location in *FULL_PATHP. */
- char *temp_path;
+ gdb::unique_xmalloc_ptr<char> full_path;
fd = openp (source_path, search_flags,
- file.get (), O_RDONLY, &temp_path);
- gdb::unique_xmalloc_ptr<char> full_path (temp_path);
+ file.get (), O_RDONLY, &full_path);
if (fd == -1)
return opened;
static void
-echo_command (char *text, int from_tty)
+echo_command (const char *text, int from_tty)
{
const char *p = text;
int c;
printf_filtered ("%c", c);
}
+ reset_terminal_style (gdb_stdout);
+
/* Force this output to appear now. */
wrap_here ("");
gdb_flush (gdb_stdout);
}
+/* Sets the last launched shell command convenience variables based on
+ EXIT_STATUS. */
+
+static void
+exit_status_set_internal_vars (int exit_status)
+{
+ struct internalvar *var_code = lookup_internalvar ("_shell_exitcode");
+ struct internalvar *var_signal = lookup_internalvar ("_shell_exitsignal");
+
+ clear_internalvar (var_code);
+ clear_internalvar (var_signal);
+ if (WIFEXITED (exit_status))
+ set_internalvar_integer (var_code, WEXITSTATUS (exit_status));
+ else if (WIFSIGNALED (exit_status))
+ set_internalvar_integer (var_signal, WTERMSIG (exit_status));
+ else
+ warning (_("unexpected shell command exit status %d"), exit_status);
+}
+
static void
shell_escape (const char *arg, int from_tty)
{
arg = "inferior shell";
if (rc == -1)
- {
- fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
- safe_strerror (errno));
- gdb_flush (gdb_stderr);
- }
+ fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", arg,
+ safe_strerror (errno));
else if (rc)
- {
- fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
- gdb_flush (gdb_stderr);
- }
+ fprintf_unfiltered (gdb_stderr, "%s exited with status %d\n", arg, rc);
#ifdef GLOBAL_CURDIR
/* Make sure to return to the directory GDB thinks it is, in case
the shell command we just ran changed it. */
chdir (current_directory);
+ exit_status_set_internal_vars (rc);
#endif
#else /* Can fork. */
int status, pid;
if ((pid = vfork ()) == 0)
{
- const char *p, *user_shell;
+ const char *p, *user_shell = get_shell ();
close_most_fds ();
- if ((user_shell = (char *) getenv ("SHELL")) == NULL)
- user_shell = "/bin/sh";
-
/* Get the name of the shell for arg0. */
p = lbasename (user_shell);
fprintf_unfiltered (gdb_stderr, "Cannot execute %s: %s\n", user_shell,
safe_strerror (errno));
- gdb_flush (gdb_stderr);
_exit (0177);
}
waitpid (pid, &status, 0);
else
error (_("Fork failed"));
+ exit_status_set_internal_vars (status);
#endif /* Can fork. */
}
/* Implementation of the "shell" command. */
static void
-shell_command (char *arg, int from_tty)
+shell_command (const char *arg, int from_tty)
{
shell_escape (arg, from_tty);
}
static void
-edit_command (char *arg, int from_tty)
+edit_command (const char *arg, int from_tty)
{
struct symtab_and_line sal;
struct symbol *sym;
error (_("No line number known for %s."), arg);
}
- if ((editor = (char *) getenv ("EDITOR")) == NULL)
- editor = "/bin/ex";
+ if ((editor = getenv ("EDITOR")) == NULL)
+ editor = "/bin/ex";
fn = symtab_to_fullname (sal.symtab);
xfree (p);
}
+/* Implementation of the "pipe" command. */
+
static void
-list_command (char *arg, int from_tty)
+pipe_command (const char *arg, int from_tty)
+{
+ std::string delim ("|");
+
+ if (arg != nullptr && check_for_argument (&arg, "-d", 2))
+ {
+ delim = extract_arg (&arg);
+ if (delim.empty ())
+ error (_("Missing delimiter DELIM after -d"));
+ }
+
+ const char *command = arg;
+ if (command == nullptr)
+ error (_("Missing COMMAND"));
+
+ arg = strstr (arg, delim.c_str ());
+
+ if (arg == nullptr)
+ error (_("Missing delimiter before SHELL_COMMAND"));
+
+ std::string gdb_cmd (command, arg - command);
+
+ arg += delim.length (); /* Skip the delimiter. */
+
+ if (gdb_cmd.empty ())
+ {
+ repeat_previous ();
+ gdb_cmd = skip_spaces (get_saved_command_line ());
+ if (gdb_cmd.empty ())
+ error (_("No previous command to relaunch"));
+ }
+
+ const char *shell_command = skip_spaces (arg);
+ if (*shell_command == '\0')
+ error (_("Missing SHELL_COMMAND"));
+
+ FILE *to_shell_command = popen (shell_command, "w");
+
+ if (to_shell_command == nullptr)
+ error (_("Error launching \"%s\""), shell_command);
+
+ try
+ {
+ stdio_file pipe_file (to_shell_command);
+
+ execute_command_to_ui_file (&pipe_file, gdb_cmd.c_str (), from_tty);
+ }
+ catch (...)
+ {
+ pclose (to_shell_command);
+ throw;
+ }
+
+ int exit_status = pclose (to_shell_command);
+
+ if (exit_status < 0)
+ error (_("shell command \"%s\" failed: %s"), shell_command,
+ safe_strerror (errno));
+ exit_status_set_internal_vars (exit_status);
+}
+
+static void
+list_command (const char *arg, int from_tty)
{
struct symbol *sym;
const char *arg1;
int dummy_end = 0;
int dummy_beg = 0;
int linenum_beg = 0;
- char *p;
+ const char *p;
/* Pull in the current default source line if necessary. */
if (arg == NULL || ((arg[0] == '+' || arg[0] == '-') && arg[1] == '\0'))
&& get_lines_to_list () == 1 && first > 1)
first -= 1;
- print_source_lines (cursal.symtab, first,
- first + get_lines_to_list (), 0);
+ print_source_lines (cursal.symtab, source_lines_range (first), 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);
+ print_source_lines (cursal.symtab,
+ source_lines_range (cursal.line), 0);
/* "l -" lists previous ten lines, the ones before the ten just
listed. */
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);
+ source_lines_range range (get_first_line_listed (),
+ source_lines_range::BACKWARD);
+ print_source_lines (cursal.symtab, range, 0);
}
return;
if (dummy_beg && sal_end.symtab == 0)
error (_("No default source file yet. Do \"help list\"."));
if (dummy_beg)
- print_source_lines (sal_end.symtab,
- std::max (sal_end.line - (get_lines_to_list () - 1), 1),
- sal_end.line + 1, 0);
+ {
+ source_lines_range range (sal_end.line + 1,
+ source_lines_range::BACKWARD);
+ print_source_lines (sal_end.symtab, range, 0);
+ }
else if (sal.symtab == 0)
error (_("No default source file yet. Do \"help list\"."));
else if (no_end)
first_line = 1;
if (sals.size () > 1)
print_sal_location (sal);
- print_source_lines (sal.symtab,
- first_line,
- first_line + get_lines_to_list (),
- 0);
+ print_source_lines (sal.symtab, source_lines_range (first_line), 0);
}
}
+ else if (dummy_end)
+ print_source_lines (sal.symtab, source_lines_range (sal.line), 0);
else
- print_source_lines (sal.symtab, sal.line,
- (dummy_end
- ? sal.line + get_lines_to_list ()
- : sal_end.line + 1),
+ print_source_lines (sal.symtab,
+ source_lines_range (sal.line, (sal_end.line + 1)),
0);
}
Perform the disassembly.
NAME is the name of the function if known, or NULL.
[LOW,HIGH) are the range of addresses to disassemble.
+ BLOCK is the block to disassemble; it needs to be provided
+ when non-contiguous blocks are disassembled; otherwise
+ it can be NULL.
MIXED is non-zero to print source with the assembler. */
static void
print_disassembly (struct gdbarch *gdbarch, const char *name,
CORE_ADDR low, CORE_ADDR high,
+ const struct block *block,
gdb_disassembly_flags flags)
{
#if defined(TUI)
{
printf_filtered ("Dump of assembler code ");
if (name != NULL)
- printf_filtered ("for function %s:\n", name);
- else
- printf_filtered ("from %s to %s:\n",
- paddress (gdbarch, low), paddress (gdbarch, high));
-
- /* Dump the specified range. */
- gdb_disassembly (gdbarch, current_uiout, flags, -1, low, high);
+ printf_filtered ("for function %s:\n", name);
+ if (block == nullptr || BLOCK_CONTIGUOUS_P (block))
+ {
+ if (name == NULL)
+ printf_filtered ("from %s to %s:\n",
+ paddress (gdbarch, low), paddress (gdbarch, high));
+ /* Dump the specified range. */
+ gdb_disassembly (gdbarch, current_uiout, flags, -1, low, high);
+ }
+ else
+ {
+ for (int i = 0; i < BLOCK_NRANGES (block); i++)
+ {
+ CORE_ADDR range_low = BLOCK_RANGE_START (block, i);
+ CORE_ADDR range_high = BLOCK_RANGE_END (block, i);
+ printf_filtered (_("Address range %s to %s:\n"),
+ paddress (gdbarch, range_low),
+ paddress (gdbarch, range_high));
+ gdb_disassembly (gdbarch, current_uiout, flags, -1,
+ range_low, range_high);
+ }
+ }
printf_filtered ("End of assembler dump.\n");
- gdb_flush (gdb_stdout);
}
#if defined(TUI)
else
struct gdbarch *gdbarch;
CORE_ADDR low, high, pc;
const char *name;
+ const struct block *block;
frame = get_selected_frame (_("No frame selected."));
gdbarch = get_frame_arch (frame);
pc = get_frame_address_in_block (frame);
- if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+ if (find_pc_partial_function (pc, &name, &low, &high, &block) == 0)
error (_("No function contains program counter for selected frame."));
#if defined(TUI)
/* NOTE: cagney/2003-02-13 The `tui_active' was previously
#endif
low += gdbarch_deprecated_function_start_offset (gdbarch);
- print_disassembly (gdbarch, name, low, high, flags);
+ print_disassembly (gdbarch, name, low, high, block, flags);
}
/* Dump a specified section of assembly code.
2) File names and contents for all relevant source files are displayed. */
static void
-disassemble_command (char *arg, int from_tty)
+disassemble_command (const char *arg, int from_tty)
{
struct gdbarch *gdbarch = get_current_arch ();
CORE_ADDR low, high;
CORE_ADDR pc;
gdb_disassembly_flags flags;
const char *p;
+ const struct block *block = nullptr;
p = arg;
name = NULL;
if (p[0] == '\0')
{
/* One argument. */
- if (find_pc_partial_function (pc, &name, &low, &high) == 0)
+ if (find_pc_partial_function (pc, &name, &low, &high, &block) == 0)
error (_("No function contains specified address."));
#if defined(TUI)
/* NOTE: cagney/2003-02-13 The `tui_active' was previously
high += low;
}
- print_disassembly (gdbarch, name, low, high, flags);
+ print_disassembly (gdbarch, name, low, high, block, flags);
}
static void
-make_command (char *arg, int from_tty)
+make_command (const char *arg, int from_tty)
{
if (arg == 0)
shell_escape ("make", from_tty);
/* Search through names of commands and documentations for a certain
regular expression. */
-static void
-apropos_command (char *searchstr, int from_tty)
+static void
+apropos_command (const char *arg, int from_tty)
{
- if (searchstr == NULL)
+ bool verbose = arg && check_for_argument (&arg, "-v", 2);
+
+ if (arg == NULL || *arg == '\0')
error (_("REGEXP string is empty"));
- compiled_regex pattern (searchstr, REG_ICASE,
+ compiled_regex pattern (arg, REG_ICASE,
_("Error in regular expression"));
- apropos_cmd (gdb_stdout, cmdlist, pattern, "");
+ apropos_cmd (gdb_stdout, cmdlist, verbose, pattern, "");
}
/* Subroutine of alias_command to simplify it.
}
/* Subroutine of alias_command to simplify it.
- Return TRUE if COMMAND exists, unambiguously. Otherwise FALSE. */
+ Return true if COMMAND exists, unambiguously. Otherwise false. */
-static int
+static bool
valid_command_p (const 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;
+ return false;
/* This is the slightly tricky part.
lookup_cmd_1 will return a pointer to the last part of COMMAND
/* Make an alias of an existing command. */
static void
-alias_command (char *args, int from_tty)
+alias_command (const char *args, int from_tty)
{
int i, alias_argc, command_argc;
int abbrev_flag = 0;
- char *equals;
+ const char *equals;
const char *alias, *command;
if (args == NULL || strchr (args, '=') == NULL)
With no arguments, run an inferior shell."));
set_cmd_completer (c, filename_completer);
+ add_com_alias ("!", "shell", class_support, 0);
+
c = add_com ("edit", class_files, edit_command, _("\
Edit specified file or function.\n\
With no argument, edits file containing most recent line listed.\n\
c->completer = location_completer;
+ c = add_com ("pipe", class_support, pipe_command, _("\
+Send the output of a gdb command to a shell command.\n\
+Usage: | [COMMAND] | SHELL_COMMAND\n\
+Usage: | -d DELIM COMMAND DELIM SHELL_COMMAND\n\
+Usage: pipe [COMMAND] | SHELL_COMMAND\n\
+Usage: pipe -d DELIM COMMAND DELIM SHELL_COMMAND\n\
+\n\
+Executes COMMAND and sends its output to SHELL_COMMAND.\n\
+\n\
+The -d option indicates to use the string DELIM to separate COMMAND\n\
+from SHELL_COMMAND, in alternative to |. This is useful in\n\
+case COMMAND contains a | character.\n\
+\n\
+With no COMMAND, repeat the last executed command\n\
+and send its output to SHELL_COMMAND."));
+ add_com_alias ("|", "pipe", class_support, 0);
+
add_com ("list", class_files, list_command, _("\
List specified function or line.\n\
With no argument, lists ten more lines after or around previous listing.\n\
you must type \"disassemble 'foo.c'::bar\" and not \"disassemble foo.c:bar\"."));
set_cmd_completer (c, location_completer);
- 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);
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,
- _("Search for commands matching a REGEXP"));
+ add_com ("apropos", class_support, apropos_command, _("\
+Search for commands matching a REGEXP\n\
+Usage: apropos [-v] REGEXP\n\
+Flag -v indicates to produce a verbose output, showing full documentation\n\
+of the matching commands."));
add_setshow_uinteger_cmd ("max-user-call-depth", no_class,
&max_user_call_depth, _("\
projects / deliverable / binutils-gdb.git / blobdiff