1 /* List lines of source files for GDB, the GNU debugger.
2 Copyright (C) 1986-2013 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
19 #include "defs.h"
20 #include "arch-utils.h"
21 #include "symtab.h"
22 #include "expression.h"
23 #include "language.h"
24 #include "command.h"
25 #include "source.h"
26 #include "gdbcmd.h"
27 #include "frame.h"
28 #include "value.h"
29 #include "gdb_assert.h"
30
31 #include <sys/types.h>
32 #include "gdb_string.h"
33 #include "gdb_stat.h"
34 #include <fcntl.h>
35 #include "gdbcore.h"
36 #include "gdb_regex.h"
37 #include "symfile.h"
38 #include "objfiles.h"
39 #include "annotate.h"
40 #include "gdbtypes.h"
41 #include "linespec.h"
42 #include "filenames.h" /* for DOSish file names */
43 #include "completer.h"
44 #include "ui-out.h"
45 #include "readline/readline.h"
46
47 #include "psymtab.h"
48
49
50 #define OPEN_MODE (O_RDONLY | O_BINARY)
51 #define FDOPEN_MODE FOPEN_RB
52
53 /* Prototypes for exported functions. */
54
55 void _initialize_source (void);
56
57 /* Prototypes for local functions. */
58
59 static int get_filename_and_charpos (struct symtab *, char **);
60
61 static void reverse_search_command (char *, int);
62
63 static void forward_search_command (char *, int);
64
65 static void line_info (char *, int);
66
67 static void source_info (char *, int);
68
69 /* Path of directories to search for source files.
70 Same format as the PATH environment variable's value. */
71
72 char *source_path;
73
74 /* Support for source path substitution commands. */
75
76 struct substitute_path_rule
77 {
78 char *from;
79 char *to;
80 struct substitute_path_rule *next;
81 };
82
83 static struct substitute_path_rule *substitute_path_rules = NULL;
84
85 /* Symtab of default file for listing lines of. */
86
87 static struct symtab *current_source_symtab;
88
89 /* Default next line to list. */
90
91 static int current_source_line;
92
93 static struct program_space *current_source_pspace;
94
95 /* Default number of lines to print with commands like "list".
96 This is based on guessing how many long (i.e. more than chars_per_line
97 characters) lines there will be. To be completely correct, "list"
98 and friends should be rewritten to count characters and see where
99 things are wrapping, but that would be a fair amount of work. */
100
101 int lines_to_list = 10;
102 static void
show_lines_to_list(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)103 show_lines_to_list (struct ui_file *file, int from_tty,
104 struct cmd_list_element *c, const char *value)
105 {
106 fprintf_filtered (file,
107 _("Number of source lines gdb "
108 "will list by default is %s.\n"),
109 value);
110 }
111
112 /* Possible values of 'set filename-display'. */
113 static const char filename_display_basename[] = "basename";
114 static const char filename_display_relative[] = "relative";
115 static const char filename_display_absolute[] = "absolute";
116
117 static const char *const filename_display_kind_names[] = {
118 filename_display_basename,
119 filename_display_relative,
120 filename_display_absolute,
121 NULL
122 };
123
124 static const char *filename_display_string = filename_display_relative;
125
126 static void
show_filename_display_string(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)127 show_filename_display_string (struct ui_file *file, int from_tty,
128 struct cmd_list_element *c, const char *value)
129 {
130 fprintf_filtered (file, _("Filenames are displayed as \"%s\".\n"), value);
131 }
132
133 /* Line number of last line printed. Default for various commands.
134 current_source_line is usually, but not always, the same as this. */
135
136 static int last_line_listed;
137
138 /* First line number listed by last listing command. */
139
140 static int first_line_listed;
141
142 /* Saves the name of the last source file visited and a possible error code.
143 Used to prevent repeating annoying "No such file or directories" msgs. */
144
145 static struct symtab *last_source_visited = NULL;
146 static int last_source_error = 0;
147
148 /* Return the first line listed by print_source_lines.
149 Used by command interpreters to request listing from
150 a previous point. */
151
152 int
get_first_line_listed(void)153 get_first_line_listed (void)
154 {
155 return first_line_listed;
156 }
157
158 /* Return the default number of lines to print with commands like the
159 cli "list". The caller of print_source_lines must use this to
160 calculate the end line and use it in the call to print_source_lines
161 as it does not automatically use this value. */
162
163 int
get_lines_to_list(void)164 get_lines_to_list (void)
165 {
166 return lines_to_list;
167 }
168
169 /* Return the current source file for listing and next line to list.
170 NOTE: The returned sal pc and end fields are not valid. */
171
172 struct symtab_and_line
get_current_source_symtab_and_line(void)173 get_current_source_symtab_and_line (void)
174 {
175 struct symtab_and_line cursal = { 0 };
176
177 cursal.pspace = current_source_pspace;
178 cursal.symtab = current_source_symtab;
179 cursal.line = current_source_line;
180 cursal.pc = 0;
181 cursal.end = 0;
182
183 return cursal;
184 }
185
186 /* If the current source file for listing is not set, try and get a default.
187 Usually called before get_current_source_symtab_and_line() is called.
188 It may err out if a default cannot be determined.
189 We must be cautious about where it is called, as it can recurse as the
190 process of determining a new default may call the caller!
191 Use get_current_source_symtab_and_line only to get whatever
192 we have without erroring out or trying to get a default. */
193
194 void
set_default_source_symtab_and_line(void)195 set_default_source_symtab_and_line (void)
196 {
197 if (!have_full_symbols () && !have_partial_symbols ())
198 error (_("No symbol table is loaded. Use the \"file\" command."));
199
200 /* Pull in a current source symtab if necessary. */
201 if (current_source_symtab == 0)
202 select_source_symtab (0);
203 }
204
205 /* Return the current default file for listing and next line to list
206 (the returned sal pc and end fields are not valid.)
207 and set the current default to whatever is in SAL.
208 NOTE: The returned sal pc and end fields are not valid. */
209
210 struct symtab_and_line
set_current_source_symtab_and_line(const struct symtab_and_line * sal)211 set_current_source_symtab_and_line (const struct symtab_and_line *sal)
212 {
213 struct symtab_and_line cursal = { 0 };
214
215 cursal.pspace = current_source_pspace;
216 cursal.symtab = current_source_symtab;
217 cursal.line = current_source_line;
218 cursal.pc = 0;
219 cursal.end = 0;
220
221 current_source_pspace = sal->pspace;
222 current_source_symtab = sal->symtab;
223 current_source_line = sal->line;
224
225 return cursal;
226 }
227
228 /* Reset any information stored about a default file and line to print. */
229
230 void
clear_current_source_symtab_and_line(void)231 clear_current_source_symtab_and_line (void)
232 {
233 current_source_symtab = 0;
234 current_source_line = 0;
235 }
236
237 /* Set the source file default for the "list" command to be S.
238
239 If S is NULL, and we don't have a default, find one. This
240 should only be called when the user actually tries to use the
241 default, since we produce an error if we can't find a reasonable
242 default. Also, since this can cause symbols to be read, doing it
243 before we need to would make things slower than necessary. */
244
245 void
select_source_symtab(struct symtab * s)246 select_source_symtab (struct symtab *s)
247 {
248 struct symtabs_and_lines sals;
249 struct symtab_and_line sal;
250 struct objfile *ofp;
251
252 if (s)
253 {
254 current_source_symtab = s;
255 current_source_line = 1;
256 current_source_pspace = SYMTAB_PSPACE (s);
257 return;
258 }
259
260 if (current_source_symtab)
261 return;
262
263 /* Make the default place to list be the function `main'
264 if one exists. */
265 if (lookup_symbol (main_name (), 0, VAR_DOMAIN, 0))
266 {
267 sals = decode_line_with_current_source (main_name (),
268 DECODE_LINE_FUNFIRSTLINE);
269 sal = sals.sals[0];
270 xfree (sals.sals);
271 current_source_pspace = sal.pspace;
272 current_source_symtab = sal.symtab;
273 current_source_line = max (sal.line - (lines_to_list - 1), 1);
274 if (current_source_symtab)
275 return;
276 }
277
278 /* Alright; find the last file in the symtab list (ignoring .h's
279 and namespace symtabs). */
280
281 current_source_line = 1;
282
283 ALL_OBJFILES (ofp)
284 {
285 for (s = ofp->symtabs; s; s = s->next)
286 {
287 const char *name = s->filename;
288 int len = strlen (name);
289
290 if (!(len > 2 && (strcmp (&name[len - 2], ".h") == 0
291 || strcmp (name, "<<C++-namespaces>>") == 0)))
292 {
293 current_source_pspace = current_program_space;
294 current_source_symtab = s;
295 }
296 }
297 }
298
299 if (current_source_symtab)
300 return;
301
302 ALL_OBJFILES (ofp)
303 {
304 if (ofp->sf)
305 s = ofp->sf->qf->find_last_source_symtab (ofp);
306 if (s)
307 current_source_symtab = s;
308 }
309 if (current_source_symtab)
310 return;
311
312 error (_("Can't find a default source file"));
313 }
314
315 /* Handler for "set directories path-list" command.
316 "set dir mumble" doesn't prepend paths, it resets the entire
317 path list. The theory is that set(show(dir)) should be a no-op. */
318
319 static void
set_directories_command(char * args,int from_tty,struct cmd_list_element * c)320 set_directories_command (char *args, int from_tty, struct cmd_list_element *c)
321 {
322 /* This is the value that was set.
323 It needs to be processed to maintain $cdir:$cwd and remove dups. */
324 char *set_path = source_path;
325
326 /* We preserve the invariant that $cdir:$cwd begins life at the end of
327 the list by calling init_source_path. If they appear earlier in
328 SET_PATH then mod_path will move them appropriately.
329 mod_path will also remove duplicates. */
330 init_source_path ();
331 if (*set_path != '\0')
332 mod_path (set_path, &source_path);
333
334 xfree (set_path);
335 }
336
337 /* Print the list of source directories.
338 This is used by the "ld" command, so it has the signature of a command
339 function. */
340
341 static void
show_directories_1(char * ignore,int from_tty)342 show_directories_1 (char *ignore, int from_tty)
343 {
344 puts_filtered ("Source directories searched: ");
345 puts_filtered (source_path);
346 puts_filtered ("\n");
347 }
348
349 /* Handler for "show directories" command. */
350
351 static void
show_directories_command(struct ui_file * file,int from_tty,struct cmd_list_element * c,const char * value)352 show_directories_command (struct ui_file *file, int from_tty,
353 struct cmd_list_element *c, const char *value)
354 {
355 show_directories_1 (NULL, from_tty);
356 }
357
358 /* Forget line positions and file names for the symtabs in a
359 particular objfile. */
360
361 void
forget_cached_source_info_for_objfile(struct objfile * objfile)362 forget_cached_source_info_for_objfile (struct objfile *objfile)
363 {
364 struct symtab *s;
365
366 ALL_OBJFILE_SYMTABS (objfile, s)
367 {
368 if (s->line_charpos != NULL)
369 {
370 xfree (s->line_charpos);
371 s->line_charpos = NULL;
372 }
373 if (s->fullname != NULL)
374 {
375 xfree (s->fullname);
376 s->fullname = NULL;
377 }
378 }
379
380 if (objfile->sf)
381 objfile->sf->qf->forget_cached_source_info (objfile);
382 }
383
384 /* Forget what we learned about line positions in source files, and
385 which directories contain them; must check again now since files
386 may be found in a different directory now. */
387
388 void
forget_cached_source_info(void)389 forget_cached_source_info (void)
390 {
391 struct program_space *pspace;
392 struct objfile *objfile;
393
394 ALL_PSPACES (pspace)
395 ALL_PSPACE_OBJFILES (pspace, objfile)
396 {
397 forget_cached_source_info_for_objfile (objfile);
398 }
399
400 last_source_visited = NULL;
401 }
402
403 void
init_source_path(void)404 init_source_path (void)
405 {
406 char buf[20];
407
408 xsnprintf (buf, sizeof (buf), "$cdir%c$cwd", DIRNAME_SEPARATOR);
409 source_path = xstrdup (buf);
410 forget_cached_source_info ();
411 }
412
413 /* Add zero or more directories to the front of the source path. */
414
415 static void
directory_command(char * dirname,int from_tty)416 directory_command (char *dirname, int from_tty)
417 {
418 dont_repeat ();
419 /* FIXME, this goes to "delete dir"... */
420 if (dirname == 0)
421 {
422 if (!from_tty || query (_("Reinitialize source path to empty? ")))
423 {
424 xfree (source_path);
425 init_source_path ();
426 }
427 }
428 else
429 {
430 mod_path (dirname, &source_path);
431 forget_cached_source_info ();
432 }
433 if (from_tty)
434 show_directories_1 ((char *) 0, from_tty);
435 }
436
437 /* Add a path given with the -d command line switch.
438 This will not be quoted so we must not treat spaces as separators. */
439
440 void
directory_switch(char * dirname,int from_tty)441 directory_switch (char *dirname, int from_tty)
442 {
443 add_path (dirname, &source_path, 0);
444 }
445
446 /* Add zero or more directories to the front of an arbitrary path. */
447
448 void
mod_path(char * dirname,char ** which_path)449 mod_path (char *dirname, char **which_path)
450 {
451 add_path (dirname, which_path, 1);
452 }
453
454 /* Workhorse of mod_path. Takes an extra argument to determine
455 if dirname should be parsed for separators that indicate multiple
456 directories. This allows for interfaces that pre-parse the dirname
457 and allow specification of traditional separator characters such
458 as space or tab. */
459
460 void
add_path(char * dirname,char ** which_path,int parse_separators)461 add_path (char *dirname, char **which_path, int parse_separators)
462 {
463 char *old = *which_path;
464 int prefix = 0;
465 VEC (char_ptr) *dir_vec = NULL;
466 struct cleanup *back_to;
467 int ix;
468 char *name;
469
470 if (dirname == 0)
471 return;
472
473 if (parse_separators)
474 {
475 char **argv, **argvp;
476
477 /* This will properly parse the space and tab separators
478 and any quotes that may exist. */
479 argv = gdb_buildargv (dirname);
480
481 for (argvp = argv; *argvp; argvp++)
482 dirnames_to_char_ptr_vec_append (&dir_vec, *argvp);
483
484 freeargv (argv);
485 }
486 else
487 VEC_safe_push (char_ptr, dir_vec, xstrdup (dirname));
488 back_to = make_cleanup_free_char_ptr_vec (dir_vec);
489
490 for (ix = 0; VEC_iterate (char_ptr, dir_vec, ix, name); ++ix)
491 {
492 char *p;
493 struct stat st;
494
495 /* Spaces and tabs will have been removed by buildargv().
496 NAME is the start of the directory.
497 P is the '\0' following the end. */
498 p = name + strlen (name);
499
500 while (!(IS_DIR_SEPARATOR (*name) && p <= name + 1) /* "/" */
501 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
502 /* On MS-DOS and MS-Windows, h:\ is different from h: */
503 && !(p == name + 3 && name[1] == ':') /* "d:/" */
504 #endif
505 && IS_DIR_SEPARATOR (p[-1]))
506 /* Sigh. "foo/" => "foo" */
507 --p;
508 *p = '\0';
509
510 while (p > name && p[-1] == '.')
511 {
512 if (p - name == 1)
513 {
514 /* "." => getwd (). */
515 name = current_directory;
516 goto append;
517 }
518 else if (p > name + 1 && IS_DIR_SEPARATOR (p[-2]))
519 {
520 if (p - name == 2)
521 {
522 /* "/." => "/". */
523 *--p = '\0';
524 goto append;
525 }
526 else
527 {
528 /* "...foo/." => "...foo". */
529 p -= 2;
530 *p = '\0';
531 continue;
532 }
533 }
534 else
535 break;
536 }
537
538 if (name[0] == '~')
539 name = tilde_expand (name);
540 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
541 else if (IS_ABSOLUTE_PATH (name) && p == name + 2) /* "d:" => "d:." */
542 name = concat (name, ".", (char *)NULL);
543 #endif
544 else if (!IS_ABSOLUTE_PATH (name) && name[0] != '$')
545 name = concat (current_directory, SLASH_STRING, name, (char *)NULL);
546 else
547 name = savestring (name, p - name);
548 make_cleanup (xfree, name);
549
550 /* Unless it's a variable, check existence. */
551 if (name[0] != '$')
552 {
553 /* These are warnings, not errors, since we don't want a
554 non-existent directory in a .gdbinit file to stop processing
555 of the .gdbinit file.
556
557 Whether they get added to the path is more debatable. Current
558 answer is yes, in case the user wants to go make the directory
559 or whatever. If the directory continues to not exist/not be
560 a directory/etc, then having them in the path should be
561 harmless. */
562 if (stat (name, &st) < 0)
563 {
564 int save_errno = errno;
565
566 fprintf_unfiltered (gdb_stderr, "Warning: ");
567 print_sys_errmsg (name, save_errno);
568 }
569 else if ((st.st_mode & S_IFMT) != S_IFDIR)
570 warning (_("%s is not a directory."), name);
571 }
572
573 append:
574 {
575 unsigned int len = strlen (name);
576 char tinybuf[2];
577
578 p = *which_path;
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_cmp (p, name))
583 {
584 /* Found it in the search path, remove old copy. */
585 if (p > *which_path)
586 p--; /* Back over leading separator. */
587 if (prefix > p - *which_path)
588 goto skip_dup; /* Same dir twice in one cmd. */
589 memmove (p, &p[len + 1], strlen (&p[len + 1]) + 1); /* Copy from next \0 or : */
590 }
591
592 tinybuf[0] = DIRNAME_SEPARATOR;
593 tinybuf[1] = '\0';
594
595 /* If we have already tacked on a name(s) in this command,
596 be sure they stay on the front as we tack on some
597 more. */
598 if (prefix)
599 {
600 char *temp, c;
601
602 c = old[prefix];
603 old[prefix] = '\0';
604 temp = concat (old, tinybuf, name, (char *)NULL);
605 old[prefix] = c;
606 *which_path = concat (temp, "", &old[prefix], (char *) NULL);
607 prefix = strlen (temp);
608 xfree (temp);
609 }
610 else
611 {
612 *which_path = concat (name, (old[0] ? tinybuf : old),
613 old, (char *)NULL);
614 prefix = strlen (name);
615 }
616 xfree (old);
617 old = *which_path;
618 }
619 skip_dup:
620 ;
621 }
622
623 do_cleanups (back_to);
624 }
625
626
627 static void
source_info(char * ignore,int from_tty)628 source_info (char *ignore, int from_tty)
629 {
630 struct symtab *s = current_source_symtab;
631
632 if (!s)
633 {
634 printf_filtered (_("No current source file.\n"));
635 return;
636 }
637 printf_filtered (_("Current source file is %s\n"), s->filename);
638 if (s->dirname)
639 printf_filtered (_("Compilation directory is %s\n"), s->dirname);
640 if (s->fullname)
641 printf_filtered (_("Located in %s\n"), s->fullname);
642 if (s->nlines)
643 printf_filtered (_("Contains %d line%s.\n"), s->nlines,
644 s->nlines == 1 ? "" : "s");
645
646 printf_filtered (_("Source language is %s.\n"), language_str (s->language));
647 printf_filtered (_("Compiled with %s debugging format.\n"), s->debugformat);
648 printf_filtered (_("%s preprocessor macro info.\n"),
649 s->macro_table ? "Includes" : "Does not include");
650 }
651
652
653 /* Return True if the file NAME exists and is a regular file. */
654 static int
is_regular_file(const char * name)655 is_regular_file (const char *name)
656 {
657 struct stat st;
658 const int status = stat (name, &st);
659
660 /* Stat should never fail except when the file does not exist.
661 If stat fails, analyze the source of error and return True
662 unless the file does not exist, to avoid returning false results
663 on obscure systems where stat does not work as expected. */
664
665 if (status != 0)
666 return (errno != ENOENT);
667
668 return S_ISREG (st.st_mode);
669 }
670
671 /* Open a file named STRING, searching path PATH (dir names sep by some char)
672 using mode MODE in the calls to open. You cannot use this function to
673 create files (O_CREAT).
674
675 OPTS specifies the function behaviour in specific cases.
676
677 If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
678 (ie pretend the first element of PATH is "."). This also indicates
679 that a slash in STRING disables searching of the path (this is
680 so that "exec-file ./foo" or "symbol-file ./foo" insures that you
681 get that particular version of foo or an error message).
682
683 If OPTS has OPF_SEARCH_IN_PATH set, absolute names will also be
684 searched in path (we usually want this for source files but not for
685 executables).
686
687 If FILENAME_OPENED is non-null, set it to a newly allocated string naming
688 the actual file opened (this string will always start with a "/"). We
689 have to take special pains to avoid doubling the "/" between the directory
690 and the file, sigh! Emacs gets confuzzed by this when we print the
691 source file name!!!
692
693 If OPTS does not have OPF_DISABLE_REALPATH set return FILENAME_OPENED
694 resolved by gdb_realpath. Even with OPF_DISABLE_REALPATH this function
695 still returns filename starting with "/". If FILENAME_OPENED is NULL
696 this option has no effect.
697
698 If a file is found, return the descriptor.
699 Otherwise, return -1, with errno set for the last name we tried to open. */
700
701 /* >>>> This should only allow files of certain types,
702 >>>> eg executable, non-directory. */
703 int
openp(const char * path,int opts,const char * string,int mode,char ** filename_opened)704 openp (const char *path, int opts, const char *string,
705 int mode, char **filename_opened)
706 {
707 int fd;
708 char *filename;
709 int alloclen;
710 VEC (char_ptr) *dir_vec;
711 struct cleanup *back_to;
712 int ix;
713 char *dir;
714
715 /* The open syscall MODE parameter is not specified. */
716 gdb_assert ((mode & O_CREAT) == 0);
717 gdb_assert (string != NULL);
718
719 /* A file with an empty name cannot possibly exist. Report a failure
720 without further checking.
721
722 This is an optimization which also defends us against buggy
723 implementations of the "stat" function. For instance, we have
724 noticed that a MinGW debugger built on Windows XP 32bits crashes
725 when the debugger is started with an empty argument. */
726 if (string[0] == '\0')
727 {
728 errno = ENOENT;
729 return -1;
730 }
731
732 if (!path)
733 path = ".";
734
735 mode |= O_BINARY;
736
737 if ((opts & OPF_TRY_CWD_FIRST) || IS_ABSOLUTE_PATH (string))
738 {
739 int i;
740
741 if (is_regular_file (string))
742 {
743 filename = alloca (strlen (string) + 1);
744 strcpy (filename, string);
745 fd = open (filename, mode);
746 if (fd >= 0)
747 goto done;
748 }
749 else
750 {
751 filename = NULL;
752 fd = -1;
753 }
754
755 if (!(opts & OPF_SEARCH_IN_PATH))
756 for (i = 0; string[i]; i++)
757 if (IS_DIR_SEPARATOR (string[i]))
758 goto done;
759 }
760
761 /* For dos paths, d:/foo -> /foo, and d:foo -> foo. */
762 if (HAS_DRIVE_SPEC (string))
763 string = STRIP_DRIVE_SPEC (string);
764
765 /* /foo => foo, to avoid multiple slashes that Emacs doesn't like. */
766 while (IS_DIR_SEPARATOR(string[0]))
767 string++;
768
769 /* ./foo => foo */
770 while (string[0] == '.' && IS_DIR_SEPARATOR (string[1]))
771 string += 2;
772
773 alloclen = strlen (path) + strlen (string) + 2;
774 filename = alloca (alloclen);
775 fd = -1;
776
777 dir_vec = dirnames_to_char_ptr_vec (path);
778 back_to = make_cleanup_free_char_ptr_vec (dir_vec);
779
780 for (ix = 0; VEC_iterate (char_ptr, dir_vec, ix, dir); ++ix)
781 {
782 size_t len = strlen (dir);
783
784 if (strcmp (dir, "$cwd") == 0)
785 {
786 /* Name is $cwd -- insert current directory name instead. */
787 int newlen;
788
789 /* First, realloc the filename buffer if too short. */
790 len = strlen (current_directory);
791 newlen = len + strlen (string) + 2;
792 if (newlen > alloclen)
793 {
794 alloclen = newlen;
795 filename = alloca (alloclen);
796 }
797 strcpy (filename, current_directory);
798 }
799 else if (strchr(dir, '~'))
800 {
801 /* See whether we need to expand the tilde. */
802 int newlen;
803 char *tilde_expanded;
804
805 tilde_expanded = tilde_expand (dir);
806
807 /* First, realloc the filename buffer if too short. */
808 len = strlen (tilde_expanded);
809 newlen = len + strlen (string) + 2;
810 if (newlen > alloclen)
811 {
812 alloclen = newlen;
813 filename = alloca (alloclen);
814 }
815 strcpy (filename, tilde_expanded);
816 xfree (tilde_expanded);
817 }
818 else
819 {
820 /* Normal file name in path -- just use it. */
821 strcpy (filename, dir);
822
823 /* Don't search $cdir. It's also a magic path like $cwd, but we
824 don't have enough information to expand it. The user *could*
825 have an actual directory named '$cdir' but handling that would
826 be confusing, it would mean different things in different
827 contexts. If the user really has '$cdir' one can use './$cdir'.
828 We can get $cdir when loading scripts. When loading source files
829 $cdir must have already been expanded to the correct value. */
830 if (strcmp (dir, "$cdir") == 0)
831 continue;
832 }
833
834 /* Remove trailing slashes. */
835 while (len > 0 && IS_DIR_SEPARATOR (filename[len - 1]))
836 filename[--len] = 0;
837
838 strcat (filename + len, SLASH_STRING);
839 strcat (filename, string);
840
841 if (is_regular_file (filename))
842 {
843 fd = open (filename, mode);
844 if (fd >= 0)
845 break;
846 }
847 }
848
849 do_cleanups (back_to);
850
851 done:
852 if (filename_opened)
853 {
854 /* If a file was opened, canonicalize its filename. */
855 if (fd < 0)
856 *filename_opened = NULL;
857 else
858 {
859 char *(*realpath_fptr) (const char *);
860
861 realpath_fptr = ((opts & OPF_DISABLE_REALPATH) != 0
862 ? xstrdup : gdb_realpath);
863
864 if (IS_ABSOLUTE_PATH (filename))
865 *filename_opened = realpath_fptr (filename);
866 else
867 {
868 /* Beware the // my son, the Emacs barfs, the botch that catch... */
869
870 char *f = concat (current_directory,
871 IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
872 ? "" : SLASH_STRING,
873 filename, (char *)NULL);
874
875 *filename_opened = realpath_fptr (f);
876 xfree (f);
877 }
878 }
879 }
880
881 return fd;
882 }
883
884
885 /* This is essentially a convenience, for clients that want the behaviour
886 of openp, using source_path, but that really don't want the file to be
887 opened but want instead just to know what the full pathname is (as
888 qualified against source_path).
889
890 The current working directory is searched first.
891
892 If the file was found, this function returns 1, and FULL_PATHNAME is
893 set to the fully-qualified pathname.
894
895 Else, this functions returns 0, and FULL_PATHNAME is set to NULL. */
896 int
source_full_path_of(const char * filename,char ** full_pathname)897 source_full_path_of (const char *filename, char **full_pathname)
898 {
899 int fd;
900
901 fd = openp (source_path, OPF_TRY_CWD_FIRST | OPF_SEARCH_IN_PATH, filename,
902 O_RDONLY, full_pathname);
903 if (fd < 0)
904 {
905 *full_pathname = NULL;
906 return 0;
907 }
908
909 close (fd);
910 return 1;
911 }
912
913 /* Return non-zero if RULE matches PATH, that is if the rule can be
914 applied to PATH. */
915
916 static int
substitute_path_rule_matches(const struct substitute_path_rule * rule,const char * path)917 substitute_path_rule_matches (const struct substitute_path_rule *rule,
918 const char *path)
919 {
920 const int from_len = strlen (rule->from);
921 const int path_len = strlen (path);
922 char *path_start;
923
924 if (path_len < from_len)
925 return 0;
926
927 /* The substitution rules are anchored at the start of the path,
928 so the path should start with rule->from. There is no filename
929 comparison routine, so we need to extract the first FROM_LEN
930 characters from PATH first and use that to do the comparison. */
931
932 path_start = alloca (from_len + 1);
933 strncpy (path_start, path, from_len);
934 path_start[from_len] = '\0';
935
936 if (FILENAME_CMP (path_start, rule->from) != 0)
937 return 0;
938
939 /* Make sure that the region in the path that matches the substitution
940 rule is immediately followed by a directory separator (or the end of
941 string character). */
942
943 if (path[from_len] != '\0' && !IS_DIR_SEPARATOR (path[from_len]))
944 return 0;
945
946 return 1;
947 }
948
949 /* Find the substitute-path rule that applies to PATH and return it.
950 Return NULL if no rule applies. */
951
952 static struct substitute_path_rule *
get_substitute_path_rule(const char * path)953 get_substitute_path_rule (const char *path)
954 {
955 struct substitute_path_rule *rule = substitute_path_rules;
956
957 while (rule != NULL && !substitute_path_rule_matches (rule, path))
958 rule = rule->next;
959
960 return rule;
961 }
962
963 /* If the user specified a source path substitution rule that applies
964 to PATH, then apply it and return the new path. This new path must
965 be deallocated afterwards.
966
967 Return NULL if no substitution rule was specified by the user,
968 or if no rule applied to the given PATH. */
969
970 char *
rewrite_source_path(const char * path)971 rewrite_source_path (const char *path)
972 {
973 const struct substitute_path_rule *rule = get_substitute_path_rule (path);
974 char *new_path;
975 int from_len;
976
977 if (rule == NULL)
978 return NULL;
979
980 from_len = strlen (rule->from);
981
982 /* Compute the rewritten path and return it. */
983
984 new_path =
985 (char *) xmalloc (strlen (path) + 1 + strlen (rule->to) - from_len);
986 strcpy (new_path, rule->to);
987 strcat (new_path, path + from_len);
988
989 return new_path;
990 }
991
992 int
find_and_open_source(const char * filename,const char * dirname,char ** fullname)993 find_and_open_source (const char *filename,
994 const char *dirname,
995 char **fullname)
996 {
997 char *path = source_path;
998 const char *p;
999 int result;
1000
1001 /* Quick way out if we already know its full name. */
1002
1003 if (*fullname)
1004 {
1005 /* The user may have requested that source paths be rewritten
1006 according to substitution rules he provided. If a substitution
1007 rule applies to this path, then apply it. */
1008 char *rewritten_fullname = rewrite_source_path (*fullname);
1009
1010 if (rewritten_fullname != NULL)
1011 {
1012 xfree (*fullname);
1013 *fullname = rewritten_fullname;
1014 }
1015
1016 result = open (*fullname, OPEN_MODE);
1017 if (result >= 0)
1018 {
1019 char *lpath = gdb_realpath (*fullname);
1020
1021 xfree (*fullname);
1022 *fullname = lpath;
1023 return result;
1024 }
1025
1026 /* Didn't work -- free old one, try again. */
1027 xfree (*fullname);
1028 *fullname = NULL;
1029 }
1030
1031 if (dirname != NULL)
1032 {
1033 /* If necessary, rewrite the compilation directory name according
1034 to the source path substitution rules specified by the user. */
1035
1036 char *rewritten_dirname = rewrite_source_path (dirname);
1037
1038 if (rewritten_dirname != NULL)
1039 {
1040 make_cleanup (xfree, rewritten_dirname);
1041 dirname = rewritten_dirname;
1042 }
1043
1044 /* Replace a path entry of $cdir with the compilation directory
1045 name. */
1046 #define cdir_len 5
1047 /* We cast strstr's result in case an ANSIhole has made it const,
1048 which produces a "required warning" when assigned to a nonconst. */
1049 p = (char *) strstr (source_path, "$cdir");
1050 if (p && (p == path || p[-1] == DIRNAME_SEPARATOR)
1051 && (p[cdir_len] == DIRNAME_SEPARATOR || p[cdir_len] == '\0'))
1052 {
1053 int len;
1054
1055 path = (char *)
1056 alloca (strlen (source_path) + 1 + strlen (dirname) + 1);
1057 len = p - source_path;
1058 strncpy (path, source_path, len); /* Before $cdir */
1059 strcpy (path + len, dirname); /* new stuff */
1060 strcat (path + len, source_path + len + cdir_len); /* After
1061 $cdir */
1062 }
1063 }
1064
1065 if (IS_ABSOLUTE_PATH (filename))
1066 {
1067 /* If filename is absolute path, try the source path
1068 substitution on it. */
1069 char *rewritten_filename = rewrite_source_path (filename);
1070
1071 if (rewritten_filename != NULL)
1072 {
1073 make_cleanup (xfree, rewritten_filename);
1074 filename = rewritten_filename;
1075 }
1076 }
1077
1078 result = openp (path, OPF_SEARCH_IN_PATH, filename, OPEN_MODE, fullname);
1079 if (result < 0)
1080 {
1081 /* Didn't work. Try using just the basename. */
1082 p = lbasename (filename);
1083 if (p != filename)
1084 result = openp (path, OPF_SEARCH_IN_PATH, p, OPEN_MODE, fullname);
1085 }
1086
1087 return result;
1088 }
1089
1090 /* Open a source file given a symtab S. Returns a file descriptor or
1091 negative number for error.
1092
1093 This function is a convience function to find_and_open_source. */
1094
1095 int
open_source_file(struct symtab * s)1096 open_source_file (struct symtab *s)
1097 {
1098 if (!s)
1099 return -1;
1100
1101 return find_and_open_source (s->filename, s->dirname, &s->fullname);
1102 }
1103
1104 /* Finds the fullname that a symtab represents.
1105
1106 This functions finds the fullname and saves it in s->fullname.
1107 It will also return the value.
1108
1109 If this function fails to find the file that this symtab represents,
1110 the expected fullname is used. Therefore the files does not have to
1111 exist. */
1112
1113 const char *
symtab_to_fullname(struct symtab * s)1114 symtab_to_fullname (struct symtab *s)
1115 {
1116 /* Use cached copy if we have it.
1117 We rely on forget_cached_source_info being called appropriately
1118 to handle cases like the file being moved. */
1119 if (s->fullname == NULL)
1120 {
1121 int fd = find_and_open_source (s->filename, s->dirname, &s->fullname);
1122
1123 if (fd >= 0)
1124 close (fd);
1125 else
1126 {
1127 char *fullname;
1128 struct cleanup *back_to;
1129
1130 /* rewrite_source_path would be applied by find_and_open_source, we
1131 should report the pathname where GDB tried to find the file. */
1132
1133 if (s->dirname == NULL || IS_ABSOLUTE_PATH (s->filename))
1134 fullname = xstrdup (s->filename);
1135 else
1136 fullname = concat (s->dirname, SLASH_STRING, s->filename, NULL);
1137
1138 back_to = make_cleanup (xfree, fullname);
1139 s->fullname = rewrite_source_path (fullname);
1140 if (s->fullname == NULL)
1141 s->fullname = xstrdup (fullname);
1142 do_cleanups (back_to);
1143 }
1144 }
1145
1146 return s->fullname;
1147 }
1148
1149 /* See commentary in source.h. */
1150
1151 const char *
symtab_to_filename_for_display(struct symtab * symtab)1152 symtab_to_filename_for_display (struct symtab *symtab)
1153 {
1154 if (filename_display_string == filename_display_basename)
1155 return lbasename (symtab->filename);
1156 else if (filename_display_string == filename_display_absolute)
1157 return symtab_to_fullname (symtab);
1158 else if (filename_display_string == filename_display_relative)
1159 return symtab->filename;
1160 else
1161 internal_error (__FILE__, __LINE__, _("invalid filename_display_string"));
1162 }
1163
1164 /* Create and initialize the table S->line_charpos that records
1165 the positions of the lines in the source file, which is assumed
1166 to be open on descriptor DESC.
1167 All set S->nlines to the number of such lines. */
1168
1169 void
find_source_lines(struct symtab * s,int desc)1170 find_source_lines (struct symtab *s, int desc)
1171 {
1172 struct stat st;
1173 char *data, *p, *end;
1174 int nlines = 0;
1175 int lines_allocated = 1000;
1176 int *line_charpos;
1177 long mtime = 0;
1178 int size;
1179
1180 gdb_assert (s);
1181 line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
1182 if (fstat (desc, &st) < 0)
1183 perror_with_name (symtab_to_filename_for_display (s));
1184
1185 if (s->objfile && s->objfile->obfd)
1186 mtime = s->objfile->mtime;
1187 else if (exec_bfd)
1188 mtime = exec_bfd_mtime;
1189
1190 if (mtime && mtime < st.st_mtime)
1191 warning (_("Source file is more recent than executable."));
1192
1193 {
1194 struct cleanup *old_cleanups;
1195
1196 /* st_size might be a large type, but we only support source files whose
1197 size fits in an int. */
1198 size = (int) st.st_size;
1199
1200 /* Use malloc, not alloca, because this may be pretty large, and we may
1201 run into various kinds of limits on stack size. */
1202 data = (char *) xmalloc (size);
1203 old_cleanups = make_cleanup (xfree, data);
1204
1205 /* Reassign `size' to result of read for systems where \r\n -> \n. */
1206 size = myread (desc, data, size);
1207 if (size < 0)
1208 perror_with_name (symtab_to_filename_for_display (s));
1209 end = data + size;
1210 p = data;
1211 line_charpos[0] = 0;
1212 nlines = 1;
1213 while (p != end)
1214 {
1215 if (*p++ == '\n'
1216 /* A newline at the end does not start a new line. */
1217 && p != end)
1218 {
1219 if (nlines == lines_allocated)
1220 {
1221 lines_allocated *= 2;
1222 line_charpos =
1223 (int *) xrealloc ((char *) line_charpos,
1224 sizeof (int) * lines_allocated);
1225 }
1226 line_charpos[nlines++] = p - data;
1227 }
1228 }
1229 do_cleanups (old_cleanups);
1230 }
1231
1232 s->nlines = nlines;
1233 s->line_charpos =
1234 (int *) xrealloc ((char *) line_charpos, nlines * sizeof (int));
1235
1236 }
1237
1238
1239
1240 /* Get full pathname and line number positions for a symtab.
1241 Return nonzero if line numbers may have changed.
1242 Set *FULLNAME to actual name of the file as found by `openp',
1243 or to 0 if the file is not found. */
1244
1245 static int
get_filename_and_charpos(struct symtab * s,char ** fullname)1246 get_filename_and_charpos (struct symtab *s, char **fullname)
1247 {
1248 int desc, linenums_changed = 0;
1249 struct cleanup *cleanups;
1250
1251 desc = open_source_file (s);
1252 if (desc < 0)
1253 {
1254 if (fullname)
1255 *fullname = NULL;
1256 return 0;
1257 }
1258 cleanups = make_cleanup_close (desc);
1259 if (fullname)
1260 *fullname = s->fullname;
1261 if (s->line_charpos == 0)
1262 linenums_changed = 1;
1263 if (linenums_changed)
1264 find_source_lines (s, desc);
1265 do_cleanups (cleanups);
1266 return linenums_changed;
1267 }
1268
1269 /* Print text describing the full name of the source file S
1270 and the line number LINE and its corresponding character position.
1271 The text starts with two Ctrl-z so that the Emacs-GDB interface
1272 can easily find it.
1273
1274 MID_STATEMENT is nonzero if the PC is not at the beginning of that line.
1275
1276 Return 1 if successful, 0 if could not find the file. */
1277
1278 int
identify_source_line(struct symtab * s,int line,int mid_statement,CORE_ADDR pc)1279 identify_source_line (struct symtab *s, int line, int mid_statement,
1280 CORE_ADDR pc)
1281 {
1282 if (s->line_charpos == 0)
1283 get_filename_and_charpos (s, (char **) NULL);
1284 if (s->fullname == 0)
1285 return 0;
1286 if (line > s->nlines)
1287 /* Don't index off the end of the line_charpos array. */
1288 return 0;
1289 annotate_source (s->fullname, line, s->line_charpos[line - 1],
1290 mid_statement, get_objfile_arch (s->objfile), pc);
1291
1292 current_source_line = line;
1293 first_line_listed = line;
1294 last_line_listed = line;
1295 current_source_symtab = s;
1296 return 1;
1297 }
1298
1299
1300 /* Print source lines from the file of symtab S,
1301 starting with line number LINE and stopping before line number STOPLINE. */
1302
1303 static void
print_source_lines_base(struct symtab * s,int line,int stopline,enum print_source_lines_flags flags)1304 print_source_lines_base (struct symtab *s, int line, int stopline,
1305 enum print_source_lines_flags flags)
1306 {
1307 int c;
1308 int desc;
1309 int noprint = 0;
1310 FILE *stream;
1311 int nlines = stopline - line;
1312 struct cleanup *cleanup;
1313 struct ui_out *uiout = current_uiout;
1314
1315 /* Regardless of whether we can open the file, set current_source_symtab. */
1316 current_source_symtab = s;
1317 current_source_line = line;
1318 first_line_listed = line;
1319
1320 /* If printing of source lines is disabled, just print file and line
1321 number. */
1322 if (ui_out_test_flags (uiout, ui_source_list))
1323 {
1324 /* Only prints "No such file or directory" once. */
1325 if ((s != last_source_visited) || (!last_source_error))
1326 {
1327 last_source_visited = s;
1328 desc = open_source_file (s);
1329 }
1330 else
1331 {
1332 desc = last_source_error;
1333 flags |= PRINT_SOURCE_LINES_NOERROR;
1334 }
1335 }
1336 else
1337 {
1338 desc = last_source_error;
1339 flags |= PRINT_SOURCE_LINES_NOERROR;
1340 noprint = 1;
1341 }
1342
1343 if (desc < 0 || noprint)
1344 {
1345 last_source_error = desc;
1346
1347 if (!(flags & PRINT_SOURCE_LINES_NOERROR))
1348 {
1349 const char *filename = symtab_to_filename_for_display (s);
1350 int len = strlen (filename) + 100;
1351 char *name = alloca (len);
1352
1353 xsnprintf (name, len, "%d\t%s", line, filename);
1354 print_sys_errmsg (name, errno);
1355 }
1356 else
1357 {
1358 ui_out_field_int (uiout, "line", line);
1359 ui_out_text (uiout, "\tin ");
1360
1361 /* CLI expects only the "file" field. TUI expects only the
1362 "fullname" field (and TUI does break if "file" is printed).
1363 MI expects both fields. ui_source_list is set only for CLI,
1364 not for TUI. */
1365 if (ui_out_is_mi_like_p (uiout)
1366 || ui_out_test_flags (uiout, ui_source_list))
1367 ui_out_field_string (uiout, "file",
1368 symtab_to_filename_for_display (s));
1369 if (ui_out_is_mi_like_p (uiout)
1370 || !ui_out_test_flags (uiout, ui_source_list))
1371 {
1372 const char *s_fullname = symtab_to_fullname (s);
1373 char *local_fullname;
1374
1375 /* ui_out_field_string may free S_FULLNAME by calling
1376 open_source_file for it again. See e.g.,
1377 tui_field_string->tui_show_source. */
1378 local_fullname = alloca (strlen (s_fullname) + 1);
1379 strcpy (local_fullname, s_fullname);
1380
1381 ui_out_field_string (uiout, "fullname", local_fullname);
1382 }
1383
1384 ui_out_text (uiout, "\n");
1385 }
1386
1387 return;
1388 }
1389
1390 last_source_error = 0;
1391
1392 if (s->line_charpos == 0)
1393 find_source_lines (s, desc);
1394
1395 if (line < 1 || line > s->nlines)
1396 {
1397 close (desc);
1398 error (_("Line number %d out of range; %s has %d lines."),
1399 line, symtab_to_filename_for_display (s), s->nlines);
1400 }
1401
1402 if (lseek (desc, s->line_charpos[line - 1], 0) < 0)
1403 {
1404 close (desc);
1405 perror_with_name (symtab_to_filename_for_display (s));
1406 }
1407
1408 stream = fdopen (desc, FDOPEN_MODE);
1409 clearerr (stream);
1410 cleanup = make_cleanup_fclose (stream);
1411
1412 while (nlines-- > 0)
1413 {
1414 char buf[20];
1415
1416 c = fgetc (stream);
1417 if (c == EOF)
1418 break;
1419 last_line_listed = current_source_line;
1420 if (flags & PRINT_SOURCE_LINES_FILENAME)
1421 {
1422 ui_out_text (uiout, symtab_to_filename_for_display (s));
1423 ui_out_text (uiout, ":");
1424 }
1425 xsnprintf (buf, sizeof (buf), "%d\t", current_source_line++);
1426 ui_out_text (uiout, buf);
1427 do
1428 {
1429 if (c < 040 && c != '\t' && c != '\n' && c != '\r')
1430 {
1431 xsnprintf (buf, sizeof (buf), "^%c", c + 0100);
1432 ui_out_text (uiout, buf);
1433 }
1434 else if (c == 0177)
1435 ui_out_text (uiout, "^?");
1436 else if (c == '\r')
1437 {
1438 /* Skip a \r character, but only before a \n. */
1439 int c1 = fgetc (stream);
1440
1441 if (c1 != '\n')
1442 printf_filtered ("^%c", c + 0100);
1443 if (c1 != EOF)
1444 ungetc (c1, stream);
1445 }
1446 else
1447 {
1448 xsnprintf (buf, sizeof (buf), "%c", c);
1449 ui_out_text (uiout, buf);
1450 }
1451 }
1452 while (c != '\n' && (c = fgetc (stream)) >= 0);
1453 }
1454
1455 do_cleanups (cleanup);
1456 }
1457
1458 /* Show source lines from the file of symtab S, starting with line
1459 number LINE and stopping before line number STOPLINE. If this is
1460 not the command line version, then the source is shown in the source
1461 window otherwise it is simply printed. */
1462
1463 void
print_source_lines(struct symtab * s,int line,int stopline,enum print_source_lines_flags flags)1464 print_source_lines (struct symtab *s, int line, int stopline,
1465 enum print_source_lines_flags flags)
1466 {
1467 print_source_lines_base (s, line, stopline, flags);
1468 }
1469
1470 /* Print info on range of pc's in a specified line. */
1471
1472 static void
line_info(char * arg,int from_tty)1473 line_info (char *arg, int from_tty)
1474 {
1475 struct symtabs_and_lines sals;
1476 struct symtab_and_line sal;
1477 CORE_ADDR start_pc, end_pc;
1478 int i;
1479 struct cleanup *cleanups;
1480
1481 init_sal (&sal); /* initialize to zeroes */
1482
1483 if (arg == 0)
1484 {
1485 sal.symtab = current_source_symtab;
1486 sal.pspace = current_program_space;
1487 sal.line = last_line_listed;
1488 sals.nelts = 1;
1489 sals.sals = (struct symtab_and_line *)
1490 xmalloc (sizeof (struct symtab_and_line));
1491 sals.sals[0] = sal;
1492 }
1493 else
1494 {
1495 sals = decode_line_with_last_displayed (arg, DECODE_LINE_LIST_MODE);
1496
1497 dont_repeat ();
1498 }
1499
1500 cleanups = make_cleanup (xfree, sals.sals);
1501
1502 /* C++ More than one line may have been specified, as when the user
1503 specifies an overloaded function name. Print info on them all. */
1504 for (i = 0; i < sals.nelts; i++)
1505 {
1506 sal = sals.sals[i];
1507 if (sal.pspace != current_program_space)
1508 continue;
1509
1510 if (sal.symtab == 0)
1511 {
1512 struct gdbarch *gdbarch = get_current_arch ();
1513
1514 printf_filtered (_("No line number information available"));
1515 if (sal.pc != 0)
1516 {
1517 /* This is useful for "info line *0x7f34". If we can't tell the
1518 user about a source line, at least let them have the symbolic
1519 address. */
1520 printf_filtered (" for address ");
1521 wrap_here (" ");
1522 print_address (gdbarch, sal.pc, gdb_stdout);
1523 }
1524 else
1525 printf_filtered (".");
1526 printf_filtered ("\n");
1527 }
1528 else if (sal.line > 0
1529 && find_line_pc_range (sal, &start_pc, &end_pc))
1530 {
1531 struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile);
1532
1533 if (start_pc == end_pc)
1534 {
1535 printf_filtered ("Line %d of \"%s\"",
1536 sal.line,
1537 symtab_to_filename_for_display (sal.symtab));
1538 wrap_here (" ");
1539 printf_filtered (" is at address ");
1540 print_address (gdbarch, start_pc, gdb_stdout);
1541 wrap_here (" ");
1542 printf_filtered (" but contains no code.\n");
1543 }
1544 else
1545 {
1546 printf_filtered ("Line %d of \"%s\"",
1547 sal.line,
1548 symtab_to_filename_for_display (sal.symtab));
1549 wrap_here (" ");
1550 printf_filtered (" starts at address ");
1551 print_address (gdbarch, start_pc, gdb_stdout);
1552 wrap_here (" ");
1553 printf_filtered (" and ends at ");
1554 print_address (gdbarch, end_pc, gdb_stdout);
1555 printf_filtered (".\n");
1556 }
1557
1558 /* x/i should display this line's code. */
1559 set_next_address (gdbarch, start_pc);
1560
1561 /* Repeating "info line" should do the following line. */
1562 last_line_listed = sal.line + 1;
1563
1564 /* If this is the only line, show the source code. If it could
1565 not find the file, don't do anything special. */
1566 if (annotation_level && sals.nelts == 1)
1567 identify_source_line (sal.symtab, sal.line, 0, start_pc);
1568 }
1569 else
1570 /* Is there any case in which we get here, and have an address
1571 which the user would want to see? If we have debugging symbols
1572 and no line numbers? */
1573 printf_filtered (_("Line number %d is out of range for \"%s\".\n"),
1574 sal.line, symtab_to_filename_for_display (sal.symtab));
1575 }
1576 do_cleanups (cleanups);
1577 }
1578
1579 /* Commands to search the source file for a regexp. */
1580
1581 static void
forward_search_command(char * regex,int from_tty)1582 forward_search_command (char *regex, int from_tty)
1583 {
1584 int c;
1585 int desc;
1586 FILE *stream;
1587 int line;
1588 char *msg;
1589 struct cleanup *cleanups;
1590
1591 line = last_line_listed + 1;
1592
1593 msg = (char *) re_comp (regex);
1594 if (msg)
1595 error (("%s"), msg);
1596
1597 if (current_source_symtab == 0)
1598 select_source_symtab (0);
1599
1600 desc = open_source_file (current_source_symtab);
1601 if (desc < 0)
1602 perror_with_name (symtab_to_filename_for_display (current_source_symtab));
1603 cleanups = make_cleanup_close (desc);
1604
1605 if (current_source_symtab->line_charpos == 0)
1606 find_source_lines (current_source_symtab, desc);
1607
1608 if (line < 1 || line > current_source_symtab->nlines)
1609 error (_("Expression not found"));
1610
1611 if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
1612 perror_with_name (symtab_to_filename_for_display (current_source_symtab));
1613
1614 discard_cleanups (cleanups);
1615 stream = fdopen (desc, FDOPEN_MODE);
1616 clearerr (stream);
1617 cleanups = make_cleanup_fclose (stream);
1618 while (1)
1619 {
1620 static char *buf = NULL;
1621 char *p;
1622 int cursize, newsize;
1623
1624 cursize = 256;
1625 buf = xmalloc (cursize);
1626 p = buf;
1627
1628 c = getc (stream);
1629 if (c == EOF)
1630 break;
1631 do
1632 {
1633 *p++ = c;
1634 if (p - buf == cursize)
1635 {
1636 newsize = cursize + cursize / 2;
1637 buf = xrealloc (buf, newsize);
1638 p = buf + cursize;
1639 cursize = newsize;
1640 }
1641 }
1642 while (c != '\n' && (c = getc (stream)) >= 0);
1643
1644 /* Remove the \r, if any, at the end of the line, otherwise
1645 regular expressions that end with $ or \n won't work. */
1646 if (p - buf > 1 && p[-2] == '\r')
1647 {
1648 p--;
1649 p[-1] = '\n';
1650 }
1651
1652 /* We now have a source line in buf, null terminate and match. */
1653 *p = 0;
1654 if (re_exec (buf) > 0)
1655 {
1656 /* Match! */
1657 do_cleanups (cleanups);
1658 print_source_lines (current_source_symtab, line, line + 1, 0);
1659 set_internalvar_integer (lookup_internalvar ("_"), line);
1660 current_source_line = max (line - lines_to_list / 2, 1);
1661 return;
1662 }
1663 line++;
1664 }
1665
1666 printf_filtered (_("Expression not found\n"));
1667 do_cleanups (cleanups);
1668 }
1669
1670 static void
reverse_search_command(char * regex,int from_tty)1671 reverse_search_command (char *regex, int from_tty)
1672 {
1673 int c;
1674 int desc;
1675 FILE *stream;
1676 int line;
1677 char *msg;
1678 struct cleanup *cleanups;
1679
1680 line = last_line_listed - 1;
1681
1682 msg = (char *) re_comp (regex);
1683 if (msg)
1684 error (("%s"), msg);
1685
1686 if (current_source_symtab == 0)
1687 select_source_symtab (0);
1688
1689 desc = open_source_file (current_source_symtab);
1690 if (desc < 0)
1691 perror_with_name (symtab_to_filename_for_display (current_source_symtab));
1692 cleanups = make_cleanup_close (desc);
1693
1694 if (current_source_symtab->line_charpos == 0)
1695 find_source_lines (current_source_symtab, desc);
1696
1697 if (line < 1 || line > current_source_symtab->nlines)
1698 error (_("Expression not found"));
1699
1700 if (lseek (desc, current_source_symtab->line_charpos[line - 1], 0) < 0)
1701 perror_with_name (symtab_to_filename_for_display (current_source_symtab));
1702
1703 discard_cleanups (cleanups);
1704 stream = fdopen (desc, FDOPEN_MODE);
1705 clearerr (stream);
1706 cleanups = make_cleanup_fclose (stream);
1707 while (line > 1)
1708 {
1709 /* FIXME!!! We walk right off the end of buf if we get a long line!!! */
1710 char buf[4096]; /* Should be reasonable??? */
1711 char *p = buf;
1712
1713 c = getc (stream);
1714 if (c == EOF)
1715 break;
1716 do
1717 {
1718 *p++ = c;
1719 }
1720 while (c != '\n' && (c = getc (stream)) >= 0);
1721
1722 /* Remove the \r, if any, at the end of the line, otherwise
1723 regular expressions that end with $ or \n won't work. */
1724 if (p - buf > 1 && p[-2] == '\r')
1725 {
1726 p--;
1727 p[-1] = '\n';
1728 }
1729
1730 /* We now have a source line in buf; null terminate and match. */
1731 *p = 0;
1732 if (re_exec (buf) > 0)
1733 {
1734 /* Match! */
1735 do_cleanups (cleanups);
1736 print_source_lines (current_source_symtab, line, line + 1, 0);
1737 set_internalvar_integer (lookup_internalvar ("_"), line);
1738 current_source_line = max (line - lines_to_list / 2, 1);
1739 return;
1740 }
1741 line--;
1742 if (fseek (stream, current_source_symtab->line_charpos[line - 1], 0) < 0)
1743 {
1744 const char *filename;
1745
1746 do_cleanups (cleanups);
1747 filename = symtab_to_filename_for_display (current_source_symtab);
1748 perror_with_name (filename);
1749 }
1750 }
1751
1752 printf_filtered (_("Expression not found\n"));
1753 do_cleanups (cleanups);
1754 return;
1755 }
1756
1757 /* If the last character of PATH is a directory separator, then strip it. */
1758
1759 static void
strip_trailing_directory_separator(char * path)1760 strip_trailing_directory_separator (char *path)
1761 {
1762 const int last = strlen (path) - 1;
1763
1764 if (last < 0)
1765 return; /* No stripping is needed if PATH is the empty string. */
1766
1767 if (IS_DIR_SEPARATOR (path[last]))
1768 path[last] = '\0';
1769 }
1770
1771 /* Return the path substitution rule that matches FROM.
1772 Return NULL if no rule matches. */
1773
1774 static struct substitute_path_rule *
find_substitute_path_rule(const char * from)1775 find_substitute_path_rule (const char *from)
1776 {
1777 struct substitute_path_rule *rule = substitute_path_rules;
1778
1779 while (rule != NULL)
1780 {
1781 if (FILENAME_CMP (rule->from, from) == 0)
1782 return rule;
1783 rule = rule->next;
1784 }
1785
1786 return NULL;
1787 }
1788
1789 /* Add a new substitute-path rule at the end of the current list of rules.
1790 The new rule will replace FROM into TO. */
1791
1792 void
add_substitute_path_rule(char * from,char * to)1793 add_substitute_path_rule (char *from, char *to)
1794 {
1795 struct substitute_path_rule *rule;
1796 struct substitute_path_rule *new_rule;
1797
1798 new_rule = xmalloc (sizeof (struct substitute_path_rule));
1799 new_rule->from = xstrdup (from);
1800 new_rule->to = xstrdup (to);
1801 new_rule->next = NULL;
1802
1803 /* If the list of rules are empty, then insert the new rule
1804 at the head of the list. */
1805
1806 if (substitute_path_rules == NULL)
1807 {
1808 substitute_path_rules = new_rule;
1809 return;
1810 }
1811
1812 /* Otherwise, skip to the last rule in our list and then append
1813 the new rule. */
1814
1815 rule = substitute_path_rules;
1816 while (rule->next != NULL)
1817 rule = rule->next;
1818
1819 rule->next = new_rule;
1820 }
1821
1822 /* Remove the given source path substitution rule from the current list
1823 of rules. The memory allocated for that rule is also deallocated. */
1824
1825 static void
delete_substitute_path_rule(struct substitute_path_rule * rule)1826 delete_substitute_path_rule (struct substitute_path_rule *rule)
1827 {
1828 if (rule == substitute_path_rules)
1829 substitute_path_rules = rule->next;
1830 else
1831 {
1832 struct substitute_path_rule *prev = substitute_path_rules;
1833
1834 while (prev != NULL && prev->next != rule)
1835 prev = prev->next;
1836
1837 gdb_assert (prev != NULL);
1838
1839 prev->next = rule->next;
1840 }
1841
1842 xfree (rule->from);
1843 xfree (rule->to);
1844 xfree (rule);
1845 }
1846
1847 /* Implement the "show substitute-path" command. */
1848
1849 static void
show_substitute_path_command(char * args,int from_tty)1850 show_substitute_path_command (char *args, int from_tty)
1851 {
1852 struct substitute_path_rule *rule = substitute_path_rules;
1853 char **argv;
1854 char *from = NULL;
1855
1856 argv = gdb_buildargv (args);
1857 make_cleanup_freeargv (argv);
1858
1859 /* We expect zero or one argument. */
1860
1861 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1862 error (_("Too many arguments in command"));
1863
1864 if (argv != NULL && argv[0] != NULL)
1865 from = argv[0];
1866
1867 /* Print the substitution rules. */
1868
1869 if (from != NULL)
1870 printf_filtered
1871 (_("Source path substitution rule matching `%s':\n"), from);
1872 else
1873 printf_filtered (_("List of all source path substitution rules:\n"));
1874
1875 while (rule != NULL)
1876 {
1877 if (from == NULL || FILENAME_CMP (rule->from, from) == 0)
1878 printf_filtered (" `%s' -> `%s'.\n", rule->from, rule->to);
1879 rule = rule->next;
1880 }
1881 }
1882
1883 /* Implement the "unset substitute-path" command. */
1884
1885 static void
unset_substitute_path_command(char * args,int from_tty)1886 unset_substitute_path_command (char *args, int from_tty)
1887 {
1888 struct substitute_path_rule *rule = substitute_path_rules;
1889 char **argv = gdb_buildargv (args);
1890 char *from = NULL;
1891 int rule_found = 0;
1892
1893 /* This function takes either 0 or 1 argument. */
1894
1895 make_cleanup_freeargv (argv);
1896 if (argv != NULL && argv[0] != NULL && argv[1] != NULL)
1897 error (_("Incorrect usage, too many arguments in command"));
1898
1899 if (argv != NULL && argv[0] != NULL)
1900 from = argv[0];
1901
1902 /* If the user asked for all the rules to be deleted, ask him
1903 to confirm and give him a chance to abort before the action
1904 is performed. */
1905
1906 if (from == NULL
1907 && !query (_("Delete all source path substitution rules? ")))
1908 error (_("Canceled"));
1909
1910 /* Delete the rule matching the argument. No argument means that
1911 all rules should be deleted. */
1912
1913 while (rule != NULL)
1914 {
1915 struct substitute_path_rule *next = rule->next;
1916
1917 if (from == NULL || FILENAME_CMP (from, rule->from) == 0)
1918 {
1919 delete_substitute_path_rule (rule);
1920 rule_found = 1;
1921 }
1922
1923 rule = next;
1924 }
1925
1926 /* If the user asked for a specific rule to be deleted but
1927 we could not find it, then report an error. */
1928
1929 if (from != NULL && !rule_found)
1930 error (_("No substitution rule defined for `%s'"), from);
1931
1932 forget_cached_source_info ();
1933 }
1934
1935 /* Add a new source path substitution rule. */
1936
1937 static void
set_substitute_path_command(char * args,int from_tty)1938 set_substitute_path_command (char *args, int from_tty)
1939 {
1940 char **argv;
1941 struct substitute_path_rule *rule;
1942
1943 argv = gdb_buildargv (args);
1944 make_cleanup_freeargv (argv);
1945
1946 if (argv == NULL || argv[0] == NULL || argv [1] == NULL)
1947 error (_("Incorrect usage, too few arguments in command"));
1948
1949 if (argv[2] != NULL)
1950 error (_("Incorrect usage, too many arguments in command"));
1951
1952 if (*(argv[0]) == '\0')
1953 error (_("First argument must be at least one character long"));
1954
1955 /* Strip any trailing directory separator character in either FROM
1956 or TO. The substitution rule already implicitly contains them. */
1957 strip_trailing_directory_separator (argv[0]);
1958 strip_trailing_directory_separator (argv[1]);
1959
1960 /* If a rule with the same "from" was previously defined, then
1961 delete it. This new rule replaces it. */
1962
1963 rule = find_substitute_path_rule (argv[0]);
1964 if (rule != NULL)
1965 delete_substitute_path_rule (rule);
1966
1967 /* Insert the new substitution rule. */
1968
1969 add_substitute_path_rule (argv[0], argv[1]);
1970 forget_cached_source_info ();
1971 }
1972
1973
1974 void
_initialize_source(void)1975 _initialize_source (void)
1976 {
1977 struct cmd_list_element *c;
1978
1979 current_source_symtab = 0;
1980 init_source_path ();
1981
1982 /* The intention is to use POSIX Basic Regular Expressions.
1983 Always use the GNU regex routine for consistency across all hosts.
1984 Our current GNU regex.c does not have all the POSIX features, so this is
1985 just an approximation. */
1986 re_set_syntax (RE_SYNTAX_GREP);
1987
1988 c = add_cmd ("directory", class_files, directory_command, _("\
1989 Add directory DIR to beginning of search path for source files.\n\
1990 Forget cached info on source file locations and line positions.\n\
1991 DIR can also be $cwd for the current working directory, or $cdir for the\n\
1992 directory in which the source file was compiled into object code.\n\
1993 With no argument, reset the search path to $cdir:$cwd, the default."),
1994 &cmdlist);
1995
1996 if (dbx_commands)
1997 add_com_alias ("use", "directory", class_files, 0);
1998
1999 set_cmd_completer (c, filename_completer);
2000
2001 add_setshow_optional_filename_cmd ("directories",
2002 class_files,
2003 &source_path,
2004 _("\
2005 Set the search path for finding source files."),
2006 _("\
2007 Show the search path for finding source files."),
2008 _("\
2009 $cwd in the path means the current working directory.\n\
2010 $cdir in the path means the compilation directory of the source file.\n\
2011 GDB ensures the search path always ends with $cdir:$cwd by\n\
2012 appending these directories if necessary.\n\
2013 Setting the value to an empty string sets it to $cdir:$cwd, the default."),
2014 set_directories_command,
2015 show_directories_command,
2016 &setlist, &showlist);
2017
2018 if (xdb_commands)
2019 {
2020 add_com_alias ("D", "directory", class_files, 0);
2021 add_cmd ("ld", no_class, show_directories_1, _("\
2022 Current search path for finding source files.\n\
2023 $cwd in the path means the current working directory.\n\
2024 $cdir in the path means the compilation directory of the source file."),
2025 &cmdlist);
2026 }
2027
2028 add_info ("source", source_info,
2029 _("Information about the current source file."));
2030
2031 add_info ("line", line_info, _("\
2032 Core addresses of the code for a source line.\n\
2033 Line can be specified as\n\
2034 LINENUM, to list around that line in current file,\n\
2035 FILE:LINENUM, to list around that line in that file,\n\
2036 FUNCTION, to list around beginning of that function,\n\
2037 FILE:FUNCTION, to distinguish among like-named static functions.\n\
2038 Default is to describe the last source line that was listed.\n\n\
2039 This sets the default address for \"x\" to the line's first instruction\n\
2040 so that \"x/i\" suffices to start examining the machine code.\n\
2041 The address is also stored as the value of \"$_\"."));
2042
2043 add_com ("forward-search", class_files, forward_search_command, _("\
2044 Search for regular expression (see regex(3)) from last line listed.\n\
2045 The matching line number is also stored as the value of \"$_\"."));
2046 add_com_alias ("search", "forward-search", class_files, 0);
2047 add_com_alias ("fo", "forward-search", class_files, 1);
2048
2049 add_com ("reverse-search", class_files, reverse_search_command, _("\
2050 Search backward for regular expression (see regex(3)) from last line listed.\n\
2051 The matching line number is also stored as the value of \"$_\"."));
2052 add_com_alias ("rev", "reverse-search", class_files, 1);
2053
2054 if (xdb_commands)
2055 {
2056 add_com_alias ("/", "forward-search", class_files, 0);
2057 add_com_alias ("?", "reverse-search", class_files, 0);
2058 }
2059
2060 add_setshow_integer_cmd ("listsize", class_support, &lines_to_list, _("\
2061 Set number of source lines gdb will list by default."), _("\
2062 Show number of source lines gdb will list by default."), NULL,
2063 NULL,
2064 show_lines_to_list,
2065 &setlist, &showlist);
2066
2067 add_cmd ("substitute-path", class_files, set_substitute_path_command,
2068 _("\
2069 Usage: set substitute-path FROM TO\n\
2070 Add a substitution rule replacing FROM into TO in source file names.\n\
2071 If a substitution rule was previously set for FROM, the old rule\n\
2072 is replaced by the new one."),
2073 &setlist);
2074
2075 add_cmd ("substitute-path", class_files, unset_substitute_path_command,
2076 _("\
2077 Usage: unset substitute-path [FROM]\n\
2078 Delete the rule for substituting FROM in source file names. If FROM\n\
2079 is not specified, all substituting rules are deleted.\n\
2080 If the debugger cannot find a rule for FROM, it will display a warning."),
2081 &unsetlist);
2082
2083 add_cmd ("substitute-path", class_files, show_substitute_path_command,
2084 _("\
2085 Usage: show substitute-path [FROM]\n\
2086 Print the rule for substituting FROM in source file names. If FROM\n\
2087 is not specified, print all substitution rules."),
2088 &showlist);
2089
2090 add_setshow_enum_cmd ("filename-display", class_files,
2091 filename_display_kind_names,
2092 &filename_display_string, _("\
2093 Set how to display filenames."), _("\
2094 Show how to display filenames."), _("\
2095 filename-display can be:\n\
2096 basename - display only basename of a filename\n\
2097 relative - display a filename relative to the compilation directory\n\
2098 absolute - display an absolute filename\n\
2099 By default, relative filenames are displayed."),
2100 NULL,
2101 show_filename_display_string,
2102 &setlist, &showlist);
2103
2104 }
2105