OSDN Git Service

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