/* List lines of source files 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 "gdbcmd.h"
#include "frame.h"
#include "value.h"
-#include "gdb_assert.h"
+#include "filestuff.h"
#include <sys/types.h>
-#include "gdb_string.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include <fcntl.h>
#include "gdbcore.h"
#include "gdb_regex.h"
#include "ui-out.h"
#include "readline/readline.h"
-#include "psymtab.h"
-
-
#define OPEN_MODE (O_RDONLY | O_BINARY)
#define FDOPEN_MODE FOPEN_RB
value);
}
+/* Possible values of 'set filename-display'. */
+static const char filename_display_basename[] = "basename";
+static const char filename_display_relative[] = "relative";
+static const char filename_display_absolute[] = "absolute";
+
+static const char *const filename_display_kind_names[] = {
+ filename_display_basename,
+ filename_display_relative,
+ filename_display_absolute,
+ NULL
+};
+
+static const char *filename_display_string = filename_display_relative;
+
+static void
+show_filename_display_string (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Filenames are displayed as \"%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. */
static int last_line_listed;
-/* First line number listed by last listing command. */
+/* First line number listed by last listing command. If 0, then no
+ source lines have yet been listed since the last time the current
+ source line was changed. */
static int first_line_listed;
return first_line_listed;
}
+/* Clear line listed range. This makes the next "list" center the
+ printed source lines around the current source line. */
+
+static void
+clear_lines_listed_range (void)
+{
+ first_line_listed = 0;
+ last_line_listed = 0;
+}
+
/* Return the default number of lines to print with commands like the
cli "list". The caller of print_source_lines must use this to
calculate the end line and use it in the call to print_source_lines
current_source_symtab = sal->symtab;
current_source_line = sal->line;
+ /* Force the next "list" to center around the current line. */
+ clear_lines_listed_range ();
+
return cursal;
}
struct symtabs_and_lines sals;
struct symtab_and_line sal;
struct objfile *ofp;
+ struct compunit_symtab *cu;
if (s)
{
/* Make the default place to list be the function `main'
if one exists. */
- if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0))
+ if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0).symbol)
{
sals = decode_line_with_current_source (main_name (),
DECODE_LINE_FUNFIRSTLINE);
current_source_line = 1;
- ALL_OBJFILES (ofp)
+ ALL_FILETABS (ofp, cu, s)
{
- for (s = ofp->symtabs; s; s = s->next)
- {
- const char *name = s->filename;
- int len = strlen (name);
+ const char *name = s->filename;
+ int len = strlen (name);
- if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
- || strcmp (name, "<<C++-namespaces>>") == 0)))
- {
- current_source_pspace = current_program_space;
- current_source_symtab = s;
- }
+ if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
+ || strcmp (name, "<<C++-namespaces>>") == 0)))
+ {
+ current_source_pspace = current_program_space;
+ current_source_symtab = s;
}
}
void
forget_cached_source_info_for_objfile (struct objfile *objfile)
{
+ struct compunit_symtab *cu;
struct symtab *s;
- ALL_OBJFILE_SYMTABS (objfile, s)
+ ALL_OBJFILE_FILETABS (objfile, cu, s)
{
if (s->line_charpos != NULL)
{
char tinybuf[2];
p = *which_path;
- /* FIXME: we should use realpath() or its work-alike
- before comparing. Then all the code above which
- removes excess slashes and dots could simply go away. */
- if (!filename_cmp (p, name))
+ while (1)
{
- /* Found it in the search path, remove old copy. */
- if (p > *which_path)
- p--; /* Back over leading separator. */
- if (prefix > p - *which_path)
- goto skip_dup; /* Same dir twice in one cmd. */
- memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1); /* Copy from next \0 or : */
+ /* FIXME: we should use realpath() or its work-alike
+ before comparing. Then all the code above which
+ removes excess slashes and dots could simply go away. */
+ if (!filename_ncmp (p, name, len)
+ && (p[len] == '\0' || p[len] == DIRNAME_SEPARATOR))
+ {
+ /* Found it in the search path, remove old copy. */
+ if (p > *which_path)
+ {
+ /* Back over leading separator. */
+ p--;
+ }
+ if (prefix > p - *which_path)
+ {
+ /* Same dir twice in one cmd. */
+ goto skip_dup;
+ }
+ /* Copy from next '\0' or ':'. */
+ memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1);
+ }
+ p = strchr (p, DIRNAME_SEPARATOR);
+ if (p != 0)
+ ++p;
+ else
+ break;
}
tinybuf[0] = DIRNAME_SEPARATOR;
source_info (char *ignore, int from_tty)
{
struct symtab *s = current_source_symtab;
+ struct compunit_symtab *cust;
if (!s)
{
printf_filtered (_("No current source file.\n"));
return;
}
+
+ cust = SYMTAB_COMPUNIT (s);
printf_filtered (_("Current source file is %s\n"), s->filename);
- if (s->dirname)
- printf_filtered (_("Compilation directory is %s\n"), s->dirname);
+ if (SYMTAB_DIRNAME (s) != NULL)
+ printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s));
if (s->fullname)
printf_filtered (_("Located in %s\n"), s->fullname);
if (s->nlines)
s->nlines == 1 ? "" : "s");
printf_filtered (_("Source language is %s.\n"), language_str (s->language));
- printf_filtered (_("Compiled with %s debugging format.\n"), s->debugformat);
+ printf_filtered (_("Producer is %s.\n"),
+ COMPUNIT_PRODUCER (cust) != NULL
+ ? COMPUNIT_PRODUCER (cust) : _("unknown"));
+ printf_filtered (_("Compiled with %s debugging format.\n"),
+ COMPUNIT_DEBUGFORMAT (cust));
printf_filtered (_("%s preprocessor macro info.\n"),
- s->macro_table ? "Includes" : "Does not include");
+ COMPUNIT_MACRO_TABLE (cust) != NULL
+ ? "Includes" : "Does not include");
}
\f
If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
(ie pretend the first element of PATH is "."). This also indicates
- that a slash in STRING disables searching of the path (this is
- so that "exec-file ./foo" or "symbol-file ./foo" insures that you
- get that particular version of foo or an error message).
+ that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
+ disables searching of the path (this is so that "exec-file ./foo" or
+ "symbol-file ./foo" insures that you get that particular version of
+ foo or an error message).
If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
searched in path (we usually want this for source files but not for
and the file, sigh! Emacs gets confuzzed by this when we print the
source file name!!!
+ If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
+ gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
+ filename starting with "/". If FILENAME_OPENED is NULL this option has no
+ effect.
+
If a file is found, return the descriptor.
Otherwise, return -1, with errno set for the last name we tried to open. */
struct cleanup *back_to;
int ix;
char *dir;
+ /* The errno set for the last name we tried to open (and
+ failed). */
+ int last_errno = 0;
/* The open syscall MODE parameter is not specified. */
gdb_assert ((mode & O_CREAT) == 0);
if (is_regular_file (string))
{
- filename = alloca (strlen (string) + 1);
+ filename = (char *) alloca (strlen (string) + 1);
strcpy (filename, string);
- fd = open (filename, mode);
+ fd = gdb_open_cloexec (filename, mode, 0);
if (fd >= 0)
goto done;
}
filename = NULL;
fd = -1;
}
+ last_errno = errno;
if (!(opts & OPF_SEARCH_IN_PATH))
for (i = 0; string[i]; i++)
string += 2;
alloclen = strlen (path) + strlen (string) + 2;
- filename = alloca (alloclen);
+ filename = (char *) alloca (alloclen);
fd = -1;
+ last_errno = ENOENT;
dir_vec = dirnames_to_char_ptr_vec (path);
back_to = make_cleanup_free_char_ptr_vec (dir_vec);
if (newlen > alloclen)
{
alloclen = newlen;
- filename = alloca (alloclen);
+ filename = (char *) alloca (alloclen);
}
strcpy (filename, current_directory);
}
if (newlen > alloclen)
{
alloclen = newlen;
- filename = alloca (alloclen);
+ filename = (char *) alloca (alloclen);
}
strcpy (filename, tilde_expanded);
xfree (tilde_expanded);
if (is_regular_file (filename))
{
- fd = open (filename, mode);
+ fd = gdb_open_cloexec (filename, mode, 0);
if (fd >= 0)
break;
+ last_errno = errno;
}
}
done:
if (filename_opened)
{
- /* If a file was opened, canonicalize its filename. Use xfullpath
- rather than gdb_realpath to avoid resolving the basename part
- of filenames when the associated file is a symbolic link. This
- fixes a potential inconsistency between the filenames known to
- GDB and the filenames it prints in the annotations. */
+ /* If a file was opened, canonicalize its filename. */
if (fd < 0)
*filename_opened = NULL;
- else if (IS_ABSOLUTE_PATH (filename))
- *filename_opened = xfullpath (filename);
+ else if ((opts & OPF_RETURN_REALPATH) != 0)
+ *filename_opened = gdb_realpath (filename);
else
- {
- /* Beware the // my son, the Emacs barfs, the botch that catch... */
-
- char *f = concat (current_directory,
- IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
- ? "" : SLASH_STRING,
- filename, (char *)NULL);
-
- *filename_opened = xfullpath (f);
- xfree (f);
- }
+ *filename_opened = gdb_abspath (filename);
}
+ errno = last_errno;
return fd;
}
{
int fd;
- fd = openp (source_path, OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH, filename,
- O_RDONLY, full_pathname);
+ fd = openp (source_path,
+ OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH,
+ filename, O_RDONLY, full_pathname);
if (fd < 0)
{
*full_pathname = NULL;
{
const int from_len = strlen (rule->from);
const int path_len = strlen (path);
- char *path_start;
if (path_len < from_len)
return 0;
/* The substitution rules are anchored at the start of the path,
- so the path should start with rule->from. There is no filename
- comparison routine, so we need to extract the first FROM_LEN
- characters from PATH first and use that to do the comparison. */
-
- path_start = alloca (from_len + 1);
- strncpy (path_start, path, from_len);
- path_start[from_len] = '\0';
+ so the path should start with rule->from. */
- if (FILENAME_CMP (path_start, rule->from) != 0)
+ if (filename_ncmp (path, rule->from, from_len) != 0)
return 0;
/* Make sure that the region in the path that matches the substitution
rule is immediately followed by a directory separator (or the end of
string character). */
-
+
if (path[from_len] != '\0' && !IS_DIR_SEPARATOR (path[from_len]))
return 0;
Return NULL if no substitution rule was specified by the user,
or if no rule applied to the given PATH. */
-static char *
+char *
rewrite_source_path (const char *path)
{
const struct substitute_path_rule *rule = get_substitute_path_rule (path);
char *path = source_path;
const char *p;
int result;
+ struct cleanup *cleanup;
/* Quick way out if we already know its full name. */
*fullname = rewritten_fullname;
}
- result = open (*fullname, OPEN_MODE);
+ result = gdb_open_cloexec (*fullname, OPEN_MODE, 0);
if (result >= 0)
{
- /* Call xfullpath here to be consistent with openp
- which we use below. */
- char *lpath = xfullpath (*fullname);
+ char *lpath = gdb_realpath (*fullname);
xfree (*fullname);
*fullname = lpath;
*fullname = NULL;
}
+ cleanup = make_cleanup (null_cleanup, NULL);
+
if (dirname != NULL)
{
/* If necessary, rewrite the compilation directory name according
}
}
- result = openp (path, OPF_SEARCH_IN_PATH, filename, OPEN_MODE, fullname);
+ result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
+ OPEN_MODE, fullname);
if (result < 0)
{
/* Didn't work. Try using just the basename. */
p = lbasename (filename);
if (p != filename)
- result = openp (path, OPF_SEARCH_IN_PATH, p, OPEN_MODE, fullname);
+ result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, p,
+ OPEN_MODE, fullname);
}
+ do_cleanups (cleanup);
return result;
}
if (!s)
return -1;
- return find_and_open_source (s->filename, s->dirname, &s->fullname);
+ return find_and_open_source (s->filename, SYMTAB_DIRNAME (s), &s->fullname);
}
/* Finds the fullname that a symtab represents.
to handle cases like the file being moved. */
if (s->fullname == NULL)
{
- int fd = find_and_open_source (s->filename, s->dirname, &s->fullname);
+ int fd = find_and_open_source (s->filename, SYMTAB_DIRNAME (s),
+ &s->fullname);
if (fd >= 0)
close (fd);
- else if (s->dirname == NULL)
- s->fullname = xstrdup (s->filename);
else
- s->fullname = concat (s->dirname, SLASH_STRING, s->filename, NULL);
+ {
+ char *fullname;
+ struct cleanup *back_to;
+
+ /* rewrite_source_path would be applied by find_and_open_source, we
+ should report the pathname where GDB tried to find the file. */
+
+ if (SYMTAB_DIRNAME (s) == NULL || IS_ABSOLUTE_PATH (s->filename))
+ fullname = xstrdup (s->filename);
+ else
+ fullname = concat (SYMTAB_DIRNAME (s), SLASH_STRING, s->filename,
+ NULL);
+
+ back_to = make_cleanup (xfree, fullname);
+ s->fullname = rewrite_source_path (fullname);
+ if (s->fullname == NULL)
+ s->fullname = xstrdup (fullname);
+ do_cleanups (back_to);
+ }
}
return s->fullname;
}
+
+/* See commentary in source.h. */
+
+const char *
+symtab_to_filename_for_display (struct symtab *symtab)
+{
+ if (filename_display_string == filename_display_basename)
+ return lbasename (symtab->filename);
+ else if (filename_display_string == filename_display_absolute)
+ return symtab_to_fullname (symtab);
+ else if (filename_display_string == filename_display_relative)
+ return symtab->filename;
+ else
+ internal_error (__FILE__, __LINE__, _("invalid filename_display_string"));
+}
\f
/* Create and initialize the table S->line_charpos that records
the positions of the lines in the source file, which is assumed
int size;
gdb_assert (s);
- line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
+ line_charpos = XNEWVEC (int, lines_allocated);
if (fstat (desc, &st) < 0)
- perror_with_name (s->filename);
+ perror_with_name (symtab_to_filename_for_display (s));
- if (s->objfile && s->objfile->obfd)
- mtime = s->objfile->mtime;
+ if (SYMTAB_OBJFILE (s) != NULL && SYMTAB_OBJFILE (s)->obfd != NULL)
+ mtime = SYMTAB_OBJFILE (s)->mtime;
else if (exec_bfd)
mtime = exec_bfd_mtime;
/* Reassign `size' to result of read for systems where \r\n -> \n. */
size = myread (desc, data, size);
if (size < 0)
- perror_with_name (s->filename);
+ perror_with_name (symtab_to_filename_for_display (s));
end = data + size;
p = data;
line_charpos[0] = 0;
/* Don't index off the end of the line_charpos array. */
return 0;
annotate_source (s->fullname, line, s->line_charpos[line - 1],
- mid_statement, get_objfile_arch (s->objfile), pc);
+ mid_statement, get_objfile_arch (SYMTAB_OBJFILE (s)), pc);
current_source_line = line;
- first_line_listed = line;
- last_line_listed = line;
current_source_symtab = s;
+ clear_lines_listed_range ();
return 1;
}
\f
if (!(flags & PRINT_SOURCE_LINES_NOERROR))
{
- int len = strlen (s->filename) + 100;
- char *name = alloca (len);
+ const char *filename = symtab_to_filename_for_display (s);
+ int len = strlen (filename) + 100;
+ char *name = (char *) alloca (len);
- xsnprintf (name, len, "%d\t%s", line, s->filename);
+ xsnprintf (name, len, "%d\t%s", line, filename);
print_sys_errmsg (name, errno);
}
else
{
ui_out_field_int (uiout, "line", line);
ui_out_text (uiout, "\tin ");
- ui_out_field_string (uiout, "file", s->filename);
- if (ui_out_is_mi_like_p (uiout))
- {
- const char *fullname = symtab_to_fullname (s);
- ui_out_field_string (uiout, "fullname", fullname);
- }
+ /* CLI expects only the "file" field. TUI expects only the
+ "fullname" field (and TUI does break if "file" is printed).
+ MI expects both fields. ui_source_list is set only for CLI,
+ not for TUI. */
+ if (ui_out_is_mi_like_p (uiout)
+ || ui_out_test_flags (uiout, ui_source_list))
+ ui_out_field_string (uiout, "file",
+ symtab_to_filename_for_display (s));
+ if (ui_out_is_mi_like_p (uiout)
+ || !ui_out_test_flags (uiout, ui_source_list))
+ {
+ const char *s_fullname = symtab_to_fullname (s);
+ char *local_fullname;
+
+ /* ui_out_field_string may free S_FULLNAME by calling
+ open_source_file for it again. See e.g.,
+ tui_field_string->tui_show_source. */
+ local_fullname = (char *) alloca (strlen (s_fullname) + 1);
+ strcpy (local_fullname, s_fullname);
+
+ ui_out_field_string (uiout, "fullname", local_fullname);
+ }
+
ui_out_text (uiout, "\n");
}
{
close (desc);
error (_("Line number %d out of range; %s has %d lines."),
- line, s->filename, s->nlines);
+ line, symtab_to_filename_for_display (s), s->nlines);
}
if (lseek (desc, s->line_charpos[line - 1], 0) < 0)
{
close (desc);
- perror_with_name (s->filename);
+ perror_with_name (symtab_to_filename_for_display (s));
}
stream = fdopen (desc, FDOPEN_MODE);
last_line_listed = current_source_line;
if (flags & PRINT_SOURCE_LINES_FILENAME)
{
- ui_out_text (uiout, s->filename);
+ ui_out_text (uiout, symtab_to_filename_for_display (s));
ui_out_text (uiout, ":");
}
xsnprintf (buf, sizeof (buf), "%d\t", current_source_line++);
{
sal.symtab = current_source_symtab;
sal.pspace = current_program_space;
- sal.line = last_line_listed;
+ if (last_line_listed != 0)
+ sal.line = last_line_listed;
+ else
+ sal.line = current_source_line;
+
sals.nelts = 1;
- sals.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
+ sals.sals = XNEW (struct symtab_and_line);
sals.sals[0] = sal;
}
else
else if (sal.line > 0
&& find_line_pc_range (sal, &start_pc, &end_pc))
{
- struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile);
+ struct gdbarch *gdbarch
+ = get_objfile_arch (SYMTAB_OBJFILE (sal.symtab));
if (start_pc == end_pc)
{
printf_filtered ("Line %d of \"%s\"",
- sal.line, sal.symtab->filename);
+ sal.line,
+ symtab_to_filename_for_display (sal.symtab));
wrap_here (" ");
printf_filtered (" is at address ");
print_address (gdbarch, start_pc, gdb_stdout);
else
{
printf_filtered ("Line %d of \"%s\"",
- sal.line, sal.symtab->filename);
+ sal.line,
+ symtab_to_filename_for_display (sal.symtab));
wrap_here (" ");
printf_filtered (" starts at address ");
print_address (gdbarch, start_pc, gdb_stdout);
which the user would want to see? If we have debugging symbols
and no line numbers? */
printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
- sal.line, sal.symtab->filename);
+ sal.line, symtab_to_filename_for_display (sal.symtab));
}
do_cleanups (cleanups);
}
desc = open_source_file (current_source_symtab);
if (desc < 0)
- perror_with_name (current_source_symtab->filename);
+ perror_with_name (symtab_to_filename_for_display (current_source_symtab));
cleanups = make_cleanup_close (desc);
if (current_source_symtab->line_charpos == 0)
error (_("Expression not found"));
if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
- perror_with_name (current_source_symtab->filename);
+ perror_with_name (symtab_to_filename_for_display (current_source_symtab));
discard_cleanups (cleanups);
stream = fdopen (desc, FDOPEN_MODE);
int cursize, newsize;
cursize = 256;
- buf = xmalloc (cursize);
+ buf = (char *) xmalloc (cursize);
p = buf;
- c = getc (stream);
+ c = fgetc (stream);
if (c == EOF)
break;
do
if (p - buf == cursize)
{
newsize = cursize + cursize / 2;
- buf = xrealloc (buf, newsize);
+ buf = (char *) xrealloc (buf, newsize);
p = buf + cursize;
cursize = newsize;
}
}
- while (c != '\n' && (c = getc (stream)) >= 0);
+ while (c != '\n' && (c = fgetc (stream)) >= 0);
/* Remove the \r, if any, at the end of the line, otherwise
regular expressions that end with $ or \n won't work. */
desc = open_source_file (current_source_symtab);
if (desc < 0)
- perror_with_name (current_source_symtab->filename);
+ perror_with_name (symtab_to_filename_for_display (current_source_symtab));
cleanups = make_cleanup_close (desc);
if (current_source_symtab->line_charpos == 0)
error (_("Expression not found"));
if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
- perror_with_name (current_source_symtab->filename);
+ perror_with_name (symtab_to_filename_for_display (current_source_symtab));
discard_cleanups (cleanups);
stream = fdopen (desc, FDOPEN_MODE);
char buf[4096]; /* Should be reasonable??? */
char *p = buf;
- c = getc (stream);
+ c = fgetc (stream);
if (c == EOF)
break;
do
{
*p++ = c;
}
- while (c != '\n' && (c = getc (stream)) >= 0);
+ while (c != '\n' && (c = fgetc (stream)) >= 0);
/* Remove the \r, if any, at the end of the line, otherwise
regular expressions that end with $ or \n won't work. */
line--;
if (fseek (stream, current_source_symtab->line_charpos[line - 1], 0) < 0)
{
+ const char *filename;
+
do_cleanups (cleanups);
- perror_with_name (current_source_symtab->filename);
+ filename = symtab_to_filename_for_display (current_source_symtab);
+ perror_with_name (filename);
}
}
add_substitute_path_rule (char *from, char *to)
{
struct substitute_path_rule *rule;
- struct substitute_path_rule *new_rule;
+ struct substitute_path_rule *new_rule = XNEW (struct substitute_path_rule);
- new_rule = xmalloc (sizeof (struct substitute_path_rule));
new_rule->from = xstrdup (from);
new_rule->to = xstrdup (to);
new_rule->next = NULL;
struct substitute_path_rule *rule = substitute_path_rules;
char **argv;
char *from = NULL;
+ struct cleanup *cleanup;
argv = gdb_buildargv (args);
- make_cleanup_freeargv (argv);
+ cleanup = make_cleanup_freeargv (argv);
/* We expect zero or one argument. */
while (rule != NULL)
{
- if (from == NULL || FILENAME_CMP (rule->from, from) == 0)
+ if (from == NULL || substitute_path_rule_matches (rule, from) != 0)
printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
rule = rule->next;
}
+
+ do_cleanups (cleanup);
}
/* Implement the "unset substitute-path" command. */
char **argv = gdb_buildargv (args);
char *from = NULL;
int rule_found = 0;
+ struct cleanup *cleanup;
/* This function takes either 0 or 1 argument. */
- make_cleanup_freeargv (argv);
+ cleanup = make_cleanup_freeargv (argv);
if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
error (_("Incorrect usage, too many arguments in command"));
error (_("No substitution rule defined for `%s'"), from);
forget_cached_source_info ();
+
+ do_cleanups (cleanup);
}
/* Add a new source path substitution rule. */
{
char **argv;
struct substitute_path_rule *rule;
+ struct cleanup *cleanup;
argv = gdb_buildargv (args);
- make_cleanup_freeargv (argv);
+ cleanup = make_cleanup_freeargv (argv);
if (argv == NULL || argv[0] == NULL || argv [1] == NULL)
error (_("Incorrect usage, too few arguments in command"));
add_substitute_path_rule (argv[0], argv[1]);
forget_cached_source_info ();
+
+ do_cleanups (cleanup);
}
\f
show_directories_command,
&setlist, &showlist);
- if (xdb_commands)
- {
- add_com_alias ("D", "directory", class_files, 0);
- add_cmd ("ld", no_class, show_directories_1, _("\
-Current search path for finding source files.\n\
-$cwd in the path means the current working directory.\n\
-$cdir in the path means the compilation directory of the source file."),
- &cmdlist);
- }
-
add_info ("source", source_info,
_("Information about the current source file."));
The matching line number is also stored as the value of \"$_\"."));
add_com_alias ("rev", "reverse-search", class_files, 1);
- if (xdb_commands)
- {
- add_com_alias ("/", "forward-search", class_files, 0);
- add_com_alias ("?", "reverse-search", class_files, 0);
- }
-
- add_setshow_zuinteger_unlimited_cmd ("listsize", class_support,
- &lines_to_list, _("\
+ add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\
Set number of source lines gdb will list by default."), _("\
-Show number of source lines gdb will list by default."), NULL,
- NULL, show_lines_to_list,
- &setlist, &showlist);
+Show number of source lines gdb will list by default."), _("\
+Use this to choose how many source lines the \"list\" displays (unless\n\
+the \"list\" argument explicitly specifies some other number).\n\
+A value of \"unlimited\", or zero, means there's no limit."),
+ NULL,
+ show_lines_to_list,
+ &setlist, &showlist);
add_cmd ("substitute-path", class_files, set_substitute_path_command,
_("\
Print the rule for substituting FROM in source file names. If FROM\n\
is not specified, print all substitution rules."),
&showlist);
+
+ add_setshow_enum_cmd ("filename-display", class_files,
+ filename_display_kind_names,
+ &filename_display_string, _("\
+Set how to display filenames."), _("\
+Show how to display filenames."), _("\
+filename-display can be:\n\
+ basename - display only basename of a filename\n\
+ relative - display a filename relative to the compilation directory\n\
+ absolute - display an absolute filename\n\
+By default, relative filenames are displayed."),
+ NULL,
+ show_filename_display_string,
+ &setlist, &showlist);
+
}