/* List lines of source files for GDB, the GNU debugger.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "completer.h"
#include "ui-out.h"
#include "readline/readline.h"
+#include "common/enum-flags.h"
+#include <algorithm>
#define OPEN_MODE (O_RDONLY | O_BINARY)
#define FDOPEN_MODE FOPEN_RB
-/* Prototypes for exported functions. */
-
-void _initialize_source (void);
-
/* Prototypes for local functions. */
static int get_filename_and_charpos (struct symtab *, char **);
-static void reverse_search_command (char *, int);
-
-static void forward_search_command (char *, int);
+static void info_line_command (char *, int);
-static void line_info (char *, int);
-
-static void source_info (char *, int);
+static void info_source_command (char *, int);
/* Path of directories to search for source files.
Same format as the PATH environment variable's value. */
and friends should be rewritten to count characters and see where
things are wrapping, but that would be a fair amount of work. */
-int lines_to_list = 10;
+static int lines_to_list = 10;
static void
show_lines_to_list (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
struct symtab_and_line
get_current_source_symtab_and_line (void)
{
- struct symtab_and_line cursal = { 0 };
+ symtab_and_line cursal;
cursal.pspace = current_source_pspace;
cursal.symtab = current_source_symtab;
NOTE: The returned sal pc and end fields are not valid. */
struct symtab_and_line
-set_current_source_symtab_and_line (const struct symtab_and_line *sal)
+set_current_source_symtab_and_line (const symtab_and_line &sal)
{
- struct symtab_and_line cursal = { 0 };
+ symtab_and_line cursal;
cursal.pspace = current_source_pspace;
cursal.symtab = current_source_symtab;
cursal.pc = 0;
cursal.end = 0;
- current_source_pspace = sal->pspace;
- current_source_symtab = sal->symtab;
- current_source_line = sal->line;
+ current_source_pspace = sal.pspace;
+ current_source_symtab = sal.symtab;
+ current_source_line = sal.line;
/* Force the next "list" to center around the current line. */
clear_lines_listed_range ();
void
select_source_symtab (struct symtab *s)
{
- struct symtabs_and_lines sals;
- struct symtab_and_line sal;
struct objfile *ofp;
struct compunit_symtab *cu;
if one exists. */
if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0).symbol)
{
- sals = decode_line_with_current_source (main_name (),
- DECODE_LINE_FUNFIRSTLINE);
- sal = sals.sals[0];
- xfree (sals.sals);
+ std::vector<symtab_and_line> sals
+ = decode_line_with_current_source (main_name (),
+ DECODE_LINE_FUNFIRSTLINE);
+ const symtab_and_line &sal = sals[0];
current_source_pspace = sal.pspace;
current_source_symtab = sal.symtab;
- current_source_line = max (sal.line - (lines_to_list - 1), 1);
+ current_source_line = std::max (sal.line - (lines_to_list - 1), 1);
if (current_source_symtab)
return;
}
This will not be quoted so we must not treat spaces as separators. */
void
-directory_switch (char *dirname, int from_tty)
+directory_switch (const char *dirname, int from_tty)
{
add_path (dirname, &source_path, 0);
}
/* Add zero or more directories to the front of an arbitrary path. */
void
-mod_path (char *dirname, char **which_path)
+mod_path (const char *dirname, char **which_path)
{
add_path (dirname, which_path, 1);
}
as space or tab. */
void
-add_path (char *dirname, char **which_path, int parse_separators)
+add_path (const char *dirname, char **which_path, int parse_separators)
{
char *old = *which_path;
int prefix = 0;
if (parse_separators)
{
- char **argv, **argvp;
-
/* This will properly parse the space and tab separators
and any quotes that may exist. */
- argv = gdb_buildargv (dirname);
+ gdb_argv argv (dirname);
- for (argvp = argv; *argvp; argvp++)
- dirnames_to_char_ptr_vec_append (&dir_vec, *argvp);
-
- freeargv (argv);
+ for (char *arg : argv)
+ dirnames_to_char_ptr_vec_append (&dir_vec, arg);
}
else
VEC_safe_push (char_ptr, dir_vec, xstrdup (dirname));
static void
-source_info (char *ignore, int from_tty)
+info_source_command (char *ignore, int from_tty)
{
struct symtab *s = current_source_symtab;
struct compunit_symtab *cust;
}
\f
-/* Return True if the file NAME exists and is a regular file. */
+/* Return True if the file NAME exists and is a regular file.
+ If the result is false then *ERRNO_PTR is set to a useful value assuming
+ we're expecting a regular file. */
+
static int
-is_regular_file (const char *name)
+is_regular_file (const char *name, int *errno_ptr)
{
struct stat st;
const int status = stat (name, &st);
on obscure systems where stat does not work as expected. */
if (status != 0)
- return (errno != ENOENT);
+ {
+ if (errno != ENOENT)
+ return 1;
+ *errno_ptr = ENOENT;
+ return 0;
+ }
+
+ if (S_ISREG (st.st_mode))
+ return 1;
- return S_ISREG (st.st_mode);
+ if (S_ISDIR (st.st_mode))
+ *errno_ptr = EISDIR;
+ else
+ *errno_ptr = EINVAL;
+ return 0;
}
/* Open a file named STRING, searching path PATH (dir names sep by some char)
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 ((opts & OPF_TRY_CWD_FIRST) || IS_ABSOLUTE_PATH (string))
{
- int i;
+ int i, reg_file_errno;
- if (is_regular_file (string))
+ if (is_regular_file (string, ®_file_errno))
{
- filename = alloca (strlen (string) + 1);
+ filename = (char *) alloca (strlen (string) + 1);
strcpy (filename, string);
fd = gdb_open_cloexec (filename, mode, 0);
if (fd >= 0)
goto done;
+ last_errno = errno;
}
else
{
filename = NULL;
fd = -1;
+ last_errno = reg_file_errno;
}
if (!(opts & OPF_SEARCH_IN_PATH))
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);
for (ix = 0; VEC_iterate (char_ptr, dir_vec, ix, dir); ++ix)
{
size_t len = strlen (dir);
+ int reg_file_errno;
if (strcmp (dir, "$cwd") == 0)
{
if (newlen > alloclen)
{
alloclen = newlen;
- filename = alloca (alloclen);
+ filename = (char *) alloca (alloclen);
}
strcpy (filename, current_directory);
}
{
/* See whether we need to expand the tilde. */
int newlen;
- char *tilde_expanded;
- tilde_expanded = tilde_expand (dir);
+ gdb::unique_xmalloc_ptr<char> tilde_expanded (tilde_expand (dir));
/* First, realloc the filename buffer if too short. */
- len = strlen (tilde_expanded);
+ len = strlen (tilde_expanded.get ());
newlen = len + strlen (string) + 2;
if (newlen > alloclen)
{
alloclen = newlen;
- filename = alloca (alloclen);
+ filename = (char *) alloca (alloclen);
}
- strcpy (filename, tilde_expanded);
- xfree (tilde_expanded);
+ strcpy (filename, tilde_expanded.get ());
}
else
{
strcat (filename + len, SLASH_STRING);
strcat (filename, string);
- if (is_regular_file (filename))
+ if (is_regular_file (filename, ®_file_errno))
{
fd = gdb_open_cloexec (filename, mode, 0);
if (fd >= 0)
break;
+ last_errno = errno;
}
+ else
+ last_errno = reg_file_errno;
}
do_cleanups (back_to);
if (fd < 0)
*filename_opened = NULL;
else if ((opts & OPF_RETURN_REALPATH) != 0)
- *filename_opened = gdb_realpath (filename);
+ *filename_opened = gdb_realpath (filename).release ();
else
- *filename_opened = gdb_abspath (filename);
+ *filename_opened = gdb_abspath (filename).release ();
}
+ errno = last_errno;
return fd;
}
}
/* If the user specified a source path substitution rule that applies
- to PATH, then apply it and return the new path. This new path must
- be deallocated afterwards.
-
+ to PATH, then apply it and return the new path.
+
Return NULL if no substitution rule was specified by the user,
or if no rule applied to the given PATH. */
-
-char *
+
+gdb::unique_xmalloc_ptr<char>
rewrite_source_path (const char *path)
{
const struct substitute_path_rule *rule = get_substitute_path_rule (path);
strcpy (new_path, rule->to);
strcat (new_path, path + from_len);
- return new_path;
+ return gdb::unique_xmalloc_ptr<char> (new_path);
}
int
char *path = source_path;
const char *p;
int result;
- struct cleanup *cleanup;
/* Quick way out if we already know its full name. */
/* 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. */
- char *rewritten_fullname = rewrite_source_path (*fullname);
+ char *rewritten_fullname = rewrite_source_path (*fullname).release ();
if (rewritten_fullname != NULL)
{
result = gdb_open_cloexec (*fullname, OPEN_MODE, 0);
if (result >= 0)
{
- char *lpath = gdb_realpath (*fullname);
+ char *lpath = gdb_realpath (*fullname).release ();
xfree (*fullname);
*fullname = lpath;
*fullname = NULL;
}
- cleanup = make_cleanup (null_cleanup, NULL);
-
+ gdb::unique_xmalloc_ptr<char> rewritten_dirname;
if (dirname != NULL)
{
/* If necessary, rewrite the compilation directory name according
to the source path substitution rules specified by the user. */
- char *rewritten_dirname = rewrite_source_path (dirname);
+ rewritten_dirname = rewrite_source_path (dirname);
if (rewritten_dirname != NULL)
- {
- make_cleanup (xfree, rewritten_dirname);
- dirname = rewritten_dirname;
- }
-
+ dirname = rewritten_dirname.get ();
+
/* Replace a path entry of $cdir with the compilation directory
name. */
#define cdir_len 5
}
}
+ gdb::unique_xmalloc_ptr<char> rewritten_filename;
if (IS_ABSOLUTE_PATH (filename))
{
/* If filename is absolute path, try the source path
substitution on it. */
- char *rewritten_filename = rewrite_source_path (filename);
+ rewritten_filename = rewrite_source_path (filename);
if (rewritten_filename != NULL)
- {
- make_cleanup (xfree, rewritten_filename);
- filename = rewritten_filename;
- }
+ filename = rewritten_filename.get ();
}
result = openp (path, OPF_SEARCH_IN_PATH | OPF_RETURN_REALPATH, filename,
OPEN_MODE, fullname);
}
- do_cleanups (cleanup);
return result;
}
close (fd);
else
{
- char *fullname;
- struct cleanup *back_to;
+ gdb::unique_xmalloc_ptr<char> fullname;
/* 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);
+ fullname.reset (xstrdup (s->filename));
else
- fullname = concat (SYMTAB_DIRNAME (s), SLASH_STRING, s->filename,
- NULL);
+ fullname.reset (concat (SYMTAB_DIRNAME (s), SLASH_STRING,
+ s->filename, (char *) NULL));
- back_to = make_cleanup (xfree, fullname);
- s->fullname = rewrite_source_path (fullname);
+ s->fullname = rewrite_source_path (fullname.get ()).release ();
if (s->fullname == NULL)
- s->fullname = xstrdup (fullname);
- do_cleanups (back_to);
+ s->fullname = fullname.release ();
}
}
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 (symtab_to_filename_for_display (s));
static void
print_source_lines_base (struct symtab *s, int line, int stopline,
- enum print_source_lines_flags flags)
+ print_source_lines_flags flags)
{
int c;
int desc;
int noprint = 0;
- FILE *stream;
int nlines = stopline - line;
- struct cleanup *cleanup;
struct ui_out *uiout = current_uiout;
/* Regardless of whether we can open the file, set current_source_symtab. */
/* If printing of source lines is disabled, just print file and line
number. */
- if (ui_out_test_flags (uiout, ui_source_list))
+ if (uiout->test_flags (ui_source_list))
{
/* Only prints "No such file or directory" once. */
if ((s != last_source_visited) || (!last_source_error))
else
{
desc = last_source_error;
- flags |= PRINT_SOURCE_LINES_NOERROR;
+ flags |= PRINT_SOURCE_LINES_NOERROR;
noprint = 1;
}
{
const char *filename = symtab_to_filename_for_display (s);
int len = strlen (filename) + 100;
- char *name = alloca (len);
+ char *name = (char *) alloca (len);
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 ");
+ uiout->field_int ("line", line);
+ uiout->text ("\tin ");
/* 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))
+ if (uiout->is_mi_like_p () || uiout->test_flags (ui_source_list))
+ uiout->field_string ("file", symtab_to_filename_for_display (s));
+ if (uiout->is_mi_like_p () || !uiout->test_flags (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 = alloca (strlen (s_fullname) + 1);
+ local_fullname = (char *) alloca (strlen (s_fullname) + 1);
strcpy (local_fullname, s_fullname);
- ui_out_field_string (uiout, "fullname", local_fullname);
+ uiout->field_string ("fullname", local_fullname);
}
- ui_out_text (uiout, "\n");
+ uiout->text ("\n");
}
return;
perror_with_name (symtab_to_filename_for_display (s));
}
- stream = fdopen (desc, FDOPEN_MODE);
- clearerr (stream);
- cleanup = make_cleanup_fclose (stream);
+ gdb_file_up stream (fdopen (desc, FDOPEN_MODE));
+ clearerr (stream.get ());
while (nlines-- > 0)
{
char buf[20];
- c = fgetc (stream);
+ c = fgetc (stream.get ());
if (c == EOF)
break;
last_line_listed = current_source_line;
if (flags & PRINT_SOURCE_LINES_FILENAME)
{
- ui_out_text (uiout, symtab_to_filename_for_display (s));
- ui_out_text (uiout, ":");
+ uiout->text (symtab_to_filename_for_display (s));
+ uiout->text (":");
}
xsnprintf (buf, sizeof (buf), "%d\t", current_source_line++);
- ui_out_text (uiout, buf);
+ uiout->text (buf);
do
{
if (c < 040 && c != '\t' && c != '\n' && c != '\r')
{
xsnprintf (buf, sizeof (buf), "^%c", c + 0100);
- ui_out_text (uiout, buf);
+ uiout->text (buf);
}
else if (c == 0177)
- ui_out_text (uiout, "^?");
+ uiout->text ("^?");
else if (c == '\r')
{
/* Skip a \r character, but only before a \n. */
- int c1 = fgetc (stream);
+ int c1 = fgetc (stream.get ());
if (c1 != '\n')
printf_filtered ("^%c", c + 0100);
if (c1 != EOF)
- ungetc (c1, stream);
+ ungetc (c1, stream.get ());
}
else
{
xsnprintf (buf, sizeof (buf), "%c", c);
- ui_out_text (uiout, buf);
+ uiout->text (buf);
}
}
- while (c != '\n' && (c = fgetc (stream)) >= 0);
+ while (c != '\n' && (c = fgetc (stream.get ())) >= 0);
}
-
- do_cleanups (cleanup);
}
\f
/* Show source lines from the file of symtab S, starting with line
void
print_source_lines (struct symtab *s, int line, int stopline,
- enum print_source_lines_flags flags)
+ print_source_lines_flags flags)
{
print_source_lines_base (s, line, stopline, flags);
}
/* Print info on range of pc's in a specified line. */
static void
-line_info (char *arg, int from_tty)
+info_line_command (char *arg, int from_tty)
{
- struct symtabs_and_lines sals;
- struct symtab_and_line sal;
CORE_ADDR start_pc, end_pc;
- int i;
- struct cleanup *cleanups;
- init_sal (&sal); /* initialize to zeroes */
+ std::vector<symtab_and_line> decoded_sals;
+ symtab_and_line curr_sal;
+ gdb::array_view<symtab_and_line> sals;
if (arg == 0)
{
- sal.symtab = current_source_symtab;
- sal.pspace = current_program_space;
+ curr_sal.symtab = current_source_symtab;
+ curr_sal.pspace = current_program_space;
if (last_line_listed != 0)
- sal.line = last_line_listed;
+ curr_sal.line = last_line_listed;
else
- sal.line = current_source_line;
+ curr_sal.line = current_source_line;
- sals.nelts = 1;
- sals.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
- sals.sals[0] = sal;
+ sals = curr_sal;
}
else
{
- sals = decode_line_with_last_displayed (arg, DECODE_LINE_LIST_MODE);
+ decoded_sals = decode_line_with_last_displayed (arg,
+ DECODE_LINE_LIST_MODE);
+ sals = decoded_sals;
dont_repeat ();
}
- cleanups = make_cleanup (xfree, sals.sals);
-
/* C++ More than one line may have been specified, as when the user
specifies an overloaded function name. Print info on them all. */
- for (i = 0; i < sals.nelts; i++)
+ for (const auto &sal : sals)
{
- sal = sals.sals[i];
if (sal.pspace != current_program_space)
continue;
/* If this is the only line, show the source code. If it could
not find the file, don't do anything special. */
- if (annotation_level && sals.nelts == 1)
+ if (annotation_level && sals.size () == 1)
identify_source_line (sal.symtab, sal.line, 0, start_pc);
}
else
printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
sal.line, symtab_to_filename_for_display (sal.symtab));
}
- do_cleanups (cleanups);
}
\f
/* Commands to search the source file for a regexp. */
static void
-forward_search_command (char *regex, int from_tty)
+forward_search_command (const char *regex, int from_tty)
{
int c;
int desc;
- FILE *stream;
int line;
char *msg;
struct cleanup *cleanups;
perror_with_name (symtab_to_filename_for_display (current_source_symtab));
discard_cleanups (cleanups);
- stream = fdopen (desc, FDOPEN_MODE);
- clearerr (stream);
- cleanups = make_cleanup_fclose (stream);
+ gdb_file_up stream (fdopen (desc, FDOPEN_MODE));
+ clearerr (stream.get ());
while (1)
{
static char *buf = NULL;
int cursize, newsize;
cursize = 256;
- buf = xmalloc (cursize);
+ buf = (char *) xmalloc (cursize);
p = buf;
- c = fgetc (stream);
+ c = fgetc (stream.get ());
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 = fgetc (stream)) >= 0);
+ 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. */
if (re_exec (buf) > 0)
{
/* Match! */
- do_cleanups (cleanups);
print_source_lines (current_source_symtab, line, line + 1, 0);
set_internalvar_integer (lookup_internalvar ("_"), line);
- current_source_line = max (line - lines_to_list / 2, 1);
+ current_source_line = std::max (line - lines_to_list / 2, 1);
return;
}
line++;
}
printf_filtered (_("Expression not found\n"));
- do_cleanups (cleanups);
}
static void
-reverse_search_command (char *regex, int from_tty)
+reverse_search_command (const char *regex, int from_tty)
{
int c;
int desc;
- FILE *stream;
int line;
char *msg;
struct cleanup *cleanups;
perror_with_name (symtab_to_filename_for_display (current_source_symtab));
discard_cleanups (cleanups);
- stream = fdopen (desc, FDOPEN_MODE);
- clearerr (stream);
- cleanups = make_cleanup_fclose (stream);
+ gdb_file_up stream (fdopen (desc, FDOPEN_MODE));
+ clearerr (stream.get ());
while (line > 1)
{
/* FIXME!!! We walk right off the end of buf if we get a long line!!! */
char buf[4096]; /* Should be reasonable??? */
char *p = buf;
- c = fgetc (stream);
+ c = fgetc (stream.get ());
if (c == EOF)
break;
do
{
*p++ = c;
}
- while (c != '\n' && (c = fgetc (stream)) >= 0);
+ 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. */
if (re_exec (buf) > 0)
{
/* Match! */
- do_cleanups (cleanups);
print_source_lines (current_source_symtab, line, line + 1, 0);
set_internalvar_integer (lookup_internalvar ("_"), line);
- current_source_line = max (line - lines_to_list / 2, 1);
+ current_source_line = std::max (line - lines_to_list / 2, 1);
return;
}
line--;
- if (fseek (stream, current_source_symtab->line_charpos[line - 1], 0) < 0)
+ if (fseek (stream.get (),
+ current_source_symtab->line_charpos[line - 1], 0) < 0)
{
const char *filename;
- do_cleanups (cleanups);
filename = symtab_to_filename_for_display (current_source_symtab);
perror_with_name (filename);
}
}
printf_filtered (_("Expression not found\n"));
- do_cleanups (cleanups);
return;
}
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;
/* Implement the "show substitute-path" command. */
static void
-show_substitute_path_command (char *args, int from_tty)
+show_substitute_path_command (const char *args, int from_tty)
{
struct substitute_path_rule *rule = substitute_path_rules;
- char **argv;
char *from = NULL;
- struct cleanup *cleanup;
- argv = gdb_buildargv (args);
- cleanup = make_cleanup_freeargv (argv);
+ gdb_argv argv (args);
/* We expect zero or one argument. */
printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
rule = rule->next;
}
-
- do_cleanups (cleanup);
}
/* Implement the "unset substitute-path" command. */
static void
-unset_substitute_path_command (char *args, int from_tty)
+unset_substitute_path_command (const char *args, int from_tty)
{
struct substitute_path_rule *rule = substitute_path_rules;
- char **argv = gdb_buildargv (args);
+ gdb_argv argv (args);
char *from = NULL;
int rule_found = 0;
- struct cleanup *cleanup;
/* This function takes either 0 or 1 argument. */
- 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. */
static void
-set_substitute_path_command (char *args, int from_tty)
+set_substitute_path_command (const char *args, int from_tty)
{
- char **argv;
struct substitute_path_rule *rule;
- struct cleanup *cleanup;
- argv = gdb_buildargv (args);
- cleanup = make_cleanup_freeargv (argv);
+ gdb_argv argv (args);
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);
- add_info ("source", source_info,
+ add_info ("source", info_source_command,
_("Information about the current source file."));
- add_info ("line", line_info, _("\
+ add_info ("line", info_line_command, _("\
Core addresses of the code for a source line.\n\
Line can be specified as\n\
LINENUM, to list around that line in current file,\n\
projects / deliverable / binutils-gdb.git / blobdiff