OSDN Git Service

Add framework support for darwin.
[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)) != 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_seach_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 > 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_map *map = linemap_lookup (pfile->line_table, pfile->line);
991
992   /* 1 = system header, 2 = system header to be treated as C.  */
993   if (syshdr)
994     flags = 1 + (externc != 0);
995   pfile->buffer->sysp = flags;
996   _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
997                        SOURCE_LINE (map, pfile->line), flags);
998 }
999
1000 /* Allow the client to change the current file.  Used by the front end
1001    to achieve pseudo-file names like <built-in>.
1002    If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1003 void
1004 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1005                  const char *new_name)
1006 {
1007   _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1008 }
1009
1010 /* Callback function for htab_traverse.  */
1011 static int
1012 report_missing_guard (void **slot, void *b)
1013 {
1014   struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1015   int *bannerp = (int *) b;
1016
1017   /* Skip directories.  */
1018   if (entry->start_dir != NULL)
1019     {
1020       _cpp_file *file = entry->u.file;
1021
1022       /* We don't want MI guard advice for the main file.  */
1023       if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1024         {
1025           if (*bannerp == 0)
1026             {
1027               fputs (_("Multiple include guards may be useful for:\n"),
1028                      stderr);
1029               *bannerp = 1;
1030             }
1031
1032           fputs (entry->u.file->path, stderr);
1033           putc ('\n', stderr);
1034         }
1035     }
1036
1037   return 0;
1038 }
1039
1040 /* Report on all files that might benefit from a multiple include guard.
1041    Triggered by -H.  */
1042 void
1043 _cpp_report_missing_guards (cpp_reader *pfile)
1044 {
1045   int banner = 0;
1046
1047   htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1048 }
1049
1050 /* Locate HEADER, and determine whether it is newer than the current
1051    file.  If it cannot be located or dated, return -1, if it is
1052    newer, return 1, otherwise 0.  */
1053 int
1054 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1055                         int angle_brackets)
1056 {
1057   _cpp_file *file;
1058   struct cpp_dir *dir;
1059
1060   dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1061   if (!dir)
1062     return -1;
1063
1064   file = _cpp_find_file (pfile, fname, dir, false);
1065   if (file->err_no)
1066     return -1;
1067
1068   if (file->fd != -1)
1069     {
1070       close (file->fd);
1071       file->fd = -1;
1072     }
1073
1074   return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1075 }
1076
1077 /* Pushes the given file onto the buffer stack.  Returns nonzero if
1078    successful.  */
1079 bool
1080 cpp_push_include (cpp_reader *pfile, const char *fname)
1081 {
1082   return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1083 }
1084
1085 /* Do appropriate cleanup when a file INC's buffer is popped off the
1086    input stack.  */
1087 void
1088 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1089 {
1090   /* Record the inclusion-preventing macro, which could be NULL
1091      meaning no controlling macro.  */
1092   if (pfile->mi_valid && file->cmacro == NULL)
1093     file->cmacro = pfile->mi_cmacro;
1094
1095   /* Invalidate control macros in the #including file.  */
1096   pfile->mi_valid = false;
1097
1098   if (file->buffer)
1099     {
1100       free ((void *) file->buffer);
1101       file->buffer = NULL;
1102     }
1103 }
1104
1105 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1106    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1107    directory of the including file.
1108
1109    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1110 void
1111 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1112                         int quote_ignores_source_dir)
1113 {
1114   pfile->quote_include = quote;
1115   pfile->bracket_include = quote;
1116   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1117
1118   for (; quote; quote = quote->next)
1119     {
1120       quote->name_map = NULL;
1121       quote->len = strlen (quote->name);
1122       if (quote == bracket)
1123         pfile->bracket_include = bracket;
1124     }
1125 }
1126
1127 /* Append the file name to the directory to create the path, but don't
1128    turn / into // or // into ///; // may be a namespace escape.  */
1129 static char *
1130 append_file_to_dir (const char *fname, cpp_dir *dir)
1131 {
1132   size_t dlen, flen;
1133   char *path;
1134
1135   dlen = dir->len;
1136   flen = strlen (fname);
1137   path = xmalloc (dlen + 1 + flen + 1);
1138   memcpy (path, dir->name, dlen);
1139   if (dlen && path[dlen - 1] != '/')
1140     path[dlen++] = '/';
1141   memcpy (&path[dlen], fname, flen + 1);
1142
1143   return path;
1144 }
1145
1146 /* Read a space delimited string of unlimited length from a stdio
1147    file F.  */
1148 static char *
1149 read_filename_string (int ch, FILE *f)
1150 {
1151   char *alloc, *set;
1152   int len;
1153
1154   len = 20;
1155   set = alloc = xmalloc (len + 1);
1156   if (! is_space (ch))
1157     {
1158       *set++ = ch;
1159       while ((ch = getc (f)) != EOF && ! is_space (ch))
1160         {
1161           if (set - alloc == len)
1162             {
1163               len *= 2;
1164               alloc = xrealloc (alloc, len + 1);
1165               set = alloc + len / 2;
1166             }
1167           *set++ = ch;
1168         }
1169     }
1170   *set = '\0';
1171   ungetc (ch, f);
1172   return alloc;
1173 }
1174
1175 /* Read the file name map file for DIR.  */
1176 static void
1177 read_name_map (cpp_dir *dir)
1178 {
1179   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1180   char *name;
1181   FILE *f;
1182   size_t len, count = 0, room = 9;
1183
1184   len = dir->len;
1185   name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1186   memcpy (name, dir->name, len);
1187   if (len && name[len - 1] != '/')
1188     name[len++] = '/';
1189   strcpy (name + len, FILE_NAME_MAP_FILE);
1190   f = fopen (name, "r");
1191
1192   dir->name_map = xmalloc (room * sizeof (char *));
1193
1194   /* Silently return NULL if we cannot open.  */
1195   if (f)
1196     {
1197       int ch;
1198
1199       while ((ch = getc (f)) != EOF)
1200         {
1201           char *to;
1202
1203           if (is_space (ch))
1204             continue;
1205
1206           if (count + 2 > room)
1207             {
1208               room += 8;
1209               dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1210             }
1211
1212           dir->name_map[count] = read_filename_string (ch, f);
1213           while ((ch = getc (f)) != EOF && is_hspace (ch))
1214             ;
1215
1216           to = read_filename_string (ch, f);
1217           if (IS_ABSOLUTE_PATH (to))
1218             dir->name_map[count + 1] = to;
1219           else
1220             {
1221               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1222               free (to);
1223             }
1224
1225           count += 2;
1226           while ((ch = getc (f)) != '\n')
1227             if (ch == EOF)
1228               break;
1229         }
1230
1231       fclose (f);
1232     }
1233
1234   /* Terminate the list of maps.  */
1235   dir->name_map[count] = NULL;
1236 }
1237
1238 /* Remap a FILE's name based on the file_name_map, if any, for
1239    FILE->dir.  If the file name has any directory separators,
1240    recursively check those directories too.  */
1241 static char *
1242 remap_filename (cpp_reader *pfile, _cpp_file *file)
1243 {
1244   const char *fname, *p;
1245   char *new_dir;
1246   cpp_dir *dir;
1247   size_t index, len;
1248
1249   dir = file->dir;
1250   fname = file->name;
1251
1252   for (;;)
1253     {
1254       if (!dir->name_map)
1255         read_name_map (dir);
1256
1257       for (index = 0; dir->name_map[index]; index += 2)
1258         if (!strcmp (dir->name_map[index], fname))
1259             return xstrdup (dir->name_map[index + 1]);
1260
1261       p = strchr (fname, '/');
1262       if (!p || p == fname)
1263         return NULL;
1264
1265       len = dir->len + (p - fname + 1);
1266       new_dir = xmalloc (len + 1);
1267       memcpy (new_dir, dir->name, dir->len);
1268       memcpy (new_dir + dir->len, fname, p - fname + 1);
1269       new_dir[len] = '\0';
1270
1271       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1272       fname = p + 1;
1273     }
1274 }
1275
1276 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1277 static bool
1278 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1279 {
1280   const char *saved_path = file->path;
1281   bool valid = false;
1282
1283   file->path = pchname;
1284   if (open_file (file))
1285     {
1286       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1287
1288       if (!valid)
1289         {
1290           close (file->fd);
1291           file->fd = -1;
1292         }
1293
1294       if (CPP_OPTION (pfile, print_include_names))
1295         {
1296           unsigned int i;
1297           for (i = 1; i < pfile->line_table->depth; i++)
1298             putc ('.', stderr);
1299           fprintf (stderr, "%c %s\n",
1300                    valid ? '!' : 'x', pchname);
1301         }
1302     }
1303
1304   file->path = saved_path;
1305   return valid;
1306 }
1307
1308 /* Get the path associated with the _cpp_file F.  The path includes
1309    the base name from the include directive and the directory it was
1310    found in via the search path.  */
1311
1312 const char *
1313 cpp_get_path (struct _cpp_file *f)
1314 {
1315   return f->path;
1316 }
1317
1318 /* Get the cpp_buffer currently associated with the cpp_reader
1319    PFILE.  */
1320
1321 cpp_buffer *
1322 cpp_get_buffer (cpp_reader *pfile)
1323 {
1324   return pfile->buffer;
1325 }
1326
1327 /* Get the _cpp_file associated with the cpp_buffer B.  */
1328
1329 _cpp_file *
1330 cpp_get_file (cpp_buffer *b)
1331 {
1332   return b->file;
1333 }
1334
1335 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1336    buffer is the buffer that included the given buffer.  */
1337
1338 cpp_buffer *
1339 cpp_get_prev (cpp_buffer *b)
1340 {
1341   return b->prev;
1342 }
1343 \f
1344 /* This datastructure holds the list of header files that were seen
1345    while the PCH was being built.  The 'entries' field is kept sorted
1346    in memcmp() order; yes, this means that on little-endian systems,
1347    it's sorted initially by the least-significant byte of 'size', but
1348    that's OK.  The code does rely on having entries with the same size
1349    next to each other.  */
1350
1351 struct pchf_data {
1352   /* Number of pchf_entry structures.  */
1353   size_t count;
1354
1355   /* Are there any values with once_only set?
1356      This is used as an optimisation, it means we don't have to search
1357      the structure if we're processing a regular #include.  */
1358   bool have_once_only;
1359
1360   struct pchf_entry {
1361     /* The size of this file.  This is used to save running a MD5 checksum
1362        if the sizes don't match.  */
1363     off_t size;
1364     /* The MD5 checksum of this file.  */
1365     unsigned char sum[16];
1366     /* Is this file to be included only once?  */
1367     bool once_only;
1368   } entries[1];
1369 };
1370
1371 static struct pchf_data *pchf;
1372
1373 /* Data for pchf_addr.  */
1374 struct pchf_adder_info
1375 {
1376   cpp_reader *pfile;
1377   struct pchf_data *d;
1378 };
1379
1380 /* A hash traversal function to add entries into DATA->D.  */
1381
1382 static int
1383 pchf_adder (void **slot, void *data)
1384 {
1385   struct file_hash_entry *h = (struct file_hash_entry *) *slot;
1386   struct pchf_adder_info *i = (struct pchf_adder_info *) data;
1387
1388   if (h->start_dir != NULL && h->u.file->stack_count != 0)
1389     {
1390       struct pchf_data *d = i->d;
1391       _cpp_file *f = h->u.file;
1392       size_t count = d->count++;
1393
1394       /* This should probably never happen, since if a read error occurred
1395          the PCH file shouldn't be written...  */
1396       if (f->dont_read || f->err_no)
1397         return 1;
1398
1399       d->entries[count].once_only = f->once_only;
1400       d->have_once_only |= f->once_only;
1401       if (f->buffer_valid)
1402           md5_buffer ((const char *)f->buffer,
1403                       f->st.st_size, d->entries[count].sum);
1404       else
1405         {
1406           FILE *ff;
1407           int oldfd = f->fd;
1408
1409           if (!open_file (f))
1410             {
1411               open_file_failed (i->pfile, f);
1412               return 0;
1413             }
1414           ff = fdopen (f->fd, "rb");
1415           md5_stream (ff, d->entries[count].sum);
1416           fclose (ff);
1417           f->fd = oldfd;
1418         }
1419       d->entries[count].size = f->st.st_size;
1420     }
1421   return 1;
1422 }
1423
1424 /* A qsort ordering function for pchf_entry structures.  */
1425
1426 static int
1427 pchf_save_compare (const void *e1, const void *e2)
1428 {
1429   return memcmp (e1, e2, sizeof (struct pchf_entry));
1430 }
1431
1432 /* Create and write to F a pchf_data structure.  */
1433
1434 bool
1435 _cpp_save_file_entries (cpp_reader *pfile, FILE *f)
1436 {
1437   size_t count = 0;
1438   struct pchf_data *result;
1439   size_t result_size;
1440   struct pchf_adder_info pai;
1441
1442   count = htab_elements (pfile->file_hash);
1443   result_size = (sizeof (struct pchf_data)
1444                  + sizeof (struct pchf_entry) * (count - 1));
1445   result = xcalloc (result_size, 1);
1446
1447   result->count = 0;
1448   result->have_once_only = false;
1449
1450   pai.pfile = pfile;
1451   pai.d = result;
1452   htab_traverse (pfile->file_hash, pchf_adder, &pai);
1453
1454   result_size = (sizeof (struct pchf_data)
1455                  + sizeof (struct pchf_entry) * (result->count - 1));
1456
1457   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1458          pchf_save_compare);
1459
1460   return fwrite (result, result_size, 1, f) == 1;
1461 }
1462
1463 /* Read the pchf_data structure from F.  */
1464
1465 bool
1466 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1467 {
1468   struct pchf_data d;
1469
1470   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1471        != 1)
1472     return false;
1473
1474   pchf = xmalloc (sizeof (struct pchf_data)
1475                   + sizeof (struct pchf_entry) * (d.count - 1));
1476   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1477   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1478       != d.count)
1479     return false;
1480   return true;
1481 }
1482
1483 /* The parameters for pchf_compare.  */
1484
1485 struct pchf_compare_data
1486 {
1487   /* The size of the file we're looking for.  */
1488   off_t size;
1489
1490   /* The MD5 checksum of the file, if it's been computed.  */
1491   unsigned char sum[16];
1492
1493   /* Is SUM valid?  */
1494   bool sum_computed;
1495
1496   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1497   bool check_included;
1498
1499   /* The file that we're searching for.  */
1500   _cpp_file *f;
1501 };
1502
1503 /* bsearch comparison function; look for D_P in E_P.  */
1504
1505 static int
1506 pchf_compare (const void *d_p, const void *e_p)
1507 {
1508   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1509   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1510   int result;
1511
1512   result = memcmp (&d->size, &e->size, sizeof (off_t));
1513   if (result != 0)
1514     return result;
1515
1516   if (! d->sum_computed)
1517     {
1518       _cpp_file *const f = d->f;
1519
1520       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1521       d->sum_computed = true;
1522     }
1523
1524   result = memcmp (d->sum, e->sum, 16);
1525   if (result != 0)
1526     return result;
1527
1528   if (d->check_included || e->once_only)
1529     return 0;
1530   else
1531     return 1;
1532 }
1533
1534 /* Check that F is not in a list read from a PCH file (if any).
1535    Assumes that f->buffer_valid is true.  Return TRUE if the file
1536    should not be read.  */
1537
1538 static bool
1539 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1540                             _cpp_file *f,
1541                             bool check_included)
1542 {
1543   struct pchf_compare_data d;
1544
1545   if (pchf == NULL
1546       || (! check_included && ! pchf->have_once_only))
1547     return false;
1548
1549   d.size = f->st.st_size;
1550   d.sum_computed = false;
1551   d.f = f;
1552   d.check_included = check_included;
1553   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1554                   pchf_compare) != NULL;
1555 }