OSDN Git Service

libcpp/
[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,
4    2006, 2007, 2008, 2009, 2010, 2011, 2012 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) != 0;
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   free ((void *) file->buffer_start);
1000   free ((void *) file->name);
1001   free (file);
1002 }
1003
1004 /* Release all the files allocated by this reader.  */
1005 static void
1006 destroy_all_cpp_files (cpp_reader *pfile)
1007 {
1008   _cpp_file *iter = pfile->all_files;
1009   while (iter)
1010     {
1011       _cpp_file *next = iter->next_file;
1012       destroy_cpp_file (iter);
1013       iter = next;
1014     }
1015 }
1016
1017 /* A hash of directory names.  The directory names are the path names
1018    of files which contain a #include "", the included file name is
1019    appended to this directories.
1020
1021    To avoid duplicate entries we follow the convention that all
1022    non-empty directory names should end in a '/'.  DIR_NAME must be
1023    stored in permanently allocated memory.  */
1024 static cpp_dir *
1025 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1026 {
1027   struct file_hash_entry *entry, **hash_slot;
1028   cpp_dir *dir;
1029
1030   hash_slot = (struct file_hash_entry **)
1031     htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1032                               htab_hash_string (dir_name),
1033                               INSERT);
1034
1035   /* Have we already hashed this directory?  */
1036   for (entry = *hash_slot; entry; entry = entry->next)
1037     if (entry->start_dir == NULL)
1038       return entry->u.dir;
1039
1040   dir = XCNEW (cpp_dir);
1041   dir->next = pfile->quote_include;
1042   dir->name = (char *) dir_name;
1043   dir->len = strlen (dir_name);
1044   dir->sysp = sysp;
1045   dir->construct = 0;
1046
1047   /* Store this new result in the hash table.  */
1048   entry = new_file_hash_entry (pfile);
1049   entry->next = *hash_slot;
1050   entry->start_dir = NULL;
1051   entry->location = pfile->line_table->highest_location;
1052   entry->u.dir = dir;
1053   *hash_slot = entry;
1054
1055   return dir;
1056 }
1057
1058 /* Create a new block of memory for file hash entries.  */
1059 static void
1060 allocate_file_hash_entries (cpp_reader *pfile)
1061 {
1062   struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1063   pool->file_hash_entries_used = 0;
1064   pool->next = pfile->file_hash_entries;
1065   pfile->file_hash_entries = pool;
1066 }
1067
1068 /* Return a new file hash entry.  */
1069 static struct file_hash_entry *
1070 new_file_hash_entry (cpp_reader *pfile)
1071 {
1072   unsigned int idx;
1073   if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1074     allocate_file_hash_entries (pfile);
1075
1076   idx = pfile->file_hash_entries->file_hash_entries_used++;
1077   return &pfile->file_hash_entries->pool[idx];
1078 }
1079
1080 /* Free the file hash entry pools.  */
1081 static void
1082 free_file_hash_entries (cpp_reader *pfile)
1083 {
1084   struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1085   while (iter)
1086     {
1087       struct file_hash_entry_pool *next = iter->next;
1088       free (iter);
1089       iter = next;
1090     }
1091 }
1092
1093 /* Returns TRUE if a file FNAME has ever been successfully opened.
1094    This routine is not intended to correctly handle filenames aliased
1095    by links or redundant . or .. traversals etc.  */
1096 bool
1097 cpp_included (cpp_reader *pfile, const char *fname)
1098 {
1099   struct file_hash_entry *entry;
1100
1101   entry = (struct file_hash_entry *)
1102      htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1103
1104   while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1105     entry = entry->next;
1106
1107   return entry != NULL;
1108 }
1109
1110 /* Returns TRUE if a file FNAME has ever been successfully opened
1111    before LOCATION.  This routine is not intended to correctly handle
1112    filenames aliased by links or redundant . or .. traversals etc.  */
1113 bool
1114 cpp_included_before (cpp_reader *pfile, const char *fname,
1115                      source_location location)
1116 {
1117   struct file_hash_entry *entry;
1118
1119   entry = (struct file_hash_entry *)
1120      htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1121
1122   while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1123                    || entry->location > location))
1124     entry = entry->next;
1125
1126   return entry != NULL;
1127 }
1128
1129 /* Calculate the hash value of a file hash entry P.  */
1130
1131 static hashval_t
1132 file_hash_hash (const void *p)
1133 {
1134   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1135   const char *hname;
1136   if (entry->start_dir)
1137     hname = entry->u.file->name;
1138   else
1139     hname = entry->u.dir->name;
1140
1141   return htab_hash_string (hname);
1142 }
1143
1144 /* Compare a string Q against a file hash entry P.  */
1145 static int
1146 file_hash_eq (const void *p, const void *q)
1147 {
1148   struct file_hash_entry *entry = (struct file_hash_entry *) p;
1149   const char *fname = (const char *) q;
1150   const char *hname;
1151
1152   if (entry->start_dir)
1153     hname = entry->u.file->name;
1154   else
1155     hname = entry->u.dir->name;
1156
1157   return filename_cmp (hname, fname) == 0;
1158 }
1159
1160 /* Compare entries in the nonexistent file hash table.  These are just
1161    strings.  */
1162 static int
1163 nonexistent_file_hash_eq (const void *p, const void *q)
1164 {
1165   return filename_cmp ((const char *) p, (const char *) q) == 0;
1166 }
1167
1168 /* Initialize everything in this source file.  */
1169 void
1170 _cpp_init_files (cpp_reader *pfile)
1171 {
1172   pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1173                                         NULL, xcalloc, free);
1174   pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1175                                         NULL, xcalloc, free);
1176   allocate_file_hash_entries (pfile);
1177   pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1178                                                     nonexistent_file_hash_eq,
1179                                                     NULL, xcalloc, free);
1180   _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1181                   (void *(*) (long)) xmalloc,
1182                   (void (*) (void *)) free);
1183 }
1184
1185 /* Finalize everything in this source file.  */
1186 void
1187 _cpp_cleanup_files (cpp_reader *pfile)
1188 {
1189   htab_delete (pfile->file_hash);
1190   htab_delete (pfile->dir_hash);
1191   htab_delete (pfile->nonexistent_file_hash);
1192   obstack_free (&pfile->nonexistent_file_ob, 0);
1193   free_file_hash_entries (pfile);
1194   destroy_all_cpp_files (pfile);
1195 }
1196
1197 /* Make the parser forget about files it has seen.  This can be useful
1198    for resetting the parser to start another run.  */
1199 void
1200 cpp_clear_file_cache (cpp_reader *pfile)
1201 {
1202   _cpp_cleanup_files (pfile);
1203   pfile->file_hash_entries = NULL;
1204   pfile->all_files = NULL;
1205   _cpp_init_files (pfile);
1206 }
1207
1208 /* Enter a file name in the hash for the sake of cpp_included.  */
1209 void
1210 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1211 {
1212   _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1213 }
1214
1215 /* Not everyone who wants to set system-header-ness on a buffer can
1216    see the details of a buffer.  This is an exported interface because
1217    fix-header needs it.  */
1218 void
1219 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1220 {
1221   int flags = 0;
1222   const struct line_maps *line_table = pfile->line_table;
1223   const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1224   /* 1 = system header, 2 = system header to be treated as C.  */
1225   if (syshdr)
1226     flags = 1 + (externc != 0);
1227   pfile->buffer->sysp = flags;
1228   _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1229                        SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1230 }
1231
1232 /* Allow the client to change the current file.  Used by the front end
1233    to achieve pseudo-file names like <built-in>.
1234    If REASON is LC_LEAVE, then NEW_NAME must be NULL.  */
1235 void
1236 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1237                  const char *new_name)
1238 {
1239   _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1240 }
1241
1242 struct report_missing_guard_data
1243 {
1244   const char **paths;
1245   size_t count;
1246 };
1247
1248 /* Callback function for htab_traverse.  */
1249 static int
1250 report_missing_guard (void **slot, void *d)
1251 {
1252   struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1253   struct report_missing_guard_data *data
1254     = (struct report_missing_guard_data *) d;
1255
1256   /* Skip directories.  */
1257   if (entry->start_dir != NULL)
1258     {
1259       _cpp_file *file = entry->u.file;
1260
1261       /* We don't want MI guard advice for the main file.  */
1262       if (!file->once_only && file->cmacro == NULL
1263           && file->stack_count == 1 && !file->main_file)
1264         {
1265           if (data->paths == NULL)
1266             {
1267               data->paths = XCNEWVEC (const char *, data->count);
1268               data->count = 0;
1269             }
1270
1271           data->paths[data->count++] = file->path;
1272         }
1273     }
1274
1275   /* Keep traversing the hash table.  */
1276   return 1;
1277 }
1278
1279 /* Comparison function for qsort.  */
1280 static int
1281 report_missing_guard_cmp (const void *p1, const void *p2)
1282 {
1283   return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1284 }
1285
1286 /* Report on all files that might benefit from a multiple include guard.
1287    Triggered by -H.  */
1288 void
1289 _cpp_report_missing_guards (cpp_reader *pfile)
1290 {
1291   struct report_missing_guard_data data;
1292
1293   data.paths = NULL;
1294   data.count = htab_elements (pfile->file_hash);
1295   htab_traverse (pfile->file_hash, report_missing_guard, &data);
1296
1297   if (data.paths != NULL)
1298     {
1299       size_t i;
1300
1301       /* Sort the paths to avoid outputting them in hash table
1302          order.  */
1303       qsort (data.paths, data.count, sizeof (const char *),
1304              report_missing_guard_cmp);
1305       fputs (_("Multiple include guards may be useful for:\n"),
1306              stderr);
1307       for (i = 0; i < data.count; i++)
1308         {
1309           fputs (data.paths[i], stderr);
1310           putc ('\n', stderr);
1311         }
1312       free (data.paths);
1313     }
1314 }
1315
1316 /* Locate HEADER, and determine whether it is newer than the current
1317    file.  If it cannot be located or dated, return -1, if it is
1318    newer, return 1, otherwise 0.  */
1319 int
1320 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1321                         int angle_brackets)
1322 {
1323   _cpp_file *file;
1324   struct cpp_dir *dir;
1325
1326   dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1327   if (!dir)
1328     return -1;
1329
1330   file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1331   if (file->err_no)
1332     return -1;
1333
1334   if (file->fd != -1)
1335     {
1336       close (file->fd);
1337       file->fd = -1;
1338     }
1339
1340   return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1341 }
1342
1343 /* Pushes the given file onto the buffer stack.  Returns nonzero if
1344    successful.  */
1345 bool
1346 cpp_push_include (cpp_reader *pfile, const char *fname)
1347 {
1348   return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1349 }
1350
1351 /* Do appropriate cleanup when a file INC's buffer is popped off the
1352    input stack.  */
1353 void
1354 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1355 {
1356   /* Record the inclusion-preventing macro, which could be NULL
1357      meaning no controlling macro.  */
1358   if (pfile->mi_valid && file->cmacro == NULL)
1359     file->cmacro = pfile->mi_cmacro;
1360
1361   /* Invalidate control macros in the #including file.  */
1362   pfile->mi_valid = false;
1363
1364   if (file->buffer_start)
1365     {
1366       free ((void *) file->buffer_start);
1367       file->buffer_start = NULL;
1368       file->buffer = NULL;
1369       file->buffer_valid = false;
1370     }
1371 }
1372
1373 /* Return the file name associated with FILE.  */
1374 const char *
1375 _cpp_get_file_name (_cpp_file *file)
1376 {
1377   return file->name;
1378 }
1379
1380 /* Inteface to file statistics record in _cpp_file structure. */
1381 struct stat *
1382 _cpp_get_file_stat (_cpp_file *file)
1383 {
1384     return &file->st;
1385 }
1386
1387 /* Set the include chain for "" to QUOTE, for <> to BRACKET.  If
1388    QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1389    directory of the including file.
1390
1391    If BRACKET does not lie in the QUOTE chain, it is set to QUOTE.  */
1392 void
1393 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1394                         int quote_ignores_source_dir)
1395 {
1396   pfile->quote_include = quote;
1397   pfile->bracket_include = quote;
1398   pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1399
1400   for (; quote; quote = quote->next)
1401     {
1402       quote->name_map = NULL;
1403       quote->len = strlen (quote->name);
1404       if (quote == bracket)
1405         pfile->bracket_include = bracket;
1406     }
1407 }
1408
1409 /* Append the file name to the directory to create the path, but don't
1410    turn / into // or // into ///; // may be a namespace escape.  */
1411 static char *
1412 append_file_to_dir (const char *fname, cpp_dir *dir)
1413 {
1414   size_t dlen, flen;
1415   char *path;
1416
1417   dlen = dir->len;
1418   flen = strlen (fname);
1419   path = XNEWVEC (char, dlen + 1 + flen + 1);
1420   memcpy (path, dir->name, dlen);
1421   if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1422     path[dlen++] = '/';
1423   memcpy (&path[dlen], fname, flen + 1);
1424
1425   return path;
1426 }
1427
1428 /* Read a space delimited string of unlimited length from a stdio
1429    file F.  */
1430 static char *
1431 read_filename_string (int ch, FILE *f)
1432 {
1433   char *alloc, *set;
1434   int len;
1435
1436   len = 20;
1437   set = alloc = XNEWVEC (char, len + 1);
1438   if (! is_space (ch))
1439     {
1440       *set++ = ch;
1441       while ((ch = getc (f)) != EOF && ! is_space (ch))
1442         {
1443           if (set - alloc == len)
1444             {
1445               len *= 2;
1446               alloc = XRESIZEVEC (char, alloc, len + 1);
1447               set = alloc + len / 2;
1448             }
1449           *set++ = ch;
1450         }
1451     }
1452   *set = '\0';
1453   ungetc (ch, f);
1454   return alloc;
1455 }
1456
1457 /* Read the file name map file for DIR.  */
1458 static void
1459 read_name_map (cpp_dir *dir)
1460 {
1461   static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1462   char *name;
1463   FILE *f;
1464   size_t len, count = 0, room = 9;
1465
1466   len = dir->len;
1467   name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1468   memcpy (name, dir->name, len);
1469   if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1470     name[len++] = '/';
1471   strcpy (name + len, FILE_NAME_MAP_FILE);
1472   f = fopen (name, "r");
1473
1474   dir->name_map = XNEWVEC (const char *, room);
1475
1476   /* Silently return NULL if we cannot open.  */
1477   if (f)
1478     {
1479       int ch;
1480
1481       while ((ch = getc (f)) != EOF)
1482         {
1483           char *to;
1484
1485           if (is_space (ch))
1486             continue;
1487
1488           if (count + 2 > room)
1489             {
1490               room += 8;
1491               dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1492             }
1493
1494           dir->name_map[count] = read_filename_string (ch, f);
1495           while ((ch = getc (f)) != EOF && is_hspace (ch))
1496             ;
1497
1498           to = read_filename_string (ch, f);
1499           if (IS_ABSOLUTE_PATH (to))
1500             dir->name_map[count + 1] = to;
1501           else
1502             {
1503               dir->name_map[count + 1] = append_file_to_dir (to, dir);
1504               free (to);
1505             }
1506
1507           count += 2;
1508           while ((ch = getc (f)) != '\n')
1509             if (ch == EOF)
1510               break;
1511         }
1512
1513       fclose (f);
1514     }
1515
1516   /* Terminate the list of maps.  */
1517   dir->name_map[count] = NULL;
1518 }
1519
1520 /* Remap a FILE's name based on the file_name_map, if any, for
1521    FILE->dir.  If the file name has any directory separators,
1522    recursively check those directories too.  */
1523 static char *
1524 remap_filename (cpp_reader *pfile, _cpp_file *file)
1525 {
1526   const char *fname, *p;
1527   char *new_dir;
1528   cpp_dir *dir;
1529   size_t index, len;
1530
1531   dir = file->dir;
1532   fname = file->name;
1533
1534   for (;;)
1535     {
1536       if (!dir->name_map)
1537         read_name_map (dir);
1538
1539       for (index = 0; dir->name_map[index]; index += 2)
1540         if (!filename_cmp (dir->name_map[index], fname))
1541             return xstrdup (dir->name_map[index + 1]);
1542       if (IS_ABSOLUTE_PATH (fname))
1543         return NULL;
1544       p = strchr (fname, '/');
1545 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1546       {
1547         char *p2 = strchr (fname, '\\');
1548         if (!p || (p > p2))
1549           p = p2;
1550       }
1551 #endif
1552       if (!p || p == fname)
1553         return NULL;
1554
1555       len = dir->len + (p - fname + 1);
1556       new_dir = XNEWVEC (char, len + 1);
1557       memcpy (new_dir, dir->name, dir->len);
1558       memcpy (new_dir + dir->len, fname, p - fname + 1);
1559       new_dir[len] = '\0';
1560
1561       dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1562       fname = p + 1;
1563     }
1564 }
1565
1566 /* Returns true if PCHNAME is a valid PCH file for FILE.  */
1567 static bool
1568 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1569 {
1570   const char *saved_path = file->path;
1571   bool valid = false;
1572
1573   file->path = pchname;
1574   if (open_file (file))
1575     {
1576       valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1577
1578       if (!valid)
1579         {
1580           close (file->fd);
1581           file->fd = -1;
1582         }
1583
1584       if (CPP_OPTION (pfile, print_include_names))
1585         {
1586           unsigned int i;
1587           for (i = 1; i < pfile->line_table->depth; i++)
1588             putc ('.', stderr);
1589           fprintf (stderr, "%c %s\n",
1590                    valid ? '!' : 'x', pchname);
1591         }
1592     }
1593
1594   file->path = saved_path;
1595   return valid;
1596 }
1597
1598 /* Get the path associated with the _cpp_file F.  The path includes
1599    the base name from the include directive and the directory it was
1600    found in via the search path.  */
1601
1602 const char *
1603 cpp_get_path (struct _cpp_file *f)
1604 {
1605   return f->path;
1606 }
1607
1608 /* Get the directory associated with the _cpp_file F.  */
1609
1610 cpp_dir *
1611 cpp_get_dir (struct _cpp_file *f)
1612 {
1613   return f->dir;
1614 }
1615
1616 /* Get the cpp_buffer currently associated with the cpp_reader
1617    PFILE.  */
1618
1619 cpp_buffer *
1620 cpp_get_buffer (cpp_reader *pfile)
1621 {
1622   return pfile->buffer;
1623 }
1624
1625 /* Get the _cpp_file associated with the cpp_buffer B.  */
1626
1627 _cpp_file *
1628 cpp_get_file (cpp_buffer *b)
1629 {
1630   return b->file;
1631 }
1632
1633 /* Get the previous cpp_buffer given a cpp_buffer B.  The previous
1634    buffer is the buffer that included the given buffer.  */
1635
1636 cpp_buffer *
1637 cpp_get_prev (cpp_buffer *b)
1638 {
1639   return b->prev;
1640 }
1641 \f
1642 /* This data structure holds the list of header files that were seen
1643    while the PCH was being built.  The 'entries' field is kept sorted
1644    in memcmp() order; yes, this means that on little-endian systems,
1645    it's sorted initially by the least-significant byte of 'size', but
1646    that's OK.  The code does rely on having entries with the same size
1647    next to each other.  */
1648
1649 struct pchf_entry {
1650   /* The size of this file.  This is used to save running a MD5 checksum
1651      if the sizes don't match.  */
1652   off_t size;
1653   /* The MD5 checksum of this file.  */
1654   unsigned char sum[16];
1655   /* Is this file to be included only once?  */
1656   bool once_only;
1657 };
1658
1659 struct pchf_data {
1660   /* Number of pchf_entry structures.  */
1661   size_t count;
1662
1663   /* Are there any values with once_only set?
1664      This is used as an optimisation, it means we don't have to search
1665      the structure if we're processing a regular #include.  */
1666   bool have_once_only;
1667
1668   struct pchf_entry entries[1];
1669 };
1670
1671 static struct pchf_data *pchf;
1672
1673 /* A qsort ordering function for pchf_entry structures.  */
1674
1675 static int
1676 pchf_save_compare (const void *e1, const void *e2)
1677 {
1678   return memcmp (e1, e2, sizeof (struct pchf_entry));
1679 }
1680
1681 /* Create and write to F a pchf_data structure.  */
1682
1683 bool
1684 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1685 {
1686   size_t count = 0;
1687   struct pchf_data *result;
1688   size_t result_size;
1689   _cpp_file *f;
1690
1691   for (f = pfile->all_files; f; f = f->next_file)
1692     ++count;
1693
1694   result_size = (sizeof (struct pchf_data)
1695                  + sizeof (struct pchf_entry) * (count - 1));
1696   result = XCNEWVAR (struct pchf_data, result_size);
1697
1698   result->count = 0;
1699   result->have_once_only = false;
1700
1701   for (f = pfile->all_files; f; f = f->next_file)
1702     {
1703       size_t count;
1704
1705       /* This should probably never happen, since if a read error occurred
1706          the PCH file shouldn't be written...  */
1707       if (f->dont_read || f->err_no)
1708         continue;
1709
1710       if (f->stack_count == 0)
1711         continue;
1712
1713       count = result->count++;
1714
1715       result->entries[count].once_only = f->once_only;
1716       /* |= is avoided in the next line because of an HP C compiler bug */
1717       result->have_once_only = result->have_once_only | f->once_only;
1718       if (f->buffer_valid)
1719         md5_buffer ((const char *)f->buffer,
1720                     f->st.st_size, result->entries[count].sum);
1721       else
1722         {
1723           FILE *ff;
1724           int oldfd = f->fd;
1725
1726           if (!open_file (f))
1727             {
1728               open_file_failed (pfile, f, 0);
1729               return false;
1730             }
1731           ff = fdopen (f->fd, "rb");
1732           md5_stream (ff, result->entries[count].sum);
1733           fclose (ff);
1734           f->fd = oldfd;
1735         }
1736       result->entries[count].size = f->st.st_size;
1737     }
1738
1739   result_size = (sizeof (struct pchf_data)
1740                  + sizeof (struct pchf_entry) * (result->count - 1));
1741
1742   qsort (result->entries, result->count, sizeof (struct pchf_entry),
1743          pchf_save_compare);
1744
1745   return fwrite (result, result_size, 1, fp) == 1;
1746 }
1747
1748 /* Read the pchf_data structure from F.  */
1749
1750 bool
1751 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1752 {
1753   struct pchf_data d;
1754
1755   if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1756        != 1)
1757     return false;
1758
1759   pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1760                   + sizeof (struct pchf_entry) * (d.count - 1));
1761   memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1762   if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1763       != d.count)
1764     return false;
1765   return true;
1766 }
1767
1768 /* The parameters for pchf_compare.  */
1769
1770 struct pchf_compare_data
1771 {
1772   /* The size of the file we're looking for.  */
1773   off_t size;
1774
1775   /* The MD5 checksum of the file, if it's been computed.  */
1776   unsigned char sum[16];
1777
1778   /* Is SUM valid?  */
1779   bool sum_computed;
1780
1781   /* Do we need to worry about entries that don't have ONCE_ONLY set?  */
1782   bool check_included;
1783
1784   /* The file that we're searching for.  */
1785   _cpp_file *f;
1786 };
1787
1788 /* bsearch comparison function; look for D_P in E_P.  */
1789
1790 static int
1791 pchf_compare (const void *d_p, const void *e_p)
1792 {
1793   const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1794   struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1795   int result;
1796
1797   result = memcmp (&d->size, &e->size, sizeof (off_t));
1798   if (result != 0)
1799     return result;
1800
1801   if (! d->sum_computed)
1802     {
1803       _cpp_file *const f = d->f;
1804
1805       md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1806       d->sum_computed = true;
1807     }
1808
1809   result = memcmp (d->sum, e->sum, 16);
1810   if (result != 0)
1811     return result;
1812
1813   if (d->check_included || e->once_only)
1814     return 0;
1815   else
1816     return 1;
1817 }
1818
1819 /* Check that F is not in a list read from a PCH file (if any).
1820    Assumes that f->buffer_valid is true.  Return TRUE if the file
1821    should not be read.  */
1822
1823 static bool
1824 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1825                             _cpp_file *f,
1826                             bool check_included)
1827 {
1828   struct pchf_compare_data d;
1829
1830   if (pchf == NULL
1831       || (! check_included && ! pchf->have_once_only))
1832     return false;
1833
1834   d.size = f->st.st_size;
1835   d.sum_computed = false;
1836   d.f = f;
1837   d.check_included = check_included;
1838   return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1839                   pchf_compare) != NULL;
1840 }