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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [source.c] - Blame information for rev 461

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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