OSDN Git Service

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