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