Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / source.c
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
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
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 \f
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
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
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
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
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
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
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
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 \f
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
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
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
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
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
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
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
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
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
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
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
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 \f
652
653 /* Return True if the file NAME exists and is a regular file.  */
654 static int
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
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
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
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 *
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 *
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
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
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 *
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 *
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 \f
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
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 \f
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
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
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 \f
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
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 \f
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
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 \f
1470 /* Print info on range of pc's in a specified line.  */
1471
1472 static void
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 \f
1579 /* Commands to search the source file for a regexp.  */
1580
1581 static void
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
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
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 *
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
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
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
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
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
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 \f
1974 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 }