OSDN Git Service

PR preprocessor/20348
[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);
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);
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)
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);
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);
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);
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)
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) > !!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);
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);
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     }
1147 }
1148
1149 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1150    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1151    directory of the including file.
1152
1153    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1154 void
1155 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1156                         int quote_ignores_source_dir)
1157 {
1158   pfile->quote_include = quote;
1159   pfile->bracket_include = quote;
1160   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1161
1162   for (; quote; quote = quote->next)
1163     {
1164       quote->name_map = NULL;
1165       quote->len = strlen (quote->name);
1166       if (quote == bracket)
1167         pfile->bracket_include = bracket;
1168     }
1169 }
1170
1171 /* Append the file name to the directory to create the path, but don't
1172    turn / into // or // into ///; // may be a namespace escape.  */
1173 static char *
1174 append_file_to_dir (const char *fname, cpp_dir *dir)
1175 {
1176   size_t dlen, flen;
1177   char *path;
1178
1179   dlen = dir->len;
1180   flen = strlen (fname);
1181   path = XNEWVEC (char, dlen + 1 + flen + 1);
1182   memcpy (path, dir->name, dlen);
1183   if (dlen && path[dlen - 1] != '/')
1184     path[dlen++] = '/';
1185   memcpy (&path[dlen], fname, flen + 1);
1186
1187   return path;
1188 }
1189
1190 /* Read a space delimited string of unlimited length from a stdio
1191    file F.  */
1192 static char *
1193 read_filename_string (int ch, FILE *f)
1194 {
1195   char *alloc, *set;
1196   int len;
1197
1198   len = 20;
1199   set = alloc = XNEWVEC (char, len + 1);
1200   if (! is_space (ch))
1201     {
1202       *set++ = ch;
1203       while ((ch = getc (f)) != EOF && ! is_space (ch))
1204         {
1205           if (set - alloc == len)
1206             {
1207               len *= 2;
1208               alloc = XRESIZEVEC (char, alloc, len + 1);
1209               set = alloc + len / 2;
1210             }
1211           *set++ = ch;
1212         }
1213     }
1214   *set = '\0';
1215   ungetc (ch, f);
1216   return alloc;
1217 }
1218
1219 /* Read the file name map file for DIR.  */
1220 static void
1221 read_name_map (cpp_dir *dir)
1222 {
1223   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1224   char *name;
1225   FILE *f;
1226   size_t len, count = 0, room = 9;
1227
1228   len = dir->len;
1229   name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1230   memcpy (name, dir->name, len);
1231   if (len && name[len - 1] != '/')
1232     name[len++] = '/';
1233   strcpy (name + len, FILE_NAME_MAP_FILE);
1234   f = fopen (name, "r");
1235
1236   dir->name_map = XNEWVEC (const char *, room);
1237
1238   /* Silently return NULL if we cannot open.  */
1239   if (f)
1240     {
1241       int ch;
1242
1243       while ((ch = getc (f)) != EOF)
1244         {
1245           char *to;
1246
1247           if (is_space (ch))
1248             continue;
1249
1250           if (count + 2 > room)
1251             {
1252               room += 8;
1253               dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1254             }
1255
1256           dir->name_map[count] = read_filename_string (ch, f);
1257           while ((ch = getc (f)) != EOF && is_hspace (ch))
1258             ;
1259
1260           to = read_filename_string (ch, f);
1261           if (IS_ABSOLUTE_PATH (to))
1262             dir->name_map[count + 1] = to;
1263           else
1264             {
1265               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1266               free (to);
1267             }
1268
1269           count += 2;
1270           while ((ch = getc (f)) != '\n')
1271             if (ch == EOF)
1272               break;
1273         }
1274
1275       fclose (f);
1276     }
1277
1278   /* Terminate the list of maps.  */
1279   dir->name_map[count] = NULL;
1280 }
1281
1282 /* Remap a FILE's name based on the file_name_map, if any, for
1283    FILE->dir.  If the file name has any directory separators,
1284    recursively check those directories too.  */
1285 static char *
1286 remap_filename (cpp_reader *pfile, _cpp_file *file)
1287 {
1288   const char *fname, *p;
1289   char *new_dir;
1290   cpp_dir *dir;
1291   size_t index, len;
1292
1293   dir = file->dir;
1294   fname = file->name;
1295
1296   for (;;)
1297     {
1298       if (!dir->name_map)
1299         read_name_map (dir);
1300
1301       for (index = 0; dir->name_map[index]; index += 2)
1302         if (!strcmp (dir->name_map[index], fname))
1303             return xstrdup (dir->name_map[index + 1]);
1304
1305       p = strchr (fname, '/');
1306       if (!p || p == fname)
1307         return NULL;
1308
1309       len = dir->len + (p - fname + 1);
1310       new_dir = XNEWVEC (char, len + 1);
1311       memcpy (new_dir, dir->name, dir->len);
1312       memcpy (new_dir + dir->len, fname, p - fname + 1);
1313       new_dir[len] = '\0';
1314
1315       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1316       fname = p + 1;
1317     }
1318 }
1319
1320 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1321 static bool
1322 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1323 {
1324   const char *saved_path = file->path;
1325   bool valid = false;
1326
1327   file->path = pchname;
1328   if (open_file (file))
1329     {
1330       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1331
1332       if (!valid)
1333         {
1334           close (file->fd);
1335           file->fd = -1;
1336         }
1337
1338       if (CPP_OPTION (pfile, print_include_names))
1339         {
1340           unsigned int i;
1341           for (i = 1; i < pfile->line_table->depth; i++)
1342             putc ('.', stderr);
1343           fprintf (stderr, "%c %s\n",
1344                    valid ? '!' : 'x', pchname);
1345         }
1346     }
1347
1348   file->path = saved_path;
1349   return valid;
1350 }
1351
1352 /* Get the path associated with the _cpp_file F.  The path includes
1353    the base name from the include directive and the directory it was
1354    found in via the search path.  */
1355
1356 const char *
1357 cpp_get_path (struct _cpp_file *f)
1358 {
1359   return f->path;
1360 }
1361
1362 /* Get the directory associated with the _cpp_file F.  */
1363
1364 cpp_dir *
1365 cpp_get_dir (struct _cpp_file *f)
1366 {
1367   return f->dir;
1368 }
1369
1370 /* Get the cpp_buffer currently associated with the cpp_reader
1371    PFILE.  */
1372
1373 cpp_buffer *
1374 cpp_get_buffer (cpp_reader *pfile)
1375 {
1376   return pfile->buffer;
1377 }
1378
1379 /* Get the _cpp_file associated with the cpp_buffer B.  */
1380
1381 _cpp_file *
1382 cpp_get_file (cpp_buffer *b)
1383 {
1384   return b->file;
1385 }
1386
1387 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1388    buffer is the buffer that included the given buffer.  */
1389
1390 cpp_buffer *
1391 cpp_get_prev (cpp_buffer *b)
1392 {
1393   return b->prev;
1394 }
1395 \f
1396 /* This data structure holds the list of header files that were seen
1397    while the PCH was being built.  The 'entries' field is kept sorted
1398    in memcmp() order; yes, this means that on little-endian systems,
1399    it's sorted initially by the least-significant byte of 'size', but
1400    that's OK.  The code does rely on having entries with the same size
1401    next to each other.  */
1402
1403 struct pchf_entry {
1404   /* The size of this file.  This is used to save running a MD5 checksum
1405      if the sizes don't match.  */
1406   off_t size;
1407   /* The MD5 checksum of this file.  */
1408   unsigned char sum[16];
1409   /* Is this file to be included only once?  */
1410   bool once_only;
1411 };
1412
1413 struct pchf_data {
1414   /* Number of pchf_entry structures.  */
1415   size_t count;
1416
1417   /* Are there any values with once_only set?
1418      This is used as an optimisation, it means we don't have to search
1419      the structure if we're processing a regular #include.  */
1420   bool have_once_only;
1421
1422   struct pchf_entry entries[1];
1423 };
1424
1425 static struct pchf_data *pchf;
1426
1427 /* A qsort ordering function for pchf_entry structures.  */
1428
1429 static int
1430 pchf_save_compare (const void *e1, const void *e2)
1431 {
1432   return memcmp (e1, e2, sizeof (struct pchf_entry));
1433 }
1434
1435 /* Create and write to F a pchf_data structure.  */
1436
1437 bool
1438 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1439 {
1440   size_t count = 0;
1441   struct pchf_data *result;
1442   size_t result_size;
1443   _cpp_file *f;
1444
1445   for (f = pfile->all_files; f; f = f->next_file)
1446     ++count;
1447
1448   result_size = (sizeof (struct pchf_data)
1449                  + sizeof (struct pchf_entry) * (count - 1));
1450   result = XCNEWVAR (struct pchf_data, result_size);
1451
1452   result->count = 0;
1453   result->have_once_only = false;
1454
1455   for (f = pfile->all_files; f; f = f->next_file)
1456     {
1457       size_t count;
1458
1459       /* This should probably never happen, since if a read error occurred
1460          the PCH file shouldn't be written...  */
1461       if (f->dont_read || f->err_no)
1462         continue;
1463
1464       if (f->stack_count == 0)
1465         continue;
1466
1467       count = result->count++;
1468
1469       result->entries[count].once_only = f->once_only;
1470       /* |= is avoided in the next line because of an HP C compiler bug */
1471       result->have_once_only = result->have_once_only | f->once_only;
1472       if (f->buffer_valid)
1473         md5_buffer ((const char *)f->buffer,
1474                     f->st.st_size, result->entries[count].sum);
1475       else
1476         {
1477           FILE *ff;
1478           int oldfd = f->fd;
1479
1480           if (!open_file (f))
1481             {
1482               open_file_failed (pfile, f);
1483               return false;
1484             }
1485           ff = fdopen (f->fd, "rb");
1486           md5_stream (ff, result->entries[count].sum);
1487           fclose (ff);
1488           f->fd = oldfd;
1489         }
1490       result->entries[count].size = f->st.st_size;
1491     }
1492
1493   result_size = (sizeof (struct pchf_data)
1494                  + sizeof (struct pchf_entry) * (result->count - 1));
1495
1496   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1497          pchf_save_compare);
1498
1499   return fwrite (result, result_size, 1, fp) == 1;
1500 }
1501
1502 /* Read the pchf_data structure from F.  */
1503
1504 bool
1505 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1506 {
1507   struct pchf_data d;
1508
1509   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1510        != 1)
1511     return false;
1512
1513   pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1514                   + sizeof (struct pchf_entry) * (d.count - 1));
1515   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1516   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1517       != d.count)
1518     return false;
1519   return true;
1520 }
1521
1522 /* The parameters for pchf_compare.  */
1523
1524 struct pchf_compare_data
1525 {
1526   /* The size of the file we're looking for.  */
1527   off_t size;
1528
1529   /* The MD5 checksum of the file, if it's been computed.  */
1530   unsigned char sum[16];
1531
1532   /* Is SUM valid?  */
1533   bool sum_computed;
1534
1535   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1536   bool check_included;
1537
1538   /* The file that we're searching for.  */
1539   _cpp_file *f;
1540 };
1541
1542 /* bsearch comparison function; look for D_P in E_P.  */
1543
1544 static int
1545 pchf_compare (const void *d_p, const void *e_p)
1546 {
1547   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1548   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1549   int result;
1550
1551   result = memcmp (&d->size, &e->size, sizeof (off_t));
1552   if (result != 0)
1553     return result;
1554
1555   if (! d->sum_computed)
1556     {
1557       _cpp_file *const f = d->f;
1558
1559       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1560       d->sum_computed = true;
1561     }
1562
1563   result = memcmp (d->sum, e->sum, 16);
1564   if (result != 0)
1565     return result;
1566
1567   if (d->check_included || e->once_only)
1568     return 0;
1569   else
1570     return 1;
1571 }
1572
1573 /* Check that F is not in a list read from a PCH file (if any).
1574    Assumes that f->buffer_valid is true.  Return TRUE if the file
1575    should not be read.  */
1576
1577 static bool
1578 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1579                             _cpp_file *f,
1580                             bool check_included)
1581 {
1582   struct pchf_compare_data d;
1583
1584   if (pchf == NULL
1585       || (! check_included && ! pchf->have_once_only))
1586     return false;
1587
1588   d.size = f->st.st_size;
1589   d.sum_computed = false;
1590   d.f = f;
1591   d.check_included = check_included;
1592   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1593                   pchf_compare) != NULL;
1594 }