OSDN Git Service

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