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