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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [files.c] - Blame information for rev 749

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

Line No. Rev Author Line
1 730 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,
4
   2006, 2007, 2008, 2009, 2010, 2011, 2012 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) != 0;
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
  free ((void *) file->buffer_start);
1000
  free ((void *) file->name);
1001
  free (file);
1002
}
1003
 
1004
/* Release all the files allocated by this reader.  */
1005
static void
1006
destroy_all_cpp_files (cpp_reader *pfile)
1007
{
1008
  _cpp_file *iter = pfile->all_files;
1009
  while (iter)
1010
    {
1011
      _cpp_file *next = iter->next_file;
1012
      destroy_cpp_file (iter);
1013
      iter = next;
1014
    }
1015
}
1016
 
1017
/* A hash of directory names.  The directory names are the path names
1018
   of files which contain a #include "", the included file name is
1019
   appended to this directories.
1020
 
1021
   To avoid duplicate entries we follow the convention that all
1022
   non-empty directory names should end in a '/'.  DIR_NAME must be
1023
   stored in permanently allocated memory.  */
1024
static cpp_dir *
1025
make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1026
{
1027
  struct file_hash_entry *entry, **hash_slot;
1028
  cpp_dir *dir;
1029
 
1030
  hash_slot = (struct file_hash_entry **)
1031
    htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1032
                              htab_hash_string (dir_name),
1033
                              INSERT);
1034
 
1035
  /* Have we already hashed this directory?  */
1036
  for (entry = *hash_slot; entry; entry = entry->next)
1037
    if (entry->start_dir == NULL)
1038
      return entry->u.dir;
1039
 
1040
  dir = XCNEW (cpp_dir);
1041
  dir->next = pfile->quote_include;
1042
  dir->name = (char *) dir_name;
1043
  dir->len = strlen (dir_name);
1044
  dir->sysp = sysp;
1045
  dir->construct = 0;
1046
 
1047
  /* Store this new result in the hash table.  */
1048
  entry = new_file_hash_entry (pfile);
1049
  entry->next = *hash_slot;
1050
  entry->start_dir = NULL;
1051
  entry->location = pfile->line_table->highest_location;
1052
  entry->u.dir = dir;
1053
  *hash_slot = entry;
1054
 
1055
  return dir;
1056
}
1057
 
1058
/* Create a new block of memory for file hash entries.  */
1059
static void
1060
allocate_file_hash_entries (cpp_reader *pfile)
1061
{
1062
  struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1063
  pool->file_hash_entries_used = 0;
1064
  pool->next = pfile->file_hash_entries;
1065
  pfile->file_hash_entries = pool;
1066
}
1067
 
1068
/* Return a new file hash entry.  */
1069
static struct file_hash_entry *
1070
new_file_hash_entry (cpp_reader *pfile)
1071
{
1072
  unsigned int idx;
1073
  if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1074
    allocate_file_hash_entries (pfile);
1075
 
1076
  idx = pfile->file_hash_entries->file_hash_entries_used++;
1077
  return &pfile->file_hash_entries->pool[idx];
1078
}
1079
 
1080
/* Free the file hash entry pools.  */
1081
static void
1082
free_file_hash_entries (cpp_reader *pfile)
1083
{
1084
  struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1085
  while (iter)
1086
    {
1087
      struct file_hash_entry_pool *next = iter->next;
1088
      free (iter);
1089
      iter = next;
1090
    }
1091
}
1092
 
1093
/* Returns TRUE if a file FNAME has ever been successfully opened.
1094
   This routine is not intended to correctly handle filenames aliased
1095
   by links or redundant . or .. traversals etc.  */
1096
bool
1097
cpp_included (cpp_reader *pfile, const char *fname)
1098
{
1099
  struct file_hash_entry *entry;
1100
 
1101
  entry = (struct file_hash_entry *)
1102
     htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1103
 
1104
  while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1105
    entry = entry->next;
1106
 
1107
  return entry != NULL;
1108
}
1109
 
1110
/* Returns TRUE if a file FNAME has ever been successfully opened
1111
   before LOCATION.  This routine is not intended to correctly handle
1112
   filenames aliased by links or redundant . or .. traversals etc.  */
1113
bool
1114
cpp_included_before (cpp_reader *pfile, const char *fname,
1115
                     source_location location)
1116
{
1117
  struct file_hash_entry *entry;
1118
 
1119
  entry = (struct file_hash_entry *)
1120
     htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1121
 
1122
  while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1123
                   || entry->location > location))
1124
    entry = entry->next;
1125
 
1126
  return entry != NULL;
1127
}
1128
 
1129
/* Calculate the hash value of a file hash entry P.  */
1130
 
1131
static hashval_t
1132
file_hash_hash (const void *p)
1133
{
1134
  struct file_hash_entry *entry = (struct file_hash_entry *) p;
1135
  const char *hname;
1136
  if (entry->start_dir)
1137
    hname = entry->u.file->name;
1138
  else
1139
    hname = entry->u.dir->name;
1140
 
1141
  return htab_hash_string (hname);
1142
}
1143
 
1144
/* Compare a string Q against a file hash entry P.  */
1145
static int
1146
file_hash_eq (const void *p, const void *q)
1147
{
1148
  struct file_hash_entry *entry = (struct file_hash_entry *) p;
1149
  const char *fname = (const char *) q;
1150
  const char *hname;
1151
 
1152
  if (entry->start_dir)
1153
    hname = entry->u.file->name;
1154
  else
1155
    hname = entry->u.dir->name;
1156
 
1157
  return filename_cmp (hname, fname) == 0;
1158
}
1159
 
1160
/* Compare entries in the nonexistent file hash table.  These are just
1161
   strings.  */
1162
static int
1163
nonexistent_file_hash_eq (const void *p, const void *q)
1164
{
1165
  return filename_cmp ((const char *) p, (const char *) q) == 0;
1166
}
1167
 
1168
/* Initialize everything in this source file.  */
1169
void
1170
_cpp_init_files (cpp_reader *pfile)
1171
{
1172
  pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1173
                                        NULL, xcalloc, free);
1174
  pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1175
                                        NULL, xcalloc, free);
1176
  allocate_file_hash_entries (pfile);
1177
  pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1178
                                                    nonexistent_file_hash_eq,
1179
                                                    NULL, xcalloc, free);
1180
  _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1181
                  (void *(*) (long)) xmalloc,
1182
                  (void (*) (void *)) free);
1183
}
1184
 
1185
/* Finalize everything in this source file.  */
1186
void
1187
_cpp_cleanup_files (cpp_reader *pfile)
1188
{
1189
  htab_delete (pfile->file_hash);
1190
  htab_delete (pfile->dir_hash);
1191
  htab_delete (pfile->nonexistent_file_hash);
1192
  obstack_free (&pfile->nonexistent_file_ob, 0);
1193
  free_file_hash_entries (pfile);
1194
  destroy_all_cpp_files (pfile);
1195
}
1196
 
1197
/* Make the parser forget about files it has seen.  This can be useful
1198
   for resetting the parser to start another run.  */
1199
void
1200
cpp_clear_file_cache (cpp_reader *pfile)
1201
{
1202
  _cpp_cleanup_files (pfile);
1203
  pfile->file_hash_entries = NULL;
1204
  pfile->all_files = NULL;
1205
  _cpp_init_files (pfile);
1206
}
1207
 
1208
/* Enter a file name in the hash for the sake of cpp_included.  */
1209
void
1210
_cpp_fake_include (cpp_reader *pfile, const char *fname)
1211
{
1212
  _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1213
}
1214
 
1215
/* Not everyone who wants to set system-header-ness on a buffer can
1216
   see the details of a buffer.  This is an exported interface because
1217
   fix-header needs it.  */
1218
void
1219
cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1220
{
1221
  int flags = 0;
1222
  const struct line_maps *line_table = pfile->line_table;
1223
  const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1224
  /* 1 = system header, 2 = system header to be treated as C.  */
1225
  if (syshdr)
1226
    flags = 1 + (externc != 0);
1227
  pfile->buffer->sysp = flags;
1228
  _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1229
                       SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1230
}
1231
 
1232
/* Allow the client to change the current file.  Used by the front end
1233
   to achieve pseudo-file names like <built-in>.
1234
   If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1235
void
1236
cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1237
                 const char *new_name)
1238
{
1239
  _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1240
}
1241
 
1242
struct report_missing_guard_data
1243
{
1244
  const char **paths;
1245
  size_t count;
1246
};
1247
 
1248
/* Callback function for htab_traverse.  */
1249
static int
1250
report_missing_guard (void **slot, void *d)
1251
{
1252
  struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1253
  struct report_missing_guard_data *data
1254
    = (struct report_missing_guard_data *) d;
1255
 
1256
  /* Skip directories.  */
1257
  if (entry->start_dir != NULL)
1258
    {
1259
      _cpp_file *file = entry->u.file;
1260
 
1261
      /* We don't want MI guard advice for the main file.  */
1262
      if (!file->once_only && file->cmacro == NULL
1263
          && file->stack_count == 1 && !file->main_file)
1264
        {
1265
          if (data->paths == NULL)
1266
            {
1267
              data->paths = XCNEWVEC (const char *, data->count);
1268
              data->count = 0;
1269
            }
1270
 
1271
          data->paths[data->count++] = file->path;
1272
        }
1273
    }
1274
 
1275
  /* Keep traversing the hash table.  */
1276
  return 1;
1277
}
1278
 
1279
/* Comparison function for qsort.  */
1280
static int
1281
report_missing_guard_cmp (const void *p1, const void *p2)
1282
{
1283
  return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1284
}
1285
 
1286
/* Report on all files that might benefit from a multiple include guard.
1287
   Triggered by -H.  */
1288
void
1289
_cpp_report_missing_guards (cpp_reader *pfile)
1290
{
1291
  struct report_missing_guard_data data;
1292
 
1293
  data.paths = NULL;
1294
  data.count = htab_elements (pfile->file_hash);
1295
  htab_traverse (pfile->file_hash, report_missing_guard, &data);
1296
 
1297
  if (data.paths != NULL)
1298
    {
1299
      size_t i;
1300
 
1301
      /* Sort the paths to avoid outputting them in hash table
1302
         order.  */
1303
      qsort (data.paths, data.count, sizeof (const char *),
1304
             report_missing_guard_cmp);
1305
      fputs (_("Multiple include guards may be useful for:\n"),
1306
             stderr);
1307
      for (i = 0; i < data.count; i++)
1308
        {
1309
          fputs (data.paths[i], stderr);
1310
          putc ('\n', stderr);
1311
        }
1312
      free (data.paths);
1313
    }
1314
}
1315
 
1316
/* Locate HEADER, and determine whether it is newer than the current
1317
   file.  If it cannot be located or dated, return -1, if it is
1318
   newer, return 1, otherwise 0.  */
1319
int
1320
_cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1321
                        int angle_brackets)
1322
{
1323
  _cpp_file *file;
1324
  struct cpp_dir *dir;
1325
 
1326
  dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1327
  if (!dir)
1328
    return -1;
1329
 
1330
  file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1331
  if (file->err_no)
1332
    return -1;
1333
 
1334
  if (file->fd != -1)
1335
    {
1336
      close (file->fd);
1337
      file->fd = -1;
1338
    }
1339
 
1340
  return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1341
}
1342
 
1343
/* Pushes the given file onto the buffer stack.  Returns nonzero if
1344
   successful.  */
1345
bool
1346
cpp_push_include (cpp_reader *pfile, const char *fname)
1347
{
1348
  return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1349
}
1350
 
1351
/* Do appropriate cleanup when a file INC's buffer is popped off the
1352
   input stack.  */
1353
void
1354
_cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1355
{
1356
  /* Record the inclusion-preventing macro, which could be NULL
1357
     meaning no controlling macro.  */
1358
  if (pfile->mi_valid && file->cmacro == NULL)
1359
    file->cmacro = pfile->mi_cmacro;
1360
 
1361
  /* Invalidate control macros in the #including file.  */
1362
  pfile->mi_valid = false;
1363
 
1364
  if (file->buffer_start)
1365
    {
1366
      free ((void *) file->buffer_start);
1367
      file->buffer_start = NULL;
1368
      file->buffer = NULL;
1369
      file->buffer_valid = false;
1370
    }
1371
}
1372
 
1373
/* Return the file name associated with FILE.  */
1374
const char *
1375
_cpp_get_file_name (_cpp_file *file)
1376
{
1377
  return file->name;
1378
}
1379
 
1380
/* Inteface to file statistics record in _cpp_file structure. */
1381
struct stat *
1382
_cpp_get_file_stat (_cpp_file *file)
1383
{
1384
    return &file->st;
1385
}
1386
 
1387
/* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1388
   QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1389
   directory of the including file.
1390
 
1391
   If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1392
void
1393
cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1394
                        int quote_ignores_source_dir)
1395
{
1396
  pfile->quote_include = quote;
1397
  pfile->bracket_include = quote;
1398
  pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1399
 
1400
  for (; quote; quote = quote->next)
1401
    {
1402
      quote->name_map = NULL;
1403
      quote->len = strlen (quote->name);
1404
      if (quote == bracket)
1405
        pfile->bracket_include = bracket;
1406
    }
1407
}
1408
 
1409
/* Append the file name to the directory to create the path, but don't
1410
   turn / into // or // into ///; // may be a namespace escape.  */
1411
static char *
1412
append_file_to_dir (const char *fname, cpp_dir *dir)
1413
{
1414
  size_t dlen, flen;
1415
  char *path;
1416
 
1417
  dlen = dir->len;
1418
  flen = strlen (fname);
1419
  path = XNEWVEC (char, dlen + 1 + flen + 1);
1420
  memcpy (path, dir->name, dlen);
1421
  if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1422
    path[dlen++] = '/';
1423
  memcpy (&path[dlen], fname, flen + 1);
1424
 
1425
  return path;
1426
}
1427
 
1428
/* Read a space delimited string of unlimited length from a stdio
1429
   file F.  */
1430
static char *
1431
read_filename_string (int ch, FILE *f)
1432
{
1433
  char *alloc, *set;
1434
  int len;
1435
 
1436
  len = 20;
1437
  set = alloc = XNEWVEC (char, len + 1);
1438
  if (! is_space (ch))
1439
    {
1440
      *set++ = ch;
1441
      while ((ch = getc (f)) != EOF && ! is_space (ch))
1442
        {
1443
          if (set - alloc == len)
1444
            {
1445
              len *= 2;
1446
              alloc = XRESIZEVEC (char, alloc, len + 1);
1447
              set = alloc + len / 2;
1448
            }
1449
          *set++ = ch;
1450
        }
1451
    }
1452
  *set = '\0';
1453
  ungetc (ch, f);
1454
  return alloc;
1455
}
1456
 
1457
/* Read the file name map file for DIR.  */
1458
static void
1459
read_name_map (cpp_dir *dir)
1460
{
1461
  static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1462
  char *name;
1463
  FILE *f;
1464
  size_t len, count = 0, room = 9;
1465
 
1466
  len = dir->len;
1467
  name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1468
  memcpy (name, dir->name, len);
1469
  if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1470
    name[len++] = '/';
1471
  strcpy (name + len, FILE_NAME_MAP_FILE);
1472
  f = fopen (name, "r");
1473
 
1474
  dir->name_map = XNEWVEC (const char *, room);
1475
 
1476
  /* Silently return NULL if we cannot open.  */
1477
  if (f)
1478
    {
1479
      int ch;
1480
 
1481
      while ((ch = getc (f)) != EOF)
1482
        {
1483
          char *to;
1484
 
1485
          if (is_space (ch))
1486
            continue;
1487
 
1488
          if (count + 2 > room)
1489
            {
1490
              room += 8;
1491
              dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1492
            }
1493
 
1494
          dir->name_map[count] = read_filename_string (ch, f);
1495
          while ((ch = getc (f)) != EOF && is_hspace (ch))
1496
            ;
1497
 
1498
          to = read_filename_string (ch, f);
1499
          if (IS_ABSOLUTE_PATH (to))
1500
            dir->name_map[count + 1] = to;
1501
          else
1502
            {
1503
              dir->name_map[count + 1] = append_file_to_dir (to, dir);
1504
              free (to);
1505
            }
1506
 
1507
          count += 2;
1508
          while ((ch = getc (f)) != '\n')
1509
            if (ch == EOF)
1510
              break;
1511
        }
1512
 
1513
      fclose (f);
1514
    }
1515
 
1516
  /* Terminate the list of maps.  */
1517
  dir->name_map[count] = NULL;
1518
}
1519
 
1520
/* Remap a FILE's name based on the file_name_map, if any, for
1521
   FILE->dir.  If the file name has any directory separators,
1522
   recursively check those directories too.  */
1523
static char *
1524
remap_filename (cpp_reader *pfile, _cpp_file *file)
1525
{
1526
  const char *fname, *p;
1527
  char *new_dir;
1528
  cpp_dir *dir;
1529
  size_t index, len;
1530
 
1531
  dir = file->dir;
1532
  fname = file->name;
1533
 
1534
  for (;;)
1535
    {
1536
      if (!dir->name_map)
1537
        read_name_map (dir);
1538
 
1539
      for (index = 0; dir->name_map[index]; index += 2)
1540
        if (!filename_cmp (dir->name_map[index], fname))
1541
            return xstrdup (dir->name_map[index + 1]);
1542
      if (IS_ABSOLUTE_PATH (fname))
1543
        return NULL;
1544
      p = strchr (fname, '/');
1545
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
1546
      {
1547
        char *p2 = strchr (fname, '\\');
1548
        if (!p || (p > p2))
1549
          p = p2;
1550
      }
1551
#endif
1552
      if (!p || p == fname)
1553
        return NULL;
1554
 
1555
      len = dir->len + (p - fname + 1);
1556
      new_dir = XNEWVEC (char, len + 1);
1557
      memcpy (new_dir, dir->name, dir->len);
1558
      memcpy (new_dir + dir->len, fname, p - fname + 1);
1559
      new_dir[len] = '\0';
1560
 
1561
      dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1562
      fname = p + 1;
1563
    }
1564
}
1565
 
1566
/* Returns true if PCHNAME is a valid PCH file for FILE.  */
1567
static bool
1568
validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1569
{
1570
  const char *saved_path = file->path;
1571
  bool valid = false;
1572
 
1573
  file->path = pchname;
1574
  if (open_file (file))
1575
    {
1576
      valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1577
 
1578
      if (!valid)
1579
        {
1580
          close (file->fd);
1581
          file->fd = -1;
1582
        }
1583
 
1584
      if (CPP_OPTION (pfile, print_include_names))
1585
        {
1586
          unsigned int i;
1587
          for (i = 1; i < pfile->line_table->depth; i++)
1588
            putc ('.', stderr);
1589
          fprintf (stderr, "%c %s\n",
1590
                   valid ? '!' : 'x', pchname);
1591
        }
1592
    }
1593
 
1594
  file->path = saved_path;
1595
  return valid;
1596
}
1597
 
1598
/* Get the path associated with the _cpp_file F.  The path includes
1599
   the base name from the include directive and the directory it was
1600
   found in via the search path.  */
1601
 
1602
const char *
1603
cpp_get_path (struct _cpp_file *f)
1604
{
1605
  return f->path;
1606
}
1607
 
1608
/* Get the directory associated with the _cpp_file F.  */
1609
 
1610
cpp_dir *
1611
cpp_get_dir (struct _cpp_file *f)
1612
{
1613
  return f->dir;
1614
}
1615
 
1616
/* Get the cpp_buffer currently associated with the cpp_reader
1617
   PFILE.  */
1618
 
1619
cpp_buffer *
1620
cpp_get_buffer (cpp_reader *pfile)
1621
{
1622
  return pfile->buffer;
1623
}
1624
 
1625
/* Get the _cpp_file associated with the cpp_buffer B.  */
1626
 
1627
_cpp_file *
1628
cpp_get_file (cpp_buffer *b)
1629
{
1630
  return b->file;
1631
}
1632
 
1633
/* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1634
   buffer is the buffer that included the given buffer.  */
1635
 
1636
cpp_buffer *
1637
cpp_get_prev (cpp_buffer *b)
1638
{
1639
  return b->prev;
1640
}
1641
 
1642
/* This data structure holds the list of header files that were seen
1643
   while the PCH was being built.  The 'entries' field is kept sorted
1644
   in memcmp() order; yes, this means that on little-endian systems,
1645
   it's sorted initially by the least-significant byte of 'size', but
1646
   that's OK.  The code does rely on having entries with the same size
1647
   next to each other.  */
1648
 
1649
struct pchf_entry {
1650
  /* The size of this file.  This is used to save running a MD5 checksum
1651
     if the sizes don't match.  */
1652
  off_t size;
1653
  /* The MD5 checksum of this file.  */
1654
  unsigned char sum[16];
1655
  /* Is this file to be included only once?  */
1656
  bool once_only;
1657
};
1658
 
1659
struct pchf_data {
1660
  /* Number of pchf_entry structures.  */
1661
  size_t count;
1662
 
1663
  /* Are there any values with once_only set?
1664
     This is used as an optimisation, it means we don't have to search
1665
     the structure if we're processing a regular #include.  */
1666
  bool have_once_only;
1667
 
1668
  struct pchf_entry entries[1];
1669
};
1670
 
1671
static struct pchf_data *pchf;
1672
 
1673
/* A qsort ordering function for pchf_entry structures.  */
1674
 
1675
static int
1676
pchf_save_compare (const void *e1, const void *e2)
1677
{
1678
  return memcmp (e1, e2, sizeof (struct pchf_entry));
1679
}
1680
 
1681
/* Create and write to F a pchf_data structure.  */
1682
 
1683
bool
1684
_cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1685
{
1686
  size_t count = 0;
1687
  struct pchf_data *result;
1688
  size_t result_size;
1689
  _cpp_file *f;
1690
 
1691
  for (f = pfile->all_files; f; f = f->next_file)
1692
    ++count;
1693
 
1694
  result_size = (sizeof (struct pchf_data)
1695
                 + sizeof (struct pchf_entry) * (count - 1));
1696
  result = XCNEWVAR (struct pchf_data, result_size);
1697
 
1698
  result->count = 0;
1699
  result->have_once_only = false;
1700
 
1701
  for (f = pfile->all_files; f; f = f->next_file)
1702
    {
1703
      size_t count;
1704
 
1705
      /* This should probably never happen, since if a read error occurred
1706
         the PCH file shouldn't be written...  */
1707
      if (f->dont_read || f->err_no)
1708
        continue;
1709
 
1710
      if (f->stack_count == 0)
1711
        continue;
1712
 
1713
      count = result->count++;
1714
 
1715
      result->entries[count].once_only = f->once_only;
1716
      /* |= is avoided in the next line because of an HP C compiler bug */
1717
      result->have_once_only = result->have_once_only | f->once_only;
1718
      if (f->buffer_valid)
1719
        md5_buffer ((const char *)f->buffer,
1720
                    f->st.st_size, result->entries[count].sum);
1721
      else
1722
        {
1723
          FILE *ff;
1724
          int oldfd = f->fd;
1725
 
1726
          if (!open_file (f))
1727
            {
1728
              open_file_failed (pfile, f, 0);
1729
              return false;
1730
            }
1731
          ff = fdopen (f->fd, "rb");
1732
          md5_stream (ff, result->entries[count].sum);
1733
          fclose (ff);
1734
          f->fd = oldfd;
1735
        }
1736
      result->entries[count].size = f->st.st_size;
1737
    }
1738
 
1739
  result_size = (sizeof (struct pchf_data)
1740
                 + sizeof (struct pchf_entry) * (result->count - 1));
1741
 
1742
  qsort (result->entries, result->count, sizeof (struct pchf_entry),
1743
         pchf_save_compare);
1744
 
1745
  return fwrite (result, result_size, 1, fp) == 1;
1746
}
1747
 
1748
/* Read the pchf_data structure from F.  */
1749
 
1750
bool
1751
_cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1752
{
1753
  struct pchf_data d;
1754
 
1755
  if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1756
       != 1)
1757
    return false;
1758
 
1759
  pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1760
                  + sizeof (struct pchf_entry) * (d.count - 1));
1761
  memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1762
  if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1763
      != d.count)
1764
    return false;
1765
  return true;
1766
}
1767
 
1768
/* The parameters for pchf_compare.  */
1769
 
1770
struct pchf_compare_data
1771
{
1772
  /* The size of the file we're looking for.  */
1773
  off_t size;
1774
 
1775
  /* The MD5 checksum of the file, if it's been computed.  */
1776
  unsigned char sum[16];
1777
 
1778
  /* Is SUM valid?  */
1779
  bool sum_computed;
1780
 
1781
  /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1782
  bool check_included;
1783
 
1784
  /* The file that we're searching for.  */
1785
  _cpp_file *f;
1786
};
1787
 
1788
/* bsearch comparison function; look for D_P in E_P.  */
1789
 
1790
static int
1791
pchf_compare (const void *d_p, const void *e_p)
1792
{
1793
  const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1794
  struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1795
  int result;
1796
 
1797
  result = memcmp (&d->size, &e->size, sizeof (off_t));
1798
  if (result != 0)
1799
    return result;
1800
 
1801
  if (! d->sum_computed)
1802
    {
1803
      _cpp_file *const f = d->f;
1804
 
1805
      md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1806
      d->sum_computed = true;
1807
    }
1808
 
1809
  result = memcmp (d->sum, e->sum, 16);
1810
  if (result != 0)
1811
    return result;
1812
 
1813
  if (d->check_included || e->once_only)
1814
    return 0;
1815
  else
1816
    return 1;
1817
}
1818
 
1819
/* Check that F is not in a list read from a PCH file (if any).
1820
   Assumes that f->buffer_valid is true.  Return TRUE if the file
1821
   should not be read.  */
1822
 
1823
static bool
1824
check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1825
                            _cpp_file *f,
1826
                            bool check_included)
1827
{
1828
  struct pchf_compare_data d;
1829
 
1830
  if (pchf == NULL
1831
      || (! check_included && ! pchf->have_once_only))
1832
    return false;
1833
 
1834
  d.size = f->st.st_size;
1835
  d.sum_computed = false;
1836
  d.f = f;
1837
  d.check_included = check_included;
1838
  return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1839
                  pchf_compare) != NULL;
1840
}

powered by: WebSVN 2.1.0

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