/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
This file is part of GDB.
#include "cli/cli-decode.h"
#include "symtab.h"
#include "inferior.h"
-#include "exceptions.h"
+#include "infrun.h"
#include <signal.h>
#include "target.h"
+#include "target-dcache.h"
#include "breakpoint.h"
#include "gdbtypes.h"
#include "expression.h"
#include "version.h"
#include "serial.h"
#include "doublest.h"
-#include "gdb_assert.h"
#include "main.h"
#include "event-loop.h"
#include "gdbthread.h"
-#include "python/python.h"
+#include "extension.h"
#include "interps.h"
#include "observer.h"
+#include "maint.h"
+#include "filenames.h"
/* readline include files. */
#include "readline/readline.h"
#include <sys/types.h>
#include "event-top.h"
-#include "gdb_string.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include <ctype.h>
#include "ui-out.h"
#include "cli-out.h"
+#include "tracepoint.h"
+#include "inf-loop.h"
extern void initialize_all_files (void);
#define DEFAULT_PROMPT "(gdb) "
#endif
-/* Initialization file name for gdb. This is overridden in some configs. */
+/* Initialization file name for gdb. This is host-dependent. */
-#ifndef PATH_MAX
-# ifdef FILENAME_MAX
-# define PATH_MAX FILENAME_MAX
-# else
-# define PATH_MAX 512
-# endif
-#endif
-
-#ifndef GDBINIT_FILENAME
-#define GDBINIT_FILENAME ".gdbinit"
-#endif
-char gdbinit[PATH_MAX + 1] = GDBINIT_FILENAME;
+const char gdbinit[] = GDBINIT;
int inhibit_gdbinit = 0;
-/* If nonzero, and GDB has been configured to be able to use windows,
- attempt to open them upon startup. */
-
-int use_windows = 0;
-
extern char lang_frame_mismatch_warn[]; /* language.c */
/* Flag for whether we want to confirm potentially dangerous
is issuing commands too. */
int server_command;
-/* Baud rate specified for talking to serial target systems. Default
- is left as -1, so targets can choose their own defaults. */
-/* FIXME: This means that "show remotebaud" and gr_files_info can
- print -1 or (unsigned int)-1. This is a Bad User Interface. */
-
-int baud_rate = -1;
-
/* Timeout limit for response from target. */
/* The default value has been changed many times over the years. It
int (*deprecated_ui_loop_hook) (int);
-/* Called instead of command_loop at top level. Can be invoked via
- throw_exception(). */
-
-void (*deprecated_command_loop_hook) (void);
-
/* Called from print_frame_info to list the line we stopped in. */
window and it can close it. */
void (*deprecated_readline_begin_hook) (char *, ...);
-char *(*deprecated_readline_hook) (char *);
+char *(*deprecated_readline_hook) (const char *);
void (*deprecated_readline_end_hook) (void);
/* Called as appropriate to notify the interface that we have attached
void (*deprecated_call_command_hook) (struct cmd_list_element * c,
char *cmd, int from_tty);
-/* Called after a `set' command has finished. Is only run if the
- `set' command succeeded. */
-
-void (*deprecated_set_hook) (struct cmd_list_element * c);
-
/* Called when the current thread changes. Argument is thread id. */
void (*deprecated_context_hook) (int id);
}
}
+/* See top.h. */
+
+void
+maybe_wait_sync_command_done (int was_sync)
+{
+ /* If the interpreter is in sync mode (we're running a user
+ command's list, running command hooks or similars), and we
+ just ran a synchronous command that started the target, wait
+ for that command to end. */
+ if (!interpreter_async && !was_sync && sync_execution)
+ {
+ while (gdb_do_one_event () >= 0)
+ if (!sync_execution)
+ break;
+ }
+}
+
/* Execute the line P as a command, in the current user context.
Pass FROM_TTY as second argument to the defining function. */
if (p == NULL)
{
do_cleanups (cleanup);
+ discard_cleanups (cleanup_if_error);
return;
}
p++;
if (*p)
{
+ const char *cmd = p;
char *arg;
+ int was_sync = sync_execution;
+
line = p;
/* If trace-commands is set then this will print this command. */
print_command_trace (p);
- c = lookup_cmd (&p, cmdlist, "", 0, 1);
+ c = lookup_cmd (&cmd, cmdlist, "", 0, 1);
+ p = (char *) cmd;
/* Pass null arg rather than an empty one. */
arg = *p ? p : 0;
/* If this command has been pre-hooked, run the hook first. */
execute_cmd_pre_hook (c);
- if (c->flags & DEPRECATED_WARN_USER)
- deprecated_cmd_warning (&line);
+ if (c->deprecated_warn_user)
+ deprecated_cmd_warning (line);
/* c->user_commands would be NULL in the case of a python command. */
- if (c->class == class_user && c->user_commands)
+ if (c->theclass == class_user && c->user_commands)
execute_user_command (c, arg);
else if (c->type == set_cmd)
do_set_command (arg, from_tty, c);
else
cmd_func (c, arg, from_tty);
- /* If the interpreter is in sync mode (we're running a user
- command's list, running command hooks or similars), and we
- just ran a synchronous command that started the target, wait
- for that command to end. */
- if (!interpreter_async && sync_execution)
- {
- while (gdb_do_one_event () >= 0)
- if (!sync_execution)
- break;
- }
+ maybe_wait_sync_command_done (was_sync);
/* If this command has been post-hooked, run the hook last. */
execute_cmd_post_hook (c);
make_command_stats_cleanup (1);
- execute_command (command, instream == stdin);
-
- /* Do any commands attached to breakpoint we are stopped at. */
- bpstat_do_actions ();
+ /* Do not execute commented lines. */
+ if (command[0] != '#')
+ {
+ execute_command (command, instream == stdin);
+ /* Do any commands attached to breakpoint we are stopped at. */
+ bpstat_do_actions ();
+ }
do_cleanups (old_chain);
}
}
A NULL return means end of file. */
char *
-gdb_readline (char *prompt_arg)
+gdb_readline (const char *prompt_arg)
{
int c;
char *result;
value);
}
-static unsigned int history_size;
+/* The variable associated with the "set/show history size"
+ command. */
+static unsigned int history_size_setshow_var;
+
static void
show_history_size (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
after_char_processing_hook = NULL;
/* Prevent parts of the prompt from being redisplayed if annotations
- are enabled, and readline's state getting out of sync. */
+ are enabled, and readline's state getting out of sync. We'll
+ reinstall the callback handler, which puts the terminal in raw
+ mode (or in readline lingo, in prepped state), when we're next
+ ready to process user input, either in display_gdb_prompt, or if
+ we're handling an asynchronous target event and running in the
+ background, just before returning to the event loop to process
+ further input (or more target events). */
if (async_command_editing_p)
- rl_callback_handler_remove ();
+ 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_assert (input_handler == gdb_readline_wrapper_line);
input_handler = cleanup->handler_orig;
+
+ /* 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. */
+
gdb_readline_wrapper_result = NULL;
gdb_readline_wrapper_done = 0;
after_char_processing_hook = saved_after_char_processing_hook;
saved_after_char_processing_hook = NULL;
+ if (cleanup->target_is_async_orig)
+ target_async (1);
+
xfree (cleanup);
}
char *
-gdb_readline_wrapper (char *prompt)
+gdb_readline_wrapper (const char *prompt)
{
struct cleanup *back_to;
struct gdb_readline_wrapper_cleanup *cleanup;
cleanup->already_prompted_orig = rl_already_prompted;
+ cleanup->target_is_async_orig = target_is_async_p ();
+
back_to = make_cleanup (gdb_readline_wrapper_cleanup, cleanup);
+ if (cleanup->target_is_async_orig)
+ target_async (0);
+
/* Display our prompt and prevent double prompt display. */
display_gdb_prompt (prompt);
rl_already_prompted = 1;
/* Find the current line, and find the next line to use. */
where = where_history();
- /* FIXME: kettenis/20020817: max_input_history is renamed into
- history_max_entries in readline-4.2. When we do a new readline
- import, we should probably change it here too, even though
- readline maintains backwards compatibility for now by still
- defining max_input_history. */
- if ((history_is_stifled () && (history_length >= max_input_history)) ||
- (where >= history_length - 1))
+ if ((history_is_stifled () && (history_length >= history_max_entries))
+ || (where >= history_length - 1))
operate_saved_history = where;
else
operate_saved_history = where + 1;
return rl_newline (1, key);
}
-\f
+
+/* Number of user commands executed during this session. */
+
+static int command_count = 0;
+
+/* Add the user command COMMAND to the input history list. */
+
+void
+gdb_add_history (const char *command)
+{
+ add_history (command);
+ command_count++;
+}
+
+/* Safely append new history entries to the history file in a corruption-free
+ way using an intermediate local history file. */
+
+static void
+gdb_safe_append_history (void)
+{
+ int ret, saved_errno;
+ char *local_history_filename;
+ struct cleanup *old_chain;
+
+ local_history_filename
+ = xstrprintf ("%s-gdb%d~", history_filename, getpid ());
+ old_chain = make_cleanup (xfree, local_history_filename);
+
+ ret = rename (history_filename, local_history_filename);
+ saved_errno = errno;
+ if (ret < 0 && saved_errno != ENOENT)
+ {
+ warning (_("Could not rename %s to %s: %s"),
+ history_filename, local_history_filename,
+ safe_strerror (saved_errno));
+ }
+ else
+ {
+ if (ret < 0)
+ {
+ /* If the rename failed with ENOENT then either the global history
+ file never existed in the first place or another GDB process is
+ currently appending to it (and has thus temporarily renamed it).
+ Since we can't distinguish between these two cases, we have to
+ conservatively assume the first case and therefore must write out
+ (not append) our known history to our local history file and try
+ to move it back anyway. Otherwise a global history file would
+ never get created! */
+ gdb_assert (saved_errno == ENOENT);
+ write_history (local_history_filename);
+ }
+ else
+ {
+ append_history (command_count, local_history_filename);
+ history_truncate_file (local_history_filename, history_max_entries);
+ }
+
+ ret = rename (local_history_filename, history_filename);
+ saved_errno = errno;
+ if (ret < 0 && saved_errno != EEXIST)
+ warning (_("Could not rename %s to %s: %s"),
+ local_history_filename, history_filename,
+ safe_strerror (saved_errno));
+ }
+
+ do_cleanups (old_chain);
+}
+
/* Read one line from the command input stream `instream'
into the local static buffer `linebuffer' (whose current length
is `linelength').
simple input as the user has requested. */
char *
-command_line_input (char *prompt_arg, int repeat, char *annotation_suffix)
+command_line_input (const char *prompt_arg, int repeat, char *annotation_suffix)
{
static char *linebuffer = 0;
static unsigned linelength = 0;
+ const char *prompt = prompt_arg;
char *p;
char *p1;
char *rl;
- char *local_prompt = prompt_arg;
char *nline;
char got_eof = 0;
if (annotation_level > 1 && instream == stdin)
{
- local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg))
+ char *local_prompt;
+
+ local_prompt = alloca ((prompt == NULL ? 0 : strlen (prompt))
+ strlen (annotation_suffix) + 40);
- if (prompt_arg == NULL)
+ if (prompt == NULL)
local_prompt[0] = '\0';
else
- strcpy (local_prompt, prompt_arg);
+ strcpy (local_prompt, prompt);
strcat (local_prompt, "\n\032\032");
strcat (local_prompt, annotation_suffix);
strcat (local_prompt, "\n");
+
+ prompt = local_prompt;
}
if (linebuffer == 0)
/* Don't use fancy stuff if not talking to stdin. */
if (deprecated_readline_hook && input_from_terminal_p ())
{
- rl = (*deprecated_readline_hook) (local_prompt);
+ rl = (*deprecated_readline_hook) (prompt);
}
else if (command_editing_p && input_from_terminal_p ())
{
- rl = gdb_readline_wrapper (local_prompt);
+ rl = gdb_readline_wrapper (prompt);
}
else
{
- rl = gdb_readline (local_prompt);
+ rl = gdb_readline (prompt);
}
if (annotation_level > 1 && instream == stdin)
break;
p--; /* Put on top of '\'. */
- local_prompt = (char *) 0;
+ prompt = NULL;
}
#ifdef STOP_SIGNAL
if (expanded < 0)
{
xfree (history_value);
- return command_line_input (prompt_arg, repeat,
+ return command_line_input (prompt, repeat,
annotation_suffix);
}
if (strlen (history_value) > linelength)
*p = 0;
/* Add line to history if appropriate. */
- if (instream == stdin
- && ISATTY (stdin) && *linebuffer)
- add_history (linebuffer);
-
- /* Note: lines consisting solely of comments are added to the command
- history. This is useful when you type a command, and then
- realize you don't want to execute it quite yet. You can comment
- out the command and then later fetch it from the value history
- and remove the '#'. The kill ring is probably better, but some
- people are in the habit of commenting things out. */
- if (*p1 == '#')
- *p1 = '\0'; /* Found a comment. */
+ if (*linebuffer && input_from_terminal_p ())
+ gdb_add_history (linebuffer);
/* Save into global buffer if appropriate. */
if (repeat)
/* Second line is a copyright notice. */
fprintf_filtered (stream,
- "Copyright (C) 2013 Free Software Foundation, Inc.\n");
+ "Copyright (C) 2015 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, "%s", host_name);
}
- fprintf_filtered (stream, "\".");
+ fprintf_filtered (stream, "\".\n\
+Type \"show configuration\" for configuration details.");
if (REPORT_BUGS_TO[0])
{
- fprintf_filtered (stream,
+ fprintf_filtered (stream,
_("\nFor bug reporting instructions, please see:\n"));
- fprintf_filtered (stream, "%s.", REPORT_BUGS_TO);
+ 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"));
+ fprintf_filtered (stream, _("For help, type \"help\".\n"));
+ fprintf_filtered (stream, _("Type \"apropos word\" to search for \
+commands related to \"word\"."));
+}
+
+/* Print the details of GDB build-time configuration. */
+void
+print_gdb_configuration (struct ui_file *stream)
+{
+ fprintf_filtered (stream, _("\
+This GDB was configured as follows:\n\
+ configure --host=%s --target=%s\n\
+"), host_name, target_name);
+ fprintf_filtered (stream, _("\
+ --with-auto-load-dir=%s\n\
+ --with-auto-load-safe-path=%s\n\
+"), AUTO_LOAD_DIR, AUTO_LOAD_SAFE_PATH);
+#if HAVE_LIBEXPAT
+ fprintf_filtered (stream, _("\
+ --with-expat\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-expat\n\
+"));
+#endif
+ if (GDB_DATADIR[0])
+ fprintf_filtered (stream, _("\
+ --with-gdb-datadir=%s%s\n\
+"), GDB_DATADIR, GDB_DATADIR_RELOCATABLE ? " (relocatable)" : "");
+#ifdef ICONV_BIN
+ fprintf_filtered (stream, _("\
+ --with-iconv-bin=%s%s\n\
+"), ICONV_BIN, ICONV_BIN_RELOCATABLE ? " (relocatable)" : "");
+#endif
+ if (JIT_READER_DIR[0])
+ fprintf_filtered (stream, _("\
+ --with-jit-reader-dir=%s%s\n\
+"), JIT_READER_DIR, JIT_READER_DIR_RELOCATABLE ? " (relocatable)" : "");
+#if HAVE_LIBUNWIND_IA64_H
+ fprintf_filtered (stream, _("\
+ --with-libunwind-ia64\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-libunwind-ia64\n\
+"));
+#endif
+#if HAVE_LIBLZMA
+ fprintf_filtered (stream, _("\
+ --with-lzma\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-lzma\n\
+"));
+#endif
+#ifdef WITH_PYTHON_PATH
+ fprintf_filtered (stream, _("\
+ --with-python=%s%s\n\
+"), WITH_PYTHON_PATH, PYTHON_PATH_RELOCATABLE ? " (relocatable)" : "");
+#endif
+#if HAVE_GUILE
+ fprintf_filtered (stream, _("\
+ --with-guile\n\
+"));
+#else
+ fprintf_filtered (stream, _("\
+ --without-guile\n\
+"));
+#endif
+#ifdef RELOC_SRCDIR
+ fprintf_filtered (stream, _("\
+ --with-relocated-sources=%s\n\
+"), RELOC_SRCDIR);
+#endif
+ if (DEBUGDIR[0])
+ fprintf_filtered (stream, _("\
+ --with-separate-debug-dir=%s%s\n\
+"), DEBUGDIR, DEBUGDIR_RELOCATABLE ? " (relocatable)" : "");
+ if (TARGET_SYSTEM_ROOT[0])
+ fprintf_filtered (stream, _("\
+ --with-sysroot=%s%s\n\
+"), TARGET_SYSTEM_ROOT, TARGET_SYSTEM_ROOT_RELOCATABLE ? " (relocatable)" : "");
+ if (SYSTEM_GDBINIT[0])
+ 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\
+(\"Relocatable\" means the directory can be moved with the GDB installation\n\
+tree, and GDB will still find it.)\n\
+"));
}
\f
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
- /* This is something of a hack. But there's no reliable way to see
- if a GUI is running. The `use_windows' variable doesn't cut
- it. */
- if (deprecated_init_ui_hook)
- fprintf_filtered (stb, _("A debugging session is active.\n"
- "Do you still want to close the debugger?"));
- else
- {
- fprintf_filtered (stb, _("A debugging session is active.\n\n"));
- iterate_over_inferiors (print_inferior_quit_action, stb);
- fprintf_filtered (stb, _("\nQuit anyway? "));
- }
+ fprintf_filtered (stb, _("A debugging session is active.\n\n"));
+ iterate_over_inferiors (print_inferior_quit_action, stb);
+ fprintf_filtered (stb, _("\nQuit anyway? "));
str = ui_file_xstrdup (stb, NULL);
make_cleanup (xfree, str);
return qr;
}
-/* Helper routine for quit_force that requires error handling. */
-
-static int
-quit_target (void *arg)
-{
- struct qt_args *qt = (struct qt_args *)arg;
-
- /* Kill or detach all inferiors. */
- iterate_over_inferiors (kill_or_detach, qt);
-
- /* Give all pushed targets a chance to do minimal cleanup, and pop
- them all out. */
- pop_all_targets (1);
-
- /* Save the history information if it is appropriate to do so. */
- if (write_history_p && history_filename)
- write_history (history_filename);
-
- do_final_cleanups (all_cleanups ()); /* Do any final cleanups before
- exiting. */
- return 0;
-}
-
/* Quit without asking for confirmation. */
void
qt.from_tty = from_tty;
/* We want to handle any quit errors and exit regardless. */
- catch_errors (quit_target, &qt,
- "Quitting: ", RETURN_MASK_ALL);
+
+ /* Get out of tfind mode, and kill or detach all inferiors. */
+ TRY
+ {
+ disconnect_tracing ();
+ iterate_over_inferiors (kill_or_detach, &qt);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ exception_print (gdb_stderr, ex);
+ }
+ END_CATCH
+
+ /* Give all pushed targets a chance to do minimal cleanup, and pop
+ them all out. */
+ TRY
+ {
+ pop_all_targets ();
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ exception_print (gdb_stderr, ex);
+ }
+ END_CATCH
+
+ /* Save the history information if it is appropriate to do so. */
+ TRY
+ {
+ if (write_history_p && history_filename
+ && input_from_terminal_p ())
+ gdb_safe_append_history ();
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ exception_print (gdb_stderr, ex);
+ }
+ END_CATCH
+
+ /* Do any final cleanups before exiting. */
+ TRY
+ {
+ do_final_cleanups (all_cleanups ());
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ exception_print (gdb_stderr, ex);
+ }
+ END_CATCH
exit (exit_code);
}
Relative to history_base. */
static int num = 0;
- /* The first command in the history which doesn't exist (i.e. one more
- than the number of the last command). Relative to history_base. */
- unsigned int hist_len;
-
/* Print out some of the commands from the command history. */
- /* First determine the length of the history list. */
- hist_len = history_size;
- for (offset = 0; offset < history_size; offset++)
- {
- if (!history_get (history_base + offset))
- {
- hist_len = offset;
- break;
- }
- }
if (args)
{
/* "show commands" means print the last Hist_print commands. */
else
{
- num = hist_len - Hist_print;
+ num = history_length - Hist_print;
}
if (num < 0)
/* If there are at least Hist_print commands, we want to display the last
Hist_print rather than, say, the last 6. */
- if (hist_len - num < Hist_print)
+ if (history_length - num < Hist_print)
{
- num = hist_len - Hist_print;
+ num = history_length - Hist_print;
if (num < 0)
num = 0;
}
- for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
+ for (offset = num;
+ offset < num + Hist_print && offset < history_length;
+ offset++)
{
printf_filtered ("%5d %s\n", history_base + offset,
(history_get (history_base + offset))->line);
static void
set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
{
- /* The type of parameter in stifle_history is int, so values from INT_MAX up
- mean 'unlimited'. */
- if (history_size >= INT_MAX)
+ /* Readline's history interface works with 'int', so it can only
+ handle history sizes up to INT_MAX. The command itself is
+ uinteger, so UINT_MAX means "unlimited", but we only get that if
+ the user does "set history size 0" -- "set history size <UINT_MAX>"
+ throws out-of-range. */
+ if (history_size_setshow_var > INT_MAX
+ && history_size_setshow_var != UINT_MAX)
{
- /* Ensure that 'show history size' prints 'unlimited'. */
- history_size = UINT_MAX;
- unstifle_history ();
+ unsigned int new_value = history_size_setshow_var;
+
+ /* Restore previous value before throwing. */
+ if (history_is_stifled ())
+ history_size_setshow_var = history_max_entries;
+ else
+ history_size_setshow_var = UINT_MAX;
+
+ error (_("integer %u out of range"), new_value);
}
+
+ /* Commit the new value to readline's history. */
+ if (history_size_setshow_var == UINT_MAX)
+ unstifle_history ();
else
- stifle_history (history_size);
+ stifle_history (history_size_setshow_var);
}
void
{
printf_unfiltered (_("\"set history\" must be followed "
"by the name of a history subcommand.\n"));
- help_list (sethistlist, "set history ", -1, gdb_stdout);
+ help_list (sethistlist, "set history ", all_commands, gdb_stdout);
}
void
void
set_verbose (char *args, int from_tty, struct cmd_list_element *c)
{
- char *cmdname = "verbose";
+ const char *cmdname = "verbose";
struct cmd_list_element *showcmd;
showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
tmpenv = getenv ("HISTSIZE");
if (tmpenv)
- history_size = atoi (tmpenv);
- else if (!history_size)
- history_size = 256;
+ {
+ int var;
- stifle_history (history_size);
+ var = atoi (tmpenv);
+ if (var < 0)
+ {
+ /* Prefer ending up with no history rather than overflowing
+ readline's history interface, which uses signed 'int'
+ everywhere. */
+ var = 0;
+ }
+
+ history_size_setshow_var = var;
+ }
+ /* If the init file hasn't set a size yet, pick the default. */
+ else if (history_size_setshow_var == 0)
+ history_size_setshow_var = 256;
+
+ /* Note that unlike "set history size 0", "HISTSIZE=0" really sets
+ the history size to 0... */
+ stifle_history (history_size_setshow_var);
tmpenv = getenv ("GDBHISTFILE");
if (tmpenv)
value);
}
+/* New values of the "data-directory" parameter are staged here. */
+static char *staged_gdb_datadir;
+
/* "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_data_directory (staged_gdb_datadir);
observer_notify_gdb_datadir_changed ();
}
+/* "show" command for the gdb_datadir configuration variable. */
+
+static void
+show_gdb_datadir (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("GDB's data directory is \"%s\".\n"),
+ gdb_datadir);
+}
+
+static void
+set_history_filename (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
+ that was read. */
+ if (!IS_ABSOLUTE_PATH (history_filename))
+ history_filename = reconcat (history_filename, current_directory, "/",
+ history_filename, (char *) NULL);
+}
+
static void
init_main (void)
{
rl_completion_entry_function = readline_line_completion_function;
rl_completer_word_break_characters = default_word_break_characters ();
rl_completer_quote_characters = get_gdb_completer_quote_characters ();
+ rl_completion_display_matches_hook = cli_display_match_list;
rl_readline_name = "gdb";
rl_terminal_name = getenv ("TERM");
show_write_history_p,
&sethistlist, &showhistlist);
- add_setshow_uinteger_cmd ("size", no_class, &history_size, _("\
+ add_setshow_uinteger_cmd ("size", no_class, &history_size_setshow_var, _("\
Set the size of the command history,"), _("\
Show the size of the command history,"), _("\
-ie. the number of previous commands to keep a record of."),
+ie. the number of previous commands to keep a record of.\n\
+If set to \"unlimited\", the number of commands kept in the history\n\
+list is unlimited. This defaults to the value of the environment\n\
+variable \"HISTSIZE\", or to 256 if this variable is not set."),
set_history_size_command,
show_history_size,
&sethistlist, &showhistlist);
Set the filename in which to record the command history"), _("\
Show the filename in which to record the command history"), _("\
(the list of previous commands of which a record is kept)."),
- NULL,
+ set_history_filename,
show_history_filename,
&sethistlist, &showhistlist);
&setlist, &showlist);
add_setshow_filename_cmd ("data-directory", class_maintenance,
- &gdb_datadir, _("Set GDB's data directory."),
+ &staged_gdb_datadir, _("Set GDB's data directory."),
_("Show GDB's data directory."),
_("\
When set, GDB uses the specified path to search for data files."),
- set_gdb_datadir, NULL,
+ set_gdb_datadir, show_gdb_datadir,
&setlist,
&showlist);
}
initialize_inferiors ();
initialize_current_architecture ();
init_cli_cmds();
- initialize_event_loop ();
init_main (); /* But that omits this file! Do it now. */
initialize_stdin_serial ();
+ /* Take a snapshot of our tty state before readline/ncurses have had a chance
+ to alter it. */
+ set_initial_gdb_ttystate ();
+
async_init_signals ();
/* We need a default language for parsing expressions, so simple
if (deprecated_init_ui_hook)
deprecated_init_ui_hook (argv0);
-#ifdef HAVE_PYTHON
- /* Python initialization can require various commands to be
+ /* Python initialization, for example, can require various commands to be
installed. For example "info pretty-printer" needs the "info"
prefix to be installed. Keep things simple and just do final
- python initialization here. */
- finish_python_initialization ();
-#endif
+ script initialization here. */
+ finish_ext_lang_initialization ();
}
projects / binutils.git / blobdiff