OSDN Git Service

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