OSDN Git Service

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