/* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/types.h>
#include <fcntl.h>
#include "gdbcore.h"
-#include "gdb_regex.h"
+#include "gdbsupport/gdb_regex.h"
#include "symfile.h"
#include "objfiles.h"
#include "annotate.h"
#include "observable.h"
#include "build-id.h"
#include "debuginfod-support.h"
+#include "gdbsupport/buildargv.h"
#define OPEN_MODE (O_RDONLY | O_BINARY)
#define FDOPEN_MODE FOPEN_RB
/* Path of directories to search for source files.
Same format as the PATH environment variable's value. */
-char *source_path;
+std::string source_path;
/* Support for source path substitution commands. */
struct substitute_path_rule
{
- char *from;
- char *to;
- struct substitute_path_rule *next;
+ substitute_path_rule (const char *from_, const char *to_)
+ : from (from_),
+ to (to_)
+ {
+ }
+
+ std::string from;
+ std::string to;
};
-static struct substitute_path_rule *substitute_path_rules = NULL;
+static std::list<substitute_path_rule> substitute_path_rules;
/* An instance of this is attached to each program space. */
{
fprintf_filtered (file, _("Filenames are displayed as \"%s\".\n"), value);
}
-
+
+/* When true GDB will stat and open source files as required, but when
+ false, GDB will avoid accessing source files as much as possible. */
+
+static bool source_open = true;
+
+/* Implement 'show source open'. */
+
+static void
+show_source_open (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Source opening is \"%s\".\n"), value);
+}
+
/* Line number of last line printed. Default for various commands.
current_source_line is usually, but not always, the same as this. */
if (bsym.symbol != nullptr && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
{
symtab_and_line sal = find_function_start_sal (bsym.symbol, true);
- loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
+ if (sal.symtab == NULL)
+ /* We couldn't find the location of `main', possibly due to missing
+ line number info, fall back to line 1 in the corresponding file. */
+ loc->set (symbol_symtab (bsym.symbol), 1);
+ else
+ loc->set (sal.symtab, std::max (sal.line - (lines_to_list - 1), 1));
return;
}
for (objfile *objfile : current_program_space->objfiles ())
{
- if (objfile->sf)
- s = objfile->sf->qf->find_last_source_symtab (objfile);
+ s = objfile->find_last_source_symtab ();
if (s)
new_symtab = s;
}
{
/* This is the value that was set.
It needs to be processed to maintain $cdir:$cwd and remove dups. */
- char *set_path = source_path;
+ std::string set_path = source_path;
/* We preserve the invariant that $cdir:$cwd begins life at the end of
the list by calling init_source_path. If they appear earlier in
SET_PATH then mod_path will move them appropriately.
mod_path will also remove duplicates. */
init_source_path ();
- if (*set_path != '\0')
- mod_path (set_path, &source_path);
-
- xfree (set_path);
+ if (!set_path.empty ())
+ mod_path (set_path.c_str (), source_path);
}
/* Print the list of source directories.
function. */
static void
-show_directories_1 (char *ignore, int from_tty)
+show_directories_1 (ui_file *file, char *ignore, int from_tty)
{
- puts_filtered ("Source directories searched: ");
- puts_filtered (source_path);
- puts_filtered ("\n");
+ fputs_filtered ("Source directories searched: ", file);
+ fputs_filtered (source_path.c_str (), file);
+ fputs_filtered ("\n", file);
}
/* Handler for "show directories" command. */
show_directories_command (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- show_directories_1 (NULL, from_tty);
+ show_directories_1 (file, NULL, from_tty);
}
/* See source.h. */
}
}
- if (objfile->sf)
- objfile->sf->qf->forget_cached_source_info (objfile);
+ objfile->forget_cached_source_info ();
}
/* See source.h. */
void
init_source_path (void)
{
- char buf[20];
-
- xsnprintf (buf, sizeof (buf), "$cdir%c$cwd", DIRNAME_SEPARATOR);
- source_path = xstrdup (buf);
+ source_path = string_printf ("$cdir%c$cwd", DIRNAME_SEPARATOR);
forget_cached_source_info ();
}
static void
directory_command (const char *dirname, int from_tty)
{
+ bool value_changed = false;
dont_repeat ();
/* FIXME, this goes to "delete dir"... */
if (dirname == 0)
{
if (!from_tty || query (_("Reinitialize source path to empty? ")))
{
- xfree (source_path);
init_source_path ();
+ value_changed = true;
}
}
else
{
- mod_path (dirname, &source_path);
+ mod_path (dirname, source_path);
forget_cached_source_info ();
+ value_changed = true;
+ }
+ if (value_changed)
+ {
+ gdb::observers::command_param_changed.notify ("directories",
+ source_path.c_str ());
+ if (from_tty)
+ show_directories_1 (gdb_stdout, (char *) 0, from_tty);
}
- if (from_tty)
- show_directories_1 ((char *) 0, from_tty);
}
/* Add a path given with the -d command line switch.
void
directory_switch (const char *dirname, int from_tty)
{
- add_path (dirname, &source_path, 0);
+ add_path (dirname, source_path, 0);
}
/* Add zero or more directories to the front of an arbitrary path. */
void
-mod_path (const char *dirname, char **which_path)
+mod_path (const char *dirname, std::string &which_path)
{
add_path (dirname, which_path, 1);
}
gdb::unique_xmalloc_ptr<char> new_name_holder;
/* Spaces and tabs will have been removed by buildargv().
- NAME is the start of the directory.
+ NAME is the start of the directory.
P is the '\0' following the end. */
p = name + strlen (name);
/* On MS-DOS and MS-Windows, h:\ is different from h: */
&& !(p == name + 3 && name[1] == ':') /* "d:/" */
#endif
+ && p > name
&& IS_DIR_SEPARATOR (p[-1]))
/* Sigh. "foo/" => "foo" */
--p;
break;
}
+ if (name[0] == '\0')
+ goto skip_dup;
if (name[0] == '~')
new_name_holder.reset (tilde_expand (name));
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
more. */
if (prefix)
{
- char *temp, c;
-
- c = old[prefix];
- old[prefix] = '\0';
- temp = concat (old, tinybuf, name, (char *)NULL);
- old[prefix] = c;
- *which_path = concat (temp, "", &old[prefix], (char *) NULL);
- prefix = strlen (temp);
- xfree (temp);
+ std::string temp = std::string (old, prefix) + tinybuf + name;
+ *which_path = concat (temp.c_str (), &old[prefix],
+ (char *) nullptr);
+ prefix = temp.length ();
}
else
{
}
}
+/* add_path would need to be re-written to work on an std::string, but this is
+ not trivial. Hence this overload which copies to a `char *` and back. */
+
+void
+add_path (const char *dirname, std::string &which_path, int parse_separators)
+{
+ char *which_path_copy = xstrdup (which_path.data ());
+ add_path (dirname, &which_path_copy, parse_separators);
+ which_path = which_path_copy;
+ xfree (which_path_copy);
+}
static void
info_source_command (const char *ignore, int from_tty)
{
filename = (char *) alloca (strlen (string) + 1);
strcpy (filename, string);
- fd = gdb_open_cloexec (filename, mode, 0);
+ fd = gdb_open_cloexec (filename, mode, 0).release ();
if (fd >= 0)
goto done;
last_errno = errno;
if (is_regular_file (filename, ®_file_errno))
{
- fd = gdb_open_cloexec (filename, mode, 0);
+ fd = gdb_open_cloexec (filename, mode, 0).release ();
if (fd >= 0)
break;
last_errno = errno;
{
int fd;
- fd = openp (source_path,
+ fd = openp (source_path.c_str (),
OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH,
filename, O_RDONLY, full_pathname);
if (fd < 0)
static int
substitute_path_rule_matches (const struct substitute_path_rule *rule,
- const char *path)
+ const char *path)
{
- const int from_len = strlen (rule->from);
+ const int from_len = rule->from.length ();
const int path_len = strlen (path);
if (path_len < from_len)
/* The substitution rules are anchored at the start of the path,
so the path should start with rule->from. */
- if (filename_ncmp (path, rule->from, from_len) != 0)
+ if (filename_ncmp (path, rule->from.c_str (), from_len) != 0)
return 0;
/* Make sure that the region in the path that matches the substitution
static struct substitute_path_rule *
get_substitute_path_rule (const char *path)
{
- struct substitute_path_rule *rule = substitute_path_rules;
-
- while (rule != NULL && !substitute_path_rule_matches (rule, path))
- rule = rule->next;
+ for (substitute_path_rule &rule : substitute_path_rules)
+ if (substitute_path_rule_matches (&rule, path))
+ return &rule;
- return rule;
+ return nullptr;
}
/* If the user specified a source path substitution rule that applies
rewrite_source_path (const char *path)
{
const struct substitute_path_rule *rule = get_substitute_path_rule (path);
- char *new_path;
- int from_len;
-
- if (rule == NULL)
- return NULL;
- from_len = strlen (rule->from);
+ if (rule == nullptr)
+ return nullptr;
/* Compute the rewritten path and return it. */
- new_path =
- (char *) xmalloc (strlen (path) + 1 + strlen (rule->to) - from_len);
- strcpy (new_path, rule->to);
- strcat (new_path, path + from_len);
-
- return gdb::unique_xmalloc_ptr<char> (new_path);
+ return (gdb::unique_xmalloc_ptr<char>
+ (concat (rule->to.c_str (), path + rule->from.length (), nullptr)));
}
/* See source.h. */
const char *dirname,
gdb::unique_xmalloc_ptr<char> *fullname)
{
- char *path = source_path;
+ const char *path = source_path.c_str ();
+ std::string expanded_path_holder;
const char *p;
- int result;
- /* Quick way out if we already know its full name. */
+ /* If reading of source files is disabled then return a result indicating
+ the attempt to read this source file failed. GDB will then display
+ the filename and line number instead. */
+ if (!source_open)
+ return scoped_fd (-1);
+ /* Quick way out if we already know its full name. */
if (*fullname)
{
/* The user may have requested that source paths be rewritten
- according to substitution rules he provided. If a substitution
- rule applies to this path, then apply it. */
+ according to substitution rules he provided. If a substitution
+ rule applies to this path, then apply it. */
gdb::unique_xmalloc_ptr<char> rewritten_fullname
= rewrite_source_path (fullname->get ());
if (rewritten_fullname != NULL)
*fullname = std::move (rewritten_fullname);
- result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0);
- if (result >= 0)
+ scoped_fd result = gdb_open_cloexec (fullname->get (), OPEN_MODE, 0);
+ if (result.get () >= 0)
{
*fullname = gdb_realpath (fullname->get ());
- return scoped_fd (result);
+ return result;
}
/* Didn't work -- free old one, try again. */
if (dirname != NULL)
{
/* If necessary, rewrite the compilation directory name according
- to the source path substitution rules specified by the user. */
+ to the source path substitution rules specified by the user. */
rewritten_dirname = rewrite_source_path (dirname);
/* Replace a path entry of $cdir with the compilation directory
name. */
#define cdir_len 5
- p = strstr (source_path, "$cdir");
+ p = strstr (source_path.c_str (), "$cdir");
if (p && (p == path || p[-1] == DIRNAME_SEPARATOR)
&& (p[cdir_len] == DIRNAME_SEPARATOR || p[cdir_len] == '\0'))
{
- int len;
-
- path = (char *)
- alloca (strlen (source_path) + 1 + strlen (dirname) + 1);
- len = p - source_path;
- strncpy (path, source_path, len); /* Before $cdir */
- strcpy (path + len, dirname); /* new stuff */
- strcat (path + len, source_path + len + cdir_len); /* After
- $cdir */
+ int len = p - source_path.c_str ();
+
+ /* Before $cdir */
+ expanded_path_holder = source_path.substr (0, len);
+
+ /* new stuff */
+ expanded_path_holder += dirname;
+
+ /* After $cdir */
+ expanded_path_holder += source_path.c_str () + len + cdir_len;
+
+ path = expanded_path_holder.c_str ();
}
}
filename = rewritten_filename.get ();
/* Try to locate file using filename. */
- result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
- OPEN_MODE, fullname);
+ int result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
+ OPEN_MODE, fullname);
if (result < 0 && dirname != NULL)
{
/* Remove characters from the start of PATH that we don't need when
return fd;
}
+/* See source.h. */
+
+gdb::unique_xmalloc_ptr<char>
+find_source_or_rewrite (const char *filename, const char *dirname)
+{
+ gdb::unique_xmalloc_ptr<char> fullname;
+
+ scoped_fd fd = find_and_open_source (filename, dirname, &fullname);
+ if (fd.get () < 0)
+ {
+ /* rewrite_source_path would be applied by find_and_open_source, we
+ should report the pathname where GDB tried to find the file. */
+
+ if (dirname == nullptr || IS_ABSOLUTE_PATH (filename))
+ fullname.reset (xstrdup (filename));
+ else
+ fullname.reset (concat (dirname, SLASH_STRING,
+ filename, (char *) nullptr));
+
+ gdb::unique_xmalloc_ptr<char> rewritten
+ = rewrite_source_path (fullname.get ());
+ if (rewritten != nullptr)
+ fullname = std::move (rewritten);
+ }
+
+ return fullname;
+}
+
/* Finds the fullname that a symtab represents.
This functions finds the fullname and saves it in s->fullname.
/* If printing of source lines is disabled, just print file and line
number. */
- if (uiout->test_flags (ui_source_list))
+ if (uiout->test_flags (ui_source_list) && source_open)
{
/* Only prints "No such file or directory" once. */
if (s == last_source_visited)
uiout->field_string ("file", symtab_to_filename_for_display (s),
file_name_style.style ());
if (uiout->is_mi_like_p () || !uiout->test_flags (ui_source_list))
- {
+ {
const char *s_fullname = symtab_to_fullname (s);
char *local_fullname;
strcpy (local_fullname, s_fullname);
uiout->field_string ("fullname", local_fullname);
- }
+ }
uiout->text ("\n");
}
last_line_listed = loc->line ();
if (flags & PRINT_SOURCE_LINES_FILENAME)
- {
- uiout->text (symtab_to_filename_for_display (s));
- uiout->text (":");
- }
+ {
+ uiout->text (symtab_to_filename_for_display (s));
+ uiout->text (":");
+ }
xsnprintf (buf, sizeof (buf), "%d\t", new_lineno++);
uiout->text (buf);
if (iter > start)
{
std::string text (start, iter);
- uiout->text (text.c_str ());
+ uiout->text (text);
}
if (*iter == '\r')
{
if (sal.pc != 0)
{
/* This is useful for "info line *0x7f34". If we can't tell the
- user about a source line, at least let them have the symbolic
- address. */
+ user about a source line, at least let them have the symbolic
+ address. */
printf_filtered (" for address ");
wrap_here (" ");
print_address (gdbarch, sal.pc, gdb_stdout);
/* If this is the only line, show the source code. If it could
not find the file, don't do anything special. */
- if (sals.size () == 1)
+ if (annotation_level > 0 && sals.size () == 1)
annotate_source_line (sal.symtab, sal.line, 0, start_pc);
}
else
if (loc->symtab () == nullptr)
select_source_symtab (0);
+ if (!source_open)
+ error (_("source code access disabled"));
+
scoped_fd desc (open_source_file (loc->symtab ()));
if (desc.get () < 0)
perror_with_name (symtab_to_filename_for_display (loc->symtab ()));
while (c != '\n' && (c = fgetc (stream.get ())) >= 0);
/* Remove the \r, if any, at the end of the line, otherwise
- regular expressions that end with $ or \n won't work. */
+ regular expressions that end with $ or \n won't work. */
size_t sz = buf.size ();
if (sz >= 2 && buf[sz - 2] == '\r')
{
path[last] = '\0';
}
-/* Return the path substitution rule that matches FROM.
- Return NULL if no rule matches. */
-
-static struct substitute_path_rule *
-find_substitute_path_rule (const char *from)
-{
- struct substitute_path_rule *rule = substitute_path_rules;
-
- while (rule != NULL)
- {
- if (FILENAME_CMP (rule->from, from) == 0)
- return rule;
- rule = rule->next;
- }
-
- return NULL;
-}
-
/* Add a new substitute-path rule at the end of the current list of rules.
The new rule will replace FROM into TO. */
void
-add_substitute_path_rule (char *from, char *to)
-{
- struct substitute_path_rule *rule;
- struct substitute_path_rule *new_rule = XNEW (struct substitute_path_rule);
-
- new_rule->from = xstrdup (from);
- new_rule->to = xstrdup (to);
- new_rule->next = NULL;
-
- /* If the list of rules are empty, then insert the new rule
- at the head of the list. */
-
- if (substitute_path_rules == NULL)
- {
- substitute_path_rules = new_rule;
- return;
- }
-
- /* Otherwise, skip to the last rule in our list and then append
- the new rule. */
-
- rule = substitute_path_rules;
- while (rule->next != NULL)
- rule = rule->next;
-
- rule->next = new_rule;
-}
-
-/* Remove the given source path substitution rule from the current list
- of rules. The memory allocated for that rule is also deallocated. */
-
-static void
-delete_substitute_path_rule (struct substitute_path_rule *rule)
+add_substitute_path_rule (const char *from, const char *to)
{
- if (rule == substitute_path_rules)
- substitute_path_rules = rule->next;
- else
- {
- struct substitute_path_rule *prev = substitute_path_rules;
-
- while (prev != NULL && prev->next != rule)
- prev = prev->next;
-
- gdb_assert (prev != NULL);
-
- prev->next = rule->next;
- }
-
- xfree (rule->from);
- xfree (rule->to);
- xfree (rule);
+ substitute_path_rules.emplace_back (from, to);
}
/* Implement the "show substitute-path" command. */
static void
show_substitute_path_command (const char *args, int from_tty)
{
- struct substitute_path_rule *rule = substitute_path_rules;
char *from = NULL;
gdb_argv argv (args);
else
printf_filtered (_("List of all source path substitution rules:\n"));
- while (rule != NULL)
+ for (substitute_path_rule &rule : substitute_path_rules)
{
- if (from == NULL || substitute_path_rule_matches (rule, from) != 0)
- printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
- rule = rule->next;
+ if (from == NULL || substitute_path_rule_matches (&rule, from) != 0)
+ printf_filtered (" `%s' -> `%s'.\n", rule.from.c_str (),
+ rule.to.c_str ());
}
}
static void
unset_substitute_path_command (const char *args, int from_tty)
{
- struct substitute_path_rule *rule = substitute_path_rules;
gdb_argv argv (args);
char *from = NULL;
- int rule_found = 0;
/* This function takes either 0 or 1 argument. */
/* Delete the rule matching the argument. No argument means that
all rules should be deleted. */
- while (rule != NULL)
+ if (from == nullptr)
+ substitute_path_rules.clear ();
+ else
{
- struct substitute_path_rule *next = rule->next;
-
- if (from == NULL || FILENAME_CMP (from, rule->from) == 0)
- {
- delete_substitute_path_rule (rule);
- rule_found = 1;
- }
-
- rule = next;
+ auto iter
+ = std::remove_if (substitute_path_rules.begin (),
+ substitute_path_rules.end (),
+ [&] (const substitute_path_rule &rule)
+ {
+ return FILENAME_CMP (from,
+ rule.from.c_str ()) == 0;
+ });
+ bool rule_found = iter != substitute_path_rules.end ();
+ substitute_path_rules.erase (iter, substitute_path_rules.end ());
+
+ /* If the user asked for a specific rule to be deleted but
+ we could not find it, then report an error. */
+
+ if (!rule_found)
+ error (_("No substitution rule defined for `%s'"), from);
}
-
- /* If the user asked for a specific rule to be deleted but
- we could not find it, then report an error. */
-
- if (from != NULL && !rule_found)
- error (_("No substitution rule defined for `%s'"), from);
forget_cached_source_info ();
}
static void
set_substitute_path_command (const char *args, int from_tty)
{
- struct substitute_path_rule *rule;
-
gdb_argv argv (args);
if (argv == NULL || argv[0] == NULL || argv [1] == NULL)
/* If a rule with the same "from" was previously defined, then
delete it. This new rule replaces it. */
- rule = find_substitute_path_rule (argv[0]);
- if (rule != NULL)
- delete_substitute_path_rule (rule);
-
+ auto iter
+ = std::remove_if (substitute_path_rules.begin (),
+ substitute_path_rules.end (),
+ [&] (const substitute_path_rule &rule)
+ {
+ return FILENAME_CMP (argv[0], rule.from.c_str ()) == 0;
+ });
+ substitute_path_rules.erase (iter, substitute_path_rules.end ());
+
/* Insert the new substitution rule. */
add_substitute_path_rule (argv[0], argv[1]);
}
}
+/* Handle the "set source" base command. */
+
+static void
+set_source (const char *arg, int from_tty)
+{
+ help_list (setsourcelist, "set source ", all_commands, gdb_stdout);
+}
+
+/* Handle the "show source" base command. */
+
+static void
+show_source (const char *args, int from_tty)
+{
+ help_list (showsourcelist, "show source ", all_commands, gdb_stdout);
+}
+
\f
void _initialize_source ();
void
_initialize_source ()
{
- struct cmd_list_element *c;
-
init_source_path ();
/* The intention is to use POSIX Basic Regular Expressions.
just an approximation. */
re_set_syntax (RE_SYNTAX_GREP);
- c = add_cmd ("directory", class_files, directory_command, _("\
+ cmd_list_element *directory_cmd
+ = add_cmd ("directory", class_files, directory_command, _("\
Add directory DIR to beginning of search path for source files.\n\
Forget cached info on source file locations and line positions.\n\
DIR can also be $cwd for the current working directory, or $cdir for the\n\
&cmdlist);
if (dbx_commands)
- add_com_alias ("use", "directory", class_files, 0);
+ add_com_alias ("use", directory_cmd, class_files, 0);
- set_cmd_completer (c, filename_completer);
+ set_cmd_completer (directory_cmd, filename_completer);
add_setshow_optional_filename_cmd ("directories",
class_files,
so that \"x/i\" suffices to start examining the machine code.\n\
The address is also stored as the value of \"$_\"."));
- add_com ("forward-search", class_files, forward_search_command, _("\
+ cmd_list_element *forward_search_cmd
+ = add_com ("forward-search", class_files, forward_search_command, _("\
Search for regular expression (see regex(3)) from last line listed.\n\
The matching line number is also stored as the value of \"$_\"."));
- add_com_alias ("search", "forward-search", class_files, 0);
- add_com_alias ("fo", "forward-search", class_files, 1);
+ add_com_alias ("search", forward_search_cmd, class_files, 0);
+ add_com_alias ("fo", forward_search_cmd, class_files, 1);
- add_com ("reverse-search", class_files, reverse_search_command, _("\
+ cmd_list_element *reverse_search_cmd
+ = add_com ("reverse-search", class_files, reverse_search_command, _("\
Search backward for regular expression (see regex(3)) from last line listed.\n\
The matching line number is also stored as the value of \"$_\"."));
- add_com_alias ("rev", "reverse-search", class_files, 1);
+ add_com_alias ("rev", reverse_search_cmd, class_files, 1);
add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\
Set number of source lines gdb will list by default."), _("\
&setlist, &showlist);
add_cmd ("substitute-path", class_files, set_substitute_path_command,
- _("\
+ _("\
Add a substitution rule to rewrite the source directories.\n\
Usage: set substitute-path FROM TO\n\
The rule is applied only if the directory name starts with FROM\n\
directly followed by a directory separator.\n\
If a substitution rule was previously set for FROM, the old rule\n\
is replaced by the new one."),
- &setlist);
+ &setlist);
add_cmd ("substitute-path", class_files, unset_substitute_path_command,
- _("\
+ _("\
Delete one or all substitution rules rewriting the source directories.\n\
Usage: unset substitute-path [FROM]\n\
Delete the rule for substituting FROM in source directories. If FROM\n\
is not specified, all substituting rules are deleted.\n\
If the debugger cannot find a rule for FROM, it will display a warning."),
- &unsetlist);
+ &unsetlist);
add_cmd ("substitute-path", class_files, show_substitute_path_command,
- _("\
+ _("\
Show one or all substitution rules rewriting the source directories.\n\
Usage: show substitute-path [FROM]\n\
Print the rule for substituting FROM in source directories. If FROM\n\
is not specified, print all substitution rules."),
- &showlist);
+ &showlist);
add_setshow_enum_cmd ("filename-display", class_files,
filename_display_kind_names,
show_filename_display_string,
&setlist, &showlist);
+ add_prefix_cmd ("source", no_class, set_source,
+ _("Generic command for setting how sources are handled."),
+ &setsourcelist, 0, &setlist);
+
+ add_prefix_cmd ("source", no_class, show_source,
+ _("Generic command for showing source settings."),
+ &showsourcelist, 0, &showlist);
+
+ add_setshow_boolean_cmd ("open", class_files, &source_open, _("\
+Set whether GDB should open source files."), _("\
+Show whether GDB should open source files."), _("\
+When this option is on GDB will open source files and display the\n\
+contents when appropriate, for example, when GDB stops, or the list\n\
+command is used.\n\
+When this option is off GDB will not try to open source files, instead\n\
+GDB will print the file and line number that would have been displayed.\n\
+This can be useful if access to source code files is slow, for example\n\
+due to the source being located over a slow network connection."),
+ NULL,
+ show_source_open,
+ &setsourcelist, &showsourcelist);
}