/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "value.h"
#include "language.h"
#include "terminal.h" /* For job_control. */
-#include "job-control.h"
+#include "common/job-control.h"
#include "annotate.h"
#include "completer.h"
#include "top.h"
-#include "version.h"
+#include "common/version.h"
#include "serial.h"
#include "main.h"
#include "event-loop.h"
#include "maint.h"
#include "filenames.h"
#include "frame.h"
-#include "buffer.h"
+#include "common/buffer.h"
#include "gdb_select.h"
+#include "common/scope-exit.h"
/* readline include files. */
#include "readline/readline.h"
argc = argv.count ();
if (argc < 2)
- error (_("usage: new-ui <interpreter> <tty>"));
+ error (_("Usage: new-ui INTERPRETER TTY"));
interpreter_name = argv[0];
tty_name = argv[1];
char *command;
/* Get a command-line. This calls the readline package. */
- command = command_line_input (NULL, 0, NULL);
+ command = command_line_input (NULL, NULL);
if (command == NULL)
break;
command_handler (command);
void
execute_command (const char *p, int from_tty)
{
- struct cleanup *cleanup_if_error;
struct cmd_list_element *c;
const char *line;
const char *cmd_start = p;
- cleanup_if_error = make_bpstat_clear_actions_cleanup ();
+ auto cleanup_if_error = make_scope_exit (bpstat_clear_actions);
scoped_value_mark cleanup = prepare_execute_command ();
/* Force cleanup of any alloca areas if using C alloca instead of
/* This can happen when command_line_input hits end of file. */
if (p == NULL)
{
- discard_cleanups (cleanup_if_error);
+ cleanup_if_error.release ();
return;
}
if (has_stack_frames () && inferior_thread ()->state != THREAD_RUNNING)
check_frame_language_change ();
- discard_cleanups (cleanup_if_error);
+ cleanup_if_error.release ();
}
/* Run execute_command for P and FROM_TTY. Capture its output into the
text. */
static void
-gdb_readline_wrapper_line (char *line)
+gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr<char> &&line)
{
gdb_assert (!gdb_readline_wrapper_done);
- gdb_readline_wrapper_result = line;
+ gdb_readline_wrapper_result = line.release ();
gdb_readline_wrapper_done = 1;
/* Prevent operate-and-get-next from acting too early. */
private:
- void (*m_handler_orig) (char *);
+ void (*m_handler_orig) (gdb::unique_xmalloc_ptr<char> &&);
int m_already_prompted_orig;
/* Whether the target was async. */
NULL is returned for end of file.
- *If* input is from an interactive stream (stdin), the line read is
- copied into the global 'saved_command_line' so that it can be
- repeated.
-
This routine either uses fancy command line editing or simple input
as the user has requested. */
char *
-command_line_input (const char *prompt_arg, int repeat,
- const char *annotation_suffix)
+command_line_input (const char *prompt_arg, const char *annotation_suffix)
{
static struct buffer cmd_line_buffer;
static int cmd_line_buffer_initialized;
while (1)
{
- char *rl;
+ gdb::unique_xmalloc_ptr<char> rl;
/* Make sure that all output has been output. Some machines may
let you get away with leaving out some of the gdb_flush, but
&& from_tty
&& input_interactive_p (current_ui))
{
- rl = (*deprecated_readline_hook) (prompt);
+ rl.reset ((*deprecated_readline_hook) (prompt));
}
else if (command_editing_p
&& from_tty
&& input_interactive_p (current_ui))
{
- rl = gdb_readline_wrapper (prompt);
+ rl.reset (gdb_readline_wrapper (prompt));
}
else
{
- rl = gdb_readline_no_editing (prompt);
+ rl.reset (gdb_readline_no_editing (prompt));
}
- cmd = handle_line_of_input (&cmd_line_buffer, rl,
- repeat, annotation_suffix);
+ cmd = handle_line_of_input (&cmd_line_buffer, rl.get (),
+ 0, annotation_suffix);
if (cmd == (char *) EOF)
{
cmd = NULL;
program to parse, and is just canonical program name and version
number, which starts after last space. */
- fprintf_filtered (stream, "GNU gdb %s%s\n", PKGVERSION, version);
+ ui_file_style style;
+ if (interactive)
+ {
+ ui_file_style nstyle = { ui_file_style::MAGENTA, ui_file_style::NONE,
+ ui_file_style::BOLD };
+ style = nstyle;
+ }
+ fprintf_styled (stream, style, "GNU gdb %s%s\n", PKGVERSION, version);
/* Second line is a copyright notice. */
fprintf_filtered (stream,
- "Copyright (C) 2018 Free Software Foundation, Inc.\n");
+ "Copyright (C) 2019 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
fprintf_filtered (stream, _("\
--with-python=%s%s\n\
"), WITH_PYTHON_PATH, PYTHON_PATH_RELOCATABLE ? " (relocatable)" : "");
+#else
+ fprintf_filtered (stream, _("\
+ --without-python\n\
+"));
#endif
#if HAVE_GUILE
fprintf_filtered (stream, _("\
int info_verbose = 0; /* Default verbose msgs off. */
-/* Called by do_setshow_command. An elaborate joke. */
+/* Called by do_set_command. An elaborate joke. */
void
set_verbose (const char *args, int from_tty, struct cmd_list_element *c)
{
showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
gdb_assert (showcmd != NULL && showcmd != CMD_LIST_AMBIGUOUS);
+ if (c->doc && c->doc_allocated)
+ xfree ((char *) c->doc);
+ if (showcmd->doc && showcmd->doc_allocated)
+ xfree ((char *) showcmd->doc);
if (info_verbose)
{
- c->doc = "Set verbose printing of informational messages.";
- showcmd->doc = "Show verbose printing of informational messages.";
+ c->doc = _("Set verbose printing of informational messages.");
+ showcmd->doc = _("Show verbose printing of informational messages.");
}
else
{
- c->doc = "Set verbosity.";
- showcmd->doc = "Show verbosity.";
+ c->doc = _("Set verbosity.");
+ showcmd->doc = _("Show verbosity.");
}
+ c->doc_allocated = 0;
+ showcmd->doc_allocated = 0;
}
/* Init the history buffer. Note that we are called after the init file(s)
void
init_history (void)
{
- char *tmpenv;
+ const char *tmpenv;
tmpenv = getenv ("GDBHISTSIZE");
if (tmpenv)