OSDN Git Service

Update comment for last commit.
[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->once_only && file->cmacro == NULL
1265           && file->stack_count == 1 && !file->main_file)
1266         {
1267           if (data->paths == NULL)
1268             {
1269               data->paths = XCNEWVEC (const char *, data->count);
1270               data->count = 0;
1271             }
1272
1273           data->paths[data->count++] = file->path;
1274         }
1275     }
1276
1277   /* Keep traversing the hash table.  */
1278   return 1;
1279 }
1280
1281 /* Comparison function for qsort.  */
1282 static int
1283 report_missing_guard_cmp (const void *p1, const void *p2)
1284 {
1285   return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1286 }
1287
1288 /* Report on all files that might benefit from a multiple include guard.
1289    Triggered by -H.  */
1290 void
1291 _cpp_report_missing_guards (cpp_reader *pfile)
1292 {
1293   struct report_missing_guard_data data;
1294
1295   data.paths = NULL;
1296   data.count = htab_elements (pfile->file_hash);
1297   htab_traverse (pfile->file_hash, report_missing_guard, &data);
1298
1299   if (data.paths != NULL)
1300     {
1301       size_t i;
1302
1303       /* Sort the paths to avoid outputting them in hash table
1304          order.  */
1305       qsort (data.paths, data.count, sizeof (const char *),
1306              report_missing_guard_cmp);
1307       fputs (_("Multiple include guards may be useful for:\n"),
1308              stderr);
1309       for (i = 0; i < data.count; i++)
1310         {
1311           fputs (data.paths[i], stderr);
1312           putc ('\n', stderr);
1313         }
1314       free (data.paths);
1315     }
1316 }
1317
1318 /* Locate HEADER, and determine whether it is newer than the current
1319    file.  If it cannot be located or dated, return -1, if it is
1320    newer, return 1, otherwise 0.  */
1321 int
1322 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1323                         int angle_brackets)
1324 {
1325   _cpp_file *file;
1326   struct cpp_dir *dir;
1327
1328   dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1329   if (!dir)
1330     return -1;
1331
1332   file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1333   if (file->err_no)
1334     return -1;
1335
1336   if (file->fd != -1)
1337     {
1338       close (file->fd);
1339       file->fd = -1;
1340     }
1341
1342   return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1343 }
1344
1345 /* Pushes the given file onto the buffer stack.  Returns nonzero if
1346    successful.  */
1347 bool
1348 cpp_push_include (cpp_reader *pfile, const char *fname)
1349 {
1350   return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1351 }
1352
1353 /* Do appropriate cleanup when a file INC's buffer is popped off the
1354    input stack.  */
1355 void
1356 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1357 {
1358   /* Record the inclusion-preventing macro, which could be NULL
1359      meaning no controlling macro.  */
1360   if (pfile->mi_valid && file->cmacro == NULL)
1361     file->cmacro = pfile->mi_cmacro;
1362
1363   /* Invalidate control macros in the #including file.  */
1364   pfile->mi_valid = false;
1365
1366   if (file->buffer_start)
1367     {
1368       free ((void *) file->buffer_start);
1369       file->buffer_start = NULL;
1370       file->buffer = NULL;
1371       file->buffer_valid = false;
1372     }
1373 }
1374
1375 /* Inteface to file statistics record in _cpp_file structure. */
1376 struct stat *
1377 _cpp_get_file_stat (_cpp_file *file)
1378 {
1379     return &file->st;
1380 }
1381
1382 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1383    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1384    directory of the including file.
1385
1386    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1387 void
1388 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1389                         int quote_ignores_source_dir)
1390 {
1391   pfile->quote_include = quote;
1392   pfile->bracket_include = quote;
1393   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1394
1395   for (; quote; quote = quote->next)
1396     {
1397       quote->name_map = NULL;
1398       quote->len = strlen (quote->name);
1399       if (quote == bracket)
1400         pfile->bracket_include = bracket;
1401     }
1402 }
1403
1404 /* Append the file name to the directory to create the path, but don't
1405    turn / into // or // into ///; // may be a namespace escape.  */
1406 static char *
1407 append_file_to_dir (const char *fname, cpp_dir *dir)
1408 {
1409   size_t dlen, flen;
1410   char *path;
1411
1412   dlen = dir->len;
1413   flen = strlen (fname);
1414   path = XNEWVEC (char, dlen + 1 + flen + 1);
1415   memcpy (path, dir->name, dlen);
1416   if (dlen && path[dlen - 1] != '/')
1417     path[dlen++] = '/';
1418   memcpy (&path[dlen], fname, flen + 1);
1419
1420   return path;
1421 }
1422
1423 /* Read a space delimited string of unlimited length from a stdio
1424    file F.  */
1425 static char *
1426 read_filename_string (int ch, FILE *f)
1427 {
1428   char *alloc, *set;
1429   int len;
1430
1431   len = 20;
1432   set = alloc = XNEWVEC (char, len + 1);
1433   if (! is_space (ch))
1434     {
1435       *set++ = ch;
1436       while ((ch = getc (f)) != EOF && ! is_space (ch))
1437         {
1438           if (set - alloc == len)
1439             {
1440               len *= 2;
1441               alloc = XRESIZEVEC (char, alloc, len + 1);
1442               set = alloc + len / 2;
1443             }
1444           *set++ = ch;
1445         }
1446     }
1447   *set = '\0';
1448   ungetc (ch, f);
1449   return alloc;
1450 }
1451
1452 /* Read the file name map file for DIR.  */
1453 static void
1454 read_name_map (cpp_dir *dir)
1455 {
1456   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1457   char *name;
1458   FILE *f;
1459   size_t len, count = 0, room = 9;
1460
1461   len = dir->len;
1462   name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1463   memcpy (name, dir->name, len);
1464   if (len && name[len - 1] != '/')
1465     name[len++] = '/';
1466   strcpy (name + len, FILE_NAME_MAP_FILE);
1467   f = fopen (name, "r");
1468
1469   dir->name_map = XNEWVEC (const char *, room);
1470
1471   /* Silently return NULL if we cannot open.  */
1472   if (f)
1473     {
1474       int ch;
1475
1476       while ((ch = getc (f)) != EOF)
1477         {
1478           char *to;
1479
1480           if (is_space (ch))
1481             continue;
1482
1483           if (count + 2 > room)
1484             {
1485               room += 8;
1486               dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1487             }
1488
1489           dir->name_map[count] = read_filename_string (ch, f);
1490           while ((ch = getc (f)) != EOF && is_hspace (ch))
1491             ;
1492
1493           to = read_filename_string (ch, f);
1494           if (IS_ABSOLUTE_PATH (to))
1495             dir->name_map[count + 1] = to;
1496           else
1497             {
1498               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1499               free (to);
1500             }
1501
1502           count += 2;
1503           while ((ch = getc (f)) != '\n')
1504             if (ch == EOF)
1505               break;
1506         }
1507
1508       fclose (f);
1509     }
1510
1511   /* Terminate the list of maps.  */
1512   dir->name_map[count] = NULL;
1513 }
1514
1515 /* Remap a FILE's name based on the file_name_map, if any, for
1516    FILE->dir.  If the file name has any directory separators,
1517    recursively check those directories too.  */
1518 static char *
1519 remap_filename (cpp_reader *pfile, _cpp_file *file)
1520 {
1521   const char *fname, *p;
1522   char *new_dir;
1523   cpp_dir *dir;
1524   size_t index, len;
1525
1526   dir = file->dir;
1527   fname = file->name;
1528
1529   for (;;)
1530     {
1531       if (!dir->name_map)
1532         read_name_map (dir);
1533
1534       for (index = 0; dir->name_map[index]; index += 2)
1535         if (!strcmp (dir->name_map[index], fname))
1536             return xstrdup (dir->name_map[index + 1]);
1537
1538       p = strchr (fname, '/');
1539       if (!p || p == fname)
1540         return NULL;
1541
1542       len = dir->len + (p - fname + 1);
1543       new_dir = XNEWVEC (char, len + 1);
1544       memcpy (new_dir, dir->name, dir->len);
1545       memcpy (new_dir + dir->len, fname, p - fname + 1);
1546       new_dir[len] = '\0';
1547
1548       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1549       fname = p + 1;
1550     }
1551 }
1552
1553 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1554 static bool
1555 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1556 {
1557   const char *saved_path = file->path;
1558   bool valid = false;
1559
1560   file->path = pchname;
1561   if (open_file (file))
1562     {
1563       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1564
1565       if (!valid)
1566         {
1567           close (file->fd);
1568           file->fd = -1;
1569         }
1570
1571       if (CPP_OPTION (pfile, print_include_names))
1572         {
1573           unsigned int i;
1574           for (i = 1; i < pfile->line_table->depth; i++)
1575             putc ('.', stderr);
1576           fprintf (stderr, "%c %s\n",
1577                    valid ? '!' : 'x', pchname);
1578         }
1579     }
1580
1581   file->path = saved_path;
1582   return valid;
1583 }
1584
1585 /* Get the path associated with the _cpp_file F.  The path includes
1586    the base name from the include directive and the directory it was
1587    found in via the search path.  */
1588
1589 const char *
1590 cpp_get_path (struct _cpp_file *f)
1591 {
1592   return f->path;
1593 }
1594
1595 /* Get the directory associated with the _cpp_file F.  */
1596
1597 cpp_dir *
1598 cpp_get_dir (struct _cpp_file *f)
1599 {
1600   return f->dir;
1601 }
1602
1603 /* Get the cpp_buffer currently associated with the cpp_reader
1604    PFILE.  */
1605
1606 cpp_buffer *
1607 cpp_get_buffer (cpp_reader *pfile)
1608 {
1609   return pfile->buffer;
1610 }
1611
1612 /* Get the _cpp_file associated with the cpp_buffer B.  */
1613
1614 _cpp_file *
1615 cpp_get_file (cpp_buffer *b)
1616 {
1617   return b->file;
1618 }
1619
1620 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1621    buffer is the buffer that included the given buffer.  */
1622
1623 cpp_buffer *
1624 cpp_get_prev (cpp_buffer *b)
1625 {
1626   return b->prev;
1627 }
1628 \f
1629 /* This data structure holds the list of header files that were seen
1630    while the PCH was being built.  The 'entries' field is kept sorted
1631    in memcmp() order; yes, this means that on little-endian systems,
1632    it's sorted initially by the least-significant byte of 'size', but
1633    that's OK.  The code does rely on having entries with the same size
1634    next to each other.  */
1635
1636 struct pchf_entry {
1637   /* The size of this file.  This is used to save running a MD5 checksum
1638      if the sizes don't match.  */
1639   off_t size;
1640   /* The MD5 checksum of this file.  */
1641   unsigned char sum[16];
1642   /* Is this file to be included only once?  */
1643   bool once_only;
1644 };
1645
1646 struct pchf_data {
1647   /* Number of pchf_entry structures.  */
1648   size_t count;
1649
1650   /* Are there any values with once_only set?
1651      This is used as an optimisation, it means we don't have to search
1652      the structure if we're processing a regular #include.  */
1653   bool have_once_only;
1654
1655   struct pchf_entry entries[1];
1656 };
1657
1658 static struct pchf_data *pchf;
1659
1660 /* A qsort ordering function for pchf_entry structures.  */
1661
1662 static int
1663 pchf_save_compare (const void *e1, const void *e2)
1664 {
1665   return memcmp (e1, e2, sizeof (struct pchf_entry));
1666 }
1667
1668 /* Create and write to F a pchf_data structure.  */
1669
1670 bool
1671 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1672 {
1673   size_t count = 0;
1674   struct pchf_data *result;
1675   size_t result_size;
1676   _cpp_file *f;
1677
1678   for (f = pfile->all_files; f; f = f->next_file)
1679     ++count;
1680
1681   result_size = (sizeof (struct pchf_data)
1682                  + sizeof (struct pchf_entry) * (count - 1));
1683   result = XCNEWVAR (struct pchf_data, result_size);
1684
1685   result->count = 0;
1686   result->have_once_only = false;
1687
1688   for (f = pfile->all_files; f; f = f->next_file)
1689     {
1690       size_t count;
1691
1692       /* This should probably never happen, since if a read error occurred
1693          the PCH file shouldn't be written...  */
1694       if (f->dont_read || f->err_no)
1695         continue;
1696
1697       if (f->stack_count == 0)
1698         continue;
1699
1700       count = result->count++;
1701
1702       result->entries[count].once_only = f->once_only;
1703       /* |= is avoided in the next line because of an HP C compiler bug */
1704       result->have_once_only = result->have_once_only | f->once_only;
1705       if (f->buffer_valid)
1706         md5_buffer ((const char *)f->buffer,
1707                     f->st.st_size, result->entries[count].sum);
1708       else
1709         {
1710           FILE *ff;
1711           int oldfd = f->fd;
1712
1713           if (!open_file (f))
1714             {
1715               open_file_failed (pfile, f, 0);
1716               return false;
1717             }
1718           ff = fdopen (f->fd, "rb");
1719           md5_stream (ff, result->entries[count].sum);
1720           fclose (ff);
1721           f->fd = oldfd;
1722         }
1723       result->entries[count].size = f->st.st_size;
1724     }
1725
1726   result_size = (sizeof (struct pchf_data)
1727                  + sizeof (struct pchf_entry) * (result->count - 1));
1728
1729   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1730          pchf_save_compare);
1731
1732   return fwrite (result, result_size, 1, fp) == 1;
1733 }
1734
1735 /* Read the pchf_data structure from F.  */
1736
1737 bool
1738 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1739 {
1740   struct pchf_data d;
1741
1742   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1743        != 1)
1744     return false;
1745
1746   pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1747                   + sizeof (struct pchf_entry) * (d.count - 1));
1748   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1749   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1750       != d.count)
1751     return false;
1752   return true;
1753 }
1754
1755 /* The parameters for pchf_compare.  */
1756
1757 struct pchf_compare_data
1758 {
1759   /* The size of the file we're looking for.  */
1760   off_t size;
1761
1762   /* The MD5 checksum of the file, if it's been computed.  */
1763   unsigned char sum[16];
1764
1765   /* Is SUM valid?  */
1766   bool sum_computed;
1767
1768   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1769   bool check_included;
1770
1771   /* The file that we're searching for.  */
1772   _cpp_file *f;
1773 };
1774
1775 /* bsearch comparison function; look for D_P in E_P.  */
1776
1777 static int
1778 pchf_compare (const void *d_p, const void *e_p)
1779 {
1780   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1781   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1782   int result;
1783
1784   result = memcmp (&d->size, &e->size, sizeof (off_t));
1785   if (result != 0)
1786     return result;
1787
1788   if (! d->sum_computed)
1789     {
1790       _cpp_file *const f = d->f;
1791
1792       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1793       d->sum_computed = true;
1794     }
1795
1796   result = memcmp (d->sum, e->sum, 16);
1797   if (result != 0)
1798     return result;
1799
1800   if (d->check_included || e->once_only)
1801     return 0;
1802   else
1803     return 1;
1804 }
1805
1806 /* Check that F is not in a list read from a PCH file (if any).
1807    Assumes that f->buffer_valid is true.  Return TRUE if the file
1808    should not be read.  */
1809
1810 static bool
1811 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1812                             _cpp_file *f,
1813                             bool check_included)
1814 {
1815   struct pchf_compare_data d;
1816
1817   if (pchf == NULL
1818       || (! check_included && ! pchf->have_once_only))
1819     return false;
1820
1821   d.size = f->st.st_size;
1822   d.sum_computed = false;
1823   d.f = f;
1824   d.check_included = check_included;
1825   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1826                   pchf_compare) != NULL;
1827 }