OSDN Git Service

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