1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2016 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 "filestuff.h"
31 #include <sys/types.h>
35 #include "gdb_regex.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "completer.h"
44 #include "readline/readline.h"
45 #include "common/enum-flags.h"
47 #define OPEN_MODE (O_RDONLY | O_BINARY)
48 #define FDOPEN_MODE FOPEN_RB
50 /* Prototypes for exported functions. */
52 void _initialize_source (void);
54 /* Prototypes for local functions. */
56 static int get_filename_and_charpos (struct symtab
*, char **);
58 static void reverse_search_command (char *, int);
60 static void forward_search_command (char *, int);
62 static void line_info (char *, int);
64 static void source_info (char *, int);
66 /* Path of directories to search for source files.
67 Same format as the PATH environment variable's value. */
71 /* Support for source path substitution commands. */
73 struct substitute_path_rule
77 struct substitute_path_rule
*next
;
80 static struct substitute_path_rule
*substitute_path_rules
= NULL
;
82 /* Symtab of default file for listing lines of. */
84 static struct symtab
*current_source_symtab
;
86 /* Default next line to list. */
88 static int current_source_line
;
90 static struct program_space
*current_source_pspace
;
92 /* Default number of lines to print with commands like "list".
93 This is based on guessing how many long (i.e. more than chars_per_line
94 characters) lines there will be. To be completely correct, "list"
95 and friends should be rewritten to count characters and see where
96 things are wrapping, but that would be a fair amount of work. */
98 static int lines_to_list
= 10;
100 show_lines_to_list (struct ui_file
*file
, int from_tty
,
101 struct cmd_list_element
*c
, const char *value
)
103 fprintf_filtered (file
,
104 _("Number of source lines gdb "
105 "will list by default is %s.\n"),
109 /* Possible values of 'set filename-display'. */
110 static const char filename_display_basename
[] = "basename";
111 static const char filename_display_relative
[] = "relative";
112 static const char filename_display_absolute
[] = "absolute";
114 static const char *const filename_display_kind_names
[] = {
115 filename_display_basename
,
116 filename_display_relative
,
117 filename_display_absolute
,
121 static const char *filename_display_string
= filename_display_relative
;
124 show_filename_display_string (struct ui_file
*file
, int from_tty
,
125 struct cmd_list_element
*c
, const char *value
)
127 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
130 /* Line number of last line printed. Default for various commands.
131 current_source_line is usually, but not always, the same as this. */
133 static int last_line_listed
;
135 /* First line number listed by last listing command. If 0, then no
136 source lines have yet been listed since the last time the current
137 source line was changed. */
139 static int first_line_listed
;
141 /* Saves the name of the last source file visited and a possible error code.
142 Used to prevent repeating annoying "No such file or directories" msgs. */
144 static struct symtab
*last_source_visited
= NULL
;
145 static int last_source_error
= 0;
147 /* Return the first line listed by print_source_lines.
148 Used by command interpreters to request listing from
152 get_first_line_listed (void)
154 return first_line_listed
;
157 /* Clear line listed range. This makes the next "list" center the
158 printed source lines around the current source line. */
161 clear_lines_listed_range (void)
163 first_line_listed
= 0;
164 last_line_listed
= 0;
167 /* Return the default number of lines to print with commands like the
168 cli "list". The caller of print_source_lines must use this to
169 calculate the end line and use it in the call to print_source_lines
170 as it does not automatically use this value. */
173 get_lines_to_list (void)
175 return lines_to_list
;
178 /* Return the current source file for listing and next line to list.
179 NOTE: The returned sal pc and end fields are not valid. */
181 struct symtab_and_line
182 get_current_source_symtab_and_line (void)
184 struct symtab_and_line cursal
= { 0 };
186 cursal
.pspace
= current_source_pspace
;
187 cursal
.symtab
= current_source_symtab
;
188 cursal
.line
= current_source_line
;
195 /* If the current source file for listing is not set, try and get a default.
196 Usually called before get_current_source_symtab_and_line() is called.
197 It may err out if a default cannot be determined.
198 We must be cautious about where it is called, as it can recurse as the
199 process of determining a new default may call the caller!
200 Use get_current_source_symtab_and_line only to get whatever
201 we have without erroring out or trying to get a default. */
204 set_default_source_symtab_and_line (void)
206 if (!have_full_symbols () && !have_partial_symbols ())
207 error (_("No symbol table is loaded. Use the \"file\" command."));
209 /* Pull in a current source symtab if necessary. */
210 if (current_source_symtab
== 0)
211 select_source_symtab (0);
214 /* Return the current default file for listing and next line to list
215 (the returned sal pc and end fields are not valid.)
216 and set the current default to whatever is in SAL.
217 NOTE: The returned sal pc and end fields are not valid. */
219 struct symtab_and_line
220 set_current_source_symtab_and_line (const struct symtab_and_line
*sal
)
222 struct symtab_and_line cursal
= { 0 };
224 cursal
.pspace
= current_source_pspace
;
225 cursal
.symtab
= current_source_symtab
;
226 cursal
.line
= current_source_line
;
230 current_source_pspace
= sal
->pspace
;
231 current_source_symtab
= sal
->symtab
;
232 current_source_line
= sal
->line
;
234 /* Force the next "list" to center around the current line. */
235 clear_lines_listed_range ();
240 /* Reset any information stored about a default file and line to print. */
243 clear_current_source_symtab_and_line (void)
245 current_source_symtab
= 0;
246 current_source_line
= 0;
249 /* Set the source file default for the "list" command to be S.
251 If S is NULL, and we don't have a default, find one. This
252 should only be called when the user actually tries to use the
253 default, since we produce an error if we can't find a reasonable
254 default. Also, since this can cause symbols to be read, doing it
255 before we need to would make things slower than necessary. */
258 select_source_symtab (struct symtab
*s
)
260 struct symtabs_and_lines sals
;
261 struct symtab_and_line sal
;
263 struct compunit_symtab
*cu
;
267 current_source_symtab
= s
;
268 current_source_line
= 1;
269 current_source_pspace
= SYMTAB_PSPACE (s
);
273 if (current_source_symtab
)
276 /* Make the default place to list be the function `main'
278 if (lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0).symbol
)
280 sals
= decode_line_with_current_source (main_name (),
281 DECODE_LINE_FUNFIRSTLINE
);
284 current_source_pspace
= sal
.pspace
;
285 current_source_symtab
= sal
.symtab
;
286 current_source_line
= max (sal
.line
- (lines_to_list
- 1), 1);
287 if (current_source_symtab
)
291 /* Alright; find the last file in the symtab list (ignoring .h's
292 and namespace symtabs). */
294 current_source_line
= 1;
296 ALL_FILETABS (ofp
, cu
, s
)
298 const char *name
= s
->filename
;
299 int len
= strlen (name
);
301 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
302 || strcmp (name
, "<<C++-namespaces>>") == 0)))
304 current_source_pspace
= current_program_space
;
305 current_source_symtab
= s
;
309 if (current_source_symtab
)
315 s
= ofp
->sf
->qf
->find_last_source_symtab (ofp
);
317 current_source_symtab
= s
;
319 if (current_source_symtab
)
322 error (_("Can't find a default source file"));
325 /* Handler for "set directories path-list" command.
326 "set dir mumble" doesn't prepend paths, it resets the entire
327 path list. The theory is that set(show(dir)) should be a no-op. */
330 set_directories_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
332 /* This is the value that was set.
333 It needs to be processed to maintain $cdir:$cwd and remove dups. */
334 char *set_path
= source_path
;
336 /* We preserve the invariant that $cdir:$cwd begins life at the end of
337 the list by calling init_source_path. If they appear earlier in
338 SET_PATH then mod_path will move them appropriately.
339 mod_path will also remove duplicates. */
341 if (*set_path
!= '\0')
342 mod_path (set_path
, &source_path
);
347 /* Print the list of source directories.
348 This is used by the "ld" command, so it has the signature of a command
352 show_directories_1 (char *ignore
, int from_tty
)
354 puts_filtered ("Source directories searched: ");
355 puts_filtered (source_path
);
356 puts_filtered ("\n");
359 /* Handler for "show directories" command. */
362 show_directories_command (struct ui_file
*file
, int from_tty
,
363 struct cmd_list_element
*c
, const char *value
)
365 show_directories_1 (NULL
, from_tty
);
368 /* Forget line positions and file names for the symtabs in a
369 particular objfile. */
372 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
374 struct compunit_symtab
*cu
;
377 ALL_OBJFILE_FILETABS (objfile
, cu
, s
)
379 if (s
->line_charpos
!= NULL
)
381 xfree (s
->line_charpos
);
382 s
->line_charpos
= NULL
;
384 if (s
->fullname
!= NULL
)
392 objfile
->sf
->qf
->forget_cached_source_info (objfile
);
395 /* Forget what we learned about line positions in source files, and
396 which directories contain them; must check again now since files
397 may be found in a different directory now. */
400 forget_cached_source_info (void)
402 struct program_space
*pspace
;
403 struct objfile
*objfile
;
406 ALL_PSPACE_OBJFILES (pspace
, objfile
)
408 forget_cached_source_info_for_objfile (objfile
);
411 last_source_visited
= NULL
;
415 init_source_path (void)
419 xsnprintf (buf
, sizeof (buf
), "$cdir%c$cwd", DIRNAME_SEPARATOR
);
420 source_path
= xstrdup (buf
);
421 forget_cached_source_info ();
424 /* Add zero or more directories to the front of the source path. */
427 directory_command (char *dirname
, int from_tty
)
430 /* FIXME, this goes to "delete dir"... */
433 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
441 mod_path (dirname
, &source_path
);
442 forget_cached_source_info ();
445 show_directories_1 ((char *) 0, from_tty
);
448 /* Add a path given with the -d command line switch.
449 This will not be quoted so we must not treat spaces as separators. */
452 directory_switch (char *dirname
, int from_tty
)
454 add_path (dirname
, &source_path
, 0);
457 /* Add zero or more directories to the front of an arbitrary path. */
460 mod_path (char *dirname
, char **which_path
)
462 add_path (dirname
, which_path
, 1);
465 /* Workhorse of mod_path. Takes an extra argument to determine
466 if dirname should be parsed for separators that indicate multiple
467 directories. This allows for interfaces that pre-parse the dirname
468 and allow specification of traditional separator characters such
472 add_path (char *dirname
, char **which_path
, int parse_separators
)
474 char *old
= *which_path
;
476 VEC (char_ptr
) *dir_vec
= NULL
;
477 struct cleanup
*back_to
;
484 if (parse_separators
)
486 char **argv
, **argvp
;
488 /* This will properly parse the space and tab separators
489 and any quotes that may exist. */
490 argv
= gdb_buildargv (dirname
);
492 for (argvp
= argv
; *argvp
; argvp
++)
493 dirnames_to_char_ptr_vec_append (&dir_vec
, *argvp
);
498 VEC_safe_push (char_ptr
, dir_vec
, xstrdup (dirname
));
499 back_to
= make_cleanup_free_char_ptr_vec (dir_vec
);
501 for (ix
= 0; VEC_iterate (char_ptr
, dir_vec
, ix
, name
); ++ix
)
506 /* Spaces and tabs will have been removed by buildargv().
507 NAME is the start of the directory.
508 P is the '\0' following the end. */
509 p
= name
+ strlen (name
);
511 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
512 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
513 /* On MS-DOS and MS-Windows, h:\ is different from h: */
514 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
516 && IS_DIR_SEPARATOR (p
[-1]))
517 /* Sigh. "foo/" => "foo" */
521 while (p
> name
&& p
[-1] == '.')
525 /* "." => getwd (). */
526 name
= current_directory
;
529 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
539 /* "...foo/." => "...foo". */
550 name
= tilde_expand (name
);
551 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
552 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
553 name
= concat (name
, ".", (char *)NULL
);
555 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
556 name
= concat (current_directory
, SLASH_STRING
, name
, (char *)NULL
);
558 name
= savestring (name
, p
- name
);
559 make_cleanup (xfree
, name
);
561 /* Unless it's a variable, check existence. */
564 /* These are warnings, not errors, since we don't want a
565 non-existent directory in a .gdbinit file to stop processing
566 of the .gdbinit file.
568 Whether they get added to the path is more debatable. Current
569 answer is yes, in case the user wants to go make the directory
570 or whatever. If the directory continues to not exist/not be
571 a directory/etc, then having them in the path should be
573 if (stat (name
, &st
) < 0)
575 int save_errno
= errno
;
577 fprintf_unfiltered (gdb_stderr
, "Warning: ");
578 print_sys_errmsg (name
, save_errno
);
580 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
581 warning (_("%s is not a directory."), name
);
586 unsigned int len
= strlen (name
);
592 /* FIXME: we should use realpath() or its work-alike
593 before comparing. Then all the code above which
594 removes excess slashes and dots could simply go away. */
595 if (!filename_ncmp (p
, name
, len
)
596 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
598 /* Found it in the search path, remove old copy. */
601 /* Back over leading separator. */
604 if (prefix
> p
- *which_path
)
606 /* Same dir twice in one cmd. */
609 /* Copy from next '\0' or ':'. */
610 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
612 p
= strchr (p
, DIRNAME_SEPARATOR
);
619 tinybuf
[0] = DIRNAME_SEPARATOR
;
622 /* If we have already tacked on a name(s) in this command,
623 be sure they stay on the front as we tack on some
631 temp
= concat (old
, tinybuf
, name
, (char *)NULL
);
633 *which_path
= concat (temp
, "", &old
[prefix
], (char *) NULL
);
634 prefix
= strlen (temp
);
639 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
641 prefix
= strlen (name
);
650 do_cleanups (back_to
);
655 source_info (char *ignore
, int from_tty
)
657 struct symtab
*s
= current_source_symtab
;
658 struct compunit_symtab
*cust
;
662 printf_filtered (_("No current source file.\n"));
666 cust
= SYMTAB_COMPUNIT (s
);
667 printf_filtered (_("Current source file is %s\n"), s
->filename
);
668 if (SYMTAB_DIRNAME (s
) != NULL
)
669 printf_filtered (_("Compilation directory is %s\n"), SYMTAB_DIRNAME (s
));
671 printf_filtered (_("Located in %s\n"), s
->fullname
);
673 printf_filtered (_("Contains %d line%s.\n"), s
->nlines
,
674 s
->nlines
== 1 ? "" : "s");
676 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
677 printf_filtered (_("Producer is %s.\n"),
678 COMPUNIT_PRODUCER (cust
) != NULL
679 ? COMPUNIT_PRODUCER (cust
) : _("unknown"));
680 printf_filtered (_("Compiled with %s debugging format.\n"),
681 COMPUNIT_DEBUGFORMAT (cust
));
682 printf_filtered (_("%s preprocessor macro info.\n"),
683 COMPUNIT_MACRO_TABLE (cust
) != NULL
684 ? "Includes" : "Does not include");
688 /* Return True if the file NAME exists and is a regular file.
689 If the result is false then *ERRNO_PTR is set to a useful value assuming
690 we're expecting a regular file. */
693 is_regular_file (const char *name
, int *errno_ptr
)
696 const int status
= stat (name
, &st
);
698 /* Stat should never fail except when the file does not exist.
699 If stat fails, analyze the source of error and return True
700 unless the file does not exist, to avoid returning false results
701 on obscure systems where stat does not work as expected. */
711 if (S_ISREG (st
.st_mode
))
714 if (S_ISDIR (st
.st_mode
))
721 /* Open a file named STRING, searching path PATH (dir names sep by some char)
722 using mode MODE in the calls to open. You cannot use this function to
723 create files (O_CREAT).
725 OPTS specifies the function behaviour in specific cases.
727 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
728 (ie pretend the first element of PATH is "."). This also indicates
729 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
730 disables searching of the path (this is so that "exec-file ./foo" or
731 "symbol-file ./foo" insures that you get that particular version of
732 foo or an error message).
734 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
735 searched in path (we usually want this for source files but not for
738 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
739 the actual file opened (this string will always start with a "/"). We
740 have to take special pains to avoid doubling the "/" between the directory
741 and the file, sigh! Emacs gets confuzzed by this when we print the
744 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
745 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
746 filename starting with "/". If FILENAME_OPENED is NULL this option has no
749 If a file is found, return the descriptor.
750 Otherwise, return -1, with errno set for the last name we tried to open. */
752 /* >>>> This should only allow files of certain types,
753 >>>> eg executable, non-directory. */
755 openp (const char *path
, int opts
, const char *string
,
756 int mode
, char **filename_opened
)
761 VEC (char_ptr
) *dir_vec
;
762 struct cleanup
*back_to
;
765 /* The errno set for the last name we tried to open (and
769 /* The open syscall MODE parameter is not specified. */
770 gdb_assert ((mode
& O_CREAT
) == 0);
771 gdb_assert (string
!= NULL
);
773 /* A file with an empty name cannot possibly exist. Report a failure
774 without further checking.
776 This is an optimization which also defends us against buggy
777 implementations of the "stat" function. For instance, we have
778 noticed that a MinGW debugger built on Windows XP 32bits crashes
779 when the debugger is started with an empty argument. */
780 if (string
[0] == '\0')
791 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
793 int i
, reg_file_errno
;
795 if (is_regular_file (string
, ®_file_errno
))
797 filename
= (char *) alloca (strlen (string
) + 1);
798 strcpy (filename
, string
);
799 fd
= gdb_open_cloexec (filename
, mode
, 0);
808 last_errno
= reg_file_errno
;
811 if (!(opts
& OPF_SEARCH_IN_PATH
))
812 for (i
= 0; string
[i
]; i
++)
813 if (IS_DIR_SEPARATOR (string
[i
]))
817 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
818 if (HAS_DRIVE_SPEC (string
))
819 string
= STRIP_DRIVE_SPEC (string
);
821 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
822 while (IS_DIR_SEPARATOR(string
[0]))
826 while (string
[0] == '.' && IS_DIR_SEPARATOR (string
[1]))
829 alloclen
= strlen (path
) + strlen (string
) + 2;
830 filename
= (char *) alloca (alloclen
);
834 dir_vec
= dirnames_to_char_ptr_vec (path
);
835 back_to
= make_cleanup_free_char_ptr_vec (dir_vec
);
837 for (ix
= 0; VEC_iterate (char_ptr
, dir_vec
, ix
, dir
); ++ix
)
839 size_t len
= strlen (dir
);
842 if (strcmp (dir
, "$cwd") == 0)
844 /* Name is $cwd -- insert current directory name instead. */
847 /* First, realloc the filename buffer if too short. */
848 len
= strlen (current_directory
);
849 newlen
= len
+ strlen (string
) + 2;
850 if (newlen
> alloclen
)
853 filename
= (char *) alloca (alloclen
);
855 strcpy (filename
, current_directory
);
857 else if (strchr(dir
, '~'))
859 /* See whether we need to expand the tilde. */
861 char *tilde_expanded
;
863 tilde_expanded
= tilde_expand (dir
);
865 /* First, realloc the filename buffer if too short. */
866 len
= strlen (tilde_expanded
);
867 newlen
= len
+ strlen (string
) + 2;
868 if (newlen
> alloclen
)
871 filename
= (char *) alloca (alloclen
);
873 strcpy (filename
, tilde_expanded
);
874 xfree (tilde_expanded
);
878 /* Normal file name in path -- just use it. */
879 strcpy (filename
, dir
);
881 /* Don't search $cdir. It's also a magic path like $cwd, but we
882 don't have enough information to expand it. The user *could*
883 have an actual directory named '$cdir' but handling that would
884 be confusing, it would mean different things in different
885 contexts. If the user really has '$cdir' one can use './$cdir'.
886 We can get $cdir when loading scripts. When loading source files
887 $cdir must have already been expanded to the correct value. */
888 if (strcmp (dir
, "$cdir") == 0)
892 /* Remove trailing slashes. */
893 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
896 strcat (filename
+ len
, SLASH_STRING
);
897 strcat (filename
, string
);
899 if (is_regular_file (filename
, ®_file_errno
))
901 fd
= gdb_open_cloexec (filename
, mode
, 0);
907 last_errno
= reg_file_errno
;
910 do_cleanups (back_to
);
915 /* If a file was opened, canonicalize its filename. */
917 *filename_opened
= NULL
;
918 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
919 *filename_opened
= gdb_realpath (filename
);
921 *filename_opened
= gdb_abspath (filename
);
929 /* This is essentially a convenience, for clients that want the behaviour
930 of openp, using source_path, but that really don't want the file to be
931 opened but want instead just to know what the full pathname is (as
932 qualified against source_path).
934 The current working directory is searched first.
936 If the file was found, this function returns 1, and FULL_PATHNAME is
937 set to the fully-qualified pathname.
939 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
941 source_full_path_of (const char *filename
, char **full_pathname
)
945 fd
= openp (source_path
,
946 OPF_TRY_CWD_FIRST
| OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
,
947 filename
, O_RDONLY
, full_pathname
);
950 *full_pathname
= NULL
;
958 /* Return non-zero if RULE matches PATH, that is if the rule can be
962 substitute_path_rule_matches (const struct substitute_path_rule
*rule
,
965 const int from_len
= strlen (rule
->from
);
966 const int path_len
= strlen (path
);
968 if (path_len
< from_len
)
971 /* The substitution rules are anchored at the start of the path,
972 so the path should start with rule->from. */
974 if (filename_ncmp (path
, rule
->from
, from_len
) != 0)
977 /* Make sure that the region in the path that matches the substitution
978 rule is immediately followed by a directory separator (or the end of
979 string character). */
981 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
987 /* Find the substitute-path rule that applies to PATH and return it.
988 Return NULL if no rule applies. */
990 static struct substitute_path_rule
*
991 get_substitute_path_rule (const char *path
)
993 struct substitute_path_rule
*rule
= substitute_path_rules
;
995 while (rule
!= NULL
&& !substitute_path_rule_matches (rule
, path
))
1001 /* If the user specified a source path substitution rule that applies
1002 to PATH, then apply it and return the new path. This new path must
1003 be deallocated afterwards.
1005 Return NULL if no substitution rule was specified by the user,
1006 or if no rule applied to the given PATH. */
1009 rewrite_source_path (const char *path
)
1011 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
1018 from_len
= strlen (rule
->from
);
1020 /* Compute the rewritten path and return it. */
1023 (char *) xmalloc (strlen (path
) + 1 + strlen (rule
->to
) - from_len
);
1024 strcpy (new_path
, rule
->to
);
1025 strcat (new_path
, path
+ from_len
);
1031 find_and_open_source (const char *filename
,
1032 const char *dirname
,
1035 char *path
= source_path
;
1038 struct cleanup
*cleanup
;
1040 /* Quick way out if we already know its full name. */
1044 /* The user may have requested that source paths be rewritten
1045 according to substitution rules he provided. If a substitution
1046 rule applies to this path, then apply it. */
1047 char *rewritten_fullname
= rewrite_source_path (*fullname
);
1049 if (rewritten_fullname
!= NULL
)
1052 *fullname
= rewritten_fullname
;
1055 result
= gdb_open_cloexec (*fullname
, OPEN_MODE
, 0);
1058 char *lpath
= gdb_realpath (*fullname
);
1065 /* Didn't work -- free old one, try again. */
1070 cleanup
= make_cleanup (null_cleanup
, NULL
);
1072 if (dirname
!= NULL
)
1074 /* If necessary, rewrite the compilation directory name according
1075 to the source path substitution rules specified by the user. */
1077 char *rewritten_dirname
= rewrite_source_path (dirname
);
1079 if (rewritten_dirname
!= NULL
)
1081 make_cleanup (xfree
, rewritten_dirname
);
1082 dirname
= rewritten_dirname
;
1085 /* Replace a path entry of $cdir with the compilation directory
1088 /* We cast strstr's result in case an ANSIhole has made it const,
1089 which produces a "required warning" when assigned to a nonconst. */
1090 p
= (char *) strstr (source_path
, "$cdir");
1091 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1092 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1097 alloca (strlen (source_path
) + 1 + strlen (dirname
) + 1);
1098 len
= p
- source_path
;
1099 strncpy (path
, source_path
, len
); /* Before $cdir */
1100 strcpy (path
+ len
, dirname
); /* new stuff */
1101 strcat (path
+ len
, source_path
+ len
+ cdir_len
); /* After
1106 if (IS_ABSOLUTE_PATH (filename
))
1108 /* If filename is absolute path, try the source path
1109 substitution on it. */
1110 char *rewritten_filename
= rewrite_source_path (filename
);
1112 if (rewritten_filename
!= NULL
)
1114 make_cleanup (xfree
, rewritten_filename
);
1115 filename
= rewritten_filename
;
1119 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, filename
,
1120 OPEN_MODE
, fullname
);
1123 /* Didn't work. Try using just the basename. */
1124 p
= lbasename (filename
);
1126 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, p
,
1127 OPEN_MODE
, fullname
);
1130 do_cleanups (cleanup
);
1134 /* Open a source file given a symtab S. Returns a file descriptor or
1135 negative number for error.
1137 This function is a convience function to find_and_open_source. */
1140 open_source_file (struct symtab
*s
)
1145 return find_and_open_source (s
->filename
, SYMTAB_DIRNAME (s
), &s
->fullname
);
1148 /* Finds the fullname that a symtab represents.
1150 This functions finds the fullname and saves it in s->fullname.
1151 It will also return the value.
1153 If this function fails to find the file that this symtab represents,
1154 the expected fullname is used. Therefore the files does not have to
1158 symtab_to_fullname (struct symtab
*s
)
1160 /* Use cached copy if we have it.
1161 We rely on forget_cached_source_info being called appropriately
1162 to handle cases like the file being moved. */
1163 if (s
->fullname
== NULL
)
1165 int fd
= find_and_open_source (s
->filename
, SYMTAB_DIRNAME (s
),
1173 struct cleanup
*back_to
;
1175 /* rewrite_source_path would be applied by find_and_open_source, we
1176 should report the pathname where GDB tried to find the file. */
1178 if (SYMTAB_DIRNAME (s
) == NULL
|| IS_ABSOLUTE_PATH (s
->filename
))
1179 fullname
= xstrdup (s
->filename
);
1181 fullname
= concat (SYMTAB_DIRNAME (s
), SLASH_STRING
,
1182 s
->filename
, (char *) NULL
);
1184 back_to
= make_cleanup (xfree
, fullname
);
1185 s
->fullname
= rewrite_source_path (fullname
);
1186 if (s
->fullname
== NULL
)
1187 s
->fullname
= xstrdup (fullname
);
1188 do_cleanups (back_to
);
1195 /* See commentary in source.h. */
1198 symtab_to_filename_for_display (struct symtab
*symtab
)
1200 if (filename_display_string
== filename_display_basename
)
1201 return lbasename (symtab
->filename
);
1202 else if (filename_display_string
== filename_display_absolute
)
1203 return symtab_to_fullname (symtab
);
1204 else if (filename_display_string
== filename_display_relative
)
1205 return symtab
->filename
;
1207 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1210 /* Create and initialize the table S->line_charpos that records
1211 the positions of the lines in the source file, which is assumed
1212 to be open on descriptor DESC.
1213 All set S->nlines to the number of such lines. */
1216 find_source_lines (struct symtab
*s
, int desc
)
1219 char *data
, *p
, *end
;
1221 int lines_allocated
= 1000;
1227 line_charpos
= XNEWVEC (int, lines_allocated
);
1228 if (fstat (desc
, &st
) < 0)
1229 perror_with_name (symtab_to_filename_for_display (s
));
1231 if (SYMTAB_OBJFILE (s
) != NULL
&& SYMTAB_OBJFILE (s
)->obfd
!= NULL
)
1232 mtime
= SYMTAB_OBJFILE (s
)->mtime
;
1234 mtime
= exec_bfd_mtime
;
1236 if (mtime
&& mtime
< st
.st_mtime
)
1237 warning (_("Source file is more recent than executable."));
1240 struct cleanup
*old_cleanups
;
1242 /* st_size might be a large type, but we only support source files whose
1243 size fits in an int. */
1244 size
= (int) st
.st_size
;
1246 /* Use malloc, not alloca, because this may be pretty large, and we may
1247 run into various kinds of limits on stack size. */
1248 data
= (char *) xmalloc (size
);
1249 old_cleanups
= make_cleanup (xfree
, data
);
1251 /* Reassign `size' to result of read for systems where \r\n -> \n. */
1252 size
= myread (desc
, data
, size
);
1254 perror_with_name (symtab_to_filename_for_display (s
));
1257 line_charpos
[0] = 0;
1262 /* A newline at the end does not start a new line. */
1265 if (nlines
== lines_allocated
)
1267 lines_allocated
*= 2;
1269 (int *) xrealloc ((char *) line_charpos
,
1270 sizeof (int) * lines_allocated
);
1272 line_charpos
[nlines
++] = p
- data
;
1275 do_cleanups (old_cleanups
);
1280 (int *) xrealloc ((char *) line_charpos
, nlines
* sizeof (int));
1286 /* Get full pathname and line number positions for a symtab.
1287 Return nonzero if line numbers may have changed.
1288 Set *FULLNAME to actual name of the file as found by `openp',
1289 or to 0 if the file is not found. */
1292 get_filename_and_charpos (struct symtab
*s
, char **fullname
)
1294 int desc
, linenums_changed
= 0;
1295 struct cleanup
*cleanups
;
1297 desc
= open_source_file (s
);
1304 cleanups
= make_cleanup_close (desc
);
1306 *fullname
= s
->fullname
;
1307 if (s
->line_charpos
== 0)
1308 linenums_changed
= 1;
1309 if (linenums_changed
)
1310 find_source_lines (s
, desc
);
1311 do_cleanups (cleanups
);
1312 return linenums_changed
;
1315 /* Print text describing the full name of the source file S
1316 and the line number LINE and its corresponding character position.
1317 The text starts with two Ctrl-z so that the Emacs-GDB interface
1320 MID_STATEMENT is nonzero if the PC is not at the beginning of that line.
1322 Return 1 if successful, 0 if could not find the file. */
1325 identify_source_line (struct symtab
*s
, int line
, int mid_statement
,
1328 if (s
->line_charpos
== 0)
1329 get_filename_and_charpos (s
, (char **) NULL
);
1330 if (s
->fullname
== 0)
1332 if (line
> s
->nlines
)
1333 /* Don't index off the end of the line_charpos array. */
1335 annotate_source (s
->fullname
, line
, s
->line_charpos
[line
- 1],
1336 mid_statement
, get_objfile_arch (SYMTAB_OBJFILE (s
)), pc
);
1338 current_source_line
= line
;
1339 current_source_symtab
= s
;
1340 clear_lines_listed_range ();
1345 /* Print source lines from the file of symtab S,
1346 starting with line number LINE and stopping before line number STOPLINE. */
1349 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1350 print_source_lines_flags flags
)
1356 int nlines
= stopline
- line
;
1357 struct cleanup
*cleanup
;
1358 struct ui_out
*uiout
= current_uiout
;
1360 /* Regardless of whether we can open the file, set current_source_symtab. */
1361 current_source_symtab
= s
;
1362 current_source_line
= line
;
1363 first_line_listed
= line
;
1365 /* If printing of source lines is disabled, just print file and line
1367 if (ui_out_test_flags (uiout
, ui_source_list
))
1369 /* Only prints "No such file or directory" once. */
1370 if ((s
!= last_source_visited
) || (!last_source_error
))
1372 last_source_visited
= s
;
1373 desc
= open_source_file (s
);
1377 desc
= last_source_error
;
1378 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1383 desc
= last_source_error
;
1384 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1388 if (desc
< 0 || noprint
)
1390 last_source_error
= desc
;
1392 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1394 const char *filename
= symtab_to_filename_for_display (s
);
1395 int len
= strlen (filename
) + 100;
1396 char *name
= (char *) alloca (len
);
1398 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1399 print_sys_errmsg (name
, errno
);
1403 ui_out_field_int (uiout
, "line", line
);
1404 ui_out_text (uiout
, "\tin ");
1406 /* CLI expects only the "file" field. TUI expects only the
1407 "fullname" field (and TUI does break if "file" is printed).
1408 MI expects both fields. ui_source_list is set only for CLI,
1410 if (ui_out_is_mi_like_p (uiout
)
1411 || ui_out_test_flags (uiout
, ui_source_list
))
1412 ui_out_field_string (uiout
, "file",
1413 symtab_to_filename_for_display (s
));
1414 if (ui_out_is_mi_like_p (uiout
)
1415 || !ui_out_test_flags (uiout
, ui_source_list
))
1417 const char *s_fullname
= symtab_to_fullname (s
);
1418 char *local_fullname
;
1420 /* ui_out_field_string may free S_FULLNAME by calling
1421 open_source_file for it again. See e.g.,
1422 tui_field_string->tui_show_source. */
1423 local_fullname
= (char *) alloca (strlen (s_fullname
) + 1);
1424 strcpy (local_fullname
, s_fullname
);
1426 ui_out_field_string (uiout
, "fullname", local_fullname
);
1429 ui_out_text (uiout
, "\n");
1435 last_source_error
= 0;
1437 if (s
->line_charpos
== 0)
1438 find_source_lines (s
, desc
);
1440 if (line
< 1 || line
> s
->nlines
)
1443 error (_("Line number %d out of range; %s has %d lines."),
1444 line
, symtab_to_filename_for_display (s
), s
->nlines
);
1447 if (lseek (desc
, s
->line_charpos
[line
- 1], 0) < 0)
1450 perror_with_name (symtab_to_filename_for_display (s
));
1453 stream
= fdopen (desc
, FDOPEN_MODE
);
1455 cleanup
= make_cleanup_fclose (stream
);
1457 while (nlines
-- > 0)
1464 last_line_listed
= current_source_line
;
1465 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1467 ui_out_text (uiout
, symtab_to_filename_for_display (s
));
1468 ui_out_text (uiout
, ":");
1470 xsnprintf (buf
, sizeof (buf
), "%d\t", current_source_line
++);
1471 ui_out_text (uiout
, buf
);
1474 if (c
< 040 && c
!= '\t' && c
!= '\n' && c
!= '\r')
1476 xsnprintf (buf
, sizeof (buf
), "^%c", c
+ 0100);
1477 ui_out_text (uiout
, buf
);
1480 ui_out_text (uiout
, "^?");
1483 /* Skip a \r character, but only before a \n. */
1484 int c1
= fgetc (stream
);
1487 printf_filtered ("^%c", c
+ 0100);
1489 ungetc (c1
, stream
);
1493 xsnprintf (buf
, sizeof (buf
), "%c", c
);
1494 ui_out_text (uiout
, buf
);
1497 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1500 do_cleanups (cleanup
);
1503 /* Show source lines from the file of symtab S, starting with line
1504 number LINE and stopping before line number STOPLINE. If this is
1505 not the command line version, then the source is shown in the source
1506 window otherwise it is simply printed. */
1509 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1510 print_source_lines_flags flags
)
1512 print_source_lines_base (s
, line
, stopline
, flags
);
1515 /* Print info on range of pc's in a specified line. */
1518 line_info (char *arg
, int from_tty
)
1520 struct symtabs_and_lines sals
;
1521 struct symtab_and_line sal
;
1522 CORE_ADDR start_pc
, end_pc
;
1524 struct cleanup
*cleanups
;
1526 init_sal (&sal
); /* initialize to zeroes */
1530 sal
.symtab
= current_source_symtab
;
1531 sal
.pspace
= current_program_space
;
1532 if (last_line_listed
!= 0)
1533 sal
.line
= last_line_listed
;
1535 sal
.line
= current_source_line
;
1538 sals
.sals
= XNEW (struct symtab_and_line
);
1543 sals
= decode_line_with_last_displayed (arg
, DECODE_LINE_LIST_MODE
);
1548 cleanups
= make_cleanup (xfree
, sals
.sals
);
1550 /* C++ More than one line may have been specified, as when the user
1551 specifies an overloaded function name. Print info on them all. */
1552 for (i
= 0; i
< sals
.nelts
; i
++)
1555 if (sal
.pspace
!= current_program_space
)
1558 if (sal
.symtab
== 0)
1560 struct gdbarch
*gdbarch
= get_current_arch ();
1562 printf_filtered (_("No line number information available"));
1565 /* This is useful for "info line *0x7f34". If we can't tell the
1566 user about a source line, at least let them have the symbolic
1568 printf_filtered (" for address ");
1570 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1573 printf_filtered (".");
1574 printf_filtered ("\n");
1576 else if (sal
.line
> 0
1577 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1579 struct gdbarch
*gdbarch
1580 = get_objfile_arch (SYMTAB_OBJFILE (sal
.symtab
));
1582 if (start_pc
== end_pc
)
1584 printf_filtered ("Line %d of \"%s\"",
1586 symtab_to_filename_for_display (sal
.symtab
));
1588 printf_filtered (" is at address ");
1589 print_address (gdbarch
, start_pc
, gdb_stdout
);
1591 printf_filtered (" but contains no code.\n");
1595 printf_filtered ("Line %d of \"%s\"",
1597 symtab_to_filename_for_display (sal
.symtab
));
1599 printf_filtered (" starts at address ");
1600 print_address (gdbarch
, start_pc
, gdb_stdout
);
1602 printf_filtered (" and ends at ");
1603 print_address (gdbarch
, end_pc
, gdb_stdout
);
1604 printf_filtered (".\n");
1607 /* x/i should display this line's code. */
1608 set_next_address (gdbarch
, start_pc
);
1610 /* Repeating "info line" should do the following line. */
1611 last_line_listed
= sal
.line
+ 1;
1613 /* If this is the only line, show the source code. If it could
1614 not find the file, don't do anything special. */
1615 if (annotation_level
&& sals
.nelts
== 1)
1616 identify_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1619 /* Is there any case in which we get here, and have an address
1620 which the user would want to see? If we have debugging symbols
1621 and no line numbers? */
1622 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1623 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1625 do_cleanups (cleanups
);
1628 /* Commands to search the source file for a regexp. */
1631 forward_search_command (char *regex
, int from_tty
)
1638 struct cleanup
*cleanups
;
1640 line
= last_line_listed
+ 1;
1642 msg
= (char *) re_comp (regex
);
1644 error (("%s"), msg
);
1646 if (current_source_symtab
== 0)
1647 select_source_symtab (0);
1649 desc
= open_source_file (current_source_symtab
);
1651 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1652 cleanups
= make_cleanup_close (desc
);
1654 if (current_source_symtab
->line_charpos
== 0)
1655 find_source_lines (current_source_symtab
, desc
);
1657 if (line
< 1 || line
> current_source_symtab
->nlines
)
1658 error (_("Expression not found"));
1660 if (lseek (desc
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1661 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1663 discard_cleanups (cleanups
);
1664 stream
= fdopen (desc
, FDOPEN_MODE
);
1666 cleanups
= make_cleanup_fclose (stream
);
1669 static char *buf
= NULL
;
1671 int cursize
, newsize
;
1674 buf
= (char *) xmalloc (cursize
);
1683 if (p
- buf
== cursize
)
1685 newsize
= cursize
+ cursize
/ 2;
1686 buf
= (char *) xrealloc (buf
, newsize
);
1691 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1693 /* Remove the \r, if any, at the end of the line, otherwise
1694 regular expressions that end with $ or \n won't work. */
1695 if (p
- buf
> 1 && p
[-2] == '\r')
1701 /* We now have a source line in buf, null terminate and match. */
1703 if (re_exec (buf
) > 0)
1706 do_cleanups (cleanups
);
1707 print_source_lines (current_source_symtab
, line
, line
+ 1, 0);
1708 set_internalvar_integer (lookup_internalvar ("_"), line
);
1709 current_source_line
= max (line
- lines_to_list
/ 2, 1);
1715 printf_filtered (_("Expression not found\n"));
1716 do_cleanups (cleanups
);
1720 reverse_search_command (char *regex
, int from_tty
)
1727 struct cleanup
*cleanups
;
1729 line
= last_line_listed
- 1;
1731 msg
= (char *) re_comp (regex
);
1733 error (("%s"), msg
);
1735 if (current_source_symtab
== 0)
1736 select_source_symtab (0);
1738 desc
= open_source_file (current_source_symtab
);
1740 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1741 cleanups
= make_cleanup_close (desc
);
1743 if (current_source_symtab
->line_charpos
== 0)
1744 find_source_lines (current_source_symtab
, desc
);
1746 if (line
< 1 || line
> current_source_symtab
->nlines
)
1747 error (_("Expression not found"));
1749 if (lseek (desc
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1750 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1752 discard_cleanups (cleanups
);
1753 stream
= fdopen (desc
, FDOPEN_MODE
);
1755 cleanups
= make_cleanup_fclose (stream
);
1758 /* FIXME!!! We walk right off the end of buf if we get a long line!!! */
1759 char buf
[4096]; /* Should be reasonable??? */
1769 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1771 /* Remove the \r, if any, at the end of the line, otherwise
1772 regular expressions that end with $ or \n won't work. */
1773 if (p
- buf
> 1 && p
[-2] == '\r')
1779 /* We now have a source line in buf; null terminate and match. */
1781 if (re_exec (buf
) > 0)
1784 do_cleanups (cleanups
);
1785 print_source_lines (current_source_symtab
, line
, line
+ 1, 0);
1786 set_internalvar_integer (lookup_internalvar ("_"), line
);
1787 current_source_line
= max (line
- lines_to_list
/ 2, 1);
1791 if (fseek (stream
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1793 const char *filename
;
1795 do_cleanups (cleanups
);
1796 filename
= symtab_to_filename_for_display (current_source_symtab
);
1797 perror_with_name (filename
);
1801 printf_filtered (_("Expression not found\n"));
1802 do_cleanups (cleanups
);
1806 /* If the last character of PATH is a directory separator, then strip it. */
1809 strip_trailing_directory_separator (char *path
)
1811 const int last
= strlen (path
) - 1;
1814 return; /* No stripping is needed if PATH is the empty string. */
1816 if (IS_DIR_SEPARATOR (path
[last
]))
1820 /* Return the path substitution rule that matches FROM.
1821 Return NULL if no rule matches. */
1823 static struct substitute_path_rule
*
1824 find_substitute_path_rule (const char *from
)
1826 struct substitute_path_rule
*rule
= substitute_path_rules
;
1828 while (rule
!= NULL
)
1830 if (FILENAME_CMP (rule
->from
, from
) == 0)
1838 /* Add a new substitute-path rule at the end of the current list of rules.
1839 The new rule will replace FROM into TO. */
1842 add_substitute_path_rule (char *from
, char *to
)
1844 struct substitute_path_rule
*rule
;
1845 struct substitute_path_rule
*new_rule
= XNEW (struct substitute_path_rule
);
1847 new_rule
->from
= xstrdup (from
);
1848 new_rule
->to
= xstrdup (to
);
1849 new_rule
->next
= NULL
;
1851 /* If the list of rules are empty, then insert the new rule
1852 at the head of the list. */
1854 if (substitute_path_rules
== NULL
)
1856 substitute_path_rules
= new_rule
;
1860 /* Otherwise, skip to the last rule in our list and then append
1863 rule
= substitute_path_rules
;
1864 while (rule
->next
!= NULL
)
1867 rule
->next
= new_rule
;
1870 /* Remove the given source path substitution rule from the current list
1871 of rules. The memory allocated for that rule is also deallocated. */
1874 delete_substitute_path_rule (struct substitute_path_rule
*rule
)
1876 if (rule
== substitute_path_rules
)
1877 substitute_path_rules
= rule
->next
;
1880 struct substitute_path_rule
*prev
= substitute_path_rules
;
1882 while (prev
!= NULL
&& prev
->next
!= rule
)
1885 gdb_assert (prev
!= NULL
);
1887 prev
->next
= rule
->next
;
1895 /* Implement the "show substitute-path" command. */
1898 show_substitute_path_command (char *args
, int from_tty
)
1900 struct substitute_path_rule
*rule
= substitute_path_rules
;
1903 struct cleanup
*cleanup
;
1905 argv
= gdb_buildargv (args
);
1906 cleanup
= make_cleanup_freeargv (argv
);
1908 /* We expect zero or one argument. */
1910 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1911 error (_("Too many arguments in command"));
1913 if (argv
!= NULL
&& argv
[0] != NULL
)
1916 /* Print the substitution rules. */
1920 (_("Source path substitution rule matching `%s':\n"), from
);
1922 printf_filtered (_("List of all source path substitution rules:\n"));
1924 while (rule
!= NULL
)
1926 if (from
== NULL
|| substitute_path_rule_matches (rule
, from
) != 0)
1927 printf_filtered (" `%s' -> `%s'.\n", rule
->from
, rule
->to
);
1931 do_cleanups (cleanup
);
1934 /* Implement the "unset substitute-path" command. */
1937 unset_substitute_path_command (char *args
, int from_tty
)
1939 struct substitute_path_rule
*rule
= substitute_path_rules
;
1940 char **argv
= gdb_buildargv (args
);
1943 struct cleanup
*cleanup
;
1945 /* This function takes either 0 or 1 argument. */
1947 cleanup
= make_cleanup_freeargv (argv
);
1948 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1949 error (_("Incorrect usage, too many arguments in command"));
1951 if (argv
!= NULL
&& argv
[0] != NULL
)
1954 /* If the user asked for all the rules to be deleted, ask him
1955 to confirm and give him a chance to abort before the action
1959 && !query (_("Delete all source path substitution rules? ")))
1960 error (_("Canceled"));
1962 /* Delete the rule matching the argument. No argument means that
1963 all rules should be deleted. */
1965 while (rule
!= NULL
)
1967 struct substitute_path_rule
*next
= rule
->next
;
1969 if (from
== NULL
|| FILENAME_CMP (from
, rule
->from
) == 0)
1971 delete_substitute_path_rule (rule
);
1978 /* If the user asked for a specific rule to be deleted but
1979 we could not find it, then report an error. */
1981 if (from
!= NULL
&& !rule_found
)
1982 error (_("No substitution rule defined for `%s'"), from
);
1984 forget_cached_source_info ();
1986 do_cleanups (cleanup
);
1989 /* Add a new source path substitution rule. */
1992 set_substitute_path_command (char *args
, int from_tty
)
1995 struct substitute_path_rule
*rule
;
1996 struct cleanup
*cleanup
;
1998 argv
= gdb_buildargv (args
);
1999 cleanup
= make_cleanup_freeargv (argv
);
2001 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
2002 error (_("Incorrect usage, too few arguments in command"));
2004 if (argv
[2] != NULL
)
2005 error (_("Incorrect usage, too many arguments in command"));
2007 if (*(argv
[0]) == '\0')
2008 error (_("First argument must be at least one character long"));
2010 /* Strip any trailing directory separator character in either FROM
2011 or TO. The substitution rule already implicitly contains them. */
2012 strip_trailing_directory_separator (argv
[0]);
2013 strip_trailing_directory_separator (argv
[1]);
2015 /* If a rule with the same "from" was previously defined, then
2016 delete it. This new rule replaces it. */
2018 rule
= find_substitute_path_rule (argv
[0]);
2020 delete_substitute_path_rule (rule
);
2022 /* Insert the new substitution rule. */
2024 add_substitute_path_rule (argv
[0], argv
[1]);
2025 forget_cached_source_info ();
2027 do_cleanups (cleanup
);
2032 _initialize_source (void)
2034 struct cmd_list_element
*c
;
2036 current_source_symtab
= 0;
2037 init_source_path ();
2039 /* The intention is to use POSIX Basic Regular Expressions.
2040 Always use the GNU regex routine for consistency across all hosts.
2041 Our current GNU regex.c does not have all the POSIX features, so this is
2042 just an approximation. */
2043 re_set_syntax (RE_SYNTAX_GREP
);
2045 c
= add_cmd ("directory", class_files
, directory_command
, _("\
2046 Add directory DIR to beginning of search path for source files.\n\
2047 Forget cached info on source file locations and line positions.\n\
2048 DIR can also be $cwd for the current working directory, or $cdir for the\n\
2049 directory in which the source file was compiled into object code.\n\
2050 With no argument, reset the search path to $cdir:$cwd, the default."),
2054 add_com_alias ("use", "directory", class_files
, 0);
2056 set_cmd_completer (c
, filename_completer
);
2058 add_setshow_optional_filename_cmd ("directories",
2062 Set the search path for finding source files."),
2064 Show the search path for finding source files."),
2066 $cwd in the path means the current working directory.\n\
2067 $cdir in the path means the compilation directory of the source file.\n\
2068 GDB ensures the search path always ends with $cdir:$cwd by\n\
2069 appending these directories if necessary.\n\
2070 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
2071 set_directories_command
,
2072 show_directories_command
,
2073 &setlist
, &showlist
);
2075 add_info ("source", source_info
,
2076 _("Information about the current source file."));
2078 add_info ("line", line_info
, _("\
2079 Core addresses of the code for a source line.\n\
2080 Line can be specified as\n\
2081 LINENUM, to list around that line in current file,\n\
2082 FILE:LINENUM, to list around that line in that file,\n\
2083 FUNCTION, to list around beginning of that function,\n\
2084 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2085 Default is to describe the last source line that was listed.\n\n\
2086 This sets the default address for \"x\" to the line's first instruction\n\
2087 so that \"x/i\" suffices to start examining the machine code.\n\
2088 The address is also stored as the value of \"$_\"."));
2090 add_com ("forward-search", class_files
, forward_search_command
, _("\
2091 Search for regular expression (see regex(3)) from last line listed.\n\
2092 The matching line number is also stored as the value of \"$_\"."));
2093 add_com_alias ("search", "forward-search", class_files
, 0);
2094 add_com_alias ("fo", "forward-search", class_files
, 1);
2096 add_com ("reverse-search", class_files
, reverse_search_command
, _("\
2097 Search backward for regular expression (see regex(3)) from last line listed.\n\
2098 The matching line number is also stored as the value of \"$_\"."));
2099 add_com_alias ("rev", "reverse-search", class_files
, 1);
2101 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
2102 Set number of source lines gdb will list by default."), _("\
2103 Show number of source lines gdb will list by default."), _("\
2104 Use this to choose how many source lines the \"list\" displays (unless\n\
2105 the \"list\" argument explicitly specifies some other number).\n\
2106 A value of \"unlimited\", or zero, means there's no limit."),
2109 &setlist
, &showlist
);
2111 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
2113 Usage: set substitute-path FROM TO\n\
2114 Add a substitution rule replacing FROM into TO in source file names.\n\
2115 If a substitution rule was previously set for FROM, the old rule\n\
2116 is replaced by the new one."),
2119 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
2121 Usage: unset substitute-path [FROM]\n\
2122 Delete the rule for substituting FROM in source file names. If FROM\n\
2123 is not specified, all substituting rules are deleted.\n\
2124 If the debugger cannot find a rule for FROM, it will display a warning."),
2127 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2129 Usage: show substitute-path [FROM]\n\
2130 Print the rule for substituting FROM in source file names. If FROM\n\
2131 is not specified, print all substitution rules."),
2134 add_setshow_enum_cmd ("filename-display", class_files
,
2135 filename_display_kind_names
,
2136 &filename_display_string
, _("\
2137 Set how to display filenames."), _("\
2138 Show how to display filenames."), _("\
2139 filename-display can be:\n\
2140 basename - display only basename of a filename\n\
2141 relative - display a filename relative to the compilation directory\n\
2142 absolute - display an absolute filename\n\
2143 By default, relative filenames are displayed."),
2145 show_filename_display_string
,
2146 &setlist
, &showlist
);