1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2019 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "arch-utils.h"
22 #include "expression.h"
29 #include "gdbsupport/filestuff.h"
31 #include <sys/types.h>
34 #include "gdb_regex.h"
40 #include "filenames.h" /* for DOSish file names */
41 #include "completer.h"
43 #include "readline/readline.h"
44 #include "gdbsupport/enum-flags.h"
45 #include "gdbsupport/scoped_fd.h"
47 #include "gdbsupport/pathstuff.h"
48 #include "source-cache.h"
49 #include "cli/cli-style.h"
51 #define OPEN_MODE (O_RDONLY | O_BINARY)
52 #define FDOPEN_MODE FOPEN_RB
54 /* Path of directories to search for source files.
55 Same format as the PATH environment variable's value. */
59 /* Support for source path substitution commands. */
61 struct substitute_path_rule
65 struct substitute_path_rule
*next
;
68 static struct substitute_path_rule
*substitute_path_rules
= NULL
;
70 /* Symtab of default file for listing lines of. */
72 static struct symtab
*current_source_symtab
;
74 /* Default next line to list. */
76 static int current_source_line
;
78 static struct program_space
*current_source_pspace
;
80 /* Default number of lines to print with commands like "list".
81 This is based on guessing how many long (i.e. more than chars_per_line
82 characters) lines there will be. To be completely correct, "list"
83 and friends should be rewritten to count characters and see where
84 things are wrapping, but that would be a fair amount of work. */
86 static int lines_to_list
= 10;
88 show_lines_to_list (struct ui_file
*file
, int from_tty
,
89 struct cmd_list_element
*c
, const char *value
)
91 fprintf_filtered (file
,
92 _("Number of source lines gdb "
93 "will list by default is %s.\n"),
97 /* Possible values of 'set filename-display'. */
98 static const char filename_display_basename
[] = "basename";
99 static const char filename_display_relative
[] = "relative";
100 static const char filename_display_absolute
[] = "absolute";
102 static const char *const filename_display_kind_names
[] = {
103 filename_display_basename
,
104 filename_display_relative
,
105 filename_display_absolute
,
109 static const char *filename_display_string
= filename_display_relative
;
112 show_filename_display_string (struct ui_file
*file
, int from_tty
,
113 struct cmd_list_element
*c
, const char *value
)
115 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
118 /* Line number of last line printed. Default for various commands.
119 current_source_line is usually, but not always, the same as this. */
121 static int last_line_listed
;
123 /* First line number listed by last listing command. If 0, then no
124 source lines have yet been listed since the last time the current
125 source line was changed. */
127 static int first_line_listed
;
129 /* Saves the name of the last source file visited and a possible error code.
130 Used to prevent repeating annoying "No such file or directories" msgs. */
132 static struct symtab
*last_source_visited
= NULL
;
133 static bool last_source_error
= false;
135 /* Return the first line listed by print_source_lines.
136 Used by command interpreters to request listing from
140 get_first_line_listed (void)
142 return first_line_listed
;
145 /* Clear line listed range. This makes the next "list" center the
146 printed source lines around the current source line. */
149 clear_lines_listed_range (void)
151 first_line_listed
= 0;
152 last_line_listed
= 0;
155 /* Return the default number of lines to print with commands like the
156 cli "list". The caller of print_source_lines must use this to
157 calculate the end line and use it in the call to print_source_lines
158 as it does not automatically use this value. */
161 get_lines_to_list (void)
163 return lines_to_list
;
166 /* Return the current source file for listing and next line to list.
167 NOTE: The returned sal pc and end fields are not valid. */
169 struct symtab_and_line
170 get_current_source_symtab_and_line (void)
172 symtab_and_line cursal
;
174 cursal
.pspace
= current_source_pspace
;
175 cursal
.symtab
= current_source_symtab
;
176 cursal
.line
= current_source_line
;
183 /* If the current source file for listing is not set, try and get a default.
184 Usually called before get_current_source_symtab_and_line() is called.
185 It may err out if a default cannot be determined.
186 We must be cautious about where it is called, as it can recurse as the
187 process of determining a new default may call the caller!
188 Use get_current_source_symtab_and_line only to get whatever
189 we have without erroring out or trying to get a default. */
192 set_default_source_symtab_and_line (void)
194 if (!have_full_symbols () && !have_partial_symbols ())
195 error (_("No symbol table is loaded. Use the \"file\" command."));
197 /* Pull in a current source symtab if necessary. */
198 if (current_source_symtab
== 0)
199 select_source_symtab (0);
202 /* Return the current default file for listing and next line to list
203 (the returned sal pc and end fields are not valid.)
204 and set the current default to whatever is in SAL.
205 NOTE: The returned sal pc and end fields are not valid. */
207 struct symtab_and_line
208 set_current_source_symtab_and_line (const symtab_and_line
&sal
)
210 symtab_and_line cursal
;
212 cursal
.pspace
= current_source_pspace
;
213 cursal
.symtab
= current_source_symtab
;
214 cursal
.line
= current_source_line
;
218 current_source_pspace
= sal
.pspace
;
219 current_source_symtab
= sal
.symtab
;
220 current_source_line
= sal
.line
;
222 /* Force the next "list" to center around the current line. */
223 clear_lines_listed_range ();
228 /* Reset any information stored about a default file and line to print. */
231 clear_current_source_symtab_and_line (void)
233 current_source_symtab
= 0;
234 current_source_line
= 0;
240 select_source_symtab (struct symtab
*s
)
244 current_source_symtab
= s
;
245 current_source_line
= 1;
246 current_source_pspace
= SYMTAB_PSPACE (s
);
250 if (current_source_symtab
)
253 /* Make the default place to list be the function `main'
255 if (lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0).symbol
)
257 std::vector
<symtab_and_line
> sals
258 = decode_line_with_current_source (main_name (),
259 DECODE_LINE_FUNFIRSTLINE
);
260 const symtab_and_line
&sal
= sals
[0];
261 current_source_pspace
= sal
.pspace
;
262 current_source_symtab
= sal
.symtab
;
263 current_source_line
= std::max (sal
.line
- (lines_to_list
- 1), 1);
264 if (current_source_symtab
)
268 /* Alright; find the last file in the symtab list (ignoring .h's
269 and namespace symtabs). */
271 current_source_line
= 1;
273 for (objfile
*ofp
: current_program_space
->objfiles ())
275 for (compunit_symtab
*cu
: ofp
->compunits ())
277 for (symtab
*symtab
: compunit_filetabs (cu
))
279 const char *name
= symtab
->filename
;
280 int len
= strlen (name
);
282 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
283 || strcmp (name
, "<<C++-namespaces>>") == 0)))
285 current_source_pspace
= current_program_space
;
286 current_source_symtab
= symtab
;
292 if (current_source_symtab
)
295 for (objfile
*objfile
: current_program_space
->objfiles ())
298 s
= objfile
->sf
->qf
->find_last_source_symtab (objfile
);
300 current_source_symtab
= s
;
302 if (current_source_symtab
)
305 error (_("Can't find a default source file"));
308 /* Handler for "set directories path-list" command.
309 "set dir mumble" doesn't prepend paths, it resets the entire
310 path list. The theory is that set(show(dir)) should be a no-op. */
313 set_directories_command (const char *args
,
314 int from_tty
, struct cmd_list_element
*c
)
316 /* This is the value that was set.
317 It needs to be processed to maintain $cdir:$cwd and remove dups. */
318 char *set_path
= source_path
;
320 /* We preserve the invariant that $cdir:$cwd begins life at the end of
321 the list by calling init_source_path. If they appear earlier in
322 SET_PATH then mod_path will move them appropriately.
323 mod_path will also remove duplicates. */
325 if (*set_path
!= '\0')
326 mod_path (set_path
, &source_path
);
331 /* Print the list of source directories.
332 This is used by the "ld" command, so it has the signature of a command
336 show_directories_1 (char *ignore
, int from_tty
)
338 puts_filtered ("Source directories searched: ");
339 puts_filtered (source_path
);
340 puts_filtered ("\n");
343 /* Handler for "show directories" command. */
346 show_directories_command (struct ui_file
*file
, int from_tty
,
347 struct cmd_list_element
*c
, const char *value
)
349 show_directories_1 (NULL
, from_tty
);
355 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
357 for (compunit_symtab
*cu
: objfile
->compunits ())
359 for (symtab
*s
: compunit_filetabs (cu
))
361 if (s
->fullname
!= NULL
)
370 objfile
->sf
->qf
->forget_cached_source_info (objfile
);
376 forget_cached_source_info (void)
378 struct program_space
*pspace
;
381 for (objfile
*objfile
: pspace
->objfiles ())
383 forget_cached_source_info_for_objfile (objfile
);
386 g_source_cache
.clear ();
387 last_source_visited
= NULL
;
391 init_source_path (void)
395 xsnprintf (buf
, sizeof (buf
), "$cdir%c$cwd", DIRNAME_SEPARATOR
);
396 source_path
= xstrdup (buf
);
397 forget_cached_source_info ();
400 /* Add zero or more directories to the front of the source path. */
403 directory_command (const char *dirname
, int from_tty
)
406 /* FIXME, this goes to "delete dir"... */
409 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
417 mod_path (dirname
, &source_path
);
418 forget_cached_source_info ();
421 show_directories_1 ((char *) 0, from_tty
);
424 /* Add a path given with the -d command line switch.
425 This will not be quoted so we must not treat spaces as separators. */
428 directory_switch (const char *dirname
, int from_tty
)
430 add_path (dirname
, &source_path
, 0);
433 /* Add zero or more directories to the front of an arbitrary path. */
436 mod_path (const char *dirname
, char **which_path
)
438 add_path (dirname
, which_path
, 1);
441 /* Workhorse of mod_path. Takes an extra argument to determine
442 if dirname should be parsed for separators that indicate multiple
443 directories. This allows for interfaces that pre-parse the dirname
444 and allow specification of traditional separator characters such
448 add_path (const char *dirname
, char **which_path
, int parse_separators
)
450 char *old
= *which_path
;
452 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
457 if (parse_separators
)
459 /* This will properly parse the space and tab separators
460 and any quotes that may exist. */
461 gdb_argv
argv (dirname
);
463 for (char *arg
: argv
)
464 dirnames_to_char_ptr_vec_append (&dir_vec
, arg
);
467 dir_vec
.emplace_back (xstrdup (dirname
));
469 for (const gdb::unique_xmalloc_ptr
<char> &name_up
: dir_vec
)
471 char *name
= name_up
.get ();
474 gdb::unique_xmalloc_ptr
<char> new_name_holder
;
476 /* Spaces and tabs will have been removed by buildargv().
477 NAME is the start of the directory.
478 P is the '\0' following the end. */
479 p
= name
+ strlen (name
);
481 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
482 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
483 /* On MS-DOS and MS-Windows, h:\ is different from h: */
484 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
486 && IS_DIR_SEPARATOR (p
[-1]))
487 /* Sigh. "foo/" => "foo" */
491 while (p
> name
&& p
[-1] == '.')
495 /* "." => getwd (). */
496 name
= current_directory
;
499 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
509 /* "...foo/." => "...foo". */
520 new_name_holder
.reset (tilde_expand (name
));
521 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
522 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
523 new_name_holder
.reset (concat (name
, ".", (char *) NULL
));
525 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
526 new_name_holder
.reset (concat (current_directory
, SLASH_STRING
, name
,
529 new_name_holder
.reset (savestring (name
, p
- name
));
530 name
= new_name_holder
.get ();
532 /* Unless it's a variable, check existence. */
535 /* These are warnings, not errors, since we don't want a
536 non-existent directory in a .gdbinit file to stop processing
537 of the .gdbinit file.
539 Whether they get added to the path is more debatable. Current
540 answer is yes, in case the user wants to go make the directory
541 or whatever. If the directory continues to not exist/not be
542 a directory/etc, then having them in the path should be
544 if (stat (name
, &st
) < 0)
546 int save_errno
= errno
;
548 fprintf_unfiltered (gdb_stderr
, "Warning: ");
549 print_sys_errmsg (name
, save_errno
);
551 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
552 warning (_("%s is not a directory."), name
);
557 unsigned int len
= strlen (name
);
563 /* FIXME: we should use realpath() or its work-alike
564 before comparing. Then all the code above which
565 removes excess slashes and dots could simply go away. */
566 if (!filename_ncmp (p
, name
, len
)
567 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
569 /* Found it in the search path, remove old copy. */
572 /* Back over leading separator. */
575 if (prefix
> p
- *which_path
)
577 /* Same dir twice in one cmd. */
580 /* Copy from next '\0' or ':'. */
581 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
583 p
= strchr (p
, DIRNAME_SEPARATOR
);
590 tinybuf
[0] = DIRNAME_SEPARATOR
;
593 /* If we have already tacked on a name(s) in this command,
594 be sure they stay on the front as we tack on some
602 temp
= concat (old
, tinybuf
, name
, (char *)NULL
);
604 *which_path
= concat (temp
, "", &old
[prefix
], (char *) NULL
);
605 prefix
= strlen (temp
);
610 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
612 prefix
= strlen (name
);
624 info_source_command (const char *ignore
, int from_tty
)
626 struct symtab
*s
= current_source_symtab
;
627 struct compunit_symtab
*cust
;
631 printf_filtered (_("No current source file.\n"));
635 cust
= SYMTAB_COMPUNIT (s
);
636 printf_filtered (_("Current source file is %s\n"), s
->filename
);
637 if (SYMTAB_DIRNAME (s
) != NULL
)
638 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s
));
640 printf_filtered (_("Located in %s\n"), s
->fullname
);
641 const std::vector
<off_t
> *offsets
;
642 if (g_source_cache
.get_line_charpos (s
, &offsets
))
643 printf_filtered (_("Contains %d line%s.\n"), (int) offsets
->size (),
644 offsets
->size () == 1 ? "" : "s");
646 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
647 printf_filtered (_("Producer is %s.\n"),
648 COMPUNIT_PRODUCER (cust
) != NULL
649 ? COMPUNIT_PRODUCER (cust
) : _("unknown"));
650 printf_filtered (_("Compiled with %s debugging format.\n"),
651 COMPUNIT_DEBUGFORMAT (cust
));
652 printf_filtered (_("%s preprocessor macro info.\n"),
653 COMPUNIT_MACRO_TABLE (cust
) != NULL
654 ? "Includes" : "Does not include");
658 /* Helper function to remove characters from the start of PATH so that
659 PATH can then be appended to a directory name. We remove leading drive
660 letters (for dos) as well as leading '/' characters and './'
664 prepare_path_for_appending (const char *path
)
666 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
667 if (HAS_DRIVE_SPEC (path
))
668 path
= STRIP_DRIVE_SPEC (path
);
670 const char *old_path
;
675 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
676 while (IS_DIR_SEPARATOR(path
[0]))
680 while (path
[0] == '.' && IS_DIR_SEPARATOR (path
[1]))
683 while (old_path
!= path
);
688 /* Open a file named STRING, searching path PATH (dir names sep by some char)
689 using mode MODE in the calls to open. You cannot use this function to
690 create files (O_CREAT).
692 OPTS specifies the function behaviour in specific cases.
694 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
695 (ie pretend the first element of PATH is "."). This also indicates
696 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
697 disables searching of the path (this is so that "exec-file ./foo" or
698 "symbol-file ./foo" insures that you get that particular version of
699 foo or an error message).
701 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
702 searched in path (we usually want this for source files but not for
705 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
706 the actual file opened (this string will always start with a "/"). We
707 have to take special pains to avoid doubling the "/" between the directory
708 and the file, sigh! Emacs gets confuzzed by this when we print the
711 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
712 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
713 filename starting with "/". If FILENAME_OPENED is NULL this option has no
716 If a file is found, return the descriptor.
717 Otherwise, return -1, with errno set for the last name we tried to open. */
719 /* >>>> This should only allow files of certain types,
720 >>>> eg executable, non-directory. */
722 openp (const char *path
, openp_flags opts
, const char *string
,
723 int mode
, gdb::unique_xmalloc_ptr
<char> *filename_opened
)
728 /* The errno set for the last name we tried to open (and
731 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
;
733 /* The open syscall MODE parameter is not specified. */
734 gdb_assert ((mode
& O_CREAT
) == 0);
735 gdb_assert (string
!= NULL
);
737 /* A file with an empty name cannot possibly exist. Report a failure
738 without further checking.
740 This is an optimization which also defends us against buggy
741 implementations of the "stat" function. For instance, we have
742 noticed that a MinGW debugger built on Windows XP 32bits crashes
743 when the debugger is started with an empty argument. */
744 if (string
[0] == '\0')
755 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
757 int i
, reg_file_errno
;
759 if (is_regular_file (string
, ®_file_errno
))
761 filename
= (char *) alloca (strlen (string
) + 1);
762 strcpy (filename
, string
);
763 fd
= gdb_open_cloexec (filename
, mode
, 0);
772 last_errno
= reg_file_errno
;
775 if (!(opts
& OPF_SEARCH_IN_PATH
))
776 for (i
= 0; string
[i
]; i
++)
777 if (IS_DIR_SEPARATOR (string
[i
]))
781 /* Remove characters from the start of PATH that we don't need when PATH
782 is appended to a directory name. */
783 string
= prepare_path_for_appending (string
);
785 alloclen
= strlen (path
) + strlen (string
) + 2;
786 filename
= (char *) alloca (alloclen
);
790 dir_vec
= dirnames_to_char_ptr_vec (path
);
792 for (const gdb::unique_xmalloc_ptr
<char> &dir_up
: dir_vec
)
794 char *dir
= dir_up
.get ();
795 size_t len
= strlen (dir
);
798 if (strcmp (dir
, "$cwd") == 0)
800 /* Name is $cwd -- insert current directory name instead. */
803 /* First, realloc the filename buffer if too short. */
804 len
= strlen (current_directory
);
805 newlen
= len
+ strlen (string
) + 2;
806 if (newlen
> alloclen
)
809 filename
= (char *) alloca (alloclen
);
811 strcpy (filename
, current_directory
);
813 else if (strchr(dir
, '~'))
815 /* See whether we need to expand the tilde. */
818 gdb::unique_xmalloc_ptr
<char> tilde_expanded (tilde_expand (dir
));
820 /* First, realloc the filename buffer if too short. */
821 len
= strlen (tilde_expanded
.get ());
822 newlen
= len
+ strlen (string
) + 2;
823 if (newlen
> alloclen
)
826 filename
= (char *) alloca (alloclen
);
828 strcpy (filename
, tilde_expanded
.get ());
832 /* Normal file name in path -- just use it. */
833 strcpy (filename
, dir
);
835 /* Don't search $cdir. It's also a magic path like $cwd, but we
836 don't have enough information to expand it. The user *could*
837 have an actual directory named '$cdir' but handling that would
838 be confusing, it would mean different things in different
839 contexts. If the user really has '$cdir' one can use './$cdir'.
840 We can get $cdir when loading scripts. When loading source files
841 $cdir must have already been expanded to the correct value. */
842 if (strcmp (dir
, "$cdir") == 0)
846 /* Remove trailing slashes. */
847 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
850 strcat (filename
+ len
, SLASH_STRING
);
851 strcat (filename
, string
);
853 if (is_regular_file (filename
, ®_file_errno
))
855 fd
= gdb_open_cloexec (filename
, mode
, 0);
861 last_errno
= reg_file_errno
;
867 /* If a file was opened, canonicalize its filename. */
869 filename_opened
->reset (NULL
);
870 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
871 *filename_opened
= gdb_realpath (filename
);
873 *filename_opened
= gdb_abspath (filename
);
881 /* This is essentially a convenience, for clients that want the behaviour
882 of openp, using source_path, but that really don't want the file to be
883 opened but want instead just to know what the full pathname is (as
884 qualified against source_path).
886 The current working directory is searched first.
888 If the file was found, this function returns 1, and FULL_PATHNAME is
889 set to the fully-qualified pathname.
891 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
893 source_full_path_of (const char *filename
,
894 gdb::unique_xmalloc_ptr
<char> *full_pathname
)
898 fd
= openp (source_path
,
899 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
900 filename
, O_RDONLY
, full_pathname
);
903 full_pathname
->reset (NULL
);
911 /* Return non-zero if RULE matches PATH, that is if the rule can be
915 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
918 const int from_len
= strlen (rule
->from
);
919 const int path_len
= strlen (path
);
921 if (path_len
< from_len
)
924 /* The substitution rules are anchored at the start of the path,
925 so the path should start with rule->from. */
927 if (filename_ncmp (path
, rule
->from
, from_len
) != 0)
930 /* Make sure that the region in the path that matches the substitution
931 rule is immediately followed by a directory separator (or the end of
932 string character). */
934 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
940 /* Find the substitute-path rule that applies to PATH and return it.
941 Return NULL if no rule applies. */
943 static struct substitute_path_rule
*
944 get_substitute_path_rule (const char *path
)
946 struct substitute_path_rule
*rule
= substitute_path_rules
;
948 while (rule
!= NULL
&& !substitute_path_rule_matches (rule
, path
))
954 /* If the user specified a source path substitution rule that applies
955 to PATH, then apply it and return the new path.
957 Return NULL if no substitution rule was specified by the user,
958 or if no rule applied to the given PATH. */
960 gdb::unique_xmalloc_ptr
<char>
961 rewrite_source_path (const char *path
)
963 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
970 from_len
= strlen (rule
->from
);
972 /* Compute the rewritten path and return it. */
975 (char *) xmalloc (strlen (path
) + 1 + strlen (rule
->to
) - from_len
);
976 strcpy (new_path
, rule
->to
);
977 strcat (new_path
, path
+ from_len
);
979 return gdb::unique_xmalloc_ptr
<char> (new_path
);
985 find_and_open_source (const char *filename
,
987 gdb::unique_xmalloc_ptr
<char> *fullname
)
989 char *path
= source_path
;
993 /* Quick way out if we already know its full name. */
997 /* The user may have requested that source paths be rewritten
998 according to substitution rules he provided. If a substitution
999 rule applies to this path, then apply it. */
1000 gdb::unique_xmalloc_ptr
<char> rewritten_fullname
1001 = rewrite_source_path (fullname
->get ());
1003 if (rewritten_fullname
!= NULL
)
1004 *fullname
= std::move (rewritten_fullname
);
1006 result
= gdb_open_cloexec (fullname
->get (), OPEN_MODE
, 0);
1009 if (basenames_may_differ
)
1010 *fullname
= gdb_realpath (fullname
->get ());
1012 *fullname
= gdb_abspath (fullname
->get ());
1013 return scoped_fd (result
);
1016 /* Didn't work -- free old one, try again. */
1017 fullname
->reset (NULL
);
1020 gdb::unique_xmalloc_ptr
<char> rewritten_dirname
;
1021 if (dirname
!= NULL
)
1023 /* If necessary, rewrite the compilation directory name according
1024 to the source path substitution rules specified by the user. */
1026 rewritten_dirname
= rewrite_source_path (dirname
);
1028 if (rewritten_dirname
!= NULL
)
1029 dirname
= rewritten_dirname
.get ();
1031 /* Replace a path entry of $cdir with the compilation directory
1034 p
= strstr (source_path
, "$cdir");
1035 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1036 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1041 alloca (strlen (source_path
) + 1 + strlen (dirname
) + 1);
1042 len
= p
- source_path
;
1043 strncpy (path
, source_path
, len
); /* Before $cdir */
1044 strcpy (path
+ len
, dirname
); /* new stuff */
1045 strcat (path
+ len
, source_path
+ len
+ cdir_len
); /* After
1050 gdb::unique_xmalloc_ptr
<char> rewritten_filename
1051 = rewrite_source_path (filename
);
1053 if (rewritten_filename
!= NULL
)
1054 filename
= rewritten_filename
.get ();
1056 openp_flags flags
= OPF_SEARCH_IN_PATH
;
1057 if (basenames_may_differ
)
1058 flags
|= OPF_RETURN_REALPATH
;
1060 /* Try to locate file using filename. */
1061 result
= openp (path
, flags
, filename
, OPEN_MODE
, fullname
);
1062 if (result
< 0 && dirname
!= NULL
)
1064 /* Remove characters from the start of PATH that we don't need when
1065 PATH is appended to a directory name. */
1066 const char *filename_start
= prepare_path_for_appending (filename
);
1068 /* Try to locate file using compilation dir + filename. This is
1069 helpful if part of the compilation directory was removed,
1070 e.g. using gcc's -fdebug-prefix-map, and we have added the missing
1071 prefix to source_path. */
1072 std::string
cdir_filename (dirname
);
1074 /* Remove any trailing directory separators. */
1075 while (IS_DIR_SEPARATOR (cdir_filename
.back ()))
1076 cdir_filename
.pop_back ();
1078 /* Add our own directory separator. */
1079 cdir_filename
.append (SLASH_STRING
);
1080 cdir_filename
.append (filename_start
);
1082 result
= openp (path
, flags
, cdir_filename
.c_str (), OPEN_MODE
,
1087 /* Didn't work. Try using just the basename. */
1088 p
= lbasename (filename
);
1090 result
= openp (path
, flags
, p
, OPEN_MODE
, fullname
);
1093 return scoped_fd (result
);
1096 /* Open a source file given a symtab S. Returns a file descriptor or
1097 negative number for error.
1099 This function is a convience function to find_and_open_source. */
1102 open_source_file (struct symtab
*s
)
1105 return scoped_fd (-1);
1107 gdb::unique_xmalloc_ptr
<char> fullname (s
->fullname
);
1109 scoped_fd fd
= find_and_open_source (s
->filename
, SYMTAB_DIRNAME (s
),
1111 s
->fullname
= fullname
.release ();
1115 /* Finds the fullname that a symtab represents.
1117 This functions finds the fullname and saves it in s->fullname.
1118 It will also return the value.
1120 If this function fails to find the file that this symtab represents,
1121 the expected fullname is used. Therefore the files does not have to
1125 symtab_to_fullname (struct symtab
*s
)
1127 /* Use cached copy if we have it.
1128 We rely on forget_cached_source_info being called appropriately
1129 to handle cases like the file being moved. */
1130 if (s
->fullname
== NULL
)
1132 scoped_fd fd
= open_source_file (s
);
1136 gdb::unique_xmalloc_ptr
<char> fullname
;
1138 /* rewrite_source_path would be applied by find_and_open_source, we
1139 should report the pathname where GDB tried to find the file. */
1141 if (SYMTAB_DIRNAME (s
) == NULL
|| IS_ABSOLUTE_PATH (s
->filename
))
1142 fullname
.reset (xstrdup (s
->filename
));
1144 fullname
.reset (concat (SYMTAB_DIRNAME (s
), SLASH_STRING
,
1145 s
->filename
, (char *) NULL
));
1147 s
->fullname
= rewrite_source_path (fullname
.get ()).release ();
1148 if (s
->fullname
== NULL
)
1149 s
->fullname
= fullname
.release ();
1156 /* See commentary in source.h. */
1159 symtab_to_filename_for_display (struct symtab
*symtab
)
1161 if (filename_display_string
== filename_display_basename
)
1162 return lbasename (symtab
->filename
);
1163 else if (filename_display_string
== filename_display_absolute
)
1164 return symtab_to_fullname (symtab
);
1165 else if (filename_display_string
== filename_display_relative
)
1166 return symtab
->filename
;
1168 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1173 /* Print source lines from the file of symtab S,
1174 starting with line number LINE and stopping before line number STOPLINE. */
1177 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1178 print_source_lines_flags flags
)
1180 bool noprint
= false;
1181 int nlines
= stopline
- line
;
1182 struct ui_out
*uiout
= current_uiout
;
1184 /* Regardless of whether we can open the file, set current_source_symtab. */
1185 current_source_symtab
= s
;
1186 current_source_line
= line
;
1187 first_line_listed
= line
;
1189 /* If printing of source lines is disabled, just print file and line
1191 if (uiout
->test_flags (ui_source_list
))
1193 /* Only prints "No such file or directory" once. */
1194 if (s
== last_source_visited
)
1196 if (last_source_error
)
1198 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1204 last_source_visited
= s
;
1205 scoped_fd desc
= open_source_file (s
);
1206 last_source_error
= desc
.get () < 0;
1207 if (last_source_error
)
1213 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1219 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1221 const char *filename
= symtab_to_filename_for_display (s
);
1222 int len
= strlen (filename
) + 100;
1223 char *name
= (char *) alloca (len
);
1225 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1226 print_sys_errmsg (name
, errno
);
1230 uiout
->field_signed ("line", line
);
1231 uiout
->text ("\tin ");
1233 /* CLI expects only the "file" field. TUI expects only the
1234 "fullname" field (and TUI does break if "file" is printed).
1235 MI expects both fields. ui_source_list is set only for CLI,
1237 if (uiout
->is_mi_like_p () || uiout
->test_flags (ui_source_list
))
1238 uiout
->field_string ("file", symtab_to_filename_for_display (s
),
1239 file_name_style
.style ());
1240 if (uiout
->is_mi_like_p () || !uiout
->test_flags (ui_source_list
))
1242 const char *s_fullname
= symtab_to_fullname (s
);
1243 char *local_fullname
;
1245 /* ui_out_field_string may free S_FULLNAME by calling
1246 open_source_file for it again. See e.g.,
1247 tui_field_string->tui_show_source. */
1248 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1249 strcpy (local_fullname
, s_fullname
);
1251 uiout
->field_string ("fullname", local_fullname
);
1260 /* If the user requested a sequence of lines that seems to go backward
1261 (from high to low line numbers) then we don't print anything. */
1262 if (stopline
<= line
)
1266 if (!g_source_cache
.get_source_lines (s
, line
, stopline
- 1, &lines
))
1268 const std::vector
<off_t
> *offsets
= nullptr;
1269 g_source_cache
.get_line_charpos (s
, &offsets
);
1270 error (_("Line number %d out of range; %s has %d lines."),
1271 line
, symtab_to_filename_for_display (s
),
1272 offsets
== nullptr ? 0 : (int) offsets
->size ());
1275 const char *iter
= lines
.c_str ();
1276 while (nlines
-- > 0 && *iter
!= '\0')
1280 last_line_listed
= current_source_line
;
1281 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1283 uiout
->text (symtab_to_filename_for_display (s
));
1286 xsnprintf (buf
, sizeof (buf
), "%d\t", current_source_line
++);
1289 while (*iter
!= '\0')
1291 /* Find a run of characters that can be emitted at once.
1292 This is done so that escape sequences are kept
1294 const char *start
= iter
;
1300 if (c
== '\033' && skip_ansi_escape (iter
, &skip_bytes
))
1302 else if (c
>= 0 && c
< 040 && c
!= '\t')
1311 std::string
text (start
, iter
);
1312 uiout
->text (text
.c_str ());
1316 /* Treat either \r or \r\n as a single newline. */
1322 else if (*iter
== '\n')
1327 else if (*iter
> 0 && *iter
< 040)
1329 xsnprintf (buf
, sizeof (buf
), "^%c", *iter
+ 0100);
1333 else if (*iter
== 0177)
1347 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1348 print_source_lines_flags flags
)
1350 print_source_lines_base (s
, line
, stopline
, flags
);
1356 print_source_lines (struct symtab
*s
, source_lines_range line_range
,
1357 print_source_lines_flags flags
)
1359 print_source_lines_base (s
, line_range
.startline (),
1360 line_range
.stopline (), flags
);
1365 /* Print info on range of pc's in a specified line. */
1368 info_line_command (const char *arg
, int from_tty
)
1370 CORE_ADDR start_pc
, end_pc
;
1372 std::vector
<symtab_and_line
> decoded_sals
;
1373 symtab_and_line curr_sal
;
1374 gdb::array_view
<symtab_and_line
> sals
;
1378 curr_sal
.symtab
= current_source_symtab
;
1379 curr_sal
.pspace
= current_program_space
;
1380 if (last_line_listed
!= 0)
1381 curr_sal
.line
= last_line_listed
;
1383 curr_sal
.line
= current_source_line
;
1389 decoded_sals
= decode_line_with_last_displayed (arg
,
1390 DECODE_LINE_LIST_MODE
);
1391 sals
= decoded_sals
;
1396 /* C++ More than one line may have been specified, as when the user
1397 specifies an overloaded function name. Print info on them all. */
1398 for (const auto &sal
: sals
)
1400 if (sal
.pspace
!= current_program_space
)
1403 if (sal
.symtab
== 0)
1405 struct gdbarch
*gdbarch
= get_current_arch ();
1407 printf_filtered (_("No line number information available"));
1410 /* This is useful for "info line *0x7f34". If we can't tell the
1411 user about a source line, at least let them have the symbolic
1413 printf_filtered (" for address ");
1415 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1418 printf_filtered (".");
1419 printf_filtered ("\n");
1421 else if (sal
.line
> 0
1422 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1424 struct gdbarch
*gdbarch
1425 = get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1427 if (start_pc
== end_pc
)
1429 printf_filtered ("Line %d of \"%s\"",
1431 symtab_to_filename_for_display (sal
.symtab
));
1433 printf_filtered (" is at address ");
1434 print_address (gdbarch
, start_pc
, gdb_stdout
);
1436 printf_filtered (" but contains no code.\n");
1440 printf_filtered ("Line %d of \"%s\"",
1442 symtab_to_filename_for_display (sal
.symtab
));
1444 printf_filtered (" starts at address ");
1445 print_address (gdbarch
, start_pc
, gdb_stdout
);
1447 printf_filtered (" and ends at ");
1448 print_address (gdbarch
, end_pc
, gdb_stdout
);
1449 printf_filtered (".\n");
1452 /* x/i should display this line's code. */
1453 set_next_address (gdbarch
, start_pc
);
1455 /* Repeating "info line" should do the following line. */
1456 last_line_listed
= sal
.line
+ 1;
1458 /* If this is the only line, show the source code. If it could
1459 not find the file, don't do anything special. */
1460 if (sals
.size () == 1)
1461 annotate_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1464 /* Is there any case in which we get here, and have an address
1465 which the user would want to see? If we have debugging symbols
1466 and no line numbers? */
1467 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1468 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1472 /* Commands to search the source file for a regexp. */
1474 /* Helper for forward_search_command/reverse_search_command. FORWARD
1475 indicates direction: true for forward, false for
1476 backward/reverse. */
1479 search_command_helper (const char *regex
, int from_tty
, bool forward
)
1481 const char *msg
= re_comp (regex
);
1483 error (("%s"), msg
);
1485 if (current_source_symtab
== 0)
1486 select_source_symtab (0);
1488 scoped_fd
desc (open_source_file (current_source_symtab
));
1489 if (desc
.get () < 0)
1490 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1493 ? last_line_listed
+ 1
1494 : last_line_listed
- 1);
1496 const std::vector
<off_t
> *offsets
;
1498 || !g_source_cache
.get_line_charpos (current_source_symtab
, &offsets
)
1499 || line
> offsets
->size ())
1500 error (_("Expression not found"));
1502 if (lseek (desc
.get (), (*offsets
)[line
- 1], 0) < 0)
1503 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1505 gdb_file_up stream
= desc
.to_file (FDOPEN_MODE
);
1506 clearerr (stream
.get ());
1508 gdb::def_vector
<char> buf
;
1515 int c
= fgetc (stream
.get ());
1522 while (c
!= '\n' && (c
= fgetc (stream
.get ())) >= 0);
1524 /* Remove the \r, if any, at the end of the line, otherwise
1525 regular expressions that end with $ or \n won't work. */
1526 size_t sz
= buf
.size ();
1527 if (sz
>= 2 && buf
[sz
- 2] == '\r')
1530 buf
.resize (sz
- 1);
1533 /* We now have a source line in buf, null terminate and match. */
1534 buf
.push_back ('\0');
1535 if (re_exec (buf
.data ()) > 0)
1538 print_source_lines (current_source_symtab
, line
, line
+ 1, 0);
1539 set_internalvar_integer (lookup_internalvar ("_"), line
);
1540 current_source_line
= std::max (line
- lines_to_list
/ 2, 1);
1551 if (fseek (stream
.get (), (*offsets
)[line
- 1], 0) < 0)
1553 const char *filename
1554 = symtab_to_filename_for_display (current_source_symtab
);
1555 perror_with_name (filename
);
1560 printf_filtered (_("Expression not found\n"));
1564 forward_search_command (const char *regex
, int from_tty
)
1566 search_command_helper (regex
, from_tty
, true);
1570 reverse_search_command (const char *regex
, int from_tty
)
1572 search_command_helper (regex
, from_tty
, false);
1575 /* If the last character of PATH is a directory separator, then strip it. */
1578 strip_trailing_directory_separator (char *path
)
1580 const int last
= strlen (path
) - 1;
1583 return; /* No stripping is needed if PATH is the empty string. */
1585 if (IS_DIR_SEPARATOR (path
[last
]))
1589 /* Return the path substitution rule that matches FROM.
1590 Return NULL if no rule matches. */
1592 static struct substitute_path_rule
*
1593 find_substitute_path_rule (const char *from
)
1595 struct substitute_path_rule
*rule
= substitute_path_rules
;
1597 while (rule
!= NULL
)
1599 if (FILENAME_CMP (rule
->from
, from
) == 0)
1607 /* Add a new substitute-path rule at the end of the current list of rules.
1608 The new rule will replace FROM into TO. */
1611 add_substitute_path_rule (char *from
, char *to
)
1613 struct substitute_path_rule
*rule
;
1614 struct substitute_path_rule
*new_rule
= XNEW (struct substitute_path_rule
);
1616 new_rule
->from
= xstrdup (from
);
1617 new_rule
->to
= xstrdup (to
);
1618 new_rule
->next
= NULL
;
1620 /* If the list of rules are empty, then insert the new rule
1621 at the head of the list. */
1623 if (substitute_path_rules
== NULL
)
1625 substitute_path_rules
= new_rule
;
1629 /* Otherwise, skip to the last rule in our list and then append
1632 rule
= substitute_path_rules
;
1633 while (rule
->next
!= NULL
)
1636 rule
->next
= new_rule
;
1639 /* Remove the given source path substitution rule from the current list
1640 of rules. The memory allocated for that rule is also deallocated. */
1643 delete_substitute_path_rule (struct substitute_path_rule
*rule
)
1645 if (rule
== substitute_path_rules
)
1646 substitute_path_rules
= rule
->next
;
1649 struct substitute_path_rule
*prev
= substitute_path_rules
;
1651 while (prev
!= NULL
&& prev
->next
!= rule
)
1654 gdb_assert (prev
!= NULL
);
1656 prev
->next
= rule
->next
;
1664 /* Implement the "show substitute-path" command. */
1667 show_substitute_path_command (const char *args
, int from_tty
)
1669 struct substitute_path_rule
*rule
= substitute_path_rules
;
1672 gdb_argv
argv (args
);
1674 /* We expect zero or one argument. */
1676 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1677 error (_("Too many arguments in command"));
1679 if (argv
!= NULL
&& argv
[0] != NULL
)
1682 /* Print the substitution rules. */
1686 (_("Source path substitution rule matching `%s':\n"), from
);
1688 printf_filtered (_("List of all source path substitution rules:\n"));
1690 while (rule
!= NULL
)
1692 if (from
== NULL
|| substitute_path_rule_matches (rule
, from
) != 0)
1693 printf_filtered (" `%s' -> `%s'.\n", rule
->from
, rule
->to
);
1698 /* Implement the "unset substitute-path" command. */
1701 unset_substitute_path_command (const char *args
, int from_tty
)
1703 struct substitute_path_rule
*rule
= substitute_path_rules
;
1704 gdb_argv
argv (args
);
1708 /* This function takes either 0 or 1 argument. */
1710 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1711 error (_("Incorrect usage, too many arguments in command"));
1713 if (argv
!= NULL
&& argv
[0] != NULL
)
1716 /* If the user asked for all the rules to be deleted, ask him
1717 to confirm and give him a chance to abort before the action
1721 && !query (_("Delete all source path substitution rules? ")))
1722 error (_("Canceled"));
1724 /* Delete the rule matching the argument. No argument means that
1725 all rules should be deleted. */
1727 while (rule
!= NULL
)
1729 struct substitute_path_rule
*next
= rule
->next
;
1731 if (from
== NULL
|| FILENAME_CMP (from
, rule
->from
) == 0)
1733 delete_substitute_path_rule (rule
);
1740 /* If the user asked for a specific rule to be deleted but
1741 we could not find it, then report an error. */
1743 if (from
!= NULL
&& !rule_found
)
1744 error (_("No substitution rule defined for `%s'"), from
);
1746 forget_cached_source_info ();
1749 /* Add a new source path substitution rule. */
1752 set_substitute_path_command (const char *args
, int from_tty
)
1754 struct substitute_path_rule
*rule
;
1756 gdb_argv
argv (args
);
1758 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1759 error (_("Incorrect usage, too few arguments in command"));
1761 if (argv
[2] != NULL
)
1762 error (_("Incorrect usage, too many arguments in command"));
1764 if (*(argv
[0]) == '\0')
1765 error (_("First argument must be at least one character long"));
1767 /* Strip any trailing directory separator character in either FROM
1768 or TO. The substitution rule already implicitly contains them. */
1769 strip_trailing_directory_separator (argv
[0]);
1770 strip_trailing_directory_separator (argv
[1]);
1772 /* If a rule with the same "from" was previously defined, then
1773 delete it. This new rule replaces it. */
1775 rule
= find_substitute_path_rule (argv
[0]);
1777 delete_substitute_path_rule (rule
);
1779 /* Insert the new substitution rule. */
1781 add_substitute_path_rule (argv
[0], argv
[1]);
1782 forget_cached_source_info ();
1787 source_lines_range::source_lines_range (int startline
,
1788 source_lines_range::direction dir
)
1790 if (dir
== source_lines_range::FORWARD
)
1792 LONGEST end
= static_cast <LONGEST
> (startline
) + get_lines_to_list ();
1797 m_startline
= startline
;
1798 m_stopline
= static_cast <int> (end
);
1802 LONGEST start
= static_cast <LONGEST
> (startline
) - get_lines_to_list ();
1807 m_startline
= static_cast <int> (start
);
1808 m_stopline
= startline
;
1814 _initialize_source (void)
1816 struct cmd_list_element
*c
;
1818 current_source_symtab
= 0;
1819 init_source_path ();
1821 /* The intention is to use POSIX Basic Regular Expressions.
1822 Always use the GNU regex routine for consistency across all hosts.
1823 Our current GNU regex.c does not have all the POSIX features, so this is
1824 just an approximation. */
1825 re_set_syntax (RE_SYNTAX_GREP
);
1827 c
= add_cmd ("directory", class_files
, directory_command
, _("\
1828 Add directory DIR to beginning of search path for source files.\n\
1829 Forget cached info on source file locations and line positions.\n\
1830 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1831 directory in which the source file was compiled into object code.\n\
1832 With no argument, reset the search path to $cdir:$cwd, the default."),
1836 add_com_alias ("use", "directory", class_files
, 0);
1838 set_cmd_completer (c
, filename_completer
);
1840 add_setshow_optional_filename_cmd ("directories",
1844 Set the search path for finding source files."),
1846 Show the search path for finding source files."),
1848 $cwd in the path means the current working directory.\n\
1849 $cdir in the path means the compilation directory of the source file.\n\
1850 GDB ensures the search path always ends with $cdir:$cwd by\n\
1851 appending these directories if necessary.\n\
1852 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
1853 set_directories_command
,
1854 show_directories_command
,
1855 &setlist
, &showlist
);
1857 add_info ("source", info_source_command
,
1858 _("Information about the current source file."));
1860 add_info ("line", info_line_command
, _("\
1861 Core addresses of the code for a source line.\n\
1862 Line can be specified as\n\
1863 LINENUM, to list around that line in current file,\n\
1864 FILE:LINENUM, to list around that line in that file,\n\
1865 FUNCTION, to list around beginning of that function,\n\
1866 FILE:FUNCTION, to distinguish among like-named static functions.\n\
1867 Default is to describe the last source line that was listed.\n\n\
1868 This sets the default address for \"x\" to the line's first instruction\n\
1869 so that \"x/i\" suffices to start examining the machine code.\n\
1870 The address is also stored as the value of \"$_\"."));
1872 add_com ("forward-search", class_files
, forward_search_command
, _("\
1873 Search for regular expression (see regex(3)) from last line listed.\n\
1874 The matching line number is also stored as the value of \"$_\"."));
1875 add_com_alias ("search", "forward-search", class_files
, 0);
1876 add_com_alias ("fo", "forward-search", class_files
, 1);
1878 add_com ("reverse-search", class_files
, reverse_search_command
, _("\
1879 Search backward for regular expression (see regex(3)) from last line listed.\n\
1880 The matching line number is also stored as the value of \"$_\"."));
1881 add_com_alias ("rev", "reverse-search", class_files
, 1);
1883 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
1884 Set number of source lines gdb will list by default."), _("\
1885 Show number of source lines gdb will list by default."), _("\
1886 Use this to choose how many source lines the \"list\" displays (unless\n\
1887 the \"list\" argument explicitly specifies some other number).\n\
1888 A value of \"unlimited\", or zero, means there's no limit."),
1891 &setlist
, &showlist
);
1893 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
1895 Add a substitution rule to rewrite the source directories.\n\
1896 Usage: set substitute-path FROM TO\n\
1897 The rule is applied only if the directory name starts with FROM\n\
1898 directly followed by a directory separator.\n\
1899 If a substitution rule was previously set for FROM, the old rule\n\
1900 is replaced by the new one."),
1903 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
1905 Delete one or all substitution rules rewriting the source directories.\n\
1906 Usage: unset substitute-path [FROM]\n\
1907 Delete the rule for substituting FROM in source directories. If FROM\n\
1908 is not specified, all substituting rules are deleted.\n\
1909 If the debugger cannot find a rule for FROM, it will display a warning."),
1912 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
1914 Show one or all substitution rules rewriting the source directories.\n\
1915 Usage: show substitute-path [FROM]\n\
1916 Print the rule for substituting FROM in source directories. If FROM\n\
1917 is not specified, print all substitution rules."),
1920 add_setshow_enum_cmd ("filename-display", class_files
,
1921 filename_display_kind_names
,
1922 &filename_display_string
, _("\
1923 Set how to display filenames."), _("\
1924 Show how to display filenames."), _("\
1925 filename-display can be:\n\
1926 basename - display only basename of a filename\n\
1927 relative - display a filename relative to the compilation directory\n\
1928 absolute - display an absolute filename\n\
1929 By default, relative filenames are displayed."),
1931 show_filename_display_string
,
1932 &setlist
, &showlist
);