/* 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"
int remote_debug = 0;
/* Sbrk location on entry to main. Used for statistics only. */
-#ifdef HAVE_SBRK
+#ifdef HAVE_USEFUL_SBRK
char *lim_at_start;
#endif
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];
/* NOTE 1999-04-29: This variable will be static again, once we modify
gdb to use the event loop as the default command loop and we merge
event-top.c into this file, top.c. */
-/* static */ const char *source_file_name;
+/* static */ std::string source_file_name;
/* Read commands from STREAM. */
void
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;
}
line = p;
/* If trace-commands is set then this will print this command. */
- print_command_trace (p);
+ print_command_trace ("%s", p);
c = lookup_cmd (&cmd, cmdlist, "", 0, 1);
p = cmd;
we just finished executing did not resume the inferior's execution.
If it did resume the inferior, we will do that check after
the inferior stopped. */
- if (has_stack_frames () && !is_running (inferior_ptid))
+ 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
gdb_flush (gdb_stdout);
gdb_flush (gdb_stderr);
- if (source_file_name != NULL)
+ if (!source_file_name.empty ())
++source_line_number;
if (from_tty && annotation_level > 1)
&& 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;
return cmd;
}
\f
-/* Print the GDB banner. */
+/* See top.h. */
void
-print_gdb_version (struct ui_file *stream)
+print_gdb_version (struct ui_file *stream, bool interactive)
{
/* From GNU coding standards, first line is meant to be easy for a
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, "\
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
\nThis is free software: you are free to change and redistribute it.\n\
-There is NO WARRANTY, to the extent permitted by law. Type \"show copying\"\n\
-and \"show warranty\" for details.\n");
+There is NO WARRANTY, to the extent permitted by law.");
+
+ if (!interactive)
+ return;
+
+ fprintf_filtered (stream, ("\nType \"show copying\" and "
+ "\"show warranty\" for details.\n"));
/* After the required info we print the configuration information. */
{
fprintf_filtered (stream, "%s", host_name);
}
- fprintf_filtered (stream, "\".\n\
-Type \"show configuration\" for configuration details.");
+ fprintf_filtered (stream, "\".\n");
+
+ fprintf_filtered (stream, _("Type \"show configuration\" "
+ "for configuration details.\n"));
if (REPORT_BUGS_TO[0])
{
fprintf_filtered (stream,
- _("\nFor bug reporting instructions, please see:\n"));
+ _("For bug reporting instructions, please see:\n"));
fprintf_filtered (stream, "%s.\n", REPORT_BUGS_TO);
}
fprintf_filtered (stream,
_("Find the GDB manual and other documentation \
-resources online at:\n<http://www.gnu.org/software/gdb/documentation/>.\n"));
+resources online at:\n <http://www.gnu.org/software/gdb/documentation/>."));
+ fprintf_filtered (stream, "\n\n");
fprintf_filtered (stream, _("For help, type \"help\".\n"));
fprintf_filtered (stream, _("Type \"apropos word\" to search for \
commands related to \"word\"."));
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, _("\
kill_or_detach (struct inferior *inf, void *args)
{
struct qt_args *qt = (struct qt_args *) args;
- struct thread_info *thread;
if (inf->pid == 0)
return 0;
- thread = any_thread_of_process (inf->pid);
+ thread_info *thread = any_thread_of_inferior (inf);
if (thread != NULL)
{
- switch_to_thread (thread->ptid);
+ switch_to_thread (thread);
/* Leave core files alone. */
if (target_has_execution)
if (inf->attach_flag)
fprintf_filtered (stb,
_("\tInferior %d [%s] will be detached.\n"), inf->num,
- target_pid_to_str (pid_to_ptid (inf->pid)));
+ target_pid_to_str (ptid_t (inf->pid)).c_str ());
else
fprintf_filtered (stb,
_("\tInferior %d [%s] will be killed.\n"), inf->num,
- target_pid_to_str (pid_to_ptid (inf->pid)));
+ target_pid_to_str (ptid_t (inf->pid)).c_str ());
return 0;
}
/* Do any final cleanups before exiting. */
TRY
{
- do_final_cleanups (all_cleanups ());
+ do_final_cleanups ();
}
CATCH (ex, RETURN_MASK_ALL)
{
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)
projects / deliverable / binutils-gdb.git / blobdiff