s/pxeldr/pxeboot/
[dragonfly.git] / contrib / gcc-4.0 / libcpp / files.c
1 /* Part of CPP library.  File handling.
2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4    Written by Per Bothner, 1994.
5    Based on CCCP program by Paul Rubin, June 1986
6    Adapted to ANSI C, Richard Stallman, Jan 1987
7    Split out of cpplib.c, Zack Weinberg, Oct 1998
8    Reimplemented, Neil Booth, Jul 2003
9
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
13 later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 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 void destroy_cpp_file (_cpp_file *);
165 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
166 static void allocate_file_hash_entries (cpp_reader *pfile);
167 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
168 static int report_missing_guard (void **slot, void *b);
169 static hashval_t file_hash_hash (const void *p);
170 static int file_hash_eq (const void *p, const void *q);
171 static char *read_filename_string (int ch, FILE *f);
172 static void read_name_map (cpp_dir *dir);
173 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
174 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
175 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
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 (file->dir == pfile->quote_include
419           || file->dir == pfile->bracket_include)
420         {
421           entry = search_cache (*hash_slot, file->dir);
422           if (entry)
423             {
424               /* Found the same file again.  Record it as reachable
425                  from this position, too.  */
426               free ((char *) file->name);
427               free (file);
428               file = entry->u.file;
429               goto found;
430             }
431         }
432
433       if (find_file_in_dir (pfile, file, &invalid_pch))
434         break;
435
436       file->dir = file->dir->next;
437       if (file->dir == NULL)
438         {
439           if (search_path_exhausted (pfile, fname, file))
440             {
441               /* Although this file must not go in the cache, because
442                  the file found might depend on things (like the current file)
443                  that aren't represented in the cache, it still has to go in
444                  the list of all files so that #import works.  */
445               file->next_file = pfile->all_files;
446               pfile->all_files = file;
447               return file;
448             }
449
450           open_file_failed (pfile, file);
451           if (invalid_pch)
452             {
453               cpp_error (pfile, CPP_DL_ERROR,
454                "one or more PCH files were found, but they were invalid");
455               if (!cpp_get_options (pfile)->warn_invalid_pch)
456                 cpp_error (pfile, CPP_DL_ERROR,
457                            "use -Winvalid-pch for more information");
458             }
459           break;
460         }
461     }
462
463   /* This is a new file; put it in the list.  */
464   file->next_file = pfile->all_files;
465   pfile->all_files = file;
466
467   /* If this file was found in the directory-of-the-current-file,
468      check whether that directory is reachable via one of the normal
469      search paths.  If so, we must record this entry as being
470      reachable that way, otherwise we will mistakenly reprocess this
471      file if it is included later from the normal search path.  */
472   if (file->dir && start_dir->next == pfile->quote_include)
473     {
474       cpp_dir *d;
475       cpp_dir *proper_start_dir = pfile->quote_include;
476
477       for (d = proper_start_dir;; d = d->next)
478         {
479           if (d == pfile->bracket_include)
480             proper_start_dir = d;
481           if (d == 0)
482             {
483               proper_start_dir = 0;
484               break;
485             }
486           /* file->dir->name will have a trailing slash.  */
487           if (!strncmp (d->name, file->dir->name, file->dir->len - 1))
488             break;
489         }
490       if (proper_start_dir)
491         start_dir = proper_start_dir;
492     }
493
494  found:
495   /* Store this new result in the hash table.  */
496   entry = new_file_hash_entry (pfile);
497   entry->next = *hash_slot;
498   entry->start_dir = start_dir;
499   entry->u.file = file;
500   *hash_slot = entry;
501
502   return file;
503 }
504
505 /* Read a file into FILE->buffer, returning true on success.
506
507    If FILE->fd is something weird, like a block device, we don't want
508    to read it at all.  Don't even try to figure out what something is,
509    except for plain files and block devices, since there is no
510    reliable portable way of doing this.
511
512    FIXME: Flush file cache and try again if we run out of memory.  */
513 static bool
514 read_file_guts (cpp_reader *pfile, _cpp_file *file)
515 {
516   ssize_t size, total, count;
517   uchar *buf;
518   bool regular;
519
520   if (S_ISBLK (file->st.st_mode))
521     {
522       cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
523       return false;
524     }
525
526   regular = S_ISREG (file->st.st_mode);
527   if (regular)
528     {
529       /* off_t might have a wider range than ssize_t - in other words,
530          the max size of a file might be bigger than the address
531          space.  We can't handle a file that large.  (Anyone with
532          a single source file bigger than 2GB needs to rethink
533          their coding style.)  Some systems (e.g. AIX 4.1) define
534          SSIZE_MAX to be much smaller than the actual range of the
535          type.  Use INTTYPE_MAXIMUM unconditionally to ensure this
536          does not bite us.  */
537       if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
538         {
539           cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
540           return false;
541         }
542
543       size = file->st.st_size;
544     }
545   else
546     /* 8 kilobytes is a sensible starting size.  It ought to be bigger
547        than the kernel pipe buffer, and it's definitely bigger than
548        the majority of C source files.  */
549     size = 8 * 1024;
550
551   buf = xmalloc (size + 1);
552   total = 0;
553   while ((count = read (file->fd, buf + total, size - total)) > 0)
554     {
555       total += count;
556
557       if (total == size)
558         {
559           if (regular)
560             break;
561           size *= 2;
562           buf = xrealloc (buf, size + 1);
563         }
564     }
565
566   if (count < 0)
567     {
568       cpp_errno (pfile, CPP_DL_ERROR, file->path);
569       return false;
570     }
571
572   if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
573     cpp_error (pfile, CPP_DL_WARNING,
574                "%s is shorter than expected", file->path);
575
576   file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
577                                      buf, size, total, &file->st.st_size);
578   file->buffer_valid = true;
579
580   return true;
581 }
582
583 /* Convenience wrapper around read_file_guts that opens the file if
584    necessary and closes the file descriptor after reading.  FILE must
585    have been passed through find_file() at some stage.  */
586 static bool
587 read_file (cpp_reader *pfile, _cpp_file *file)
588 {
589   /* If we already have its contents in memory, succeed immediately.  */
590   if (file->buffer_valid)
591     return true;
592
593   /* If an earlier read failed for some reason don't try again.  */
594   if (file->dont_read || file->err_no)
595     return false;
596
597   if (file->fd == -1 && !open_file (file))
598     {
599       open_file_failed (pfile, file);
600       return false;
601     }
602
603   file->dont_read = !read_file_guts (pfile, file);
604   close (file->fd);
605   file->fd = -1;
606
607   return !file->dont_read;
608 }
609
610 /* Returns TRUE if FILE's contents have been successfully placed in
611    FILE->buffer and the file should be stacked, otherwise false.  */
612 static bool
613 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
614 {
615   _cpp_file *f;
616
617   /* Skip once-only files.  */
618   if (file->once_only)
619     return false;
620
621   /* We must mark the file once-only if #import now, before header
622      guard checks.  Otherwise, undefining the header guard might
623      cause the file to be re-stacked.  */
624   if (import)
625     {
626       _cpp_mark_file_once_only (pfile, file);
627
628       /* Don't stack files that have been stacked before.  */
629       if (file->stack_count)
630         return false;
631     }
632
633   /* Skip if the file had a header guard and the macro is defined.
634      PCH relies on this appearing before the PCH handler below.  */
635   if (file->cmacro && file->cmacro->type == NT_MACRO)
636     return false;
637
638   /* Handle PCH files immediately; don't stack them.  */
639   if (file->pch)
640     {
641       pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
642       close (file->fd);
643       file->fd = -1;
644       return false;
645     }
646
647   if (!read_file (pfile, file))
648     return false;
649
650   /* Check the file against the PCH file.  This is done before
651      checking against files we've already seen, since it may save on
652      I/O.  */
653   if (check_file_against_entries (pfile, file, import))
654     {
655       /* If this isn't a #import, but yet we can't include the file,
656          that means that it was #import-ed in the PCH file,
657          so we can never include it again.  */
658       if (! import)
659         _cpp_mark_file_once_only (pfile, file);
660       return false;
661     }
662
663   /* Now we've read the file's contents, we can stack it if there
664      are no once-only files.  */
665   if (!pfile->seen_once_only)
666     return true;
667
668   /* We may have read the file under a different name.  Look
669      for likely candidates and compare file contents to be sure.  */
670   for (f = pfile->all_files; f; f = f->next_file)
671     {
672       if (f == file)
673         continue;
674
675       if ((import || f->once_only)
676           && f->err_no == 0
677           && f->st.st_mtime == file->st.st_mtime
678           && f->st.st_size == file->st.st_size)
679         {
680           _cpp_file *ref_file;
681           bool same_file_p = false;
682
683           if (f->buffer && !f->buffer_valid)
684             {
685               /* We already have a buffer but it is not valid, because
686                  the file is still stacked.  Make a new one.  */
687               ref_file = make_cpp_file (pfile, f->dir, f->name);
688               ref_file->path = f->path;
689             }
690           else
691             /* The file is not stacked anymore.  We can reuse it.  */
692             ref_file = f;
693
694           same_file_p = read_file (pfile, ref_file)
695                         /* Size might have changed in read_file().  */
696                         && ref_file->st.st_size == file->st.st_size
697                         && !memcmp (ref_file->buffer,
698                                     file->buffer,
699                                     file->st.st_size);
700
701           if (f->buffer && !f->buffer_valid)
702             {
703               ref_file->path = 0;
704               destroy_cpp_file (ref_file);
705             }
706
707           if (same_file_p)
708             break;
709         }
710     }
711
712   return f == NULL;
713 }
714
715 /* Place the file referenced by FILE into a new buffer on the buffer
716    stack if possible.  IMPORT is true if this stacking attempt is
717    because of a #import directive.  Returns true if a buffer is
718    stacked.  */
719 bool
720 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
721 {
722   cpp_buffer *buffer;
723   int sysp;
724
725   if (!should_stack_file (pfile, file, import))
726       return false;
727
728   if (pfile->buffer == NULL || file->dir == NULL)
729     sysp = 0;
730   else
731     sysp = MAX (pfile->buffer->sysp,  file->dir->sysp);
732
733   /* Add the file to the dependencies on its first inclusion.  */
734   if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
735     {
736       if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
737         deps_add_dep (pfile->deps, file->path);
738     }
739
740   /* Clear buffer_valid since _cpp_clean_line messes it up.  */
741   file->buffer_valid = false;
742   file->stack_count++;
743
744   /* Stack the buffer.  */
745   buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
746                             CPP_OPTION (pfile, preprocessed));
747   buffer->file = file;
748   buffer->sysp = sysp;
749
750   /* Initialize controlling macro state.  */
751   pfile->mi_valid = true;
752   pfile->mi_cmacro = 0;
753
754   /* Generate the call back.  */
755   _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
756
757   return true;
758 }
759
760 /* Mark FILE to be included once only.  */
761 void
762 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
763 {
764   pfile->seen_once_only = true;
765   file->once_only = true;
766 }
767
768 /* Return the directory from which searching for FNAME should start,
769    considering the directive TYPE and ANGLE_BRACKETS.  If there is
770    nothing left in the path, returns NULL.  */
771 static struct cpp_dir *
772 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
773                   enum include_type type)
774 {
775   cpp_dir *dir;
776   _cpp_file *file;
777
778   if (IS_ABSOLUTE_PATH (fname))
779     return &pfile->no_search_path;
780
781   /* pfile->buffer is NULL when processing an -include command-line flag.  */
782   file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
783
784   /* For #include_next, skip in the search path past the dir in which
785      the current file was found, but if it was found via an absolute
786      path use the normal search logic.  */
787   if (type == IT_INCLUDE_NEXT && file->dir)
788     dir = file->dir->next;
789   else if (angle_brackets)
790     dir = pfile->bracket_include;
791   else if (type == IT_CMDLINE)
792     /* -include and -imacros use the #include "" chain with the
793        preprocessor's cwd prepended.  */
794     return make_cpp_dir (pfile, "./", false);
795   else if (pfile->quote_ignores_source_dir)
796     dir = pfile->quote_include;
797   else
798     return make_cpp_dir (pfile, dir_name_of_file (file),
799                          pfile->buffer ? pfile->buffer->sysp : 0);
800
801   if (dir == NULL)
802     cpp_error (pfile, CPP_DL_ERROR,
803                "no include path in which to search for %s", fname);
804
805   return dir;
806 }
807
808 /* Strip the basename from the file's path.  It ends with a slash if
809    of nonzero length.  Note that this procedure also works for
810    <stdin>, which is represented by the empty string.  */
811 static const char *
812 dir_name_of_file (_cpp_file *file)
813 {
814   if (!file->dir_name)
815     {
816       size_t len = lbasename (file->path) - file->path;
817       char *dir_name = xmalloc (len + 1);
818
819       memcpy (dir_name, file->path, len);
820       dir_name[len] = '\0';
821       file->dir_name = dir_name;
822     }
823
824   return file->dir_name;
825 }
826
827 /* Handles #include-family directives (distinguished by TYPE),
828    including HEADER, and the command line -imacros and -include.
829    Returns true if a buffer was stacked.  */
830 bool
831 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
832                     enum include_type type)
833 {
834   struct cpp_dir *dir;
835   _cpp_file *file;
836
837   dir = search_path_head (pfile, fname, angle_brackets, type);
838   if (!dir)
839     return false;
840
841   file = _cpp_find_file (pfile, fname, dir, false);
842
843   /* Compensate for the increment in linemap_add.  In the case of a
844      normal #include, we're currently at the start of the line
845      *following* the #include.  A separate source_location for this
846      location makes no sense (until we do the LC_LEAVE), and
847      complicates LAST_SOURCE_LINE_LOCATION.  This does not apply if we
848      found a PCH file (in which case linemap_add is not called) or we
849      were included from the command-line.  */
850   if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
851     pfile->line_table->highest_location--;
852
853   return _cpp_stack_file (pfile, file, type == IT_IMPORT);
854 }
855
856 /* Could not open FILE.  The complication is dependency output.  */
857 static void
858 open_file_failed (cpp_reader *pfile, _cpp_file *file)
859 {
860   int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
861   bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
862
863   errno = file->err_no;
864   if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
865     deps_add_dep (pfile->deps, file->name);
866   else
867     {
868       /* If we are outputting dependencies but not for this file then
869          don't error because we can still produce correct output.  */
870       if (CPP_OPTION (pfile, deps.style) && ! print_dep)
871         cpp_errno (pfile, CPP_DL_WARNING, file->path);
872       else
873         cpp_errno (pfile, CPP_DL_ERROR, file->path);
874     }
875 }
876
877 /* Search in the chain beginning at HEAD for a file whose search path
878    started at START_DIR != NULL.  */
879 static struct file_hash_entry *
880 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
881 {
882   struct file_hash_entry *p;
883
884   /* Look for a file that was found from a search starting at the
885      given location.  */
886   for (p = head; p; p = p->next)
887     if (p->start_dir == start_dir)
888       return p;
889   return 0;
890 }
891
892 /* Allocate a new _cpp_file structure.  */
893 static _cpp_file *
894 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
895 {
896   _cpp_file *file;
897
898   file = xcalloc (1, sizeof (_cpp_file));
899   file->main_file = !pfile->buffer;
900   file->fd = -1;
901   file->dir = dir;
902   file->name = xstrdup (fname);
903
904   return file;
905 }
906
907 /* Release a _cpp_file structure.  */
908 static void
909 destroy_cpp_file (_cpp_file *file)
910 {
911   if (file->buffer)
912     free ((void *) file->buffer);
913   free ((void *) file->name);
914   free (file);
915 }
916
917 /* A hash of directory names.  The directory names are the path names
918    of files which contain a #include "", the included file name is
919    appended to this directories.
920
921    To avoid duplicate entries we follow the convention that all
922    non-empty directory names should end in a '/'.  DIR_NAME must be
923    stored in permanently allocated memory.  */
924 static cpp_dir *
925 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
926 {
927   struct file_hash_entry *entry, **hash_slot;
928   cpp_dir *dir;
929
930   hash_slot = (struct file_hash_entry **)
931     htab_find_slot_with_hash (pfile->dir_hash, dir_name,
932                               htab_hash_string (dir_name),
933                               INSERT);
934
935   /* Have we already hashed this directory?  */
936   for (entry = *hash_slot; entry; entry = entry->next)
937     if (entry->start_dir == NULL)
938       return entry->u.dir;
939
940   dir = xcalloc (1, sizeof (cpp_dir));
941   dir->next = pfile->quote_include;
942   dir->name = (char *) dir_name;
943   dir->len = strlen (dir_name);
944   dir->sysp = sysp;
945   dir->construct = 0;
946
947   /* Store this new result in the hash table.  */
948   entry = new_file_hash_entry (pfile);
949   entry->next = *hash_slot;
950   entry->start_dir = NULL;
951   entry->u.dir = dir;
952   *hash_slot = entry;
953
954   return dir;
955 }
956
957 /* Create a new block of memory for file hash entries.  */
958 static void
959 allocate_file_hash_entries (cpp_reader *pfile)
960 {
961   pfile->file_hash_entries_used = 0;
962   pfile->file_hash_entries_allocated = 127;
963   pfile->file_hash_entries = xmalloc
964     (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
965 }
966
967 /* Return a new file hash entry.  */
968 static struct file_hash_entry *
969 new_file_hash_entry (cpp_reader *pfile)
970 {
971   if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
972     allocate_file_hash_entries (pfile);
973
974   return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
975 }
976
977 /* Returns TRUE if a file FNAME has ever been successfully opened.
978    This routine is not intended to correctly handle filenames aliased
979    by links or redundant . or .. traversals etc.  */
980 bool
981 cpp_included (cpp_reader *pfile, const char *fname)
982 {
983   struct file_hash_entry *entry;
984
985   entry = htab_find_with_hash (pfile->file_hash, fname,
986                                htab_hash_string (fname));
987
988   while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
989     entry = entry->next;
990
991   return entry != NULL;
992 }
993
994 /* Calculate the hash value of a file hash entry P.  */
995
996 static hashval_t
997 file_hash_hash (const void *p)
998 {
999   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1000   const char *hname;
1001   if (entry->start_dir)
1002     hname = entry->u.file->name;
1003   else
1004     hname = entry->u.dir->name;
1005
1006   return htab_hash_string (hname);
1007 }
1008
1009 /* Compare a string Q against a file hash entry P.  */
1010 static int
1011 file_hash_eq (const void *p, const void *q)
1012 {
1013   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1014   const char *fname = (const char *) q;
1015   const char *hname;
1016
1017   if (entry->start_dir)
1018     hname = entry->u.file->name;
1019   else
1020     hname = entry->u.dir->name;
1021
1022   return strcmp (hname, fname) == 0;
1023 }
1024
1025 /* Initialize everything in this source file.  */
1026 void
1027 _cpp_init_files (cpp_reader *pfile)
1028 {
1029   pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1030                                         NULL, xcalloc, free);
1031   pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1032                                         NULL, xcalloc, free);
1033   allocate_file_hash_entries (pfile);
1034 }
1035
1036 /* Finalize everything in this source file.  */
1037 void
1038 _cpp_cleanup_files (cpp_reader *pfile)
1039 {
1040   htab_delete (pfile->file_hash);
1041   htab_delete (pfile->dir_hash);
1042 }
1043
1044 /* Enter a file name in the hash for the sake of cpp_included.  */
1045 void
1046 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1047 {
1048   _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
1049 }
1050
1051 /* Not everyone who wants to set system-header-ness on a buffer can
1052    see the details of a buffer.  This is an exported interface because
1053    fix-header needs it.  */
1054 void
1055 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1056 {
1057   int flags = 0;
1058   const struct line_maps *line_table = pfile->line_table;
1059   const struct line_map *map = &line_table->maps[line_table->used-1];
1060
1061   /* 1 = system header, 2 = system header to be treated as C.  */
1062   if (syshdr)
1063     flags = 1 + (externc != 0);
1064   pfile->buffer->sysp = flags;
1065   _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1066                        SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1067 }
1068
1069 /* Allow the client to change the current file.  Used by the front end
1070    to achieve pseudo-file names like <built-in>.
1071    If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1072 void
1073 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1074                  const char *new_name)
1075 {
1076   _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1077 }
1078
1079 /* Callback function for htab_traverse.  */
1080 static int
1081 report_missing_guard (void **slot, void *b)
1082 {
1083   struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1084   int *bannerp = (int *) b;
1085
1086   /* Skip directories.  */
1087   if (entry->start_dir != NULL)
1088     {
1089       _cpp_file *file = entry->u.file;
1090
1091       /* We don't want MI guard advice for the main file.  */
1092       if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1093         {
1094           if (*bannerp == 0)
1095             {
1096               fputs (_("Multiple include guards may be useful for:\n"),
1097                      stderr);
1098               *bannerp = 1;
1099             }
1100
1101           fputs (entry->u.file->path, stderr);
1102           putc ('\n', stderr);
1103         }
1104     }
1105
1106   return 0;
1107 }
1108
1109 /* Report on all files that might benefit from a multiple include guard.
1110    Triggered by -H.  */
1111 void
1112 _cpp_report_missing_guards (cpp_reader *pfile)
1113 {
1114   int banner = 0;
1115
1116   htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1117 }
1118
1119 /* Locate HEADER, and determine whether it is newer than the current
1120    file.  If it cannot be located or dated, return -1, if it is
1121    newer, return 1, otherwise 0.  */
1122 int
1123 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1124                         int angle_brackets)
1125 {
1126   _cpp_file *file;
1127   struct cpp_dir *dir;
1128
1129   dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1130   if (!dir)
1131     return -1;
1132
1133   file = _cpp_find_file (pfile, fname, dir, false);
1134   if (file->err_no)
1135     return -1;
1136
1137   if (file->fd != -1)
1138     {
1139       close (file->fd);
1140       file->fd = -1;
1141     }
1142
1143   return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1144 }
1145
1146 /* Pushes the given file onto the buffer stack.  Returns nonzero if
1147    successful.  */
1148 bool
1149 cpp_push_include (cpp_reader *pfile, const char *fname)
1150 {
1151   return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1152 }
1153
1154 /* Do appropriate cleanup when a file INC's buffer is popped off the
1155    input stack.  */
1156 void
1157 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1158 {
1159   /* Record the inclusion-preventing macro, which could be NULL
1160      meaning no controlling macro.  */
1161   if (pfile->mi_valid && file->cmacro == NULL)
1162     file->cmacro = pfile->mi_cmacro;
1163
1164   /* Invalidate control macros in the #including file.  */
1165   pfile->mi_valid = false;
1166
1167   if (file->buffer)
1168     {
1169       free ((void *) file->buffer);
1170       file->buffer = NULL;
1171     }
1172 }
1173
1174 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1175    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1176    directory of the including file.
1177
1178    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1179 void
1180 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1181                         int quote_ignores_source_dir)
1182 {
1183   pfile->quote_include = quote;
1184   pfile->bracket_include = quote;
1185   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1186
1187   for (; quote; quote = quote->next)
1188     {
1189       quote->name_map = NULL;
1190       quote->len = strlen (quote->name);
1191       if (quote == bracket)
1192         pfile->bracket_include = bracket;
1193     }
1194 }
1195
1196 /* Append the file name to the directory to create the path, but don't
1197    turn / into // or // into ///; // may be a namespace escape.  */
1198 static char *
1199 append_file_to_dir (const char *fname, cpp_dir *dir)
1200 {
1201   size_t dlen, flen;
1202   char *path;
1203
1204   dlen = dir->len;
1205   flen = strlen (fname);
1206   path = xmalloc (dlen + 1 + flen + 1);
1207   memcpy (path, dir->name, dlen);
1208   if (dlen && path[dlen - 1] != '/')
1209     path[dlen++] = '/';
1210   memcpy (&path[dlen], fname, flen + 1);
1211
1212   return path;
1213 }
1214
1215 /* Read a space delimited string of unlimited length from a stdio
1216    file F.  */
1217 static char *
1218 read_filename_string (int ch, FILE *f)
1219 {
1220   char *alloc, *set;
1221   int len;
1222
1223   len = 20;
1224   set = alloc = xmalloc (len + 1);
1225   if (! is_space (ch))
1226     {
1227       *set++ = ch;
1228       while ((ch = getc (f)) != EOF && ! is_space (ch))
1229         {
1230           if (set - alloc == len)
1231             {
1232               len *= 2;
1233               alloc = xrealloc (alloc, len + 1);
1234               set = alloc + len / 2;
1235             }
1236           *set++ = ch;
1237         }
1238     }
1239   *set = '\0';
1240   ungetc (ch, f);
1241   return alloc;
1242 }
1243
1244 /* Read the file name map file for DIR.  */
1245 static void
1246 read_name_map (cpp_dir *dir)
1247 {
1248   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1249   char *name;
1250   FILE *f;
1251   size_t len, count = 0, room = 9;
1252
1253   len = dir->len;
1254   name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1255   memcpy (name, dir->name, len);
1256   if (len && name[len - 1] != '/')
1257     name[len++] = '/';
1258   strcpy (name + len, FILE_NAME_MAP_FILE);
1259   f = fopen (name, "r");
1260
1261   dir->name_map = xmalloc (room * sizeof (char *));
1262
1263   /* Silently return NULL if we cannot open.  */
1264   if (f)
1265     {
1266       int ch;
1267
1268       while ((ch = getc (f)) != EOF)
1269         {
1270           char *to;
1271
1272           if (is_space (ch))
1273             continue;
1274
1275           if (count + 2 > room)
1276             {
1277               room += 8;
1278               dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1279             }
1280
1281           dir->name_map[count] = read_filename_string (ch, f);
1282           while ((ch = getc (f)) != EOF && is_hspace (ch))
1283             ;
1284
1285           to = read_filename_string (ch, f);
1286           if (IS_ABSOLUTE_PATH (to))
1287             dir->name_map[count + 1] = to;
1288           else
1289             {
1290               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1291               free (to);
1292             }
1293
1294           count += 2;
1295           while ((ch = getc (f)) != '\n')
1296             if (ch == EOF)
1297               break;
1298         }
1299
1300       fclose (f);
1301     }
1302
1303   /* Terminate the list of maps.  */
1304   dir->name_map[count] = NULL;
1305 }
1306
1307 /* Remap a FILE's name based on the file_name_map, if any, for
1308    FILE->dir.  If the file name has any directory separators,
1309    recursively check those directories too.  */
1310 static char *
1311 remap_filename (cpp_reader *pfile, _cpp_file *file)
1312 {
1313   const char *fname, *p;
1314   char *new_dir;
1315   cpp_dir *dir;
1316   size_t index, len;
1317
1318   dir = file->dir;
1319   fname = file->name;
1320
1321   for (;;)
1322     {
1323       if (!dir->name_map)
1324         read_name_map (dir);
1325
1326       for (index = 0; dir->name_map[index]; index += 2)
1327         if (!strcmp (dir->name_map[index], fname))
1328             return xstrdup (dir->name_map[index + 1]);
1329
1330       p = strchr (fname, '/');
1331       if (!p || p == fname)
1332         return NULL;
1333
1334       len = dir->len + (p - fname + 1);
1335       new_dir = xmalloc (len + 1);
1336       memcpy (new_dir, dir->name, dir->len);
1337       memcpy (new_dir + dir->len, fname, p - fname + 1);
1338       new_dir[len] = '\0';
1339
1340       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1341       fname = p + 1;
1342     }
1343 }
1344
1345 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1346 static bool
1347 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1348 {
1349   const char *saved_path = file->path;
1350   bool valid = false;
1351
1352   file->path = pchname;
1353   if (open_file (file))
1354     {
1355       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1356
1357       if (!valid)
1358         {
1359           close (file->fd);
1360           file->fd = -1;
1361         }
1362
1363       if (CPP_OPTION (pfile, print_include_names))
1364         {
1365           unsigned int i;
1366           for (i = 1; i < pfile->line_table->depth; i++)
1367             putc ('.', stderr);
1368           fprintf (stderr, "%c %s\n",
1369                    valid ? '!' : 'x', pchname);
1370         }
1371     }
1372
1373   file->path = saved_path;
1374   return valid;
1375 }
1376
1377 /* Get the path associated with the _cpp_file F.  The path includes
1378    the base name from the include directive and the directory it was
1379    found in via the search path.  */
1380
1381 const char *
1382 cpp_get_path (struct _cpp_file *f)
1383 {
1384   return f->path;
1385 }
1386
1387 /* Get the directory associated with the _cpp_file F.  */
1388
1389 cpp_dir *
1390 cpp_get_dir (struct _cpp_file *f)
1391 {
1392   return f->dir;
1393 }
1394
1395 /* Get the cpp_buffer currently associated with the cpp_reader
1396    PFILE.  */
1397
1398 cpp_buffer *
1399 cpp_get_buffer (cpp_reader *pfile)
1400 {
1401   return pfile->buffer;
1402 }
1403
1404 /* Get the _cpp_file associated with the cpp_buffer B.  */
1405
1406 _cpp_file *
1407 cpp_get_file (cpp_buffer *b)
1408 {
1409   return b->file;
1410 }
1411
1412 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1413    buffer is the buffer that included the given buffer.  */
1414
1415 cpp_buffer *
1416 cpp_get_prev (cpp_buffer *b)
1417 {
1418   return b->prev;
1419 }
1420 \f
1421 /* This data structure holds the list of header files that were seen
1422    while the PCH was being built.  The 'entries' field is kept sorted
1423    in memcmp() order; yes, this means that on little-endian systems,
1424    it's sorted initially by the least-significant byte of 'size', but
1425    that's OK.  The code does rely on having entries with the same size
1426    next to each other.  */
1427
1428 struct pchf_data {
1429   /* Number of pchf_entry structures.  */
1430   size_t count;
1431
1432   /* Are there any values with once_only set?
1433      This is used as an optimisation, it means we don't have to search
1434      the structure if we're processing a regular #include.  */
1435   bool have_once_only;
1436
1437   struct pchf_entry {
1438     /* The size of this file.  This is used to save running a MD5 checksum
1439        if the sizes don't match.  */
1440     off_t size;
1441     /* The MD5 checksum of this file.  */
1442     unsigned char sum[16];
1443     /* Is this file to be included only once?  */
1444     bool once_only;
1445   } entries[1];
1446 };
1447
1448 static struct pchf_data *pchf;
1449
1450 /* A qsort ordering function for pchf_entry structures.  */
1451
1452 static int
1453 pchf_save_compare (const void *e1, const void *e2)
1454 {
1455   return memcmp (e1, e2, sizeof (struct pchf_entry));
1456 }
1457
1458 /* Create and write to F a pchf_data structure.  */
1459
1460 bool
1461 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1462 {
1463   size_t count = 0;
1464   struct pchf_data *result;
1465   size_t result_size;
1466   _cpp_file *f;
1467
1468   for (f = pfile->all_files; f; f = f->next_file)
1469     ++count;
1470
1471   result_size = (sizeof (struct pchf_data)
1472                  + sizeof (struct pchf_entry) * (count - 1));
1473   result = xcalloc (result_size, 1);
1474
1475   result->count = 0;
1476   result->have_once_only = false;
1477
1478   for (f = pfile->all_files; f; f = f->next_file)
1479     {
1480       size_t count;
1481
1482       /* This should probably never happen, since if a read error occurred
1483          the PCH file shouldn't be written...  */
1484       if (f->dont_read || f->err_no)
1485         continue;
1486
1487       if (f->stack_count == 0)
1488         continue;
1489
1490       count = result->count++;
1491
1492       result->entries[count].once_only = f->once_only;
1493       /* |= is avoided in the next line because of an HP C compiler bug */
1494       result->have_once_only = result->have_once_only | f->once_only;
1495       if (f->buffer_valid)
1496         md5_buffer ((const char *)f->buffer,
1497                     f->st.st_size, result->entries[count].sum);
1498       else
1499         {
1500           FILE *ff;
1501           int oldfd = f->fd;
1502
1503           if (!open_file (f))
1504             {
1505               open_file_failed (pfile, f);
1506               return false;
1507             }
1508           ff = fdopen (f->fd, "rb");
1509           md5_stream (ff, result->entries[count].sum);
1510           fclose (ff);
1511           f->fd = oldfd;
1512         }
1513       result->entries[count].size = f->st.st_size;
1514     }
1515
1516   result_size = (sizeof (struct pchf_data)
1517                  + sizeof (struct pchf_entry) * (result->count - 1));
1518
1519   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1520          pchf_save_compare);
1521
1522   return fwrite (result, result_size, 1, fp) == 1;
1523 }
1524
1525 /* Read the pchf_data structure from F.  */
1526
1527 bool
1528 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1529 {
1530   struct pchf_data d;
1531
1532   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1533        != 1)
1534     return false;
1535
1536   pchf = xmalloc (sizeof (struct pchf_data)
1537                   + sizeof (struct pchf_entry) * (d.count - 1));
1538   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1539   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1540       != d.count)
1541     return false;
1542   return true;
1543 }
1544
1545 /* The parameters for pchf_compare.  */
1546
1547 struct pchf_compare_data
1548 {
1549   /* The size of the file we're looking for.  */
1550   off_t size;
1551
1552   /* The MD5 checksum of the file, if it's been computed.  */
1553   unsigned char sum[16];
1554
1555   /* Is SUM valid?  */
1556   bool sum_computed;
1557
1558   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1559   bool check_included;
1560
1561   /* The file that we're searching for.  */
1562   _cpp_file *f;
1563 };
1564
1565 /* bsearch comparison function; look for D_P in E_P.  */
1566
1567 static int
1568 pchf_compare (const void *d_p, const void *e_p)
1569 {
1570   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1571   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1572   int result;
1573
1574   result = memcmp (&d->size, &e->size, sizeof (off_t));
1575   if (result != 0)
1576     return result;
1577
1578   if (! d->sum_computed)
1579     {
1580       _cpp_file *const f = d->f;
1581
1582       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1583       d->sum_computed = true;
1584     }
1585
1586   result = memcmp (d->sum, e->sum, 16);
1587   if (result != 0)
1588     return result;
1589
1590   if (d->check_included || e->once_only)
1591     return 0;
1592   else
1593     return 1;
1594 }
1595
1596 /* Check that F is not in a list read from a PCH file (if any).
1597    Assumes that f->buffer_valid is true.  Return TRUE if the file
1598    should not be read.  */
1599
1600 static bool
1601 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1602                             _cpp_file *f,
1603                             bool check_included)
1604 {
1605   struct pchf_compare_data d;
1606
1607   if (pchf == NULL
1608       || (! check_included && ! pchf->have_once_only))
1609     return false;
1610
1611   d.size = f->st.st_size;
1612   d.sum_computed = false;
1613   d.f = f;
1614   d.check_included = check_included;
1615   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1616                   pchf_compare) != NULL;
1617 }