OSDN Git Service

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