OSDN Git Service

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