OSDN Git Service

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