/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1986-2017 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbthread.h"
#include "extension.h"
#include "interps.h"
-#include "observer.h"
+#include "observable.h"
#include "maint.h"
#include "filenames.h"
#include "frame.h"
things like enabling/disabling buttons, etc... */
void (*deprecated_call_command_hook) (struct cmd_list_element * c,
- char *cmd, int from_tty);
+ const char *cmd, int from_tty);
/* Called when the current thread changes. Argument is thread id. */
static void
new_ui_command (const char *args, int from_tty)
{
- struct interp *interp;
gdb_file_up stream[3];
int i;
- int res;
int argc;
const char *interpreter_name;
const char *tty_name;
wait_sync_command_done ();
}
+/* If not NULL, the arguments that should be passed if the current
+ command is repeated. */
+
+static const char *repeat_arguments;
+
+/* See command.h. */
+
+void
+set_repeat_arguments (const char *args)
+{
+ repeat_arguments = args;
+}
+
/* Execute the line P as a command, in the current user context.
Pass FROM_TTY as second argument to the defining function. */
void
-execute_command (char *p, int from_tty)
+execute_command (const char *p, int from_tty)
{
struct cleanup *cleanup_if_error;
struct cmd_list_element *c;
- char *line;
+ const char *line;
+ const char *cmd_start = p;
cleanup_if_error = make_bpstat_clear_actions_cleanup ();
scoped_value_mark cleanup = prepare_execute_command ();
if (*p)
{
const char *cmd = p;
- char *arg;
+ const char *arg;
int was_sync = current_ui->prompt_state == PROMPT_BLOCKED;
line = p;
print_command_trace (p);
c = lookup_cmd (&cmd, cmdlist, "", 0, 1);
- p = (char *) cmd;
+ p = cmd;
+
+ scoped_restore save_repeat_args
+ = make_scoped_restore (&repeat_arguments, nullptr);
+ const char *args_pointer = p;
/* Pass null arg rather than an empty one. */
arg = *p ? p : 0;
is_complete_command hack is testing for. */
/* Clear off trailing whitespace, except for set and complete
command. */
+ std::string without_whitespace;
if (arg
&& c->type != set_cmd
&& !is_complete_command (c))
{
- p = arg + strlen (arg) - 1;
+ const char *old_end = arg + strlen (arg) - 1;
+ p = old_end;
while (p >= arg && (*p == ' ' || *p == '\t'))
p--;
- *(p + 1) = '\0';
+ if (p != old_end)
+ {
+ without_whitespace = std::string (arg, p + 1);
+ arg = without_whitespace.c_str ();
+ }
}
/* If this command has been pre-hooked, run the hook first. */
/* If this command has been post-hooked, run the hook last. */
execute_cmd_post_hook (c);
+ if (repeat_arguments != NULL && cmd_start == saved_command_line)
+ {
+ gdb_assert (strlen (args_pointer) >= strlen (repeat_arguments));
+ strcpy (saved_command_line + (args_pointer - cmd_start),
+ repeat_arguments);
+ }
}
check_frame_language_change ();
temporarily set to true. */
std::string
-execute_command_to_string (char *p, int from_tty)
+execute_command_to_string (const char *p, int from_tty)
{
/* GDB_STDOUT should be better already restored during these
restoration callbacks. */
while (1)
{
int c;
- int numfds;
fd_set readfds;
QUIT;
gdb_rl_callback_handler_remove ();
}
-struct gdb_readline_wrapper_cleanup
- {
- void (*handler_orig) (char *);
- int already_prompted_orig;
-
- /* Whether the target was async. */
- int target_is_async_orig;
- };
-
-static void
-gdb_readline_wrapper_cleanup (void *arg)
+class gdb_readline_wrapper_cleanup
{
- struct ui *ui = current_ui;
- struct gdb_readline_wrapper_cleanup *cleanup
- = (struct gdb_readline_wrapper_cleanup *) arg;
+public:
+ gdb_readline_wrapper_cleanup ()
+ : m_handler_orig (current_ui->input_handler),
+ m_already_prompted_orig (current_ui->command_editing
+ ? rl_already_prompted : 0),
+ m_target_is_async_orig (target_is_async_p ()),
+ m_save_ui (¤t_ui)
+ {
+ current_ui->input_handler = gdb_readline_wrapper_line;
+ current_ui->secondary_prompt_depth++;
- if (ui->command_editing)
- rl_already_prompted = cleanup->already_prompted_orig;
+ if (m_target_is_async_orig)
+ target_async (0);
+ }
- gdb_assert (ui->input_handler == gdb_readline_wrapper_line);
- ui->input_handler = cleanup->handler_orig;
+ ~gdb_readline_wrapper_cleanup ()
+ {
+ struct ui *ui = current_ui;
- /* Don't restore our input handler in readline yet. That would make
- readline prep the terminal (putting it in raw mode), while the
- line we just read may trigger execution of a command that expects
- the terminal in the default cooked/canonical mode, such as e.g.,
- running Python's interactive online help utility. See
- gdb_readline_wrapper_line for when we'll reinstall it. */
+ if (ui->command_editing)
+ rl_already_prompted = m_already_prompted_orig;
- gdb_readline_wrapper_result = NULL;
- gdb_readline_wrapper_done = 0;
- ui->secondary_prompt_depth--;
- gdb_assert (ui->secondary_prompt_depth >= 0);
+ gdb_assert (ui->input_handler == gdb_readline_wrapper_line);
+ ui->input_handler = m_handler_orig;
- after_char_processing_hook = saved_after_char_processing_hook;
- saved_after_char_processing_hook = NULL;
+ /* Don't restore our input handler in readline yet. That would make
+ readline prep the terminal (putting it in raw mode), while the
+ line we just read may trigger execution of a command that expects
+ the terminal in the default cooked/canonical mode, such as e.g.,
+ running Python's interactive online help utility. See
+ gdb_readline_wrapper_line for when we'll reinstall it. */
- if (cleanup->target_is_async_orig)
- target_async (1);
+ gdb_readline_wrapper_result = NULL;
+ gdb_readline_wrapper_done = 0;
+ ui->secondary_prompt_depth--;
+ gdb_assert (ui->secondary_prompt_depth >= 0);
- xfree (cleanup);
-}
+ after_char_processing_hook = saved_after_char_processing_hook;
+ saved_after_char_processing_hook = NULL;
-char *
-gdb_readline_wrapper (const char *prompt)
-{
- struct ui *ui = current_ui;
- struct cleanup *back_to;
- struct gdb_readline_wrapper_cleanup *cleanup;
- char *retval;
+ if (m_target_is_async_orig)
+ target_async (1);
+ }
- cleanup = XNEW (struct gdb_readline_wrapper_cleanup);
- cleanup->handler_orig = ui->input_handler;
- ui->input_handler = gdb_readline_wrapper_line;
+ DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup);
- if (ui->command_editing)
- cleanup->already_prompted_orig = rl_already_prompted;
- else
- cleanup->already_prompted_orig = 0;
+private:
- cleanup->target_is_async_orig = target_is_async_p ();
+ void (*m_handler_orig) (char *);
+ int m_already_prompted_orig;
- ui->secondary_prompt_depth++;
- back_to = make_cleanup (gdb_readline_wrapper_cleanup, cleanup);
+ /* Whether the target was async. */
+ int m_target_is_async_orig;
/* Processing events may change the current UI. */
- scoped_restore save_ui = make_scoped_restore (¤t_ui);
+ scoped_restore_tmpl<struct ui *> m_save_ui;
+};
- if (cleanup->target_is_async_orig)
- target_async (0);
+char *
+gdb_readline_wrapper (const char *prompt)
+{
+ struct ui *ui = current_ui;
+
+ gdb_readline_wrapper_cleanup cleanup;
/* Display our prompt and prevent double prompt display. Don't pass
down a NULL prompt, since that has special meaning for
if (gdb_readline_wrapper_done)
break;
- retval = gdb_readline_wrapper_result;
- do_cleanups (back_to);
- return retval;
+ return gdb_readline_wrapper_result;
}
\f
/* Starting a new command line. */
cmd_line_buffer.used_size = 0;
-#ifdef STOP_SIGNAL
+#ifdef SIGTSTP
if (job_control)
- signal (STOP_SIGNAL, handle_stop_sig);
+ signal (SIGTSTP, handle_sigtstp);
#endif
while (1)
prompt = NULL;
}
-#ifdef STOP_SIGNAL
+#ifdef SIGTSTP
if (job_control)
- signal (STOP_SIGNAL, SIG_DFL);
+ signal (SIGTSTP, SIG_DFL);
#endif
return cmd;
/* Second line is a copyright notice. */
fprintf_filtered (stream,
- "Copyright (C) 2017 Free Software Foundation, Inc.\n");
+ "Copyright (C) 2018 Free Software Foundation, Inc.\n");
/* Following the copyright is a brief statement that the program is
free software, that users are free to copy and change it on
--without-lzma\n\
"));
#endif
+#if HAVE_LIBBABELTRACE
+ fprintf_filtered (stream, _("\
+ --with-babeltrace\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-babeltrace\n\
+"));
+#endif
+#if HAVE_LIBIPT
+ fprintf_filtered (stream, _("\
+ --with-intel-pt\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-intel-pt\n\
+"));
+#endif
+#if HAVE_LIBMCHECK
+ fprintf_filtered (stream, _("\
+ --enable-libmcheck\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --disable-libmcheck\n\
+"));
+#endif
+#if HAVE_LIBMPFR
+ fprintf_filtered (stream, _("\
+ --with-mpfr\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-mpfr\n\
+"));
+#endif
#ifdef WITH_PYTHON_PATH
fprintf_filtered (stream, _("\
--with-python=%s%s\n\
fprintf_filtered (stream, _("\
--with-system-gdbinit=%s%s\n\
"), SYSTEM_GDBINIT, SYSTEM_GDBINIT_RELOCATABLE ? " (relocatable)" : "");
-#if HAVE_LIBBABELTRACE
- fprintf_filtered (stream, _("\
- --with-babeltrace\n\
-"));
-#else
- fprintf_filtered (stream, _("\
- --without-babeltrace\n\
-"));
-#endif
/* We assume "relocatable" will be printed at least once, thus we always
print this text. It's a reasonably safe assumption for now. */
fprintf_filtered (stream, _("\n\
struct qt_args
{
- char *args;
int from_tty;
};
if (target_has_execution)
{
if (inf->attach_flag)
- target_detach (qt->args, qt->from_tty);
+ target_detach (inf, qt->from_tty);
else
target_kill ();
}
else if (return_child_result)
exit_code = return_child_result_value;
- qt.args = NULL;
qt.from_tty = from_tty;
/* We want to handle any quit errors and exit regardless. */
}
\f
static void
-dont_repeat_command (char *ignored, int from_tty)
+dont_repeat_command (const char *ignored, int from_tty)
{
/* Can't call dont_repeat here because we're not necessarily reading
from stdin. */
/* Number of commands to print in each call to show_commands. */
#define Hist_print 10
void
-show_commands (char *args, int from_tty)
+show_commands (const char *args, int from_tty)
{
/* Index for history commands. Relative to history_base. */
int offset;
"show commands +" does. This is unnecessary if arg is null,
because "show commands +" is not useful after "show commands". */
if (from_tty && args)
- {
- args[0] = '+';
- args[1] = '\0';
- }
+ set_repeat_arguments ("+");
}
/* Update the size of our command history file to HISTORY_SIZE.
/* Called by do_setshow_command. */
static void
-set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
+set_history_size_command (const char *args,
+ int from_tty, struct cmd_list_element *c)
{
set_readline_history_size (history_size_setshow_var);
}
/* Called by do_setshow_command. An elaborate joke. */
void
-set_verbose (char *args, int from_tty, struct cmd_list_element *c)
+set_verbose (const char *args, int from_tty, struct cmd_list_element *c)
{
const char *cmdname = "verbose";
struct cmd_list_element *showcmd;
/* "set editing" command. */
static void
-set_editing (char *args, int from_tty, struct cmd_list_element *c)
+set_editing (const char *args, int from_tty, struct cmd_list_element *c)
{
change_line_handler (set_editing_cmd_var);
/* Update the control variable so that MI's =cmd-param-changed event
/* "set" command for the gdb_datadir configuration variable. */
static void
-set_gdb_datadir (char *args, int from_tty, struct cmd_list_element *c)
+set_gdb_datadir (const char *args, int from_tty, struct cmd_list_element *c)
{
set_gdb_data_directory (staged_gdb_datadir);
- observer_notify_gdb_datadir_changed ();
+ gdb::observers::gdb_datadir_changed.notify ();
}
/* "show" command for the gdb_datadir configuration variable. */
}
static void
-set_history_filename (char *args, int from_tty, struct cmd_list_element *c)
+set_history_filename (const char *args,
+ int from_tty, struct cmd_list_element *c)
{
/* We include the current directory so that if the user changes
directories the file written will be the same as the one