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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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