OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [source.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.