1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2014 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 "gdb_assert.h"
30 #include "filestuff.h"
32 #include <sys/types.h>
37 #include "gdb_regex.h"
43 #include "filenames.h" /* for DOSish file names */
44 #include "completer.h"
46 #include "readline/readline.h"
48 #define OPEN_MODE (O_RDONLY | O_BINARY)
49 #define FDOPEN_MODE FOPEN_RB
51 /* Prototypes for exported functions. */
53 void _initialize_source (void);
55 /* Prototypes for local functions. */
57 static int get_filename_and_charpos (struct symtab
*, char **);
59 static void reverse_search_command (char *, int);
61 static void forward_search_command (char *, int);
63 static void line_info (char *, int);
65 static void source_info (char *, int);
67 /* Path of directories to search for source files.
68 Same format as the PATH environment variable's value. */
72 /* Support for source path substitution commands. */
74 struct substitute_path_rule
78 struct substitute_path_rule
*next
;
81 static struct substitute_path_rule
*substitute_path_rules
= NULL
;
83 /* Symtab of default file for listing lines of. */
85 static struct symtab
*current_source_symtab
;
87 /* Default next line to list. */
89 static int current_source_line
;
91 static struct program_space
*current_source_pspace
;
93 /* Default number of lines to print with commands like "list".
94 This is based on guessing how many long (i.e. more than chars_per_line
95 characters) lines there will be. To be completely correct, "list"
96 and friends should be rewritten to count characters and see where
97 things are wrapping, but that would be a fair amount of work. */
99 int lines_to_list
= 10;
101 show_lines_to_list (struct ui_file
*file
, int from_tty
,
102 struct cmd_list_element
*c
, const char *value
)
104 fprintf_filtered (file
,
105 _("Number of source lines gdb "
106 "will list by default is %s.\n"),
110 /* Possible values of 'set filename-display'. */
111 static const char filename_display_basename
[] = "basename";
112 static const char filename_display_relative
[] = "relative";
113 static const char filename_display_absolute
[] = "absolute";
115 static const char *const filename_display_kind_names
[] = {
116 filename_display_basename
,
117 filename_display_relative
,
118 filename_display_absolute
,
122 static const char *filename_display_string
= filename_display_relative
;
125 show_filename_display_string (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
, const char *value
)
128 fprintf_filtered (file
, _("Filenames are displayed as \"%s\".\n"), value
);
131 /* Line number of last line printed. Default for various commands.
132 current_source_line is usually, but not always, the same as this. */
134 static int last_line_listed
;
136 /* First line number listed by last listing command. */
138 static int first_line_listed
;
140 /* Saves the name of the last source file visited and a possible error code.
141 Used to prevent repeating annoying "No such file or directories" msgs. */
143 static struct symtab
*last_source_visited
= NULL
;
144 static int last_source_error
= 0;
146 /* Return the first line listed by print_source_lines.
147 Used by command interpreters to request listing from
151 get_first_line_listed (void)
153 return first_line_listed
;
156 /* Return the default number of lines to print with commands like the
157 cli "list". The caller of print_source_lines must use this to
158 calculate the end line and use it in the call to print_source_lines
159 as it does not automatically use this value. */
162 get_lines_to_list (void)
164 return lines_to_list
;
167 /* Return the current source file for listing and next line to list.
168 NOTE: The returned sal pc and end fields are not valid. */
170 struct symtab_and_line
171 get_current_source_symtab_and_line (void)
173 struct symtab_and_line cursal
= { 0 };
175 cursal
.pspace
= current_source_pspace
;
176 cursal
.symtab
= current_source_symtab
;
177 cursal
.line
= current_source_line
;
184 /* If the current source file for listing is not set, try and get a default.
185 Usually called before get_current_source_symtab_and_line() is called.
186 It may err out if a default cannot be determined.
187 We must be cautious about where it is called, as it can recurse as the
188 process of determining a new default may call the caller!
189 Use get_current_source_symtab_and_line only to get whatever
190 we have without erroring out or trying to get a default. */
193 set_default_source_symtab_and_line (void)
195 if (!have_full_symbols () && !have_partial_symbols ())
196 error (_("No symbol table is loaded. Use the \"file\" command."));
198 /* Pull in a current source symtab if necessary. */
199 if (current_source_symtab
== 0)
200 select_source_symtab (0);
203 /* Return the current default file for listing and next line to list
204 (the returned sal pc and end fields are not valid.)
205 and set the current default to whatever is in SAL.
206 NOTE: The returned sal pc and end fields are not valid. */
208 struct symtab_and_line
209 set_current_source_symtab_and_line (const struct symtab_and_line
*sal
)
211 struct symtab_and_line cursal
= { 0 };
213 cursal
.pspace
= current_source_pspace
;
214 cursal
.symtab
= current_source_symtab
;
215 cursal
.line
= current_source_line
;
219 current_source_pspace
= sal
->pspace
;
220 current_source_symtab
= sal
->symtab
;
221 current_source_line
= sal
->line
;
226 /* Reset any information stored about a default file and line to print. */
229 clear_current_source_symtab_and_line (void)
231 current_source_symtab
= 0;
232 current_source_line
= 0;
235 /* Set the source file default for the "list" command to be S.
237 If S is NULL, and we don't have a default, find one. This
238 should only be called when the user actually tries to use the
239 default, since we produce an error if we can't find a reasonable
240 default. Also, since this can cause symbols to be read, doing it
241 before we need to would make things slower than necessary. */
244 select_source_symtab (struct symtab
*s
)
246 struct symtabs_and_lines sals
;
247 struct symtab_and_line sal
;
252 current_source_symtab
= s
;
253 current_source_line
= 1;
254 current_source_pspace
= SYMTAB_PSPACE (s
);
258 if (current_source_symtab
)
261 /* Make the default place to list be the function `main'
263 if (lookup_symbol (main_name (), 0, VAR_DOMAIN
, 0))
265 sals
= decode_line_with_current_source (main_name (),
266 DECODE_LINE_FUNFIRSTLINE
);
269 current_source_pspace
= sal
.pspace
;
270 current_source_symtab
= sal
.symtab
;
271 current_source_line
= max (sal
.line
- (lines_to_list
- 1), 1);
272 if (current_source_symtab
)
276 /* Alright; find the last file in the symtab list (ignoring .h's
277 and namespace symtabs). */
279 current_source_line
= 1;
283 for (s
= ofp
->symtabs
; s
; s
= s
->next
)
285 const char *name
= s
->filename
;
286 int len
= strlen (name
);
288 if (!(len
> 2 && (strcmp (&name
[len
- 2], ".h") == 0
289 || strcmp (name
, "<<C++-namespaces>>") == 0)))
291 current_source_pspace
= current_program_space
;
292 current_source_symtab
= s
;
297 if (current_source_symtab
)
303 s
= ofp
->sf
->qf
->find_last_source_symtab (ofp
);
305 current_source_symtab
= s
;
307 if (current_source_symtab
)
310 error (_("Can't find a default source file"));
313 /* Handler for "set directories path-list" command.
314 "set dir mumble" doesn't prepend paths, it resets the entire
315 path list. The theory is that set(show(dir)) should be a no-op. */
318 set_directories_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
320 /* This is the value that was set.
321 It needs to be processed to maintain $cdir:$cwd and remove dups. */
322 char *set_path
= source_path
;
324 /* We preserve the invariant that $cdir:$cwd begins life at the end of
325 the list by calling init_source_path. If they appear earlier in
326 SET_PATH then mod_path will move them appropriately.
327 mod_path will also remove duplicates. */
329 if (*set_path
!= '\0')
330 mod_path (set_path
, &source_path
);
335 /* Print the list of source directories.
336 This is used by the "ld" command, so it has the signature of a command
340 show_directories_1 (char *ignore
, int from_tty
)
342 puts_filtered ("Source directories searched: ");
343 puts_filtered (source_path
);
344 puts_filtered ("\n");
347 /* Handler for "show directories" command. */
350 show_directories_command (struct ui_file
*file
, int from_tty
,
351 struct cmd_list_element
*c
, const char *value
)
353 show_directories_1 (NULL
, from_tty
);
356 /* Forget line positions and file names for the symtabs in a
357 particular objfile. */
360 forget_cached_source_info_for_objfile (struct objfile
*objfile
)
364 ALL_OBJFILE_SYMTABS (objfile
, s
)
366 if (s
->line_charpos
!= NULL
)
368 xfree (s
->line_charpos
);
369 s
->line_charpos
= NULL
;
371 if (s
->fullname
!= NULL
)
379 objfile
->sf
->qf
->forget_cached_source_info (objfile
);
382 /* Forget what we learned about line positions in source files, and
383 which directories contain them; must check again now since files
384 may be found in a different directory now. */
387 forget_cached_source_info (void)
389 struct program_space
*pspace
;
390 struct objfile
*objfile
;
393 ALL_PSPACE_OBJFILES (pspace
, objfile
)
395 forget_cached_source_info_for_objfile (objfile
);
398 last_source_visited
= NULL
;
402 init_source_path (void)
406 xsnprintf (buf
, sizeof (buf
), "$cdir%c$cwd", DIRNAME_SEPARATOR
);
407 source_path
= xstrdup (buf
);
408 forget_cached_source_info ();
411 /* Add zero or more directories to the front of the source path. */
414 directory_command (char *dirname
, int from_tty
)
417 /* FIXME, this goes to "delete dir"... */
420 if (!from_tty
|| query (_("Reinitialize source path to empty? ")))
428 mod_path (dirname
, &source_path
);
429 forget_cached_source_info ();
432 show_directories_1 ((char *) 0, from_tty
);
435 /* Add a path given with the -d command line switch.
436 This will not be quoted so we must not treat spaces as separators. */
439 directory_switch (char *dirname
, int from_tty
)
441 add_path (dirname
, &source_path
, 0);
444 /* Add zero or more directories to the front of an arbitrary path. */
447 mod_path (char *dirname
, char **which_path
)
449 add_path (dirname
, which_path
, 1);
452 /* Workhorse of mod_path. Takes an extra argument to determine
453 if dirname should be parsed for separators that indicate multiple
454 directories. This allows for interfaces that pre-parse the dirname
455 and allow specification of traditional separator characters such
459 add_path (char *dirname
, char **which_path
, int parse_separators
)
461 char *old
= *which_path
;
463 VEC (char_ptr
) *dir_vec
= NULL
;
464 struct cleanup
*back_to
;
471 if (parse_separators
)
473 char **argv
, **argvp
;
475 /* This will properly parse the space and tab separators
476 and any quotes that may exist. */
477 argv
= gdb_buildargv (dirname
);
479 for (argvp
= argv
; *argvp
; argvp
++)
480 dirnames_to_char_ptr_vec_append (&dir_vec
, *argvp
);
485 VEC_safe_push (char_ptr
, dir_vec
, xstrdup (dirname
));
486 back_to
= make_cleanup_free_char_ptr_vec (dir_vec
);
488 for (ix
= 0; VEC_iterate (char_ptr
, dir_vec
, ix
, name
); ++ix
)
493 /* Spaces and tabs will have been removed by buildargv().
494 NAME is the start of the directory.
495 P is the '\0' following the end. */
496 p
= name
+ strlen (name
);
498 while (!(IS_DIR_SEPARATOR (*name
) && p
<= name
+ 1) /* "/" */
499 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
500 /* On MS-DOS and MS-Windows, h:\ is different from h: */
501 && !(p
== name
+ 3 && name
[1] == ':') /* "d:/" */
503 && IS_DIR_SEPARATOR (p
[-1]))
504 /* Sigh. "foo/" => "foo" */
508 while (p
> name
&& p
[-1] == '.')
512 /* "." => getwd (). */
513 name
= current_directory
;
516 else if (p
> name
+ 1 && IS_DIR_SEPARATOR (p
[-2]))
526 /* "...foo/." => "...foo". */
537 name
= tilde_expand (name
);
538 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
539 else if (IS_ABSOLUTE_PATH (name
) && p
== name
+ 2) /* "d:" => "d:." */
540 name
= concat (name
, ".", (char *)NULL
);
542 else if (!IS_ABSOLUTE_PATH (name
) && name
[0] != '$')
543 name
= concat (current_directory
, SLASH_STRING
, name
, (char *)NULL
);
545 name
= savestring (name
, p
- name
);
546 make_cleanup (xfree
, name
);
548 /* Unless it's a variable, check existence. */
551 /* These are warnings, not errors, since we don't want a
552 non-existent directory in a .gdbinit file to stop processing
553 of the .gdbinit file.
555 Whether they get added to the path is more debatable. Current
556 answer is yes, in case the user wants to go make the directory
557 or whatever. If the directory continues to not exist/not be
558 a directory/etc, then having them in the path should be
560 if (stat (name
, &st
) < 0)
562 int save_errno
= errno
;
564 fprintf_unfiltered (gdb_stderr
, "Warning: ");
565 print_sys_errmsg (name
, save_errno
);
567 else if ((st
.st_mode
& S_IFMT
) != S_IFDIR
)
568 warning (_("%s is not a directory."), name
);
573 unsigned int len
= strlen (name
);
579 /* FIXME: we should use realpath() or its work-alike
580 before comparing. Then all the code above which
581 removes excess slashes and dots could simply go away. */
582 if (!filename_ncmp (p
, name
, len
)
583 && (p
[len
] == '\0' || p
[len
] == DIRNAME_SEPARATOR
))
585 /* Found it in the search path, remove old copy. */
588 /* Back over leading separator. */
591 if (prefix
> p
- *which_path
)
593 /* Same dir twice in one cmd. */
596 /* Copy from next '\0' or ':'. */
597 memmove (p
, &p
[len
+ 1], strlen (&p
[len
+ 1]) + 1);
599 p
= strchr (p
, DIRNAME_SEPARATOR
);
606 tinybuf
[0] = DIRNAME_SEPARATOR
;
609 /* If we have already tacked on a name(s) in this command,
610 be sure they stay on the front as we tack on some
618 temp
= concat (old
, tinybuf
, name
, (char *)NULL
);
620 *which_path
= concat (temp
, "", &old
[prefix
], (char *) NULL
);
621 prefix
= strlen (temp
);
626 *which_path
= concat (name
, (old
[0] ? tinybuf
: old
),
628 prefix
= strlen (name
);
637 do_cleanups (back_to
);
642 source_info (char *ignore
, int from_tty
)
644 struct symtab
*s
= current_source_symtab
;
648 printf_filtered (_("No current source file.\n"));
651 printf_filtered (_("Current source file is %s\n"), s
->filename
);
653 printf_filtered (_("Compilation directory is %s\n"), s
->dirname
);
655 printf_filtered (_("Located in %s\n"), s
->fullname
);
657 printf_filtered (_("Contains %d line%s.\n"), s
->nlines
,
658 s
->nlines
== 1 ? "" : "s");
660 printf_filtered (_("Source language is %s.\n"), language_str (s
->language
));
661 printf_filtered (_("Compiled with %s debugging format.\n"), s
->debugformat
);
662 printf_filtered (_("%s preprocessor macro info.\n"),
663 s
->macro_table
? "Includes" : "Does not include");
667 /* Return True if the file NAME exists and is a regular file. */
669 is_regular_file (const char *name
)
672 const int status
= stat (name
, &st
);
674 /* Stat should never fail except when the file does not exist.
675 If stat fails, analyze the source of error and return True
676 unless the file does not exist, to avoid returning false results
677 on obscure systems where stat does not work as expected. */
680 return (errno
!= ENOENT
);
682 return S_ISREG (st
.st_mode
);
685 /* Open a file named STRING, searching path PATH (dir names sep by some char)
686 using mode MODE in the calls to open. You cannot use this function to
687 create files (O_CREAT).
689 OPTS specifies the function behaviour in specific cases.
691 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
692 (ie pretend the first element of PATH is "."). This also indicates
693 that, unless OPF_SEARCH_IN_PATH is also specified, a slash in STRING
694 disables searching of the path (this is so that "exec-file ./foo" or
695 "symbol-file ./foo" insures that you get that particular version of
696 foo or an error message).
698 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
699 searched in path (we usually want this for source files but not for
702 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
703 the actual file opened (this string will always start with a "/"). We
704 have to take special pains to avoid doubling the "/" between the directory
705 and the file, sigh! Emacs gets confuzzed by this when we print the
708 If OPTS has OPF_RETURN_REALPATH set return FILENAME_OPENED resolved by
709 gdb_realpath. Even without OPF_RETURN_REALPATH this function still returns
710 filename starting with "/". If FILENAME_OPENED is NULL this option has no
713 If a file is found, return the descriptor.
714 Otherwise, return -1, with errno set for the last name we tried to open. */
716 /* >>>> This should only allow files of certain types,
717 >>>> eg executable, non-directory. */
719 openp (const char *path
, int opts
, const char *string
,
720 int mode
, char **filename_opened
)
725 VEC (char_ptr
) *dir_vec
;
726 struct cleanup
*back_to
;
730 /* The open syscall MODE parameter is not specified. */
731 gdb_assert ((mode
& O_CREAT
) == 0);
732 gdb_assert (string
!= NULL
);
734 /* A file with an empty name cannot possibly exist. Report a failure
735 without further checking.
737 This is an optimization which also defends us against buggy
738 implementations of the "stat" function. For instance, we have
739 noticed that a MinGW debugger built on Windows XP 32bits crashes
740 when the debugger is started with an empty argument. */
741 if (string
[0] == '\0')
752 if ((opts
& OPF_TRY_CWD_FIRST
) || IS_ABSOLUTE_PATH (string
))
756 if (is_regular_file (string
))
758 filename
= alloca (strlen (string
) + 1);
759 strcpy (filename
, string
);
760 fd
= gdb_open_cloexec (filename
, mode
, 0);
770 if (!(opts
& OPF_SEARCH_IN_PATH
))
771 for (i
= 0; string
[i
]; i
++)
772 if (IS_DIR_SEPARATOR (string
[i
]))
776 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
777 if (HAS_DRIVE_SPEC (string
))
778 string
= STRIP_DRIVE_SPEC (string
);
780 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
781 while (IS_DIR_SEPARATOR(string
[0]))
785 while (string
[0] == '.' && IS_DIR_SEPARATOR (string
[1]))
788 alloclen
= strlen (path
) + strlen (string
) + 2;
789 filename
= alloca (alloclen
);
792 dir_vec
= dirnames_to_char_ptr_vec (path
);
793 back_to
= make_cleanup_free_char_ptr_vec (dir_vec
);
795 for (ix
= 0; VEC_iterate (char_ptr
, dir_vec
, ix
, dir
); ++ix
)
797 size_t len
= strlen (dir
);
799 if (strcmp (dir
, "$cwd") == 0)
801 /* Name is $cwd -- insert current directory name instead. */
804 /* First, realloc the filename buffer if too short. */
805 len
= strlen (current_directory
);
806 newlen
= len
+ strlen (string
) + 2;
807 if (newlen
> alloclen
)
810 filename
= alloca (alloclen
);
812 strcpy (filename
, current_directory
);
814 else if (strchr(dir
, '~'))
816 /* See whether we need to expand the tilde. */
818 char *tilde_expanded
;
820 tilde_expanded
= tilde_expand (dir
);
822 /* First, realloc the filename buffer if too short. */
823 len
= strlen (tilde_expanded
);
824 newlen
= len
+ strlen (string
) + 2;
825 if (newlen
> alloclen
)
828 filename
= alloca (alloclen
);
830 strcpy (filename
, tilde_expanded
);
831 xfree (tilde_expanded
);
835 /* Normal file name in path -- just use it. */
836 strcpy (filename
, dir
);
838 /* Don't search $cdir. It's also a magic path like $cwd, but we
839 don't have enough information to expand it. The user *could*
840 have an actual directory named '$cdir' but handling that would
841 be confusing, it would mean different things in different
842 contexts. If the user really has '$cdir' one can use './$cdir'.
843 We can get $cdir when loading scripts. When loading source files
844 $cdir must have already been expanded to the correct value. */
845 if (strcmp (dir
, "$cdir") == 0)
849 /* Remove trailing slashes. */
850 while (len
> 0 && IS_DIR_SEPARATOR (filename
[len
- 1]))
853 strcat (filename
+ len
, SLASH_STRING
);
854 strcat (filename
, string
);
856 if (is_regular_file (filename
))
858 fd
= gdb_open_cloexec (filename
, mode
, 0);
864 do_cleanups (back_to
);
869 /* If a file was opened, canonicalize its filename. */
871 *filename_opened
= NULL
;
872 else if ((opts
& OPF_RETURN_REALPATH
) != 0)
873 *filename_opened
= gdb_realpath (filename
);
875 *filename_opened
= gdb_abspath (filename
);
882 /* This is essentially a convenience, for clients that want the behaviour
883 of openp, using source_path, but that really don't want the file to be
884 opened but want instead just to know what the full pathname is (as
885 qualified against source_path).
887 The current working directory is searched first.
889 If the file was found, this function returns 1, and FULL_PATHNAME is
890 set to the fully-qualified pathname.
892 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
894 source_full_path_of (const char *filename
, 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
= 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
);
922 if (path_len
< from_len
)
925 /* The substitution rules are anchored at the start of the path,
926 so the path should start with rule->from. There is no filename
927 comparison routine, so we need to extract the first FROM_LEN
928 characters from PATH first and use that to do the comparison. */
930 path_start
= alloca (from_len
+ 1);
931 strncpy (path_start
, path
, from_len
);
932 path_start
[from_len
] = '\0';
934 if (FILENAME_CMP (path_start
, rule
->from
) != 0)
937 /* Make sure that the region in the path that matches the substitution
938 rule is immediately followed by a directory separator (or the end of
939 string character). */
941 if (path
[from_len
] != '\0' && !IS_DIR_SEPARATOR (path
[from_len
]))
947 /* Find the substitute-path rule that applies to PATH and return it.
948 Return NULL if no rule applies. */
950 static struct substitute_path_rule
*
951 get_substitute_path_rule (const char *path
)
953 struct substitute_path_rule
*rule
= substitute_path_rules
;
955 while (rule
!= NULL
&& !substitute_path_rule_matches (rule
, path
))
961 /* If the user specified a source path substitution rule that applies
962 to PATH, then apply it and return the new path. This new path must
963 be deallocated afterwards.
965 Return NULL if no substitution rule was specified by the user,
966 or if no rule applied to the given PATH. */
969 rewrite_source_path (const char *path
)
971 const struct substitute_path_rule
*rule
= get_substitute_path_rule (path
);
978 from_len
= strlen (rule
->from
);
980 /* Compute the rewritten path and return it. */
983 (char *) xmalloc (strlen (path
) + 1 + strlen (rule
->to
) - from_len
);
984 strcpy (new_path
, rule
->to
);
985 strcat (new_path
, path
+ from_len
);
991 find_and_open_source (const char *filename
,
995 char *path
= source_path
;
998 struct cleanup
*cleanup
;
1000 /* Quick way out if we already know its full name. */
1004 /* The user may have requested that source paths be rewritten
1005 according to substitution rules he provided. If a substitution
1006 rule applies to this path, then apply it. */
1007 char *rewritten_fullname
= rewrite_source_path (*fullname
);
1009 if (rewritten_fullname
!= NULL
)
1012 *fullname
= rewritten_fullname
;
1015 result
= gdb_open_cloexec (*fullname
, OPEN_MODE
, 0);
1018 char *lpath
= gdb_realpath (*fullname
);
1025 /* Didn't work -- free old one, try again. */
1030 cleanup
= make_cleanup (null_cleanup
, NULL
);
1032 if (dirname
!= NULL
)
1034 /* If necessary, rewrite the compilation directory name according
1035 to the source path substitution rules specified by the user. */
1037 char *rewritten_dirname
= rewrite_source_path (dirname
);
1039 if (rewritten_dirname
!= NULL
)
1041 make_cleanup (xfree
, rewritten_dirname
);
1042 dirname
= rewritten_dirname
;
1045 /* Replace a path entry of $cdir with the compilation directory
1048 /* We cast strstr's result in case an ANSIhole has made it const,
1049 which produces a "required warning" when assigned to a nonconst. */
1050 p
= (char *) strstr (source_path
, "$cdir");
1051 if (p
&& (p
== path
|| p
[-1] == DIRNAME_SEPARATOR
)
1052 && (p
[cdir_len
] == DIRNAME_SEPARATOR
|| p
[cdir_len
] == '\0'))
1057 alloca (strlen (source_path
) + 1 + strlen (dirname
) + 1);
1058 len
= p
- source_path
;
1059 strncpy (path
, source_path
, len
); /* Before $cdir */
1060 strcpy (path
+ len
, dirname
); /* new stuff */
1061 strcat (path
+ len
, source_path
+ len
+ cdir_len
); /* After
1066 if (IS_ABSOLUTE_PATH (filename
))
1068 /* If filename is absolute path, try the source path
1069 substitution on it. */
1070 char *rewritten_filename
= rewrite_source_path (filename
);
1072 if (rewritten_filename
!= NULL
)
1074 make_cleanup (xfree
, rewritten_filename
);
1075 filename
= rewritten_filename
;
1079 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, filename
,
1080 OPEN_MODE
, fullname
);
1083 /* Didn't work. Try using just the basename. */
1084 p
= lbasename (filename
);
1086 result
= openp (path
, OPF_SEARCH_IN_PATH
| OPF_RETURN_REALPATH
, p
,
1087 OPEN_MODE
, fullname
);
1090 do_cleanups (cleanup
);
1094 /* Open a source file given a symtab S. Returns a file descriptor or
1095 negative number for error.
1097 This function is a convience function to find_and_open_source. */
1100 open_source_file (struct symtab
*s
)
1105 return find_and_open_source (s
->filename
, s
->dirname
, &s
->fullname
);
1108 /* Finds the fullname that a symtab represents.
1110 This functions finds the fullname and saves it in s->fullname.
1111 It will also return the value.
1113 If this function fails to find the file that this symtab represents,
1114 the expected fullname is used. Therefore the files does not have to
1118 symtab_to_fullname (struct symtab
*s
)
1120 /* Use cached copy if we have it.
1121 We rely on forget_cached_source_info being called appropriately
1122 to handle cases like the file being moved. */
1123 if (s
->fullname
== NULL
)
1125 int fd
= find_and_open_source (s
->filename
, s
->dirname
, &s
->fullname
);
1132 struct cleanup
*back_to
;
1134 /* rewrite_source_path would be applied by find_and_open_source, we
1135 should report the pathname where GDB tried to find the file. */
1137 if (s
->dirname
== NULL
|| IS_ABSOLUTE_PATH (s
->filename
))
1138 fullname
= xstrdup (s
->filename
);
1140 fullname
= concat (s
->dirname
, SLASH_STRING
, s
->filename
, NULL
);
1142 back_to
= make_cleanup (xfree
, fullname
);
1143 s
->fullname
= rewrite_source_path (fullname
);
1144 if (s
->fullname
== NULL
)
1145 s
->fullname
= xstrdup (fullname
);
1146 do_cleanups (back_to
);
1153 /* See commentary in source.h. */
1156 symtab_to_filename_for_display (struct symtab
*symtab
)
1158 if (filename_display_string
== filename_display_basename
)
1159 return lbasename (symtab
->filename
);
1160 else if (filename_display_string
== filename_display_absolute
)
1161 return symtab_to_fullname (symtab
);
1162 else if (filename_display_string
== filename_display_relative
)
1163 return symtab
->filename
;
1165 internal_error (__FILE__
, __LINE__
, _("invalid filename_display_string"));
1168 /* Create and initialize the table S->line_charpos that records
1169 the positions of the lines in the source file, which is assumed
1170 to be open on descriptor DESC.
1171 All set S->nlines to the number of such lines. */
1174 find_source_lines (struct symtab
*s
, int desc
)
1177 char *data
, *p
, *end
;
1179 int lines_allocated
= 1000;
1185 line_charpos
= (int *) xmalloc (lines_allocated
* sizeof (int));
1186 if (fstat (desc
, &st
) < 0)
1187 perror_with_name (symtab_to_filename_for_display (s
));
1189 if (s
->objfile
&& s
->objfile
->obfd
)
1190 mtime
= s
->objfile
->mtime
;
1192 mtime
= exec_bfd_mtime
;
1194 if (mtime
&& mtime
< st
.st_mtime
)
1195 warning (_("Source file is more recent than executable."));
1198 struct cleanup
*old_cleanups
;
1200 /* st_size might be a large type, but we only support source files whose
1201 size fits in an int. */
1202 size
= (int) st
.st_size
;
1204 /* Use malloc, not alloca, because this may be pretty large, and we may
1205 run into various kinds of limits on stack size. */
1206 data
= (char *) xmalloc (size
);
1207 old_cleanups
= make_cleanup (xfree
, data
);
1209 /* Reassign `size' to result of read for systems where \r\n -> \n. */
1210 size
= myread (desc
, data
, size
);
1212 perror_with_name (symtab_to_filename_for_display (s
));
1215 line_charpos
[0] = 0;
1220 /* A newline at the end does not start a new line. */
1223 if (nlines
== lines_allocated
)
1225 lines_allocated
*= 2;
1227 (int *) xrealloc ((char *) line_charpos
,
1228 sizeof (int) * lines_allocated
);
1230 line_charpos
[nlines
++] = p
- data
;
1233 do_cleanups (old_cleanups
);
1238 (int *) xrealloc ((char *) line_charpos
, nlines
* sizeof (int));
1244 /* Get full pathname and line number positions for a symtab.
1245 Return nonzero if line numbers may have changed.
1246 Set *FULLNAME to actual name of the file as found by `openp',
1247 or to 0 if the file is not found. */
1250 get_filename_and_charpos (struct symtab
*s
, char **fullname
)
1252 int desc
, linenums_changed
= 0;
1253 struct cleanup
*cleanups
;
1255 desc
= open_source_file (s
);
1262 cleanups
= make_cleanup_close (desc
);
1264 *fullname
= s
->fullname
;
1265 if (s
->line_charpos
== 0)
1266 linenums_changed
= 1;
1267 if (linenums_changed
)
1268 find_source_lines (s
, desc
);
1269 do_cleanups (cleanups
);
1270 return linenums_changed
;
1273 /* Print text describing the full name of the source file S
1274 and the line number LINE and its corresponding character position.
1275 The text starts with two Ctrl-z so that the Emacs-GDB interface
1278 MID_STATEMENT is nonzero if the PC is not at the beginning of that line.
1280 Return 1 if successful, 0 if could not find the file. */
1283 identify_source_line (struct symtab
*s
, int line
, int mid_statement
,
1286 if (s
->line_charpos
== 0)
1287 get_filename_and_charpos (s
, (char **) NULL
);
1288 if (s
->fullname
== 0)
1290 if (line
> s
->nlines
)
1291 /* Don't index off the end of the line_charpos array. */
1293 annotate_source (s
->fullname
, line
, s
->line_charpos
[line
- 1],
1294 mid_statement
, get_objfile_arch (s
->objfile
), pc
);
1296 current_source_line
= line
;
1297 first_line_listed
= line
;
1298 last_line_listed
= line
;
1299 current_source_symtab
= s
;
1304 /* Print source lines from the file of symtab S,
1305 starting with line number LINE and stopping before line number STOPLINE. */
1308 print_source_lines_base (struct symtab
*s
, int line
, int stopline
,
1309 enum print_source_lines_flags flags
)
1315 int nlines
= stopline
- line
;
1316 struct cleanup
*cleanup
;
1317 struct ui_out
*uiout
= current_uiout
;
1319 /* Regardless of whether we can open the file, set current_source_symtab. */
1320 current_source_symtab
= s
;
1321 current_source_line
= line
;
1322 first_line_listed
= line
;
1324 /* If printing of source lines is disabled, just print file and line
1326 if (ui_out_test_flags (uiout
, ui_source_list
))
1328 /* Only prints "No such file or directory" once. */
1329 if ((s
!= last_source_visited
) || (!last_source_error
))
1331 last_source_visited
= s
;
1332 desc
= open_source_file (s
);
1336 desc
= last_source_error
;
1337 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1342 desc
= last_source_error
;
1343 flags
|= PRINT_SOURCE_LINES_NOERROR
;
1347 if (desc
< 0 || noprint
)
1349 last_source_error
= desc
;
1351 if (!(flags
& PRINT_SOURCE_LINES_NOERROR
))
1353 const char *filename
= symtab_to_filename_for_display (s
);
1354 int len
= strlen (filename
) + 100;
1355 char *name
= alloca (len
);
1357 xsnprintf (name
, len
, "%d\t%s", line
, filename
);
1358 print_sys_errmsg (name
, errno
);
1362 ui_out_field_int (uiout
, "line", line
);
1363 ui_out_text (uiout
, "\tin ");
1365 /* CLI expects only the "file" field. TUI expects only the
1366 "fullname" field (and TUI does break if "file" is printed).
1367 MI expects both fields. ui_source_list is set only for CLI,
1369 if (ui_out_is_mi_like_p (uiout
)
1370 || ui_out_test_flags (uiout
, ui_source_list
))
1371 ui_out_field_string (uiout
, "file",
1372 symtab_to_filename_for_display (s
));
1373 if (ui_out_is_mi_like_p (uiout
)
1374 || !ui_out_test_flags (uiout
, ui_source_list
))
1376 const char *s_fullname
= symtab_to_fullname (s
);
1377 char *local_fullname
;
1379 /* ui_out_field_string may free S_FULLNAME by calling
1380 open_source_file for it again. See e.g.,
1381 tui_field_string->tui_show_source. */
1382 local_fullname
= alloca (strlen (s_fullname
) + 1);
1383 strcpy (local_fullname
, s_fullname
);
1385 ui_out_field_string (uiout
, "fullname", local_fullname
);
1388 ui_out_text (uiout
, "\n");
1394 last_source_error
= 0;
1396 if (s
->line_charpos
== 0)
1397 find_source_lines (s
, desc
);
1399 if (line
< 1 || line
> s
->nlines
)
1402 error (_("Line number %d out of range; %s has %d lines."),
1403 line
, symtab_to_filename_for_display (s
), s
->nlines
);
1406 if (lseek (desc
, s
->line_charpos
[line
- 1], 0) < 0)
1409 perror_with_name (symtab_to_filename_for_display (s
));
1412 stream
= fdopen (desc
, FDOPEN_MODE
);
1414 cleanup
= make_cleanup_fclose (stream
);
1416 while (nlines
-- > 0)
1423 last_line_listed
= current_source_line
;
1424 if (flags
& PRINT_SOURCE_LINES_FILENAME
)
1426 ui_out_text (uiout
, symtab_to_filename_for_display (s
));
1427 ui_out_text (uiout
, ":");
1429 xsnprintf (buf
, sizeof (buf
), "%d\t", current_source_line
++);
1430 ui_out_text (uiout
, buf
);
1433 if (c
< 040 && c
!= '\t' && c
!= '\n' && c
!= '\r')
1435 xsnprintf (buf
, sizeof (buf
), "^%c", c
+ 0100);
1436 ui_out_text (uiout
, buf
);
1439 ui_out_text (uiout
, "^?");
1442 /* Skip a \r character, but only before a \n. */
1443 int c1
= fgetc (stream
);
1446 printf_filtered ("^%c", c
+ 0100);
1448 ungetc (c1
, stream
);
1452 xsnprintf (buf
, sizeof (buf
), "%c", c
);
1453 ui_out_text (uiout
, buf
);
1456 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1459 do_cleanups (cleanup
);
1462 /* Show source lines from the file of symtab S, starting with line
1463 number LINE and stopping before line number STOPLINE. If this is
1464 not the command line version, then the source is shown in the source
1465 window otherwise it is simply printed. */
1468 print_source_lines (struct symtab
*s
, int line
, int stopline
,
1469 enum print_source_lines_flags flags
)
1471 print_source_lines_base (s
, line
, stopline
, flags
);
1474 /* Print info on range of pc's in a specified line. */
1477 line_info (char *arg
, int from_tty
)
1479 struct symtabs_and_lines sals
;
1480 struct symtab_and_line sal
;
1481 CORE_ADDR start_pc
, end_pc
;
1483 struct cleanup
*cleanups
;
1485 init_sal (&sal
); /* initialize to zeroes */
1489 sal
.symtab
= current_source_symtab
;
1490 sal
.pspace
= current_program_space
;
1491 sal
.line
= last_line_listed
;
1493 sals
.sals
= (struct symtab_and_line
*)
1494 xmalloc (sizeof (struct symtab_and_line
));
1499 sals
= decode_line_with_last_displayed (arg
, DECODE_LINE_LIST_MODE
);
1504 cleanups
= make_cleanup (xfree
, sals
.sals
);
1506 /* C++ More than one line may have been specified, as when the user
1507 specifies an overloaded function name. Print info on them all. */
1508 for (i
= 0; i
< sals
.nelts
; i
++)
1511 if (sal
.pspace
!= current_program_space
)
1514 if (sal
.symtab
== 0)
1516 struct gdbarch
*gdbarch
= get_current_arch ();
1518 printf_filtered (_("No line number information available"));
1521 /* This is useful for "info line *0x7f34". If we can't tell the
1522 user about a source line, at least let them have the symbolic
1524 printf_filtered (" for address ");
1526 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
1529 printf_filtered (".");
1530 printf_filtered ("\n");
1532 else if (sal
.line
> 0
1533 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1535 struct gdbarch
*gdbarch
= get_objfile_arch (sal
.symtab
->objfile
);
1537 if (start_pc
== end_pc
)
1539 printf_filtered ("Line %d of \"%s\"",
1541 symtab_to_filename_for_display (sal
.symtab
));
1543 printf_filtered (" is at address ");
1544 print_address (gdbarch
, start_pc
, gdb_stdout
);
1546 printf_filtered (" but contains no code.\n");
1550 printf_filtered ("Line %d of \"%s\"",
1552 symtab_to_filename_for_display (sal
.symtab
));
1554 printf_filtered (" starts at address ");
1555 print_address (gdbarch
, start_pc
, gdb_stdout
);
1557 printf_filtered (" and ends at ");
1558 print_address (gdbarch
, end_pc
, gdb_stdout
);
1559 printf_filtered (".\n");
1562 /* x/i should display this line's code. */
1563 set_next_address (gdbarch
, start_pc
);
1565 /* Repeating "info line" should do the following line. */
1566 last_line_listed
= sal
.line
+ 1;
1568 /* If this is the only line, show the source code. If it could
1569 not find the file, don't do anything special. */
1570 if (annotation_level
&& sals
.nelts
== 1)
1571 identify_source_line (sal
.symtab
, sal
.line
, 0, start_pc
);
1574 /* Is there any case in which we get here, and have an address
1575 which the user would want to see? If we have debugging symbols
1576 and no line numbers? */
1577 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1578 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
1580 do_cleanups (cleanups
);
1583 /* Commands to search the source file for a regexp. */
1586 forward_search_command (char *regex
, int from_tty
)
1593 struct cleanup
*cleanups
;
1595 line
= last_line_listed
+ 1;
1597 msg
= (char *) re_comp (regex
);
1599 error (("%s"), msg
);
1601 if (current_source_symtab
== 0)
1602 select_source_symtab (0);
1604 desc
= open_source_file (current_source_symtab
);
1606 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1607 cleanups
= make_cleanup_close (desc
);
1609 if (current_source_symtab
->line_charpos
== 0)
1610 find_source_lines (current_source_symtab
, desc
);
1612 if (line
< 1 || line
> current_source_symtab
->nlines
)
1613 error (_("Expression not found"));
1615 if (lseek (desc
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1616 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1618 discard_cleanups (cleanups
);
1619 stream
= fdopen (desc
, FDOPEN_MODE
);
1621 cleanups
= make_cleanup_fclose (stream
);
1624 static char *buf
= NULL
;
1626 int cursize
, newsize
;
1629 buf
= xmalloc (cursize
);
1638 if (p
- buf
== cursize
)
1640 newsize
= cursize
+ cursize
/ 2;
1641 buf
= xrealloc (buf
, newsize
);
1646 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1648 /* Remove the \r, if any, at the end of the line, otherwise
1649 regular expressions that end with $ or \n won't work. */
1650 if (p
- buf
> 1 && p
[-2] == '\r')
1656 /* We now have a source line in buf, null terminate and match. */
1658 if (re_exec (buf
) > 0)
1661 do_cleanups (cleanups
);
1662 print_source_lines (current_source_symtab
, line
, line
+ 1, 0);
1663 set_internalvar_integer (lookup_internalvar ("_"), line
);
1664 current_source_line
= max (line
- lines_to_list
/ 2, 1);
1670 printf_filtered (_("Expression not found\n"));
1671 do_cleanups (cleanups
);
1675 reverse_search_command (char *regex
, int from_tty
)
1682 struct cleanup
*cleanups
;
1684 line
= last_line_listed
- 1;
1686 msg
= (char *) re_comp (regex
);
1688 error (("%s"), msg
);
1690 if (current_source_symtab
== 0)
1691 select_source_symtab (0);
1693 desc
= open_source_file (current_source_symtab
);
1695 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1696 cleanups
= make_cleanup_close (desc
);
1698 if (current_source_symtab
->line_charpos
== 0)
1699 find_source_lines (current_source_symtab
, desc
);
1701 if (line
< 1 || line
> current_source_symtab
->nlines
)
1702 error (_("Expression not found"));
1704 if (lseek (desc
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1705 perror_with_name (symtab_to_filename_for_display (current_source_symtab
));
1707 discard_cleanups (cleanups
);
1708 stream
= fdopen (desc
, FDOPEN_MODE
);
1710 cleanups
= make_cleanup_fclose (stream
);
1713 /* FIXME!!! We walk right off the end of buf if we get a long line!!! */
1714 char buf
[4096]; /* Should be reasonable??? */
1724 while (c
!= '\n' && (c
= fgetc (stream
)) >= 0);
1726 /* Remove the \r, if any, at the end of the line, otherwise
1727 regular expressions that end with $ or \n won't work. */
1728 if (p
- buf
> 1 && p
[-2] == '\r')
1734 /* We now have a source line in buf; null terminate and match. */
1736 if (re_exec (buf
) > 0)
1739 do_cleanups (cleanups
);
1740 print_source_lines (current_source_symtab
, line
, line
+ 1, 0);
1741 set_internalvar_integer (lookup_internalvar ("_"), line
);
1742 current_source_line
= max (line
- lines_to_list
/ 2, 1);
1746 if (fseek (stream
, current_source_symtab
->line_charpos
[line
- 1], 0) < 0)
1748 const char *filename
;
1750 do_cleanups (cleanups
);
1751 filename
= symtab_to_filename_for_display (current_source_symtab
);
1752 perror_with_name (filename
);
1756 printf_filtered (_("Expression not found\n"));
1757 do_cleanups (cleanups
);
1761 /* If the last character of PATH is a directory separator, then strip it. */
1764 strip_trailing_directory_separator (char *path
)
1766 const int last
= strlen (path
) - 1;
1769 return; /* No stripping is needed if PATH is the empty string. */
1771 if (IS_DIR_SEPARATOR (path
[last
]))
1775 /* Return the path substitution rule that matches FROM.
1776 Return NULL if no rule matches. */
1778 static struct substitute_path_rule
*
1779 find_substitute_path_rule (const char *from
)
1781 struct substitute_path_rule
*rule
= substitute_path_rules
;
1783 while (rule
!= NULL
)
1785 if (FILENAME_CMP (rule
->from
, from
) == 0)
1793 /* Add a new substitute-path rule at the end of the current list of rules.
1794 The new rule will replace FROM into TO. */
1797 add_substitute_path_rule (char *from
, char *to
)
1799 struct substitute_path_rule
*rule
;
1800 struct substitute_path_rule
*new_rule
;
1802 new_rule
= xmalloc (sizeof (struct substitute_path_rule
));
1803 new_rule
->from
= xstrdup (from
);
1804 new_rule
->to
= xstrdup (to
);
1805 new_rule
->next
= NULL
;
1807 /* If the list of rules are empty, then insert the new rule
1808 at the head of the list. */
1810 if (substitute_path_rules
== NULL
)
1812 substitute_path_rules
= new_rule
;
1816 /* Otherwise, skip to the last rule in our list and then append
1819 rule
= substitute_path_rules
;
1820 while (rule
->next
!= NULL
)
1823 rule
->next
= new_rule
;
1826 /* Remove the given source path substitution rule from the current list
1827 of rules. The memory allocated for that rule is also deallocated. */
1830 delete_substitute_path_rule (struct substitute_path_rule
*rule
)
1832 if (rule
== substitute_path_rules
)
1833 substitute_path_rules
= rule
->next
;
1836 struct substitute_path_rule
*prev
= substitute_path_rules
;
1838 while (prev
!= NULL
&& prev
->next
!= rule
)
1841 gdb_assert (prev
!= NULL
);
1843 prev
->next
= rule
->next
;
1851 /* Implement the "show substitute-path" command. */
1854 show_substitute_path_command (char *args
, int from_tty
)
1856 struct substitute_path_rule
*rule
= substitute_path_rules
;
1859 struct cleanup
*cleanup
;
1861 argv
= gdb_buildargv (args
);
1862 cleanup
= make_cleanup_freeargv (argv
);
1864 /* We expect zero or one argument. */
1866 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1867 error (_("Too many arguments in command"));
1869 if (argv
!= NULL
&& argv
[0] != NULL
)
1872 /* Print the substitution rules. */
1876 (_("Source path substitution rule matching `%s':\n"), from
);
1878 printf_filtered (_("List of all source path substitution rules:\n"));
1880 while (rule
!= NULL
)
1882 if (from
== NULL
|| FILENAME_CMP (rule
->from
, from
) == 0)
1883 printf_filtered (" `%s' -> `%s'.\n", rule
->from
, rule
->to
);
1887 do_cleanups (cleanup
);
1890 /* Implement the "unset substitute-path" command. */
1893 unset_substitute_path_command (char *args
, int from_tty
)
1895 struct substitute_path_rule
*rule
= substitute_path_rules
;
1896 char **argv
= gdb_buildargv (args
);
1899 struct cleanup
*cleanup
;
1901 /* This function takes either 0 or 1 argument. */
1903 cleanup
= make_cleanup_freeargv (argv
);
1904 if (argv
!= NULL
&& argv
[0] != NULL
&& argv
[1] != NULL
)
1905 error (_("Incorrect usage, too many arguments in command"));
1907 if (argv
!= NULL
&& argv
[0] != NULL
)
1910 /* If the user asked for all the rules to be deleted, ask him
1911 to confirm and give him a chance to abort before the action
1915 && !query (_("Delete all source path substitution rules? ")))
1916 error (_("Canceled"));
1918 /* Delete the rule matching the argument. No argument means that
1919 all rules should be deleted. */
1921 while (rule
!= NULL
)
1923 struct substitute_path_rule
*next
= rule
->next
;
1925 if (from
== NULL
|| FILENAME_CMP (from
, rule
->from
) == 0)
1927 delete_substitute_path_rule (rule
);
1934 /* If the user asked for a specific rule to be deleted but
1935 we could not find it, then report an error. */
1937 if (from
!= NULL
&& !rule_found
)
1938 error (_("No substitution rule defined for `%s'"), from
);
1940 forget_cached_source_info ();
1942 do_cleanups (cleanup
);
1945 /* Add a new source path substitution rule. */
1948 set_substitute_path_command (char *args
, int from_tty
)
1951 struct substitute_path_rule
*rule
;
1952 struct cleanup
*cleanup
;
1954 argv
= gdb_buildargv (args
);
1955 cleanup
= make_cleanup_freeargv (argv
);
1957 if (argv
== NULL
|| argv
[0] == NULL
|| argv
[1] == NULL
)
1958 error (_("Incorrect usage, too few arguments in command"));
1960 if (argv
[2] != NULL
)
1961 error (_("Incorrect usage, too many arguments in command"));
1963 if (*(argv
[0]) == '\0')
1964 error (_("First argument must be at least one character long"));
1966 /* Strip any trailing directory separator character in either FROM
1967 or TO. The substitution rule already implicitly contains them. */
1968 strip_trailing_directory_separator (argv
[0]);
1969 strip_trailing_directory_separator (argv
[1]);
1971 /* If a rule with the same "from" was previously defined, then
1972 delete it. This new rule replaces it. */
1974 rule
= find_substitute_path_rule (argv
[0]);
1976 delete_substitute_path_rule (rule
);
1978 /* Insert the new substitution rule. */
1980 add_substitute_path_rule (argv
[0], argv
[1]);
1981 forget_cached_source_info ();
1983 do_cleanups (cleanup
);
1988 _initialize_source (void)
1990 struct cmd_list_element
*c
;
1992 current_source_symtab
= 0;
1993 init_source_path ();
1995 /* The intention is to use POSIX Basic Regular Expressions.
1996 Always use the GNU regex routine for consistency across all hosts.
1997 Our current GNU regex.c does not have all the POSIX features, so this is
1998 just an approximation. */
1999 re_set_syntax (RE_SYNTAX_GREP
);
2001 c
= add_cmd ("directory", class_files
, directory_command
, _("\
2002 Add directory DIR to beginning of search path for source files.\n\
2003 Forget cached info on source file locations and line positions.\n\
2004 DIR can also be $cwd for the current working directory, or $cdir for the\n\
2005 directory in which the source file was compiled into object code.\n\
2006 With no argument, reset the search path to $cdir:$cwd, the default."),
2010 add_com_alias ("use", "directory", class_files
, 0);
2012 set_cmd_completer (c
, filename_completer
);
2014 add_setshow_optional_filename_cmd ("directories",
2018 Set the search path for finding source files."),
2020 Show the search path for finding source files."),
2022 $cwd in the path means the current working directory.\n\
2023 $cdir in the path means the compilation directory of the source file.\n\
2024 GDB ensures the search path always ends with $cdir:$cwd by\n\
2025 appending these directories if necessary.\n\
2026 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
2027 set_directories_command
,
2028 show_directories_command
,
2029 &setlist
, &showlist
);
2033 add_com_alias ("D", "directory", class_files
, 0);
2034 add_cmd ("ld", no_class
, show_directories_1
, _("\
2035 Current search path for finding source files.\n\
2036 $cwd in the path means the current working directory.\n\
2037 $cdir in the path means the compilation directory of the source file."),
2041 add_info ("source", source_info
,
2042 _("Information about the current source file."));
2044 add_info ("line", line_info
, _("\
2045 Core addresses of the code for a source line.\n\
2046 Line can be specified as\n\
2047 LINENUM, to list around that line in current file,\n\
2048 FILE:LINENUM, to list around that line in that file,\n\
2049 FUNCTION, to list around beginning of that function,\n\
2050 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2051 Default is to describe the last source line that was listed.\n\n\
2052 This sets the default address for \"x\" to the line's first instruction\n\
2053 so that \"x/i\" suffices to start examining the machine code.\n\
2054 The address is also stored as the value of \"$_\"."));
2056 add_com ("forward-search", class_files
, forward_search_command
, _("\
2057 Search for regular expression (see regex(3)) from last line listed.\n\
2058 The matching line number is also stored as the value of \"$_\"."));
2059 add_com_alias ("search", "forward-search", class_files
, 0);
2060 add_com_alias ("fo", "forward-search", class_files
, 1);
2062 add_com ("reverse-search", class_files
, reverse_search_command
, _("\
2063 Search backward for regular expression (see regex(3)) from last line listed.\n\
2064 The matching line number is also stored as the value of \"$_\"."));
2065 add_com_alias ("rev", "reverse-search", class_files
, 1);
2069 add_com_alias ("/", "forward-search", class_files
, 0);
2070 add_com_alias ("?", "reverse-search", class_files
, 0);
2073 add_setshow_integer_cmd ("listsize", class_support
, &lines_to_list
, _("\
2074 Set number of source lines gdb will list by default."), _("\
2075 Show number of source lines gdb will list by default."), _("\
2076 Use this to choose how many source lines the \"list\" displays (unless\n\
2077 the \"list\" argument explicitly specifies some other number).\n\
2078 A value of \"unlimited\", or zero, means there's no limit."),
2081 &setlist
, &showlist
);
2083 add_cmd ("substitute-path", class_files
, set_substitute_path_command
,
2085 Usage: set substitute-path FROM TO\n\
2086 Add a substitution rule replacing FROM into TO in source file names.\n\
2087 If a substitution rule was previously set for FROM, the old rule\n\
2088 is replaced by the new one."),
2091 add_cmd ("substitute-path", class_files
, unset_substitute_path_command
,
2093 Usage: unset substitute-path [FROM]\n\
2094 Delete the rule for substituting FROM in source file names. If FROM\n\
2095 is not specified, all substituting rules are deleted.\n\
2096 If the debugger cannot find a rule for FROM, it will display a warning."),
2099 add_cmd ("substitute-path", class_files
, show_substitute_path_command
,
2101 Usage: show substitute-path [FROM]\n\
2102 Print the rule for substituting FROM in source file names. If FROM\n\
2103 is not specified, print all substitution rules."),
2106 add_setshow_enum_cmd ("filename-display", class_files
,
2107 filename_display_kind_names
,
2108 &filename_display_string
, _("\
2109 Set how to display filenames."), _("\
2110 Show how to display filenames."), _("\
2111 filename-display can be:\n\
2112 basename - display only basename of a filename\n\
2113 relative - display a filename relative to the compilation directory\n\
2114 absolute - display an absolute filename\n\
2115 By default, relative filenames are displayed."),
2117 show_filename_display_string
,
2118 &setlist
, &showlist
);