OSDN Git Service

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