Daily bump.
[official-gcc.git] / libcpp / files.c
blob2f491224c6fcb6f07d6d750996ec7a75a9c80ca4
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2015 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Split out of cpplib.c, Zack Weinberg, Oct 1998
7 Reimplemented, Neil Booth, Jul 2003
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
12 later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "cpplib.h"
26 #include "internal.h"
27 #include "mkdeps.h"
28 #include "obstack.h"
29 #include "hashtab.h"
30 #include "md5.h"
31 #include <dirent.h>
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
35 #ifdef VMS
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
38 #else
39 # define STAT_SIZE_RELIABLE(ST) true
40 #endif
42 #ifdef __DJGPP__
43 #include <io.h>
44 /* For DJGPP redirected input is opened in text mode. */
45 # define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY)
47 #else
48 # define set_stdin_to_binary_mode() /* Nothing */
49 #endif
51 /* This structure represents a file searched for by CPP, whether it
52 exists or not. An instance may be pointed to by more than one
53 cpp_file_hash_entry; at present no reference count is kept. */
54 struct _cpp_file
56 /* Filename as given to #include or command line switch. */
57 const char *name;
59 /* The full path used to find the file. */
60 const char *path;
62 /* The full path of the pch file. */
63 const char *pchname;
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
67 const char *dir_name;
69 /* Chain through all files. */
70 struct _cpp_file *next_file;
72 /* The contents of NAME after calling read_file(). */
73 const uchar *buffer;
75 /* Pointer to the real start of BUFFER. read_file() might increment
76 BUFFER; when freeing, this this pointer must be used instead. */
77 const uchar *buffer_start;
79 /* The macro, if any, preventing re-inclusion. */
80 const cpp_hashnode *cmacro;
82 /* The directory in the search path where FILE was found. Used for
83 #include_next and determining whether a header is a system
84 header. */
85 cpp_dir *dir;
87 /* As filled in by stat(2) for the file. */
88 struct stat st;
90 /* File descriptor. Invalid if -1, otherwise open. */
91 int fd;
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
95 int err_no;
97 /* Number of times the file has been stacked for preprocessing. */
98 unsigned short stack_count;
100 /* If opened with #import or contains #pragma once. */
101 bool once_only;
103 /* If read() failed before. */
104 bool dont_read;
106 /* If this file is the main file. */
107 bool main_file;
109 /* If BUFFER above contains the true contents of the file. */
110 bool buffer_valid;
112 /* If this file is implicitly preincluded. */
113 bool implicit_preinclude;
116 /* A singly-linked list for all searches for a given file name, with
117 its head pointed to by a slot in FILE_HASH. The file name is what
118 appeared between the quotes in a #include directive; it can be
119 determined implicitly from the hash table location or explicitly
120 from FILE->name.
122 FILE is a structure containing details about the file that was
123 found with that search, or details of how the search failed.
125 START_DIR is the starting location of the search in the include
126 chain. The current directories for "" includes are also hashed in
127 the hash table and therefore unique. Files that are looked up
128 without using a search path, such as absolute filenames and file
129 names from the command line share a special starting directory so
130 they don't cause cache hits with normal include-chain lookups.
132 If START_DIR is NULL then the entry is for a directory, not a file,
133 and the directory is in DIR. Since the starting point in a file
134 lookup chain is never NULL, this means that simple pointer
135 comparisons against START_DIR can be made to determine cache hits
136 in file lookups.
138 If a cache lookup fails because of e.g. an extra "./" in the path,
139 then nothing will break. It is just less efficient as CPP will
140 have to do more work re-preprocessing the file, and/or comparing
141 its contents against earlier once-only files.
143 struct cpp_file_hash_entry
145 struct cpp_file_hash_entry *next;
146 cpp_dir *start_dir;
147 source_location location;
148 union
150 _cpp_file *file;
151 cpp_dir *dir;
152 } u;
155 /* Number of entries to put in a cpp_file_hash_entry pool. */
156 #define FILE_HASH_POOL_SIZE 127
158 /* A file hash entry pool. We allocate cpp_file_hash_entry object from
159 one of these. */
160 struct file_hash_entry_pool
162 /* Number of entries used from this pool. */
163 unsigned int file_hash_entries_used;
164 /* Next pool in the chain; used when freeing. */
165 struct file_hash_entry_pool *next;
166 /* The memory pool. */
167 struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE];
170 static bool open_file (_cpp_file *file);
171 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
172 bool *invalid_pch);
173 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
174 bool *invalid_pch);
175 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
176 static bool read_file (cpp_reader *pfile, _cpp_file *file);
177 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
178 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
179 int angle_brackets, enum include_type);
180 static const char *dir_name_of_file (_cpp_file *file);
181 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
182 static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
183 const cpp_dir *start_dir);
184 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
185 static void destroy_cpp_file (_cpp_file *);
186 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
187 static void allocate_file_hash_entries (cpp_reader *pfile);
188 static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
189 static int report_missing_guard (void **slot, void *b);
190 static hashval_t file_hash_hash (const void *p);
191 static int file_hash_eq (const void *p, const void *q);
192 static char *read_filename_string (int ch, FILE *f);
193 static void read_name_map (cpp_dir *dir);
194 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
195 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
196 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
197 static int pchf_save_compare (const void *e1, const void *e2);
198 static int pchf_compare (const void *d_p, const void *e_p);
199 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
201 /* Given a filename in FILE->PATH, with the empty string interpreted
202 as <stdin>, open it.
204 On success FILE contains an open file descriptor and stat
205 information for the file. On failure the file descriptor is -1 and
206 the appropriate errno is also stored in FILE. Returns TRUE iff
207 successful.
209 We used to open files in nonblocking mode, but that caused more
210 problems than it solved. Do take care not to acquire a controlling
211 terminal by mistake (this can't happen on sane systems, but
212 paranoia is a virtue).
214 Use the three-argument form of open even though we aren't
215 specifying O_CREAT, to defend against broken system headers.
217 O_BINARY tells some runtime libraries (notably DJGPP) not to do
218 newline translation; we can handle DOS line breaks just fine
219 ourselves. */
220 static bool
221 open_file (_cpp_file *file)
223 if (file->path[0] == '\0')
225 file->fd = 0;
226 set_stdin_to_binary_mode ();
228 else
229 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
231 if (file->fd != -1)
233 if (fstat (file->fd, &file->st) == 0)
235 if (!S_ISDIR (file->st.st_mode))
237 file->err_no = 0;
238 return true;
241 /* Ignore a directory and continue the search. The file we're
242 looking for may be elsewhere in the search path. */
243 errno = ENOENT;
246 close (file->fd);
247 file->fd = -1;
249 #if defined(_WIN32) && !defined(__CYGWIN__)
250 else if (errno == EACCES)
252 /* On most UNIX systems, open succeeds on a directory. Above,
253 we check if we have opened a directory and if so, set errno
254 to ENOENT. However, on Windows, opening a directory
255 fails with EACCES. We want to return ENOENT in that
256 case too. */
257 if (stat (file->path, &file->st) == 0
258 && S_ISDIR (file->st.st_mode))
259 errno = ENOENT;
260 else
261 /* The call to stat may have reset errno. */
262 errno = EACCES;
264 #endif
265 else if (errno == ENOTDIR)
266 errno = ENOENT;
268 file->err_no = errno;
270 return false;
273 /* Temporary PCH intercept of opening a file. Try to find a PCH file
274 based on FILE->name and FILE->dir, and test those found for
275 validity using PFILE->cb.valid_pch. Return true iff a valid file is
276 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
278 static bool
279 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
281 static const char extension[] = ".gch";
282 const char *path = file->path;
283 size_t len, flen;
284 char *pchname;
285 struct stat st;
286 bool valid = false;
288 /* No PCH on <stdin> or if not requested. */
289 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
290 return false;
292 /* If the file is not included as first include from either the toplevel
293 file or the command-line it is not a valid use of PCH. */
294 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
295 if (f->implicit_preinclude)
296 continue;
297 else if (f->main_file)
298 break;
299 else
300 return false;
302 flen = strlen (path);
303 len = flen + sizeof (extension);
304 pchname = XNEWVEC (char, len);
305 memcpy (pchname, path, flen);
306 memcpy (pchname + flen, extension, sizeof (extension));
308 if (stat (pchname, &st) == 0)
310 DIR *pchdir;
311 struct dirent *d;
312 size_t dlen, plen = len;
314 if (!S_ISDIR (st.st_mode))
315 valid = validate_pch (pfile, file, pchname);
316 else if ((pchdir = opendir (pchname)) != NULL)
318 pchname[plen - 1] = '/';
319 while ((d = readdir (pchdir)) != NULL)
321 dlen = strlen (d->d_name) + 1;
322 if ((strcmp (d->d_name, ".") == 0)
323 || (strcmp (d->d_name, "..") == 0))
324 continue;
325 if (dlen + plen > len)
327 len += dlen + 64;
328 pchname = XRESIZEVEC (char, pchname, len);
330 memcpy (pchname + plen, d->d_name, dlen);
331 valid = validate_pch (pfile, file, pchname);
332 if (valid)
333 break;
335 closedir (pchdir);
337 if (!valid)
338 *invalid_pch = true;
341 if (valid)
342 file->pchname = pchname;
343 else
344 free (pchname);
346 return valid;
349 /* Canonicalize the path to FILE. Return the canonical form if it is
350 shorter, otherwise return NULL. This function does NOT free the
351 memory pointed by FILE. */
353 static char *
354 maybe_shorter_path (const char * file)
356 char * file2 = lrealpath (file);
357 if (file2 && strlen (file2) < strlen (file))
359 return file2;
361 else
363 free (file2);
364 return NULL;
368 /* Try to open the path FILE->name appended to FILE->dir. This is
369 where remap and PCH intercept the file lookup process. Return true
370 if the file was found, whether or not the open was successful.
371 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
373 static bool
374 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
376 char *path;
378 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
380 else
381 if (file->dir->construct)
382 path = file->dir->construct (file->name, file->dir);
383 else
384 path = append_file_to_dir (file->name, file->dir);
386 if (path)
388 hashval_t hv;
389 char *copy;
390 void **pp;
392 /* We try to canonicalize system headers. For DOS based file
393 * system, we always try to shorten non-system headers, as DOS
394 * has a tighter constraint on max path length. */
395 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
396 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
397 || !file->dir->sysp
398 #endif
401 char * canonical_path = maybe_shorter_path (path);
402 if (canonical_path)
404 /* The canonical path was newly allocated. Let's free the
405 non-canonical one. */
406 free (path);
407 path = canonical_path;
411 hv = htab_hash_string (path);
412 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
414 file->err_no = ENOENT;
415 return false;
418 file->path = path;
419 if (pch_open_file (pfile, file, invalid_pch))
420 return true;
422 if (open_file (file))
423 return true;
425 if (file->err_no != ENOENT)
427 open_file_failed (pfile, file, 0);
428 return true;
431 /* We copy the path name onto an obstack partly so that we don't
432 leak the memory, but mostly so that we don't fragment the
433 heap. */
434 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
435 strlen (path));
436 free (path);
437 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
438 copy, hv, INSERT);
439 *pp = copy;
441 file->path = file->name;
443 else
445 file->err_no = ENOENT;
446 file->path = NULL;
449 return false;
452 /* Return tue iff the missing_header callback found the given HEADER. */
453 static bool
454 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
456 missing_header_cb func = pfile->cb.missing_header;
458 /* When the regular search path doesn't work, try context dependent
459 headers search paths. */
460 if (func
461 && file->dir == NULL)
463 if ((file->path = func (pfile, header, &file->dir)) != NULL)
465 if (open_file (file))
466 return true;
467 free ((void *)file->path);
469 file->path = file->name;
472 return false;
475 bool
476 _cpp_find_failed (_cpp_file *file)
478 return file->err_no != 0;
481 /* Given a filename FNAME search for such a file in the include path
482 starting from START_DIR. If FNAME is the empty string it is
483 interpreted as STDIN if START_DIR is PFILE->no_search_path.
485 If the file is not found in the file cache fall back to the O/S and
486 add the result to our cache.
488 If the file was not found in the filesystem, or there was an error
489 opening it, then ERR_NO is nonzero and FD is -1. If the file was
490 found, then ERR_NO is zero and FD could be -1 or an open file
491 descriptor. FD can be -1 if the file was found in the cache and
492 had previously been closed. To open it again pass the return value
493 to open_file().
495 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
496 If present, it is OK for a precompiled header to be included after
499 _cpp_file *
500 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
501 bool fake, int angle_brackets, bool implicit_preinclude)
503 struct cpp_file_hash_entry *entry;
504 void **hash_slot;
505 _cpp_file *file;
506 bool invalid_pch = false;
507 bool saw_bracket_include = false;
508 bool saw_quote_include = false;
509 struct cpp_dir *found_in_cache = NULL;
511 /* Ensure we get no confusion between cached files and directories. */
512 if (start_dir == NULL)
513 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
515 hash_slot
516 = htab_find_slot_with_hash (pfile->file_hash, fname,
517 htab_hash_string (fname), INSERT);
519 /* First check the cache before we resort to memory allocation. */
520 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
521 if (entry)
522 return entry->u.file;
524 file = make_cpp_file (pfile, start_dir, fname);
525 file->implicit_preinclude = implicit_preinclude;
527 /* Try each path in the include chain. */
528 for (; !fake ;)
530 if (find_file_in_dir (pfile, file, &invalid_pch))
531 break;
533 file->dir = file->dir->next;
534 if (file->dir == NULL)
536 if (search_path_exhausted (pfile, fname, file))
538 /* Although this file must not go in the cache, because
539 the file found might depend on things (like the current file)
540 that aren't represented in the cache, it still has to go in
541 the list of all files so that #import works. */
542 file->next_file = pfile->all_files;
543 pfile->all_files = file;
544 if (*hash_slot == NULL)
546 /* If *hash_slot is NULL, the above htab_find_slot_with_hash
547 call just created the slot, but we aren't going to store
548 there anything, so need to remove the newly created entry.
549 htab_clear_slot requires that it is non-NULL, so store
550 there some non-NULL pointer, htab_clear_slot will
551 overwrite it immediately. */
552 *hash_slot = file;
553 htab_clear_slot (pfile->file_hash, hash_slot);
555 return file;
558 if (invalid_pch)
560 cpp_error (pfile, CPP_DL_ERROR,
561 "one or more PCH files were found, but they were invalid");
562 if (!cpp_get_options (pfile)->warn_invalid_pch)
563 cpp_error (pfile, CPP_DL_ERROR,
564 "use -Winvalid-pch for more information");
566 if (implicit_preinclude)
568 free ((char *) file->name);
569 free (file);
570 if (*hash_slot == NULL)
572 /* See comment on the above htab_clear_slot call. */
573 *hash_slot = file;
574 htab_clear_slot (pfile->file_hash, hash_slot);
576 return NULL;
578 else
579 open_file_failed (pfile, file, angle_brackets);
580 break;
583 /* Only check the cache for the starting location (done above)
584 and the quote and bracket chain heads because there are no
585 other possible starting points for searches. */
586 if (file->dir == pfile->bracket_include)
587 saw_bracket_include = true;
588 else if (file->dir == pfile->quote_include)
589 saw_quote_include = true;
590 else
591 continue;
593 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
594 if (entry)
596 found_in_cache = file->dir;
597 break;
601 if (entry)
603 /* Cache for START_DIR too, sharing the _cpp_file structure. */
604 free ((char *) file->name);
605 free (file);
606 file = entry->u.file;
608 else
610 /* This is a new file; put it in the list. */
611 file->next_file = pfile->all_files;
612 pfile->all_files = file;
615 /* Store this new result in the hash table. */
616 entry = new_file_hash_entry (pfile);
617 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
618 entry->start_dir = start_dir;
619 entry->location = pfile->line_table->highest_location;
620 entry->u.file = file;
621 *hash_slot = (void *) entry;
623 /* If we passed the quote or bracket chain heads, cache them also.
624 This speeds up processing if there are lots of -I options. */
625 if (saw_bracket_include
626 && pfile->bracket_include != start_dir
627 && found_in_cache != pfile->bracket_include)
629 entry = new_file_hash_entry (pfile);
630 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
631 entry->start_dir = pfile->bracket_include;
632 entry->location = pfile->line_table->highest_location;
633 entry->u.file = file;
634 *hash_slot = (void *) entry;
636 if (saw_quote_include
637 && pfile->quote_include != start_dir
638 && found_in_cache != pfile->quote_include)
640 entry = new_file_hash_entry (pfile);
641 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
642 entry->start_dir = pfile->quote_include;
643 entry->location = pfile->line_table->highest_location;
644 entry->u.file = file;
645 *hash_slot = (void *) entry;
648 return file;
651 /* Read a file into FILE->buffer, returning true on success.
653 If FILE->fd is something weird, like a block device, we don't want
654 to read it at all. Don't even try to figure out what something is,
655 except for plain files and block devices, since there is no
656 reliable portable way of doing this.
658 FIXME: Flush file cache and try again if we run out of memory. */
659 static bool
660 read_file_guts (cpp_reader *pfile, _cpp_file *file)
662 ssize_t size, total, count;
663 uchar *buf;
664 bool regular;
666 if (S_ISBLK (file->st.st_mode))
668 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
669 return false;
672 regular = S_ISREG (file->st.st_mode) != 0;
673 if (regular)
675 /* off_t might have a wider range than ssize_t - in other words,
676 the max size of a file might be bigger than the address
677 space. We can't handle a file that large. (Anyone with
678 a single source file bigger than 2GB needs to rethink
679 their coding style.) Some systems (e.g. AIX 4.1) define
680 SSIZE_MAX to be much smaller than the actual range of the
681 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
682 does not bite us. */
683 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
685 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
686 return false;
689 size = file->st.st_size;
691 else
692 /* 8 kilobytes is a sensible starting size. It ought to be bigger
693 than the kernel pipe buffer, and it's definitely bigger than
694 the majority of C source files. */
695 size = 8 * 1024;
697 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
698 used to quiet warnings from valgrind or Address Sanitizer, when the
699 optimized lexer accesses aligned 16-byte memory chunks, including
700 the bytes after the malloced, area, and stops lexing on '\n'. */
701 buf = XNEWVEC (uchar, size + 16);
702 total = 0;
703 while ((count = read (file->fd, buf + total, size - total)) > 0)
705 total += count;
707 if (total == size)
709 if (regular)
710 break;
711 size *= 2;
712 buf = XRESIZEVEC (uchar, buf, size + 16);
716 if (count < 0)
718 cpp_errno (pfile, CPP_DL_ERROR, file->path);
719 free (buf);
720 return false;
723 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
724 cpp_error (pfile, CPP_DL_WARNING,
725 "%s is shorter than expected", file->path);
727 file->buffer = _cpp_convert_input (pfile,
728 CPP_OPTION (pfile, input_charset),
729 buf, size + 16, total,
730 &file->buffer_start,
731 &file->st.st_size);
732 file->buffer_valid = true;
734 return true;
737 /* Convenience wrapper around read_file_guts that opens the file if
738 necessary and closes the file descriptor after reading. FILE must
739 have been passed through find_file() at some stage. */
740 static bool
741 read_file (cpp_reader *pfile, _cpp_file *file)
743 /* If we already have its contents in memory, succeed immediately. */
744 if (file->buffer_valid)
745 return true;
747 /* If an earlier read failed for some reason don't try again. */
748 if (file->dont_read || file->err_no)
749 return false;
751 if (file->fd == -1 && !open_file (file))
753 open_file_failed (pfile, file, 0);
754 return false;
757 file->dont_read = !read_file_guts (pfile, file);
758 close (file->fd);
759 file->fd = -1;
761 return !file->dont_read;
764 /* Returns TRUE if FILE's contents have been successfully placed in
765 FILE->buffer and the file should be stacked, otherwise false. */
766 static bool
767 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
769 _cpp_file *f;
771 /* Skip once-only files. */
772 if (file->once_only)
773 return false;
775 /* We must mark the file once-only if #import now, before header
776 guard checks. Otherwise, undefining the header guard might
777 cause the file to be re-stacked. */
778 if (import)
780 _cpp_mark_file_once_only (pfile, file);
782 /* Don't stack files that have been stacked before. */
783 if (file->stack_count)
784 return false;
787 /* Skip if the file had a header guard and the macro is defined.
788 PCH relies on this appearing before the PCH handler below. */
789 if (file->cmacro && file->cmacro->type == NT_MACRO)
790 return false;
792 /* Handle PCH files immediately; don't stack them. */
793 if (file->pchname)
795 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
796 file->fd = -1;
797 free ((void *) file->pchname);
798 file->pchname = NULL;
799 return false;
802 if (!read_file (pfile, file))
803 return false;
805 /* Check the file against the PCH file. This is done before
806 checking against files we've already seen, since it may save on
807 I/O. */
808 if (check_file_against_entries (pfile, file, import))
810 /* If this isn't a #import, but yet we can't include the file,
811 that means that it was #import-ed in the PCH file,
812 so we can never include it again. */
813 if (! import)
814 _cpp_mark_file_once_only (pfile, file);
815 return false;
818 /* Now we've read the file's contents, we can stack it if there
819 are no once-only files. */
820 if (!pfile->seen_once_only)
821 return true;
823 /* We may have read the file under a different name. Look
824 for likely candidates and compare file contents to be sure. */
825 for (f = pfile->all_files; f; f = f->next_file)
827 if (f == file)
828 continue;
830 if ((import || f->once_only)
831 && f->err_no == 0
832 && f->st.st_mtime == file->st.st_mtime
833 && f->st.st_size == file->st.st_size)
835 _cpp_file *ref_file;
836 bool same_file_p = false;
838 if (f->buffer && !f->buffer_valid)
840 /* We already have a buffer but it is not valid, because
841 the file is still stacked. Make a new one. */
842 ref_file = make_cpp_file (pfile, f->dir, f->name);
843 ref_file->path = f->path;
845 else
846 /* The file is not stacked anymore. We can reuse it. */
847 ref_file = f;
849 same_file_p = read_file (pfile, ref_file)
850 /* Size might have changed in read_file(). */
851 && ref_file->st.st_size == file->st.st_size
852 && !memcmp (ref_file->buffer,
853 file->buffer,
854 file->st.st_size);
856 if (f->buffer && !f->buffer_valid)
858 ref_file->path = 0;
859 destroy_cpp_file (ref_file);
862 if (same_file_p)
863 break;
867 return f == NULL;
870 /* Place the file referenced by FILE into a new buffer on the buffer
871 stack if possible. IMPORT is true if this stacking attempt is
872 because of a #import directive. Returns true if a buffer is
873 stacked. */
874 bool
875 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
877 cpp_buffer *buffer;
878 int sysp;
880 if (!should_stack_file (pfile, file, import))
881 return false;
883 if (pfile->buffer == NULL || file->dir == NULL)
884 sysp = 0;
885 else
886 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
888 /* Add the file to the dependencies on its first inclusion. */
889 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
891 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
892 deps_add_dep (pfile->deps, file->path);
895 /* Clear buffer_valid since _cpp_clean_line messes it up. */
896 file->buffer_valid = false;
897 file->stack_count++;
899 /* Stack the buffer. */
900 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
901 CPP_OPTION (pfile, preprocessed)
902 && !CPP_OPTION (pfile, directives_only));
903 buffer->file = file;
904 buffer->sysp = sysp;
905 buffer->to_free = file->buffer_start;
907 /* Initialize controlling macro state. */
908 pfile->mi_valid = true;
909 pfile->mi_cmacro = 0;
911 /* Generate the call back. */
912 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
914 return true;
917 /* Mark FILE to be included once only. */
918 void
919 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
921 pfile->seen_once_only = true;
922 file->once_only = true;
925 /* Return the directory from which searching for FNAME should start,
926 considering the directive TYPE and ANGLE_BRACKETS. If there is
927 nothing left in the path, returns NULL. */
928 static struct cpp_dir *
929 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
930 enum include_type type)
932 cpp_dir *dir;
933 _cpp_file *file;
935 if (IS_ABSOLUTE_PATH (fname))
936 return &pfile->no_search_path;
938 /* pfile->buffer is NULL when processing an -include command-line flag. */
939 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
941 /* For #include_next, skip in the search path past the dir in which
942 the current file was found, but if it was found via an absolute
943 path use the normal search logic. */
944 if (type == IT_INCLUDE_NEXT && file->dir
945 && file->dir != &pfile->no_search_path)
946 dir = file->dir->next;
947 else if (angle_brackets)
948 dir = pfile->bracket_include;
949 else if (type == IT_CMDLINE)
950 /* -include and -imacros use the #include "" chain with the
951 preprocessor's cwd prepended. */
952 return make_cpp_dir (pfile, "./", false);
953 else if (pfile->quote_ignores_source_dir)
954 dir = pfile->quote_include;
955 else
956 return make_cpp_dir (pfile, dir_name_of_file (file),
957 pfile->buffer ? pfile->buffer->sysp : 0);
959 if (dir == NULL)
960 cpp_error (pfile, CPP_DL_ERROR,
961 "no include path in which to search for %s", fname);
963 return dir;
966 /* Strip the basename from the file's path. It ends with a slash if
967 of nonzero length. Note that this procedure also works for
968 <stdin>, which is represented by the empty string. */
969 static const char *
970 dir_name_of_file (_cpp_file *file)
972 if (!file->dir_name)
974 size_t len = lbasename (file->path) - file->path;
975 char *dir_name = XNEWVEC (char, len + 1);
977 memcpy (dir_name, file->path, len);
978 dir_name[len] = '\0';
979 file->dir_name = dir_name;
982 return file->dir_name;
985 /* Handles #include-family directives (distinguished by TYPE),
986 including HEADER, and the command line -imacros and -include.
987 Returns true if a buffer was stacked. */
988 bool
989 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
990 enum include_type type)
992 struct cpp_dir *dir;
993 _cpp_file *file;
994 bool stacked;
996 /* For -include command-line flags we have type == IT_CMDLINE.
997 When the first -include file is processed we have the case, where
998 pfile->cur_token == pfile->cur_run->base, we are directly called up
999 by the front end. However in the case of the second -include file,
1000 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1001 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1002 and pfile->cur_token[-1].src_loc not (yet) initialized.
1003 However, when the include file cannot be found, we need src_loc to
1004 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1005 if (type == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
1006 pfile->cur_token[-1].src_loc = 0;
1008 dir = search_path_head (pfile, fname, angle_brackets, type);
1009 if (!dir)
1010 return false;
1012 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets,
1013 type == IT_DEFAULT);
1014 if (type == IT_DEFAULT && file == NULL)
1015 return false;
1017 /* Compensate for the increment in linemap_add that occurs if
1018 _cpp_stack_file actually stacks the file. In the case of a
1019 normal #include, we're currently at the start of the line
1020 *following* the #include. A separate source_location for this
1021 location makes no sense (until we do the LC_LEAVE), and
1022 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
1023 found a PCH file (in which case linemap_add is not called) or we
1024 were included from the command-line. */
1025 if (file->pchname == NULL && file->err_no == 0
1026 && type != IT_CMDLINE && type != IT_DEFAULT)
1027 pfile->line_table->highest_location--;
1029 stacked = _cpp_stack_file (pfile, file, type == IT_IMPORT);
1031 if (!stacked)
1032 /* _cpp_stack_file didn't stack the file, so let's rollback the
1033 compensation dance we performed above. */
1034 pfile->line_table->highest_location++;
1036 return stacked;
1039 /* Could not open FILE. The complication is dependency output. */
1040 static void
1041 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
1043 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1044 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1046 if (pfile->state.in__has_include__)
1047 return;
1049 errno = file->err_no;
1050 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1052 deps_add_dep (pfile->deps, file->name);
1053 /* If the preprocessor output (other than dependency information) is
1054 being used, we must also flag an error. */
1055 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1056 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1058 else
1060 /* If we are not outputting dependencies, or if we are and dependencies
1061 were requested for this file, or if preprocessor output is needed
1062 in addition to dependency information, this is an error.
1064 Otherwise (outputting dependencies but not for this file, and not
1065 using the preprocessor output), we can still produce correct output
1066 so it's only a warning. */
1067 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1068 || print_dep
1069 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1070 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1071 else
1072 cpp_errno (pfile, CPP_DL_WARNING, file->path);
1076 /* Search in the chain beginning at HEAD for a file whose search path
1077 started at START_DIR != NULL. */
1078 static struct cpp_file_hash_entry *
1079 search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir)
1081 while (head && head->start_dir != start_dir)
1082 head = head->next;
1084 return head;
1087 /* Allocate a new _cpp_file structure. */
1088 static _cpp_file *
1089 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
1091 _cpp_file *file;
1093 file = XCNEW (_cpp_file);
1094 file->main_file = !pfile->buffer;
1095 file->fd = -1;
1096 file->dir = dir;
1097 file->name = xstrdup (fname);
1099 return file;
1102 /* Release a _cpp_file structure. */
1103 static void
1104 destroy_cpp_file (_cpp_file *file)
1106 free ((void *) file->buffer_start);
1107 free ((void *) file->name);
1108 free (file);
1111 /* Release all the files allocated by this reader. */
1112 static void
1113 destroy_all_cpp_files (cpp_reader *pfile)
1115 _cpp_file *iter = pfile->all_files;
1116 while (iter)
1118 _cpp_file *next = iter->next_file;
1119 destroy_cpp_file (iter);
1120 iter = next;
1124 /* A hash of directory names. The directory names are the path names
1125 of files which contain a #include "", the included file name is
1126 appended to this directories.
1128 To avoid duplicate entries we follow the convention that all
1129 non-empty directory names should end in a '/'. DIR_NAME must be
1130 stored in permanently allocated memory. */
1131 static cpp_dir *
1132 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1134 struct cpp_file_hash_entry *entry, **hash_slot;
1135 cpp_dir *dir;
1137 hash_slot = (struct cpp_file_hash_entry **)
1138 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1139 htab_hash_string (dir_name),
1140 INSERT);
1142 /* Have we already hashed this directory? */
1143 for (entry = *hash_slot; entry; entry = entry->next)
1144 if (entry->start_dir == NULL)
1145 return entry->u.dir;
1147 dir = XCNEW (cpp_dir);
1148 dir->next = pfile->quote_include;
1149 dir->name = (char *) dir_name;
1150 dir->len = strlen (dir_name);
1151 dir->sysp = sysp;
1152 dir->construct = 0;
1154 /* Store this new result in the hash table. */
1155 entry = new_file_hash_entry (pfile);
1156 entry->next = *hash_slot;
1157 entry->start_dir = NULL;
1158 entry->location = pfile->line_table->highest_location;
1159 entry->u.dir = dir;
1160 *hash_slot = entry;
1162 return dir;
1165 /* Create a new block of memory for file hash entries. */
1166 static void
1167 allocate_file_hash_entries (cpp_reader *pfile)
1169 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1170 pool->file_hash_entries_used = 0;
1171 pool->next = pfile->file_hash_entries;
1172 pfile->file_hash_entries = pool;
1175 /* Return a new file hash entry. */
1176 static struct cpp_file_hash_entry *
1177 new_file_hash_entry (cpp_reader *pfile)
1179 unsigned int idx;
1180 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1181 allocate_file_hash_entries (pfile);
1183 idx = pfile->file_hash_entries->file_hash_entries_used++;
1184 return &pfile->file_hash_entries->pool[idx];
1187 /* Free the file hash entry pools. */
1188 static void
1189 free_file_hash_entries (cpp_reader *pfile)
1191 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1192 while (iter)
1194 struct file_hash_entry_pool *next = iter->next;
1195 free (iter);
1196 iter = next;
1200 /* Returns TRUE if a file FNAME has ever been successfully opened.
1201 This routine is not intended to correctly handle filenames aliased
1202 by links or redundant . or .. traversals etc. */
1203 bool
1204 cpp_included (cpp_reader *pfile, const char *fname)
1206 struct cpp_file_hash_entry *entry;
1208 entry = (struct cpp_file_hash_entry *)
1209 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1211 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1212 entry = entry->next;
1214 return entry != NULL;
1217 /* Returns TRUE if a file FNAME has ever been successfully opened
1218 before LOCATION. This routine is not intended to correctly handle
1219 filenames aliased by links or redundant . or .. traversals etc. */
1220 bool
1221 cpp_included_before (cpp_reader *pfile, const char *fname,
1222 source_location location)
1224 struct cpp_file_hash_entry *entry;
1226 entry = (struct cpp_file_hash_entry *)
1227 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1229 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1230 || entry->location > location))
1231 entry = entry->next;
1233 return entry != NULL;
1236 /* Calculate the hash value of a file hash entry P. */
1238 static hashval_t
1239 file_hash_hash (const void *p)
1241 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1242 const char *hname;
1243 if (entry->start_dir)
1244 hname = entry->u.file->name;
1245 else
1246 hname = entry->u.dir->name;
1248 return htab_hash_string (hname);
1251 /* Compare a string Q against a file hash entry P. */
1252 static int
1253 file_hash_eq (const void *p, const void *q)
1255 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1256 const char *fname = (const char *) q;
1257 const char *hname;
1259 if (entry->start_dir)
1260 hname = entry->u.file->name;
1261 else
1262 hname = entry->u.dir->name;
1264 return filename_cmp (hname, fname) == 0;
1267 /* Compare entries in the nonexistent file hash table. These are just
1268 strings. */
1269 static int
1270 nonexistent_file_hash_eq (const void *p, const void *q)
1272 return filename_cmp ((const char *) p, (const char *) q) == 0;
1275 /* Initialize everything in this source file. */
1276 void
1277 _cpp_init_files (cpp_reader *pfile)
1279 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1280 NULL, xcalloc, free);
1281 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1282 NULL, xcalloc, free);
1283 allocate_file_hash_entries (pfile);
1284 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1285 nonexistent_file_hash_eq,
1286 NULL, xcalloc, free);
1287 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,
1288 xmalloc, free);
1291 /* Finalize everything in this source file. */
1292 void
1293 _cpp_cleanup_files (cpp_reader *pfile)
1295 htab_delete (pfile->file_hash);
1296 htab_delete (pfile->dir_hash);
1297 htab_delete (pfile->nonexistent_file_hash);
1298 obstack_free (&pfile->nonexistent_file_ob, 0);
1299 free_file_hash_entries (pfile);
1300 destroy_all_cpp_files (pfile);
1303 /* Make the parser forget about files it has seen. This can be useful
1304 for resetting the parser to start another run. */
1305 void
1306 cpp_clear_file_cache (cpp_reader *pfile)
1308 _cpp_cleanup_files (pfile);
1309 pfile->file_hash_entries = NULL;
1310 pfile->all_files = NULL;
1311 _cpp_init_files (pfile);
1314 /* Enter a file name in the hash for the sake of cpp_included. */
1315 void
1316 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1318 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0, false);
1321 /* Not everyone who wants to set system-header-ness on a buffer can
1322 see the details of a buffer. This is an exported interface because
1323 fix-header needs it. */
1324 void
1325 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1327 int flags = 0;
1328 const struct line_maps *line_table = pfile->line_table;
1329 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1330 /* 1 = system header, 2 = system header to be treated as C. */
1331 if (syshdr)
1332 flags = 1 + (externc != 0);
1333 pfile->buffer->sysp = flags;
1334 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1335 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1338 /* Allow the client to change the current file. Used by the front end
1339 to achieve pseudo-file names like <built-in>.
1340 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1341 void
1342 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1343 const char *new_name)
1345 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1348 struct report_missing_guard_data
1350 const char **paths;
1351 size_t count;
1354 /* Callback function for htab_traverse. */
1355 static int
1356 report_missing_guard (void **slot, void *d)
1358 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
1359 struct report_missing_guard_data *data
1360 = (struct report_missing_guard_data *) d;
1362 /* Skip directories. */
1363 if (entry->start_dir != NULL)
1365 _cpp_file *file = entry->u.file;
1367 /* We don't want MI guard advice for the main file. */
1368 if (!file->once_only && file->cmacro == NULL
1369 && file->stack_count == 1 && !file->main_file)
1371 if (data->paths == NULL)
1373 data->paths = XCNEWVEC (const char *, data->count);
1374 data->count = 0;
1377 data->paths[data->count++] = file->path;
1381 /* Keep traversing the hash table. */
1382 return 1;
1385 /* Comparison function for qsort. */
1386 static int
1387 report_missing_guard_cmp (const void *p1, const void *p2)
1389 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1392 /* Report on all files that might benefit from a multiple include guard.
1393 Triggered by -H. */
1394 void
1395 _cpp_report_missing_guards (cpp_reader *pfile)
1397 struct report_missing_guard_data data;
1399 data.paths = NULL;
1400 data.count = htab_elements (pfile->file_hash);
1401 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1403 if (data.paths != NULL)
1405 size_t i;
1407 /* Sort the paths to avoid outputting them in hash table
1408 order. */
1409 qsort (data.paths, data.count, sizeof (const char *),
1410 report_missing_guard_cmp);
1411 fputs (_("Multiple include guards may be useful for:\n"),
1412 stderr);
1413 for (i = 0; i < data.count; i++)
1415 fputs (data.paths[i], stderr);
1416 putc ('\n', stderr);
1418 free (data.paths);
1422 /* Locate HEADER, and determine whether it is newer than the current
1423 file. If it cannot be located or dated, return -1, if it is
1424 newer, return 1, otherwise 0. */
1426 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1427 int angle_brackets)
1429 _cpp_file *file;
1430 struct cpp_dir *dir;
1432 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1433 if (!dir)
1434 return -1;
1436 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, false);
1437 if (file->err_no)
1438 return -1;
1440 if (file->fd != -1)
1442 close (file->fd);
1443 file->fd = -1;
1446 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1449 /* Pushes the given file onto the buffer stack. Returns nonzero if
1450 successful. */
1451 bool
1452 cpp_push_include (cpp_reader *pfile, const char *fname)
1454 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1457 /* Pushes the given file, implicitly included at the start of a
1458 compilation, onto the buffer stack but without any errors if the
1459 file is not found. Returns nonzero if successful. */
1460 bool
1461 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1463 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT);
1466 /* Do appropriate cleanup when a file INC's buffer is popped off the
1467 input stack. */
1468 void
1469 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1470 const unsigned char *to_free)
1472 /* Record the inclusion-preventing macro, which could be NULL
1473 meaning no controlling macro. */
1474 if (pfile->mi_valid && file->cmacro == NULL)
1475 file->cmacro = pfile->mi_cmacro;
1477 /* Invalidate control macros in the #including file. */
1478 pfile->mi_valid = false;
1480 if (to_free)
1482 if (to_free == file->buffer_start)
1484 file->buffer_start = NULL;
1485 file->buffer = NULL;
1486 file->buffer_valid = false;
1488 free ((void *) to_free);
1492 /* Return the file name associated with FILE. */
1493 const char *
1494 _cpp_get_file_name (_cpp_file *file)
1496 return file->name;
1499 /* Inteface to file statistics record in _cpp_file structure. */
1500 struct stat *
1501 _cpp_get_file_stat (_cpp_file *file)
1503 return &file->st;
1506 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1507 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1508 directory of the including file.
1510 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1511 void
1512 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1513 int quote_ignores_source_dir)
1515 pfile->quote_include = quote;
1516 pfile->bracket_include = quote;
1517 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1519 for (; quote; quote = quote->next)
1521 quote->name_map = NULL;
1522 quote->len = strlen (quote->name);
1523 if (quote == bracket)
1524 pfile->bracket_include = bracket;
1528 /* Append the file name to the directory to create the path, but don't
1529 turn / into // or // into ///; // may be a namespace escape. */
1530 static char *
1531 append_file_to_dir (const char *fname, cpp_dir *dir)
1533 size_t dlen, flen;
1534 char *path;
1536 dlen = dir->len;
1537 flen = strlen (fname);
1538 path = XNEWVEC (char, dlen + 1 + flen + 1);
1539 memcpy (path, dir->name, dlen);
1540 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1541 path[dlen++] = '/';
1542 memcpy (&path[dlen], fname, flen + 1);
1544 return path;
1547 /* Read a space delimited string of unlimited length from a stdio
1548 file F. */
1549 static char *
1550 read_filename_string (int ch, FILE *f)
1552 char *alloc, *set;
1553 int len;
1555 len = 20;
1556 set = alloc = XNEWVEC (char, len + 1);
1557 if (! is_space (ch))
1559 *set++ = ch;
1560 while ((ch = getc (f)) != EOF && ! is_space (ch))
1562 if (set - alloc == len)
1564 len *= 2;
1565 alloc = XRESIZEVEC (char, alloc, len + 1);
1566 set = alloc + len / 2;
1568 *set++ = ch;
1571 *set = '\0';
1572 ungetc (ch, f);
1573 return alloc;
1576 /* Read the file name map file for DIR. */
1577 static void
1578 read_name_map (cpp_dir *dir)
1580 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1581 char *name;
1582 FILE *f;
1583 size_t len, count = 0, room = 9;
1585 len = dir->len;
1586 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1587 memcpy (name, dir->name, len);
1588 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1589 name[len++] = '/';
1590 strcpy (name + len, FILE_NAME_MAP_FILE);
1591 f = fopen (name, "r");
1593 dir->name_map = XNEWVEC (const char *, room);
1595 /* Silently return NULL if we cannot open. */
1596 if (f)
1598 int ch;
1600 while ((ch = getc (f)) != EOF)
1602 char *to;
1604 if (is_space (ch))
1605 continue;
1607 if (count + 2 > room)
1609 room += 8;
1610 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1613 dir->name_map[count] = read_filename_string (ch, f);
1614 while ((ch = getc (f)) != EOF && is_hspace (ch))
1617 to = read_filename_string (ch, f);
1618 if (IS_ABSOLUTE_PATH (to))
1619 dir->name_map[count + 1] = to;
1620 else
1622 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1623 free (to);
1626 count += 2;
1627 while ((ch = getc (f)) != '\n')
1628 if (ch == EOF)
1629 break;
1632 fclose (f);
1635 /* Terminate the list of maps. */
1636 dir->name_map[count] = NULL;
1639 /* Remap a FILE's name based on the file_name_map, if any, for
1640 FILE->dir. If the file name has any directory separators,
1641 recursively check those directories too. */
1642 static char *
1643 remap_filename (cpp_reader *pfile, _cpp_file *file)
1645 const char *fname, *p;
1646 char *new_dir;
1647 cpp_dir *dir;
1648 size_t index, len;
1650 dir = file->dir;
1651 fname = file->name;
1653 for (;;)
1655 if (!dir->name_map)
1656 read_name_map (dir);
1658 for (index = 0; dir->name_map[index]; index += 2)
1659 if (!filename_cmp (dir->name_map[index], fname))
1660 return xstrdup (dir->name_map[index + 1]);
1661 if (IS_ABSOLUTE_PATH (fname))
1662 return NULL;
1663 p = strchr (fname, '/');
1664 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1666 char *p2 = strchr (fname, '\\');
1667 if (!p || (p > p2))
1668 p = p2;
1670 #endif
1671 if (!p || p == fname)
1672 return NULL;
1674 len = dir->len + (p - fname + 1);
1675 new_dir = XNEWVEC (char, len + 1);
1676 memcpy (new_dir, dir->name, dir->len);
1677 memcpy (new_dir + dir->len, fname, p - fname + 1);
1678 new_dir[len] = '\0';
1680 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1681 fname = p + 1;
1685 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1686 static bool
1687 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1689 const char *saved_path = file->path;
1690 bool valid = false;
1692 file->path = pchname;
1693 if (open_file (file))
1695 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1697 if (!valid)
1699 close (file->fd);
1700 file->fd = -1;
1703 if (CPP_OPTION (pfile, print_include_names))
1705 unsigned int i;
1706 for (i = 1; i < pfile->line_table->depth; i++)
1707 putc ('.', stderr);
1708 fprintf (stderr, "%c %s\n",
1709 valid ? '!' : 'x', pchname);
1713 file->path = saved_path;
1714 return valid;
1717 /* Get the path associated with the _cpp_file F. The path includes
1718 the base name from the include directive and the directory it was
1719 found in via the search path. */
1721 const char *
1722 cpp_get_path (struct _cpp_file *f)
1724 return f->path;
1727 /* Get the directory associated with the _cpp_file F. */
1729 cpp_dir *
1730 cpp_get_dir (struct _cpp_file *f)
1732 return f->dir;
1735 /* Get the cpp_buffer currently associated with the cpp_reader
1736 PFILE. */
1738 cpp_buffer *
1739 cpp_get_buffer (cpp_reader *pfile)
1741 return pfile->buffer;
1744 /* Get the _cpp_file associated with the cpp_buffer B. */
1746 _cpp_file *
1747 cpp_get_file (cpp_buffer *b)
1749 return b->file;
1752 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1753 buffer is the buffer that included the given buffer. */
1755 cpp_buffer *
1756 cpp_get_prev (cpp_buffer *b)
1758 return b->prev;
1761 /* This data structure holds the list of header files that were seen
1762 while the PCH was being built. The 'entries' field is kept sorted
1763 in memcmp() order; yes, this means that on little-endian systems,
1764 it's sorted initially by the least-significant byte of 'size', but
1765 that's OK. The code does rely on having entries with the same size
1766 next to each other. */
1768 struct pchf_entry {
1769 /* The size of this file. This is used to save running a MD5 checksum
1770 if the sizes don't match. */
1771 off_t size;
1772 /* The MD5 checksum of this file. */
1773 unsigned char sum[16];
1774 /* Is this file to be included only once? */
1775 bool once_only;
1778 struct pchf_data {
1779 /* Number of pchf_entry structures. */
1780 size_t count;
1782 /* Are there any values with once_only set?
1783 This is used as an optimisation, it means we don't have to search
1784 the structure if we're processing a regular #include. */
1785 bool have_once_only;
1787 struct pchf_entry entries[1];
1790 static struct pchf_data *pchf;
1792 /* A qsort ordering function for pchf_entry structures. */
1794 static int
1795 pchf_save_compare (const void *e1, const void *e2)
1797 return memcmp (e1, e2, sizeof (struct pchf_entry));
1800 /* Create and write to F a pchf_data structure. */
1802 bool
1803 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1805 size_t count = 0;
1806 struct pchf_data *result;
1807 size_t result_size;
1808 _cpp_file *f;
1809 bool ret;
1811 for (f = pfile->all_files; f; f = f->next_file)
1812 ++count;
1814 result_size = (sizeof (struct pchf_data)
1815 + sizeof (struct pchf_entry) * (count - 1));
1816 result = XCNEWVAR (struct pchf_data, result_size);
1818 result->count = 0;
1819 result->have_once_only = false;
1821 for (f = pfile->all_files; f; f = f->next_file)
1823 size_t count;
1825 /* This should probably never happen, since if a read error occurred
1826 the PCH file shouldn't be written... */
1827 if (f->dont_read || f->err_no)
1828 continue;
1830 if (f->stack_count == 0)
1831 continue;
1833 count = result->count++;
1835 result->entries[count].once_only = f->once_only;
1836 /* |= is avoided in the next line because of an HP C compiler bug */
1837 result->have_once_only = result->have_once_only | f->once_only;
1838 if (f->buffer_valid)
1839 md5_buffer ((const char *)f->buffer,
1840 f->st.st_size, result->entries[count].sum);
1841 else
1843 FILE *ff;
1844 int oldfd = f->fd;
1846 if (!open_file (f))
1848 open_file_failed (pfile, f, 0);
1849 free (result);
1850 return false;
1852 ff = fdopen (f->fd, "rb");
1853 md5_stream (ff, result->entries[count].sum);
1854 fclose (ff);
1855 f->fd = oldfd;
1857 result->entries[count].size = f->st.st_size;
1860 result_size = (sizeof (struct pchf_data)
1861 + sizeof (struct pchf_entry) * (result->count - 1));
1863 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1864 pchf_save_compare);
1866 ret = fwrite (result, result_size, 1, fp) == 1;
1867 free (result);
1868 return ret;
1871 /* Read the pchf_data structure from F. */
1873 bool
1874 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1876 struct pchf_data d;
1878 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1879 != 1)
1880 return false;
1882 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1883 + sizeof (struct pchf_entry) * (d.count - 1));
1884 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1885 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1886 != d.count)
1887 return false;
1888 return true;
1891 /* The parameters for pchf_compare. */
1893 struct pchf_compare_data
1895 /* The size of the file we're looking for. */
1896 off_t size;
1898 /* The MD5 checksum of the file, if it's been computed. */
1899 unsigned char sum[16];
1901 /* Is SUM valid? */
1902 bool sum_computed;
1904 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1905 bool check_included;
1907 /* The file that we're searching for. */
1908 _cpp_file *f;
1911 /* bsearch comparison function; look for D_P in E_P. */
1913 static int
1914 pchf_compare (const void *d_p, const void *e_p)
1916 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1917 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1918 int result;
1920 result = memcmp (&d->size, &e->size, sizeof (off_t));
1921 if (result != 0)
1922 return result;
1924 if (! d->sum_computed)
1926 _cpp_file *const f = d->f;
1928 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1929 d->sum_computed = true;
1932 result = memcmp (d->sum, e->sum, 16);
1933 if (result != 0)
1934 return result;
1936 if (d->check_included || e->once_only)
1937 return 0;
1938 else
1939 return 1;
1942 /* Check that F is not in a list read from a PCH file (if any).
1943 Assumes that f->buffer_valid is true. Return TRUE if the file
1944 should not be read. */
1946 static bool
1947 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1948 _cpp_file *f,
1949 bool check_included)
1951 struct pchf_compare_data d;
1953 if (pchf == NULL
1954 || (! check_included && ! pchf->have_once_only))
1955 return false;
1957 d.size = f->st.st_size;
1958 d.sum_computed = false;
1959 d.f = f;
1960 d.check_included = check_included;
1961 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1962 pchf_compare) != NULL;
1965 /* Return true if the file FNAME is found in the appropriate include file path
1966 as indicated by ANGLE_BRACKETS. */
1968 bool
1969 _cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
1970 enum include_type type)
1972 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
1973 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir,
1974 /*fake=*/false, angle_brackets,
1975 /*implicit_preinclude=*/false);
1976 return file->err_no != ENOENT;