OSDN Git Service

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