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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [libcpp/] [files.c] - Blame information for rev 859

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

Line No. Rev Author Line
1 270 jeremybenn
/* Part of CPP library.  File handling.
2
   Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
   Written by Per Bothner, 1994.
6
   Based on CCCP program by Paul Rubin, June 1986
7
   Adapted to ANSI C, Richard Stallman, Jan 1987
8
   Split out of cpplib.c, Zack Weinberg, Oct 1998
9
   Reimplemented, Neil Booth, Jul 2003
10
 
11
This program is free software; you can redistribute it and/or modify it
12
under the terms of the GNU General Public License as published by the
13
Free Software Foundation; either version 3, or (at your option) any
14
later version.
15
 
16
This program is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
GNU General Public License for more details.
20
 
21
You should have received a copy of the GNU General Public License
22
along with this program; see the file COPYING3.  If not see
23
<http://www.gnu.org/licenses/>.  */
24
 
25
#include "config.h"
26
#include "system.h"
27
#include "cpplib.h"
28
#include "internal.h"
29
#include "mkdeps.h"
30
#include "obstack.h"
31
#include "hashtab.h"
32
#include "md5.h"
33
#include <dirent.h>
34
 
35
/* Variable length record files on VMS will have a stat size that includes
36
   record control characters that won't be included in the read size.  */
37
#ifdef VMS
38
# define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
39
# define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
40
#else
41
# define STAT_SIZE_RELIABLE(ST) true
42
#endif
43
 
44
#ifdef __DJGPP__
45
#include <io.h>
46
  /* For DJGPP redirected input is opened in text mode.  */
47
#  define set_stdin_to_binary_mode() \
48
     if (! isatty (0)) setmode (0, O_BINARY)
49
#else
50
#  define set_stdin_to_binary_mode() /* Nothing */
51
#endif
52
 
53
/* This structure represents a file searched for by CPP, whether it
54
   exists or not.  An instance may be pointed to by more than one
55
   file_hash_entry; at present no reference count is kept.  */
56
struct _cpp_file
57
{
58
  /* Filename as given to #include or command line switch.  */
59
  const char *name;
60
 
61
  /* The full path used to find the file.  */
62
  const char *path;
63
 
64
  /* The full path of the pch file.  */
65
  const char *pchname;
66
 
67
  /* The file's path with the basename stripped.  NULL if it hasn't
68
     been calculated yet.  */
69
  const char *dir_name;
70
 
71
  /* Chain through all files.  */
72
  struct _cpp_file *next_file;
73
 
74
  /* The contents of NAME after calling read_file().  */
75
  const uchar *buffer;
76
 
77
  /* Pointer to the real start of BUFFER.  read_file() might increment
78
     BUFFER; when freeing, this this pointer must be used instead.  */
79
  const uchar *buffer_start;
80
 
81
  /* The macro, if any, preventing re-inclusion.  */
82
  const cpp_hashnode *cmacro;
83
 
84
  /* The directory in the search path where FILE was found.  Used for
85
     #include_next and determining whether a header is a system
86
     header.  */
87
  cpp_dir *dir;
88
 
89
  /* As filled in by stat(2) for the file.  */
90
  struct stat st;
91
 
92
  /* File descriptor.  Invalid if -1, otherwise open.  */
93
  int fd;
94
 
95
  /* Zero if this file was successfully opened and stat()-ed,
96
     otherwise errno obtained from failure.  */
97
  int err_no;
98
 
99
  /* Number of times the file has been stacked for preprocessing.  */
100
  unsigned short stack_count;
101
 
102
  /* If opened with #import or contains #pragma once.  */
103
  bool once_only;
104
 
105
  /* If read() failed before.  */
106
  bool dont_read;
107
 
108
  /* If this file is the main file.  */
109
  bool main_file;
110
 
111
  /* If BUFFER above contains the true contents of the file.  */
112
  bool buffer_valid;
113
};
114
 
115
/* A singly-linked list for all searches for a given file name, with
116
   its head pointed to by a slot in FILE_HASH.  The file name is what
117
   appeared between the quotes in a #include directive; it can be
118
   determined implicitly from the hash table location or explicitly
119
   from FILE->name.
120
 
121
   FILE is a structure containing details about the file that was
122
   found with that search, or details of how the search failed.
123
 
124
   START_DIR is the starting location of the search in the include
125
   chain.  The current directories for "" includes are also hashed in
126
   the hash table and therefore unique.  Files that are looked up
127
   without using a search path, such as absolute filenames and file
128
   names from the command line share a special starting directory so
129
   they don't cause cache hits with normal include-chain lookups.
130
 
131
   If START_DIR is NULL then the entry is for a directory, not a file,
132
   and the directory is in DIR.  Since the starting point in a file
133
   lookup chain is never NULL, this means that simple pointer
134
   comparisons against START_DIR can be made to determine cache hits
135
   in file lookups.
136
 
137
   If a cache lookup fails because of e.g. an extra "./" in the path,
138
   then nothing will break.  It is just less efficient as CPP will
139
   have to do more work re-preprocessing the file, and/or comparing
140
   its contents against earlier once-only files.
141
*/
142
struct file_hash_entry
143
{
144
  struct file_hash_entry *next;
145
  cpp_dir *start_dir;
146
  source_location location;
147
  union
148
  {
149
    _cpp_file *file;
150
    cpp_dir *dir;
151
  } u;
152
};
153
 
154
/* Number of entries to put in a file_hash_entry pool.  */
155
#define FILE_HASH_POOL_SIZE 127
156
 
157
/* A file hash entry pool.  We allocate file_hash_entry object from
158
   one of these.  */
159
struct file_hash_entry_pool
160
{
161
  /* Number of entries used from this pool.  */
162
  unsigned int file_hash_entries_used;
163
  /* Next pool in the chain; used when freeing.  */
164
  struct file_hash_entry_pool *next;
165
  /* The memory pool.  */
166
  struct file_hash_entry pool[FILE_HASH_POOL_SIZE];
167
};
168
 
169
static bool open_file (_cpp_file *file);
170
static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
171
                           bool *invalid_pch);
172
static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
173
                              bool *invalid_pch);
174
static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
175
static bool read_file (cpp_reader *pfile, _cpp_file *file);
176
static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
177
static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
178
                                 int angle_brackets, enum include_type);
179
static const char *dir_name_of_file (_cpp_file *file);
180
static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
181
static struct file_hash_entry *search_cache (struct file_hash_entry *head,
182
                                             const cpp_dir *start_dir);
183
static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
184
static void destroy_cpp_file (_cpp_file *);
185
static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
186
static void allocate_file_hash_entries (cpp_reader *pfile);
187
static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
188
static int report_missing_guard (void **slot, void *b);
189
static hashval_t file_hash_hash (const void *p);
190
static int file_hash_eq (const void *p, const void *q);
191
static char *read_filename_string (int ch, FILE *f);
192
static void read_name_map (cpp_dir *dir);
193
static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
194
static char *append_file_to_dir (const char *fname, cpp_dir *dir);
195
static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
196
static int pchf_save_compare (const void *e1, const void *e2);
197
static int pchf_compare (const void *d_p, const void *e_p);
198
static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
199
 
200
/* Given a filename in FILE->PATH, with the empty string interpreted
201
   as <stdin>, open it.
202
 
203
   On success FILE contains an open file descriptor and stat
204
   information for the file.  On failure the file descriptor is -1 and
205
   the appropriate errno is also stored in FILE.  Returns TRUE iff
206
   successful.
207
 
208
   We used to open files in nonblocking mode, but that caused more
209
   problems than it solved.  Do take care not to acquire a controlling
210
   terminal by mistake (this can't happen on sane systems, but
211
   paranoia is a virtue).
212
 
213
   Use the three-argument form of open even though we aren't
214
   specifying O_CREAT, to defend against broken system headers.
215
 
216
   O_BINARY tells some runtime libraries (notably DJGPP) not to do
217
   newline translation; we can handle DOS line breaks just fine
218
   ourselves.  */
219
static bool
220
open_file (_cpp_file *file)
221
{
222
  if (file->path[0] == '\0')
223
    {
224
      file->fd = 0;
225
      set_stdin_to_binary_mode ();
226
    }
227
  else
228
    file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
229
 
230
  if (file->fd != -1)
231
    {
232
      if (fstat (file->fd, &file->st) == 0)
233
        {
234
          if (!S_ISDIR (file->st.st_mode))
235
            {
236
              file->err_no = 0;
237
              return true;
238
            }
239
 
240
          /* Ignore a directory and continue the search.  The file we're
241
             looking for may be elsewhere in the search path.  */
242
          errno = ENOENT;
243
        }
244
 
245
      close (file->fd);
246
      file->fd = -1;
247
    }
248
#if defined(_WIN32) && !defined(__CYGWIN__)
249
  else if (errno == EACCES)
250
    {
251
      /* On most UNIX systems, open succeeds on a directory.  Above,
252
         we check if we have opened a directory and if so, set errno
253
         to ENOENT.  However, on Windows, opening a directory
254
         fails with EACCES.  We want to return ENOENT in that
255
         case too.  */
256
      if (stat (file->path, &file->st) == 0
257
          && S_ISDIR (file->st.st_mode))
258
        errno = ENOENT;
259
      else
260
        /* The call to stat may have reset errno.  */
261
        errno = EACCES;
262
    }
263
#endif    
264
  else if (errno == ENOTDIR)
265
    errno = ENOENT;
266
 
267
  file->err_no = errno;
268
 
269
  return false;
270
}
271
 
272
/* Temporary PCH intercept of opening a file.  Try to find a PCH file
273
   based on FILE->name and FILE->dir, and test those found for
274
   validity using PFILE->cb.valid_pch.  Return true iff a valid file is
275
   found.  Set *INVALID_PCH if a PCH file is found but wasn't valid.  */
276
 
277
static bool
278
pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
279
{
280
  static const char extension[] = ".gch";
281
  const char *path = file->path;
282
  size_t len, flen;
283
  char *pchname;
284
  struct stat st;
285
  bool valid = false;
286
 
287
  /* No PCH on <stdin> or if not requested.  */
288
  if (file->name[0] == '\0' || !pfile->cb.valid_pch)
289
    return false;
290
 
291
  /* If the file is not included as first include from either the toplevel
292
     file or the command-line it is not a valid use of PCH.  */
293
  if (pfile->all_files
294
      && pfile->all_files->next_file)
295
    return false;
296
 
297
  flen = strlen (path);
298
  len = flen + sizeof (extension);
299
  pchname = XNEWVEC (char, len);
300
  memcpy (pchname, path, flen);
301
  memcpy (pchname + flen, extension, sizeof (extension));
302
 
303
  if (stat (pchname, &st) == 0)
304
    {
305
      DIR *pchdir;
306
      struct dirent *d;
307
      size_t dlen, plen = len;
308
 
309
      if (!S_ISDIR (st.st_mode))
310
        valid = validate_pch (pfile, file, pchname);
311
      else if ((pchdir = opendir (pchname)) != NULL)
312
        {
313
          pchname[plen - 1] = '/';
314
          while ((d = readdir (pchdir)) != NULL)
315
            {
316
              dlen = strlen (d->d_name) + 1;
317
              if ((strcmp (d->d_name, ".") == 0)
318
                  || (strcmp (d->d_name, "..") == 0))
319
                continue;
320
              if (dlen + plen > len)
321
                {
322
                  len += dlen + 64;
323
                  pchname = XRESIZEVEC (char, pchname, len);
324
                }
325
              memcpy (pchname + plen, d->d_name, dlen);
326
              valid = validate_pch (pfile, file, pchname);
327
              if (valid)
328
                break;
329
            }
330
          closedir (pchdir);
331
        }
332
      if (!valid)
333
        *invalid_pch = true;
334
    }
335
 
336
  if (valid)
337
    file->pchname = pchname;
338
  else
339
    free (pchname);
340
 
341
  return valid;
342
}
343
 
344
/* Try to open the path FILE->name appended to FILE->dir.  This is
345
   where remap and PCH intercept the file lookup process.  Return true
346
   if the file was found, whether or not the open was successful.
347
   Set *INVALID_PCH to true if a PCH file is found but wasn't valid.  */
348
 
349
static bool
350
find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
351
{
352
  char *path;
353
 
354
  if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
355
    ;
356
  else
357
    if (file->dir->construct)
358
      path = file->dir->construct (file->name, file->dir);
359
    else
360
      path = append_file_to_dir (file->name, file->dir);
361
 
362
  if (path)
363
    {
364
      hashval_t hv = htab_hash_string (path);
365
      char *copy;
366
      void **pp;
367
 
368
      if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
369
        {
370
          file->err_no = ENOENT;
371
          return false;
372
        }
373
 
374
      file->path = path;
375
      if (pch_open_file (pfile, file, invalid_pch))
376
        return true;
377
 
378
      if (open_file (file))
379
        return true;
380
 
381
      if (file->err_no != ENOENT)
382
        {
383
          open_file_failed (pfile, file, 0);
384
          return true;
385
        }
386
 
387
      /* We copy the path name onto an obstack partly so that we don't
388
         leak the memory, but mostly so that we don't fragment the
389
         heap.  */
390
      copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
391
                                     strlen (path));
392
      free (path);
393
      pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
394
                                     copy, hv, INSERT);
395
      *pp = copy;
396
 
397
      file->path = file->name;
398
    }
399
  else
400
    {
401
      file->err_no = ENOENT;
402
      file->path = NULL;
403
    }
404
 
405
  return false;
406
}
407
 
408
/* Return tue iff the missing_header callback found the given HEADER.  */
409
static bool
410
search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
411
{
412
  missing_header_cb func = pfile->cb.missing_header;
413
 
414
  /* When the regular search path doesn't work, try context dependent
415
     headers search paths.  */
416
  if (func
417
      && file->dir == NULL)
418
    {
419
      if ((file->path = func (pfile, header, &file->dir)) != NULL)
420
        {
421
          if (open_file (file))
422
            return true;
423
          free ((void *)file->path);
424
        }
425
      file->path = file->name;
426
    }
427
 
428
  return false;
429
}
430
 
431
bool
432
_cpp_find_failed (_cpp_file *file)
433
{
434
  return file->err_no != 0;
435
}
436
 
437
/* Given a filename FNAME search for such a file in the include path
438
   starting from START_DIR.  If FNAME is the empty string it is
439
   interpreted as STDIN if START_DIR is PFILE->no_search_path.
440
 
441
   If the file is not found in the file cache fall back to the O/S and
442
   add the result to our cache.
443
 
444
   If the file was not found in the filesystem, or there was an error
445
   opening it, then ERR_NO is nonzero and FD is -1.  If the file was
446
   found, then ERR_NO is zero and FD could be -1 or an open file
447
   descriptor.  FD can be -1 if the file was found in the cache and
448
   had previously been closed.  To open it again pass the return value
449
   to open_file().
450
*/
451
_cpp_file *
452
_cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
453
{
454
  struct file_hash_entry *entry, **hash_slot;
455
  _cpp_file *file;
456
  bool invalid_pch = false;
457
  bool saw_bracket_include = false;
458
  bool saw_quote_include = false;
459
  struct cpp_dir *found_in_cache = NULL;
460
 
461
  /* Ensure we get no confusion between cached files and directories.  */
462
  if (start_dir == NULL)
463
    cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
464
 
465
  hash_slot = (struct file_hash_entry **)
466
    htab_find_slot_with_hash (pfile->file_hash, fname,
467
                              htab_hash_string (fname),
468
                              INSERT);
469
 
470
  /* First check the cache before we resort to memory allocation.  */
471
  entry = search_cache (*hash_slot, start_dir);
472
  if (entry)
473
    return entry->u.file;
474
 
475
  file = make_cpp_file (pfile, start_dir, fname);
476
 
477
  /* Try each path in the include chain.  */
478
  for (; !fake ;)
479
    {
480
      if (find_file_in_dir (pfile, file, &invalid_pch))
481
        break;
482
 
483
      file->dir = file->dir->next;
484
      if (file->dir == NULL)
485
        {
486
          if (search_path_exhausted (pfile, fname, file))
487
            {
488
              /* Although this file must not go in the cache, because
489
                 the file found might depend on things (like the current file)
490
                 that aren't represented in the cache, it still has to go in
491
                 the list of all files so that #import works.  */
492
              file->next_file = pfile->all_files;
493
              pfile->all_files = file;
494
              return file;
495
            }
496
 
497
          if (invalid_pch)
498
            {
499
              cpp_error (pfile, CPP_DL_ERROR,
500
               "one or more PCH files were found, but they were invalid");
501
              if (!cpp_get_options (pfile)->warn_invalid_pch)
502
                cpp_error (pfile, CPP_DL_ERROR,
503
                           "use -Winvalid-pch for more information");
504
            }
505
          open_file_failed (pfile, file, angle_brackets);
506
          break;
507
        }
508
 
509
      /* Only check the cache for the starting location (done above)
510
         and the quote and bracket chain heads because there are no
511
         other possible starting points for searches.  */
512
      if (file->dir == pfile->bracket_include)
513
        saw_bracket_include = true;
514
      else if (file->dir == pfile->quote_include)
515
        saw_quote_include = true;
516
      else
517
        continue;
518
 
519
      entry = search_cache (*hash_slot, file->dir);
520
      if (entry)
521
        {
522
          found_in_cache = file->dir;
523
          break;
524
        }
525
    }
526
 
527
  if (entry)
528
    {
529
      /* Cache for START_DIR too, sharing the _cpp_file structure.  */
530
      free ((char *) file->name);
531
      free (file);
532
      file = entry->u.file;
533
    }
534
  else
535
    {
536
      /* This is a new file; put it in the list.  */
537
      file->next_file = pfile->all_files;
538
      pfile->all_files = file;
539
    }
540
 
541
  /* Store this new result in the hash table.  */
542
  entry = new_file_hash_entry (pfile);
543
  entry->next = *hash_slot;
544
  entry->start_dir = start_dir;
545
  entry->location = pfile->line_table->highest_location;
546
  entry->u.file = file;
547
  *hash_slot = entry;
548
 
549
  /* If we passed the quote or bracket chain heads, cache them also.
550
     This speeds up processing if there are lots of -I options.  */
551
  if (saw_bracket_include
552
      && pfile->bracket_include != start_dir
553
      && found_in_cache != pfile->bracket_include)
554
    {
555
      entry = new_file_hash_entry (pfile);
556
      entry->next = *hash_slot;
557
      entry->start_dir = pfile->bracket_include;
558
      entry->location = pfile->line_table->highest_location;
559
      entry->u.file = file;
560
      *hash_slot = entry;
561
    }
562
  if (saw_quote_include
563
      && pfile->quote_include != start_dir
564
      && found_in_cache != pfile->quote_include)
565
    {
566
      entry = new_file_hash_entry (pfile);
567
      entry->next = *hash_slot;
568
      entry->start_dir = pfile->quote_include;
569
      entry->location = pfile->line_table->highest_location;
570
      entry->u.file = file;
571
      *hash_slot = entry;
572
    }
573
 
574
  return file;
575
}
576
 
577
/* Read a file into FILE->buffer, returning true on success.
578
 
579
   If FILE->fd is something weird, like a block device, we don't want
580
   to read it at all.  Don't even try to figure out what something is,
581
   except for plain files and block devices, since there is no
582
   reliable portable way of doing this.
583
 
584
   FIXME: Flush file cache and try again if we run out of memory.  */
585
static bool
586
read_file_guts (cpp_reader *pfile, _cpp_file *file)
587
{
588
  ssize_t size, total, count;
589
  uchar *buf;
590
  bool regular;
591
 
592
  if (S_ISBLK (file->st.st_mode))
593
    {
594
      cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
595
      return false;
596
    }
597
 
598
  regular = S_ISREG (file->st.st_mode);
599
  if (regular)
600
    {
601
      /* off_t might have a wider range than ssize_t - in other words,
602
         the max size of a file might be bigger than the address
603
         space.  We can't handle a file that large.  (Anyone with
604
         a single source file bigger than 2GB needs to rethink
605
         their coding style.)  Some systems (e.g. AIX 4.1) define
606
         SSIZE_MAX to be much smaller than the actual range of the
607
         type.  Use INTTYPE_MAXIMUM unconditionally to ensure this
608
         does not bite us.  */
609
      if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
610
        {
611
          cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
612
          return false;
613
        }
614
 
615
      size = file->st.st_size;
616
    }
617
  else
618
    /* 8 kilobytes is a sensible starting size.  It ought to be bigger
619
       than the kernel pipe buffer, and it's definitely bigger than
620
       the majority of C source files.  */
621
    size = 8 * 1024;
622
 
623
  buf = XNEWVEC (uchar, size + 1);
624
  total = 0;
625
  while ((count = read (file->fd, buf + total, size - total)) > 0)
626
    {
627
      total += count;
628
 
629
      if (total == size)
630
        {
631
          if (regular)
632
            break;
633
          size *= 2;
634
          buf = XRESIZEVEC (uchar, buf, size + 1);
635
        }
636
    }
637
 
638
  if (count < 0)
639
    {
640
      cpp_errno (pfile, CPP_DL_ERROR, file->path);
641
      return false;
642
    }
643
 
644
  if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
645
    cpp_error (pfile, CPP_DL_WARNING,
646
               "%s is shorter than expected", file->path);
647
 
648
  file->buffer = _cpp_convert_input (pfile,
649
                                     CPP_OPTION (pfile, input_charset),
650
                                     buf, size, total,
651
                                     &file->buffer_start,
652
                                     &file->st.st_size);
653
  file->buffer_valid = true;
654
 
655
  return true;
656
}
657
 
658
/* Convenience wrapper around read_file_guts that opens the file if
659
   necessary and closes the file descriptor after reading.  FILE must
660
   have been passed through find_file() at some stage.  */
661
static bool
662
read_file (cpp_reader *pfile, _cpp_file *file)
663
{
664
  /* If we already have its contents in memory, succeed immediately.  */
665
  if (file->buffer_valid)
666
    return true;
667
 
668
  /* If an earlier read failed for some reason don't try again.  */
669
  if (file->dont_read || file->err_no)
670
    return false;
671
 
672
  if (file->fd == -1 && !open_file (file))
673
    {
674
      open_file_failed (pfile, file, 0);
675
      return false;
676
    }
677
 
678
  file->dont_read = !read_file_guts (pfile, file);
679
  close (file->fd);
680
  file->fd = -1;
681
 
682
  return !file->dont_read;
683
}
684
 
685
/* Returns TRUE if FILE's contents have been successfully placed in
686
   FILE->buffer and the file should be stacked, otherwise false.  */
687
static bool
688
should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
689
{
690
  _cpp_file *f;
691
 
692
  /* Skip once-only files.  */
693
  if (file->once_only)
694
    return false;
695
 
696
  /* We must mark the file once-only if #import now, before header
697
     guard checks.  Otherwise, undefining the header guard might
698
     cause the file to be re-stacked.  */
699
  if (import)
700
    {
701
      _cpp_mark_file_once_only (pfile, file);
702
 
703
      /* Don't stack files that have been stacked before.  */
704
      if (file->stack_count)
705
        return false;
706
    }
707
 
708
  /* Skip if the file had a header guard and the macro is defined.
709
     PCH relies on this appearing before the PCH handler below.  */
710
  if (file->cmacro && file->cmacro->type == NT_MACRO)
711
    return false;
712
 
713
  /* Handle PCH files immediately; don't stack them.  */
714
  if (file->pchname)
715
    {
716
      pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
717
      file->fd = -1;
718
      free ((void *) file->pchname);
719
      file->pchname = NULL;
720
      return false;
721
    }
722
 
723
  if (!read_file (pfile, file))
724
    return false;
725
 
726
  /* Check the file against the PCH file.  This is done before
727
     checking against files we've already seen, since it may save on
728
     I/O.  */
729
  if (check_file_against_entries (pfile, file, import))
730
    {
731
      /* If this isn't a #import, but yet we can't include the file,
732
         that means that it was #import-ed in the PCH file,
733
         so we can never include it again.  */
734
      if (! import)
735
        _cpp_mark_file_once_only (pfile, file);
736
      return false;
737
    }
738
 
739
  /* Now we've read the file's contents, we can stack it if there
740
     are no once-only files.  */
741
  if (!pfile->seen_once_only)
742
    return true;
743
 
744
  /* We may have read the file under a different name.  Look
745
     for likely candidates and compare file contents to be sure.  */
746
  for (f = pfile->all_files; f; f = f->next_file)
747
    {
748
      if (f == file)
749
        continue;
750
 
751
      if ((import || f->once_only)
752
          && f->err_no == 0
753
          && f->st.st_mtime == file->st.st_mtime
754
          && f->st.st_size == file->st.st_size)
755
        {
756
          _cpp_file *ref_file;
757
          bool same_file_p = false;
758
 
759
          if (f->buffer && !f->buffer_valid)
760
            {
761
              /* We already have a buffer but it is not valid, because
762
                 the file is still stacked.  Make a new one.  */
763
              ref_file = make_cpp_file (pfile, f->dir, f->name);
764
              ref_file->path = f->path;
765
            }
766
          else
767
            /* The file is not stacked anymore.  We can reuse it.  */
768
            ref_file = f;
769
 
770
          same_file_p = read_file (pfile, ref_file)
771
                        /* Size might have changed in read_file().  */
772
                        && ref_file->st.st_size == file->st.st_size
773
                        && !memcmp (ref_file->buffer,
774
                                    file->buffer,
775
                                    file->st.st_size);
776
 
777
          if (f->buffer && !f->buffer_valid)
778
            {
779
              ref_file->path = 0;
780
              destroy_cpp_file (ref_file);
781
            }
782
 
783
          if (same_file_p)
784
            break;
785
        }
786
    }
787
 
788
  return f == NULL;
789
}
790
 
791
/* Place the file referenced by FILE into a new buffer on the buffer
792
   stack if possible.  IMPORT is true if this stacking attempt is
793
   because of a #import directive.  Returns true if a buffer is
794
   stacked.  */
795
bool
796
_cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
797
{
798
  cpp_buffer *buffer;
799
  int sysp;
800
 
801
  if (!should_stack_file (pfile, file, import))
802
      return false;
803
 
804
  if (pfile->buffer == NULL || file->dir == NULL)
805
    sysp = 0;
806
  else
807
    sysp = MAX (pfile->buffer->sysp,  file->dir->sysp);
808
 
809
  /* Add the file to the dependencies on its first inclusion.  */
810
  if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
811
    {
812
      if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
813
        deps_add_dep (pfile->deps, file->path);
814
    }
815
 
816
  /* Clear buffer_valid since _cpp_clean_line messes it up.  */
817
  file->buffer_valid = false;
818
  file->stack_count++;
819
 
820
  /* Stack the buffer.  */
821
  buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
822
                            CPP_OPTION (pfile, preprocessed)
823
                            && !CPP_OPTION (pfile, directives_only));
824
  buffer->file = file;
825
  buffer->sysp = sysp;
826
 
827
  /* Initialize controlling macro state.  */
828
  pfile->mi_valid = true;
829
  pfile->mi_cmacro = 0;
830
 
831
  /* Generate the call back.  */
832
  _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
833
 
834
  return true;
835
}
836
 
837
/* Mark FILE to be included once only.  */
838
void
839
_cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
840
{
841
  pfile->seen_once_only = true;
842
  file->once_only = true;
843
}
844
 
845
/* Return the directory from which searching for FNAME should start,
846
   considering the directive TYPE and ANGLE_BRACKETS.  If there is
847
   nothing left in the path, returns NULL.  */
848
static struct cpp_dir *
849
search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
850
                  enum include_type type)
851
{
852
  cpp_dir *dir;
853
  _cpp_file *file;
854
 
855
  if (IS_ABSOLUTE_PATH (fname))
856
    return &pfile->no_search_path;
857
 
858
  /* pfile->buffer is NULL when processing an -include command-line flag.  */
859
  file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
860
 
861
  /* For #include_next, skip in the search path past the dir in which
862
     the current file was found, but if it was found via an absolute
863
     path use the normal search logic.  */
864
  if (type == IT_INCLUDE_NEXT && file->dir
865
      && file->dir != &pfile->no_search_path)
866
    dir = file->dir->next;
867
  else if (angle_brackets)
868
    dir = pfile->bracket_include;
869
  else if (type == IT_CMDLINE)
870
    /* -include and -imacros use the #include "" chain with the
871
       preprocessor's cwd prepended.  */
872
    return make_cpp_dir (pfile, "./", false);
873
  else if (pfile->quote_ignores_source_dir)
874
    dir = pfile->quote_include;
875
  else
876
    return make_cpp_dir (pfile, dir_name_of_file (file),
877
                         pfile->buffer ? pfile->buffer->sysp : 0);
878
 
879
  if (dir == NULL)
880
    cpp_error (pfile, CPP_DL_ERROR,
881
               "no include path in which to search for %s", fname);
882
 
883
  return dir;
884
}
885
 
886
/* Strip the basename from the file's path.  It ends with a slash if
887
   of nonzero length.  Note that this procedure also works for
888
   <stdin>, which is represented by the empty string.  */
889
static const char *
890
dir_name_of_file (_cpp_file *file)
891
{
892
  if (!file->dir_name)
893
    {
894
      size_t len = lbasename (file->path) - file->path;
895
      char *dir_name = XNEWVEC (char, len + 1);
896
 
897
      memcpy (dir_name, file->path, len);
898
      dir_name[len] = '\0';
899
      file->dir_name = dir_name;
900
    }
901
 
902
  return file->dir_name;
903
}
904
 
905
/* Handles #include-family directives (distinguished by TYPE),
906
   including HEADER, and the command line -imacros and -include.
907
   Returns true if a buffer was stacked.  */
908
bool
909
_cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
910
                    enum include_type type)
911
{
912
  struct cpp_dir *dir;
913
  _cpp_file *file;
914
 
915
  dir = search_path_head (pfile, fname, angle_brackets, type);
916
  if (!dir)
917
    return false;
918
 
919
  file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
920
 
921
  /* Compensate for the increment in linemap_add that occurs in
922
     _cpp_stack_file.  In the case of a normal #include, we're
923
     currently at the start of the line *following* the #include.  A
924
     separate source_location for this location makes no sense (until
925
     we do the LC_LEAVE), and complicates LAST_SOURCE_LINE_LOCATION.
926
     This does not apply if we found a PCH file (in which case
927
     linemap_add is not called) or we were included from the
928
     command-line.  */
929
  if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
930
    pfile->line_table->highest_location--;
931
 
932
  return _cpp_stack_file (pfile, file, type == IT_IMPORT);
933
}
934
 
935
/* Could not open FILE.  The complication is dependency output.  */
936
static void
937
open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
938
{
939
  int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
940
  bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
941
 
942
  errno = file->err_no;
943
  if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
944
    {
945
      deps_add_dep (pfile->deps, file->name);
946
      /* If the preprocessor output (other than dependency information) is
947
         being used, we must also flag an error.  */
948
      if (CPP_OPTION (pfile, deps.need_preprocessor_output))
949
        cpp_errno (pfile, CPP_DL_FATAL, file->path);
950
    }
951
  else
952
    {
953
      /* If we are not outputting dependencies, or if we are and dependencies
954
         were requested for this file, or if preprocessor output is needed
955
         in addition to dependency information, this is an error.
956
 
957
         Otherwise (outputting dependencies but not for this file, and not
958
         using the preprocessor output), we can still produce correct output
959
         so it's only a warning.  */
960
      if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
961
          || print_dep
962
          || CPP_OPTION (pfile, deps.need_preprocessor_output))
963
        cpp_errno (pfile, CPP_DL_FATAL, file->path);
964
      else
965
        cpp_errno (pfile, CPP_DL_WARNING, file->path);
966
    }
967
}
968
 
969
/* Search in the chain beginning at HEAD for a file whose search path
970
   started at START_DIR != NULL.  */
971
static struct file_hash_entry *
972
search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
973
{
974
  while (head && head->start_dir != start_dir)
975
    head = head->next;
976
 
977
  return head;
978
}
979
 
980
/* Allocate a new _cpp_file structure.  */
981
static _cpp_file *
982
make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
983
{
984
  _cpp_file *file;
985
 
986
  file = XCNEW (_cpp_file);
987
  file->main_file = !pfile->buffer;
988
  file->fd = -1;
989
  file->dir = dir;
990
  file->name = xstrdup (fname);
991
 
992
  return file;
993
}
994
 
995
/* Release a _cpp_file structure.  */
996
static void
997
destroy_cpp_file (_cpp_file *file)
998
{
999
  if (file->buffer_start)
1000
    free ((void *) file->buffer_start);
1001
  free ((void *) file->name);
1002
  free (file);
1003
}
1004
 
1005
/* Release all the files allocated by this reader.  */
1006
static void
1007
destroy_all_cpp_files (cpp_reader *pfile)
1008
{
1009
  _cpp_file *iter = pfile->all_files;
1010
  while (iter)
1011
    {
1012
      _cpp_file *next = iter->next_file;
1013
      destroy_cpp_file (iter);
1014
      iter = next;
1015
    }
1016
}
1017
 
1018
/* A hash of directory names.  The directory names are the path names
1019
   of files which contain a #include "", the included file name is
1020
   appended to this directories.
1021
 
1022
   To avoid duplicate entries we follow the convention that all
1023
   non-empty directory names should end in a '/'.  DIR_NAME must be
1024
   stored in permanently allocated memory.  */
1025
static cpp_dir *
1026
make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1027
{
1028
  struct file_hash_entry *entry, **hash_slot;
1029
  cpp_dir *dir;
1030
 
1031
  hash_slot = (struct file_hash_entry **)
1032
    htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1033
                              htab_hash_string (dir_name),
1034
                              INSERT);
1035
 
1036
  /* Have we already hashed this directory?  */
1037
  for (entry = *hash_slot; entry; entry = entry->next)
1038
    if (entry->start_dir == NULL)
1039
      return entry->u.dir;
1040
 
1041
  dir = XCNEW (cpp_dir);
1042
  dir->next = pfile->quote_include;
1043
  dir->name = (char *) dir_name;
1044
  dir->len = strlen (dir_name);
1045
  dir->sysp = sysp;
1046
  dir->construct = 0;
1047
 
1048
  /* Store this new result in the hash table.  */
1049
  entry = new_file_hash_entry (pfile);
1050
  entry->next = *hash_slot;
1051
  entry->start_dir = NULL;
1052
  entry->location = pfile->line_table->highest_location;
1053
  entry->u.dir = dir;
1054
  *hash_slot = entry;
1055
 
1056
  return dir;
1057
}
1058
 
1059
/* Create a new block of memory for file hash entries.  */
1060
static void
1061
allocate_file_hash_entries (cpp_reader *pfile)
1062
{
1063
  struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1064
  pool->file_hash_entries_used = 0;
1065
  pool->next = pfile->file_hash_entries;
1066
  pfile->file_hash_entries = pool;
1067
}
1068
 
1069
/* Return a new file hash entry.  */
1070
static struct file_hash_entry *
1071
new_file_hash_entry (cpp_reader *pfile)
1072
{
1073
  unsigned int idx;
1074
  if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1075
    allocate_file_hash_entries (pfile);
1076
 
1077
  idx = pfile->file_hash_entries->file_hash_entries_used++;
1078
  return &pfile->file_hash_entries->pool[idx];
1079
}
1080
 
1081
/* Free the file hash entry pools.  */
1082
static void
1083
free_file_hash_entries (cpp_reader *pfile)
1084
{
1085
  struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1086
  while (iter)
1087
    {
1088
      struct file_hash_entry_pool *next = iter->next;
1089
      free (iter);
1090
      iter = next;
1091
    }
1092
}
1093
 
1094
/* Returns TRUE if a file FNAME has ever been successfully opened.
1095
   This routine is not intended to correctly handle filenames aliased
1096
   by links or redundant . or .. traversals etc.  */
1097
bool
1098
cpp_included (cpp_reader *pfile, const char *fname)
1099
{
1100
  struct file_hash_entry *entry;
1101
 
1102
  entry = (struct file_hash_entry *)
1103
     htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1104
 
1105
  while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1106
    entry = entry->next;
1107
 
1108
  return entry != NULL;
1109
}
1110
 
1111
/* Returns TRUE if a file FNAME has ever been successfully opened
1112
   before LOCATION.  This routine is not intended to correctly handle
1113
   filenames aliased by links or redundant . or .. traversals etc.  */
1114
bool
1115
cpp_included_before (cpp_reader *pfile, const char *fname,
1116
                     source_location location)
1117
{
1118
  struct file_hash_entry *entry;
1119
 
1120
  entry = (struct file_hash_entry *)
1121
     htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1122
 
1123
  while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1124
                   || entry->location > location))
1125
    entry = entry->next;
1126
 
1127
  return entry != NULL;
1128
}
1129
 
1130
/* Calculate the hash value of a file hash entry P.  */
1131
 
1132
static hashval_t
1133
file_hash_hash (const void *p)
1134
{
1135
  struct file_hash_entry *entry = (struct file_hash_entry *) p;
1136
  const char *hname;
1137
  if (entry->start_dir)
1138
    hname = entry->u.file->name;
1139
  else
1140
    hname = entry->u.dir->name;
1141
 
1142
  return htab_hash_string (hname);
1143
}
1144
 
1145
/* Compare a string Q against a file hash entry P.  */
1146
static int
1147
file_hash_eq (const void *p, const void *q)
1148
{
1149
  struct file_hash_entry *entry = (struct file_hash_entry *) p;
1150
  const char *fname = (const char *) q;
1151
  const char *hname;
1152
 
1153
  if (entry->start_dir)
1154
    hname = entry->u.file->name;
1155
  else
1156
    hname = entry->u.dir->name;
1157
 
1158
  return strcmp (hname, fname) == 0;
1159
}
1160
 
1161
/* Compare entries in the nonexistent file hash table.  These are just
1162
   strings.  */
1163
static int
1164
nonexistent_file_hash_eq (const void *p, const void *q)
1165
{
1166
  return strcmp ((const char *) p, (const char *) q) == 0;
1167
}
1168
 
1169
/* Initialize everything in this source file.  */
1170
void
1171
_cpp_init_files (cpp_reader *pfile)
1172
{
1173
  pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1174
                                        NULL, xcalloc, free);
1175
  pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1176
                                        NULL, xcalloc, free);
1177
  allocate_file_hash_entries (pfile);
1178
  pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1179
                                                    nonexistent_file_hash_eq,
1180
                                                    NULL, xcalloc, free);
1181
  _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1182
                  (void *(*) (long)) xmalloc,
1183
                  (void (*) (void *)) free);
1184
}
1185
 
1186
/* Finalize everything in this source file.  */
1187
void
1188
_cpp_cleanup_files (cpp_reader *pfile)
1189
{
1190
  htab_delete (pfile->file_hash);
1191
  htab_delete (pfile->dir_hash);
1192
  htab_delete (pfile->nonexistent_file_hash);
1193
  obstack_free (&pfile->nonexistent_file_ob, 0);
1194
  free_file_hash_entries (pfile);
1195
  destroy_all_cpp_files (pfile);
1196
}
1197
 
1198
/* Make the parser forget about files it has seen.  This can be useful
1199
   for resetting the parser to start another run.  */
1200
void
1201
cpp_clear_file_cache (cpp_reader *pfile)
1202
{
1203
  _cpp_cleanup_files (pfile);
1204
  pfile->file_hash_entries = NULL;
1205
  pfile->all_files = NULL;
1206
  _cpp_init_files (pfile);
1207
}
1208
 
1209
/* Enter a file name in the hash for the sake of cpp_included.  */
1210
void
1211
_cpp_fake_include (cpp_reader *pfile, const char *fname)
1212
{
1213
  _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1214
}
1215
 
1216
/* Not everyone who wants to set system-header-ness on a buffer can
1217
   see the details of a buffer.  This is an exported interface because
1218
   fix-header needs it.  */
1219
void
1220
cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1221
{
1222
  int flags = 0;
1223
  const struct line_maps *line_table = pfile->line_table;
1224
  const struct line_map *map = &line_table->maps[line_table->used-1];
1225
 
1226
  /* 1 = system header, 2 = system header to be treated as C.  */
1227
  if (syshdr)
1228
    flags = 1 + (externc != 0);
1229
  pfile->buffer->sysp = flags;
1230
  _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1231
                       SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1232
}
1233
 
1234
/* Allow the client to change the current file.  Used by the front end
1235
   to achieve pseudo-file names like <built-in>.
1236
   If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1237
void
1238
cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1239
                 const char *new_name)
1240
{
1241
  _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1242
}
1243
 
1244
struct report_missing_guard_data
1245
{
1246
  const char **paths;
1247
  size_t count;
1248
};
1249
 
1250
/* Callback function for htab_traverse.  */
1251
static int
1252
report_missing_guard (void **slot, void *d)
1253
{
1254
  struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1255
  struct report_missing_guard_data *data
1256
    = (struct report_missing_guard_data *) d;
1257
 
1258
  /* Skip directories.  */
1259
  if (entry->start_dir != NULL)
1260
    {
1261
      _cpp_file *file = entry->u.file;
1262
 
1263
      /* We don't want MI guard advice for the main file.  */
1264
      if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1265
        {
1266
          if (data->paths == NULL)
1267
            {
1268
              data->paths = XCNEWVEC (const char *, data->count);
1269
              data->count = 0;
1270
            }
1271
 
1272
          data->paths[data->count++] = file->path;
1273
        }
1274
    }
1275
 
1276
  /* Keep traversing the hash table.  */
1277
  return 1;
1278
}
1279
 
1280
/* Comparison function for qsort.  */
1281
static int
1282
report_missing_guard_cmp (const void *p1, const void *p2)
1283
{
1284
  return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1285
}
1286
 
1287
/* Report on all files that might benefit from a multiple include guard.
1288
   Triggered by -H.  */
1289
void
1290
_cpp_report_missing_guards (cpp_reader *pfile)
1291
{
1292
  struct report_missing_guard_data data;
1293
 
1294
  data.paths = NULL;
1295
  data.count = htab_elements (pfile->file_hash);
1296
  htab_traverse (pfile->file_hash, report_missing_guard, &data);
1297
 
1298
  if (data.paths != NULL)
1299
    {
1300
      size_t i;
1301
 
1302
      /* Sort the paths to avoid outputting them in hash table
1303
         order.  */
1304
      qsort (data.paths, data.count, sizeof (const char *),
1305
             report_missing_guard_cmp);
1306
      fputs (_("Multiple include guards may be useful for:\n"),
1307
             stderr);
1308
      for (i = 0; i < data.count; i++)
1309
        {
1310
          fputs (data.paths[i], stderr);
1311
          putc ('\n', stderr);
1312
        }
1313
      free (data.paths);
1314
    }
1315
}
1316
 
1317
/* Locate HEADER, and determine whether it is newer than the current
1318
   file.  If it cannot be located or dated, return -1, if it is
1319
   newer, return 1, otherwise 0.  */
1320
int
1321
_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1322
                        int angle_brackets)
1323
{
1324
  _cpp_file *file;
1325
  struct cpp_dir *dir;
1326
 
1327
  dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1328
  if (!dir)
1329
    return -1;
1330
 
1331
  file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1332
  if (file->err_no)
1333
    return -1;
1334
 
1335
  if (file->fd != -1)
1336
    {
1337
      close (file->fd);
1338
      file->fd = -1;
1339
    }
1340
 
1341
  return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1342
}
1343
 
1344
/* Pushes the given file onto the buffer stack.  Returns nonzero if
1345
   successful.  */
1346
bool
1347
cpp_push_include (cpp_reader *pfile, const char *fname)
1348
{
1349
  return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1350
}
1351
 
1352
/* Do appropriate cleanup when a file INC's buffer is popped off the
1353
   input stack.  */
1354
void
1355
_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1356
{
1357
  /* Record the inclusion-preventing macro, which could be NULL
1358
     meaning no controlling macro.  */
1359
  if (pfile->mi_valid && file->cmacro == NULL)
1360
    file->cmacro = pfile->mi_cmacro;
1361
 
1362
  /* Invalidate control macros in the #including file.  */
1363
  pfile->mi_valid = false;
1364
 
1365
  if (file->buffer_start)
1366
    {
1367
      free ((void *) file->buffer_start);
1368
      file->buffer_start = NULL;
1369
      file->buffer = NULL;
1370
      file->buffer_valid = false;
1371
    }
1372
}
1373
 
1374
/* Inteface to file statistics record in _cpp_file structure. */
1375
struct stat *
1376
_cpp_get_file_stat (_cpp_file *file)
1377
{
1378
    return &file->st;
1379
}
1380
 
1381
/* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1382
   QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1383
   directory of the including file.
1384
 
1385
   If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1386
void
1387
cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1388
                        int quote_ignores_source_dir)
1389
{
1390
  pfile->quote_include = quote;
1391
  pfile->bracket_include = quote;
1392
  pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1393
 
1394
  for (; quote; quote = quote->next)
1395
    {
1396
      quote->name_map = NULL;
1397
      quote->len = strlen (quote->name);
1398
      if (quote == bracket)
1399
        pfile->bracket_include = bracket;
1400
    }
1401
}
1402
 
1403
/* Append the file name to the directory to create the path, but don't
1404
   turn / into // or // into ///; // may be a namespace escape.  */
1405
static char *
1406
append_file_to_dir (const char *fname, cpp_dir *dir)
1407
{
1408
  size_t dlen, flen;
1409
  char *path;
1410
 
1411
  dlen = dir->len;
1412
  flen = strlen (fname);
1413
  path = XNEWVEC (char, dlen + 1 + flen + 1);
1414
  memcpy (path, dir->name, dlen);
1415
  if (dlen && path[dlen - 1] != '/')
1416
    path[dlen++] = '/';
1417
  memcpy (&path[dlen], fname, flen + 1);
1418
 
1419
  return path;
1420
}
1421
 
1422
/* Read a space delimited string of unlimited length from a stdio
1423
   file F.  */
1424
static char *
1425
read_filename_string (int ch, FILE *f)
1426
{
1427
  char *alloc, *set;
1428
  int len;
1429
 
1430
  len = 20;
1431
  set = alloc = XNEWVEC (char, len + 1);
1432
  if (! is_space (ch))
1433
    {
1434
      *set++ = ch;
1435
      while ((ch = getc (f)) != EOF && ! is_space (ch))
1436
        {
1437
          if (set - alloc == len)
1438
            {
1439
              len *= 2;
1440
              alloc = XRESIZEVEC (char, alloc, len + 1);
1441
              set = alloc + len / 2;
1442
            }
1443
          *set++ = ch;
1444
        }
1445
    }
1446
  *set = '\0';
1447
  ungetc (ch, f);
1448
  return alloc;
1449
}
1450
 
1451
/* Read the file name map file for DIR.  */
1452
static void
1453
read_name_map (cpp_dir *dir)
1454
{
1455
  static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1456
  char *name;
1457
  FILE *f;
1458
  size_t len, count = 0, room = 9;
1459
 
1460
  len = dir->len;
1461
  name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1462
  memcpy (name, dir->name, len);
1463
  if (len && name[len - 1] != '/')
1464
    name[len++] = '/';
1465
  strcpy (name + len, FILE_NAME_MAP_FILE);
1466
  f = fopen (name, "r");
1467
 
1468
  dir->name_map = XNEWVEC (const char *, room);
1469
 
1470
  /* Silently return NULL if we cannot open.  */
1471
  if (f)
1472
    {
1473
      int ch;
1474
 
1475
      while ((ch = getc (f)) != EOF)
1476
        {
1477
          char *to;
1478
 
1479
          if (is_space (ch))
1480
            continue;
1481
 
1482
          if (count + 2 > room)
1483
            {
1484
              room += 8;
1485
              dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1486
            }
1487
 
1488
          dir->name_map[count] = read_filename_string (ch, f);
1489
          while ((ch = getc (f)) != EOF && is_hspace (ch))
1490
            ;
1491
 
1492
          to = read_filename_string (ch, f);
1493
          if (IS_ABSOLUTE_PATH (to))
1494
            dir->name_map[count + 1] = to;
1495
          else
1496
            {
1497
              dir->name_map[count + 1] = append_file_to_dir (to, dir);
1498
              free (to);
1499
            }
1500
 
1501
          count += 2;
1502
          while ((ch = getc (f)) != '\n')
1503
            if (ch == EOF)
1504
              break;
1505
        }
1506
 
1507
      fclose (f);
1508
    }
1509
 
1510
  /* Terminate the list of maps.  */
1511
  dir->name_map[count] = NULL;
1512
}
1513
 
1514
/* Remap a FILE's name based on the file_name_map, if any, for
1515
   FILE->dir.  If the file name has any directory separators,
1516
   recursively check those directories too.  */
1517
static char *
1518
remap_filename (cpp_reader *pfile, _cpp_file *file)
1519
{
1520
  const char *fname, *p;
1521
  char *new_dir;
1522
  cpp_dir *dir;
1523
  size_t index, len;
1524
 
1525
  dir = file->dir;
1526
  fname = file->name;
1527
 
1528
  for (;;)
1529
    {
1530
      if (!dir->name_map)
1531
        read_name_map (dir);
1532
 
1533
      for (index = 0; dir->name_map[index]; index += 2)
1534
        if (!strcmp (dir->name_map[index], fname))
1535
            return xstrdup (dir->name_map[index + 1]);
1536
 
1537
      p = strchr (fname, '/');
1538
      if (!p || p == fname)
1539
        return NULL;
1540
 
1541
      len = dir->len + (p - fname + 1);
1542
      new_dir = XNEWVEC (char, len + 1);
1543
      memcpy (new_dir, dir->name, dir->len);
1544
      memcpy (new_dir + dir->len, fname, p - fname + 1);
1545
      new_dir[len] = '\0';
1546
 
1547
      dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1548
      fname = p + 1;
1549
    }
1550
}
1551
 
1552
/* Returns true if PCHNAME is a valid PCH file for FILE.  */
1553
static bool
1554
validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1555
{
1556
  const char *saved_path = file->path;
1557
  bool valid = false;
1558
 
1559
  file->path = pchname;
1560
  if (open_file (file))
1561
    {
1562
      valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1563
 
1564
      if (!valid)
1565
        {
1566
          close (file->fd);
1567
          file->fd = -1;
1568
        }
1569
 
1570
      if (CPP_OPTION (pfile, print_include_names))
1571
        {
1572
          unsigned int i;
1573
          for (i = 1; i < pfile->line_table->depth; i++)
1574
            putc ('.', stderr);
1575
          fprintf (stderr, "%c %s\n",
1576
                   valid ? '!' : 'x', pchname);
1577
        }
1578
    }
1579
 
1580
  file->path = saved_path;
1581
  return valid;
1582
}
1583
 
1584
/* Get the path associated with the _cpp_file F.  The path includes
1585
   the base name from the include directive and the directory it was
1586
   found in via the search path.  */
1587
 
1588
const char *
1589
cpp_get_path (struct _cpp_file *f)
1590
{
1591
  return f->path;
1592
}
1593
 
1594
/* Get the directory associated with the _cpp_file F.  */
1595
 
1596
cpp_dir *
1597
cpp_get_dir (struct _cpp_file *f)
1598
{
1599
  return f->dir;
1600
}
1601
 
1602
/* Get the cpp_buffer currently associated with the cpp_reader
1603
   PFILE.  */
1604
 
1605
cpp_buffer *
1606
cpp_get_buffer (cpp_reader *pfile)
1607
{
1608
  return pfile->buffer;
1609
}
1610
 
1611
/* Get the _cpp_file associated with the cpp_buffer B.  */
1612
 
1613
_cpp_file *
1614
cpp_get_file (cpp_buffer *b)
1615
{
1616
  return b->file;
1617
}
1618
 
1619
/* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1620
   buffer is the buffer that included the given buffer.  */
1621
 
1622
cpp_buffer *
1623
cpp_get_prev (cpp_buffer *b)
1624
{
1625
  return b->prev;
1626
}
1627
 
1628
/* This data structure holds the list of header files that were seen
1629
   while the PCH was being built.  The 'entries' field is kept sorted
1630
   in memcmp() order; yes, this means that on little-endian systems,
1631
   it's sorted initially by the least-significant byte of 'size', but
1632
   that's OK.  The code does rely on having entries with the same size
1633
   next to each other.  */
1634
 
1635
struct pchf_entry {
1636
  /* The size of this file.  This is used to save running a MD5 checksum
1637
     if the sizes don't match.  */
1638
  off_t size;
1639
  /* The MD5 checksum of this file.  */
1640
  unsigned char sum[16];
1641
  /* Is this file to be included only once?  */
1642
  bool once_only;
1643
};
1644
 
1645
struct pchf_data {
1646
  /* Number of pchf_entry structures.  */
1647
  size_t count;
1648
 
1649
  /* Are there any values with once_only set?
1650
     This is used as an optimisation, it means we don't have to search
1651
     the structure if we're processing a regular #include.  */
1652
  bool have_once_only;
1653
 
1654
  struct pchf_entry entries[1];
1655
};
1656
 
1657
static struct pchf_data *pchf;
1658
 
1659
/* A qsort ordering function for pchf_entry structures.  */
1660
 
1661
static int
1662
pchf_save_compare (const void *e1, const void *e2)
1663
{
1664
  return memcmp (e1, e2, sizeof (struct pchf_entry));
1665
}
1666
 
1667
/* Create and write to F a pchf_data structure.  */
1668
 
1669
bool
1670
_cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1671
{
1672
  size_t count = 0;
1673
  struct pchf_data *result;
1674
  size_t result_size;
1675
  _cpp_file *f;
1676
 
1677
  for (f = pfile->all_files; f; f = f->next_file)
1678
    ++count;
1679
 
1680
  result_size = (sizeof (struct pchf_data)
1681
                 + sizeof (struct pchf_entry) * (count - 1));
1682
  result = XCNEWVAR (struct pchf_data, result_size);
1683
 
1684
  result->count = 0;
1685
  result->have_once_only = false;
1686
 
1687
  for (f = pfile->all_files; f; f = f->next_file)
1688
    {
1689
      size_t count;
1690
 
1691
      /* This should probably never happen, since if a read error occurred
1692
         the PCH file shouldn't be written...  */
1693
      if (f->dont_read || f->err_no)
1694
        continue;
1695
 
1696
      if (f->stack_count == 0)
1697
        continue;
1698
 
1699
      count = result->count++;
1700
 
1701
      result->entries[count].once_only = f->once_only;
1702
      /* |= is avoided in the next line because of an HP C compiler bug */
1703
      result->have_once_only = result->have_once_only | f->once_only;
1704
      if (f->buffer_valid)
1705
        md5_buffer ((const char *)f->buffer,
1706
                    f->st.st_size, result->entries[count].sum);
1707
      else
1708
        {
1709
          FILE *ff;
1710
          int oldfd = f->fd;
1711
 
1712
          if (!open_file (f))
1713
            {
1714
              open_file_failed (pfile, f, 0);
1715
              return false;
1716
            }
1717
          ff = fdopen (f->fd, "rb");
1718
          md5_stream (ff, result->entries[count].sum);
1719
          fclose (ff);
1720
          f->fd = oldfd;
1721
        }
1722
      result->entries[count].size = f->st.st_size;
1723
    }
1724
 
1725
  result_size = (sizeof (struct pchf_data)
1726
                 + sizeof (struct pchf_entry) * (result->count - 1));
1727
 
1728
  qsort (result->entries, result->count, sizeof (struct pchf_entry),
1729
         pchf_save_compare);
1730
 
1731
  return fwrite (result, result_size, 1, fp) == 1;
1732
}
1733
 
1734
/* Read the pchf_data structure from F.  */
1735
 
1736
bool
1737
_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1738
{
1739
  struct pchf_data d;
1740
 
1741
  if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1742
       != 1)
1743
    return false;
1744
 
1745
  pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1746
                  + sizeof (struct pchf_entry) * (d.count - 1));
1747
  memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1748
  if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1749
      != d.count)
1750
    return false;
1751
  return true;
1752
}
1753
 
1754
/* The parameters for pchf_compare.  */
1755
 
1756
struct pchf_compare_data
1757
{
1758
  /* The size of the file we're looking for.  */
1759
  off_t size;
1760
 
1761
  /* The MD5 checksum of the file, if it's been computed.  */
1762
  unsigned char sum[16];
1763
 
1764
  /* Is SUM valid?  */
1765
  bool sum_computed;
1766
 
1767
  /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1768
  bool check_included;
1769
 
1770
  /* The file that we're searching for.  */
1771
  _cpp_file *f;
1772
};
1773
 
1774
/* bsearch comparison function; look for D_P in E_P.  */
1775
 
1776
static int
1777
pchf_compare (const void *d_p, const void *e_p)
1778
{
1779
  const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1780
  struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1781
  int result;
1782
 
1783
  result = memcmp (&d->size, &e->size, sizeof (off_t));
1784
  if (result != 0)
1785
    return result;
1786
 
1787
  if (! d->sum_computed)
1788
    {
1789
      _cpp_file *const f = d->f;
1790
 
1791
      md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1792
      d->sum_computed = true;
1793
    }
1794
 
1795
  result = memcmp (d->sum, e->sum, 16);
1796
  if (result != 0)
1797
    return result;
1798
 
1799
  if (d->check_included || e->once_only)
1800
    return 0;
1801
  else
1802
    return 1;
1803
}
1804
 
1805
/* Check that F is not in a list read from a PCH file (if any).
1806
   Assumes that f->buffer_valid is true.  Return TRUE if the file
1807
   should not be read.  */
1808
 
1809
static bool
1810
check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1811
                            _cpp_file *f,
1812
                            bool check_included)
1813
{
1814
  struct pchf_compare_data d;
1815
 
1816
  if (pchf == NULL
1817
      || (! check_included && ! pchf->have_once_only))
1818
    return false;
1819
 
1820
  d.size = f->st.st_size;
1821
  d.sum_computed = false;
1822
  d.f = f;
1823
  d.check_included = check_included;
1824
  return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1825
                  pchf_compare) != NULL;
1826
}

powered by: WebSVN 2.1.0

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