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