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