OSDN Git Service

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