2013-11-15 Paolo Carlini <paolo.carlini@oracle.com>
[official-gcc.git] / libcpp / files.c
blobea91b02047da4c6989cdb8d1341fa008597ef3f4
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2013 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 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 file_hash_entry
145 struct 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 file_hash_entry pool. */
156 #define FILE_HASH_POOL_SIZE 127
158 /* A file hash entry pool. We allocate 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 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 file_hash_entry *search_cache (struct 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 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 if (pfile->all_files
295 && pfile->all_files->next_file
296 && !(pfile->all_files->implicit_preinclude
297 || pfile->all_files->next_file->implicit_preinclude))
298 return false;
300 flen = strlen (path);
301 len = flen + sizeof (extension);
302 pchname = XNEWVEC (char, len);
303 memcpy (pchname, path, flen);
304 memcpy (pchname + flen, extension, sizeof (extension));
306 if (stat (pchname, &st) == 0)
308 DIR *pchdir;
309 struct dirent *d;
310 size_t dlen, plen = len;
312 if (!S_ISDIR (st.st_mode))
313 valid = validate_pch (pfile, file, pchname);
314 else if ((pchdir = opendir (pchname)) != NULL)
316 pchname[plen - 1] = '/';
317 while ((d = readdir (pchdir)) != NULL)
319 dlen = strlen (d->d_name) + 1;
320 if ((strcmp (d->d_name, ".") == 0)
321 || (strcmp (d->d_name, "..") == 0))
322 continue;
323 if (dlen + plen > len)
325 len += dlen + 64;
326 pchname = XRESIZEVEC (char, pchname, len);
328 memcpy (pchname + plen, d->d_name, dlen);
329 valid = validate_pch (pfile, file, pchname);
330 if (valid)
331 break;
333 closedir (pchdir);
335 if (!valid)
336 *invalid_pch = true;
339 if (valid)
340 file->pchname = pchname;
341 else
342 free (pchname);
344 return valid;
347 /* Canonicalize the path to FILE. Return the canonical form if it is
348 shorter, otherwise return NULL. This function does NOT free the
349 memory pointed by FILE. */
351 static char *
352 maybe_shorter_path (const char * file)
354 char * file2 = lrealpath (file);
355 if (file2 && strlen (file2) < strlen (file))
357 return file2;
359 else
361 free (file2);
362 return NULL;
366 /* Try to open the path FILE->name appended to FILE->dir. This is
367 where remap and PCH intercept the file lookup process. Return true
368 if the file was found, whether or not the open was successful.
369 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
371 static bool
372 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
374 char *path;
376 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
378 else
379 if (file->dir->construct)
380 path = file->dir->construct (file->name, file->dir);
381 else
382 path = append_file_to_dir (file->name, file->dir);
384 if (path)
386 hashval_t hv;
387 char *copy;
388 void **pp;
390 /* We try to canonicalize system headers. */
391 if (CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
393 char * canonical_path = maybe_shorter_path (path);
394 if (canonical_path)
396 /* The canonical path was newly allocated. Let's free the
397 non-canonical one. */
398 free (path);
399 path = canonical_path;
403 hv = htab_hash_string (path);
404 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
406 file->err_no = ENOENT;
407 return false;
410 file->path = path;
411 if (pch_open_file (pfile, file, invalid_pch))
412 return true;
414 if (open_file (file))
415 return true;
417 if (file->err_no != ENOENT)
419 open_file_failed (pfile, file, 0);
420 return true;
423 /* We copy the path name onto an obstack partly so that we don't
424 leak the memory, but mostly so that we don't fragment the
425 heap. */
426 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
427 strlen (path));
428 free (path);
429 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
430 copy, hv, INSERT);
431 *pp = copy;
433 file->path = file->name;
435 else
437 file->err_no = ENOENT;
438 file->path = NULL;
441 return false;
444 /* Return tue iff the missing_header callback found the given HEADER. */
445 static bool
446 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
448 missing_header_cb func = pfile->cb.missing_header;
450 /* When the regular search path doesn't work, try context dependent
451 headers search paths. */
452 if (func
453 && file->dir == NULL)
455 if ((file->path = func (pfile, header, &file->dir)) != NULL)
457 if (open_file (file))
458 return true;
459 free ((void *)file->path);
461 file->path = file->name;
464 return false;
467 bool
468 _cpp_find_failed (_cpp_file *file)
470 return file->err_no != 0;
473 /* Given a filename FNAME search for such a file in the include path
474 starting from START_DIR. If FNAME is the empty string it is
475 interpreted as STDIN if START_DIR is PFILE->no_search_path.
477 If the file is not found in the file cache fall back to the O/S and
478 add the result to our cache.
480 If the file was not found in the filesystem, or there was an error
481 opening it, then ERR_NO is nonzero and FD is -1. If the file was
482 found, then ERR_NO is zero and FD could be -1 or an open file
483 descriptor. FD can be -1 if the file was found in the cache and
484 had previously been closed. To open it again pass the return value
485 to open_file().
487 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
488 If present, it is OK for a precompiled header to be included after
491 _cpp_file *
492 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
493 bool fake, int angle_brackets, bool implicit_preinclude)
495 struct file_hash_entry *entry;
496 void **hash_slot;
497 _cpp_file *file;
498 bool invalid_pch = false;
499 bool saw_bracket_include = false;
500 bool saw_quote_include = false;
501 struct cpp_dir *found_in_cache = NULL;
503 /* Ensure we get no confusion between cached files and directories. */
504 if (start_dir == NULL)
505 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
507 hash_slot
508 = htab_find_slot_with_hash (pfile->file_hash, fname,
509 htab_hash_string (fname), INSERT);
511 /* First check the cache before we resort to memory allocation. */
512 entry = search_cache ((struct file_hash_entry *) *hash_slot, start_dir);
513 if (entry)
514 return entry->u.file;
516 file = make_cpp_file (pfile, start_dir, fname);
517 file->implicit_preinclude = implicit_preinclude;
519 /* Try each path in the include chain. */
520 for (; !fake ;)
522 if (find_file_in_dir (pfile, file, &invalid_pch))
523 break;
525 file->dir = file->dir->next;
526 if (file->dir == NULL)
528 if (search_path_exhausted (pfile, fname, file))
530 /* Although this file must not go in the cache, because
531 the file found might depend on things (like the current file)
532 that aren't represented in the cache, it still has to go in
533 the list of all files so that #import works. */
534 file->next_file = pfile->all_files;
535 pfile->all_files = file;
536 if (*hash_slot == NULL)
538 /* If *hash_slot is NULL, the above htab_find_slot_with_hash
539 call just created the slot, but we aren't going to store
540 there anything, so need to remove the newly created entry.
541 htab_clear_slot requires that it is non-NULL, so store
542 there some non-NULL pointer, htab_clear_slot will
543 overwrite it immediately. */
544 *hash_slot = file;
545 htab_clear_slot (pfile->file_hash, hash_slot);
547 return file;
550 if (invalid_pch)
552 cpp_error (pfile, CPP_DL_ERROR,
553 "one or more PCH files were found, but they were invalid");
554 if (!cpp_get_options (pfile)->warn_invalid_pch)
555 cpp_error (pfile, CPP_DL_ERROR,
556 "use -Winvalid-pch for more information");
558 if (implicit_preinclude)
560 free ((char *) file->name);
561 free (file);
562 if (*hash_slot == NULL)
564 /* See comment on the above htab_clear_slot call. */
565 *hash_slot = file;
566 htab_clear_slot (pfile->file_hash, hash_slot);
568 return NULL;
570 else
571 open_file_failed (pfile, file, angle_brackets);
572 break;
575 /* Only check the cache for the starting location (done above)
576 and the quote and bracket chain heads because there are no
577 other possible starting points for searches. */
578 if (file->dir == pfile->bracket_include)
579 saw_bracket_include = true;
580 else if (file->dir == pfile->quote_include)
581 saw_quote_include = true;
582 else
583 continue;
585 entry = search_cache ((struct file_hash_entry *) *hash_slot, file->dir);
586 if (entry)
588 found_in_cache = file->dir;
589 break;
593 if (entry)
595 /* Cache for START_DIR too, sharing the _cpp_file structure. */
596 free ((char *) file->name);
597 free (file);
598 file = entry->u.file;
600 else
602 /* This is a new file; put it in the list. */
603 file->next_file = pfile->all_files;
604 pfile->all_files = file;
607 /* Store this new result in the hash table. */
608 entry = new_file_hash_entry (pfile);
609 entry->next = (struct file_hash_entry *) *hash_slot;
610 entry->start_dir = start_dir;
611 entry->location = pfile->line_table->highest_location;
612 entry->u.file = file;
613 *hash_slot = (void *) entry;
615 /* If we passed the quote or bracket chain heads, cache them also.
616 This speeds up processing if there are lots of -I options. */
617 if (saw_bracket_include
618 && pfile->bracket_include != start_dir
619 && found_in_cache != pfile->bracket_include)
621 entry = new_file_hash_entry (pfile);
622 entry->next = (struct file_hash_entry *) *hash_slot;
623 entry->start_dir = pfile->bracket_include;
624 entry->location = pfile->line_table->highest_location;
625 entry->u.file = file;
626 *hash_slot = (void *) entry;
628 if (saw_quote_include
629 && pfile->quote_include != start_dir
630 && found_in_cache != pfile->quote_include)
632 entry = new_file_hash_entry (pfile);
633 entry->next = (struct file_hash_entry *) *hash_slot;
634 entry->start_dir = pfile->quote_include;
635 entry->location = pfile->line_table->highest_location;
636 entry->u.file = file;
637 *hash_slot = (void *) entry;
640 return file;
643 /* Read a file into FILE->buffer, returning true on success.
645 If FILE->fd is something weird, like a block device, we don't want
646 to read it at all. Don't even try to figure out what something is,
647 except for plain files and block devices, since there is no
648 reliable portable way of doing this.
650 FIXME: Flush file cache and try again if we run out of memory. */
651 static bool
652 read_file_guts (cpp_reader *pfile, _cpp_file *file)
654 ssize_t size, total, count;
655 uchar *buf;
656 bool regular;
658 if (S_ISBLK (file->st.st_mode))
660 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
661 return false;
664 regular = S_ISREG (file->st.st_mode) != 0;
665 if (regular)
667 /* off_t might have a wider range than ssize_t - in other words,
668 the max size of a file might be bigger than the address
669 space. We can't handle a file that large. (Anyone with
670 a single source file bigger than 2GB needs to rethink
671 their coding style.) Some systems (e.g. AIX 4.1) define
672 SSIZE_MAX to be much smaller than the actual range of the
673 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
674 does not bite us. */
675 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
677 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
678 return false;
681 size = file->st.st_size;
683 else
684 /* 8 kilobytes is a sensible starting size. It ought to be bigger
685 than the kernel pipe buffer, and it's definitely bigger than
686 the majority of C source files. */
687 size = 8 * 1024;
689 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
690 used to quiet warnings from valgrind or Address Sanitizer, when the
691 optimized lexer accesses aligned 16-byte memory chunks, including
692 the bytes after the malloced, area, and stops lexing on '\n'. */
693 buf = XNEWVEC (uchar, size + 16);
694 total = 0;
695 while ((count = read (file->fd, buf + total, size - total)) > 0)
697 total += count;
699 if (total == size)
701 if (regular)
702 break;
703 size *= 2;
704 buf = XRESIZEVEC (uchar, buf, size + 16);
708 if (count < 0)
710 cpp_errno (pfile, CPP_DL_ERROR, file->path);
711 free (buf);
712 return false;
715 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
716 cpp_error (pfile, CPP_DL_WARNING,
717 "%s is shorter than expected", file->path);
719 file->buffer = _cpp_convert_input (pfile,
720 CPP_OPTION (pfile, input_charset),
721 buf, size + 16, total,
722 &file->buffer_start,
723 &file->st.st_size);
724 file->buffer_valid = true;
726 return true;
729 /* Convenience wrapper around read_file_guts that opens the file if
730 necessary and closes the file descriptor after reading. FILE must
731 have been passed through find_file() at some stage. */
732 static bool
733 read_file (cpp_reader *pfile, _cpp_file *file)
735 /* If we already have its contents in memory, succeed immediately. */
736 if (file->buffer_valid)
737 return true;
739 /* If an earlier read failed for some reason don't try again. */
740 if (file->dont_read || file->err_no)
741 return false;
743 if (file->fd == -1 && !open_file (file))
745 open_file_failed (pfile, file, 0);
746 return false;
749 file->dont_read = !read_file_guts (pfile, file);
750 close (file->fd);
751 file->fd = -1;
753 return !file->dont_read;
756 /* Returns TRUE if FILE's contents have been successfully placed in
757 FILE->buffer and the file should be stacked, otherwise false. */
758 static bool
759 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
761 _cpp_file *f;
763 /* Skip once-only files. */
764 if (file->once_only)
765 return false;
767 /* We must mark the file once-only if #import now, before header
768 guard checks. Otherwise, undefining the header guard might
769 cause the file to be re-stacked. */
770 if (import)
772 _cpp_mark_file_once_only (pfile, file);
774 /* Don't stack files that have been stacked before. */
775 if (file->stack_count)
776 return false;
779 /* Skip if the file had a header guard and the macro is defined.
780 PCH relies on this appearing before the PCH handler below. */
781 if (file->cmacro && file->cmacro->type == NT_MACRO)
782 return false;
784 /* Handle PCH files immediately; don't stack them. */
785 if (file->pchname)
787 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
788 file->fd = -1;
789 free ((void *) file->pchname);
790 file->pchname = NULL;
791 return false;
794 if (!read_file (pfile, file))
795 return false;
797 /* Check the file against the PCH file. This is done before
798 checking against files we've already seen, since it may save on
799 I/O. */
800 if (check_file_against_entries (pfile, file, import))
802 /* If this isn't a #import, but yet we can't include the file,
803 that means that it was #import-ed in the PCH file,
804 so we can never include it again. */
805 if (! import)
806 _cpp_mark_file_once_only (pfile, file);
807 return false;
810 /* Now we've read the file's contents, we can stack it if there
811 are no once-only files. */
812 if (!pfile->seen_once_only)
813 return true;
815 /* We may have read the file under a different name. Look
816 for likely candidates and compare file contents to be sure. */
817 for (f = pfile->all_files; f; f = f->next_file)
819 if (f == file)
820 continue;
822 if ((import || f->once_only)
823 && f->err_no == 0
824 && f->st.st_mtime == file->st.st_mtime
825 && f->st.st_size == file->st.st_size)
827 _cpp_file *ref_file;
828 bool same_file_p = false;
830 if (f->buffer && !f->buffer_valid)
832 /* We already have a buffer but it is not valid, because
833 the file is still stacked. Make a new one. */
834 ref_file = make_cpp_file (pfile, f->dir, f->name);
835 ref_file->path = f->path;
837 else
838 /* The file is not stacked anymore. We can reuse it. */
839 ref_file = f;
841 same_file_p = read_file (pfile, ref_file)
842 /* Size might have changed in read_file(). */
843 && ref_file->st.st_size == file->st.st_size
844 && !memcmp (ref_file->buffer,
845 file->buffer,
846 file->st.st_size);
848 if (f->buffer && !f->buffer_valid)
850 ref_file->path = 0;
851 destroy_cpp_file (ref_file);
854 if (same_file_p)
855 break;
859 return f == NULL;
862 /* Place the file referenced by FILE into a new buffer on the buffer
863 stack if possible. IMPORT is true if this stacking attempt is
864 because of a #import directive. Returns true if a buffer is
865 stacked. */
866 bool
867 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
869 cpp_buffer *buffer;
870 int sysp;
872 if (!should_stack_file (pfile, file, import))
873 return false;
875 if (pfile->buffer == NULL || file->dir == NULL)
876 sysp = 0;
877 else
878 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
880 /* Add the file to the dependencies on its first inclusion. */
881 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
883 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
884 deps_add_dep (pfile->deps, file->path);
887 /* Clear buffer_valid since _cpp_clean_line messes it up. */
888 file->buffer_valid = false;
889 file->stack_count++;
891 /* Stack the buffer. */
892 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
893 CPP_OPTION (pfile, preprocessed)
894 && !CPP_OPTION (pfile, directives_only));
895 buffer->file = file;
896 buffer->sysp = sysp;
897 buffer->to_free = file->buffer_start;
899 /* Initialize controlling macro state. */
900 pfile->mi_valid = true;
901 pfile->mi_cmacro = 0;
903 /* Generate the call back. */
904 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
906 return true;
909 /* Mark FILE to be included once only. */
910 void
911 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
913 pfile->seen_once_only = true;
914 file->once_only = true;
917 /* Return the directory from which searching for FNAME should start,
918 considering the directive TYPE and ANGLE_BRACKETS. If there is
919 nothing left in the path, returns NULL. */
920 static struct cpp_dir *
921 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
922 enum include_type type)
924 cpp_dir *dir;
925 _cpp_file *file;
927 if (IS_ABSOLUTE_PATH (fname))
928 return &pfile->no_search_path;
930 /* pfile->buffer is NULL when processing an -include command-line flag. */
931 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
933 /* For #include_next, skip in the search path past the dir in which
934 the current file was found, but if it was found via an absolute
935 path use the normal search logic. */
936 if (type == IT_INCLUDE_NEXT && file->dir
937 && file->dir != &pfile->no_search_path)
938 dir = file->dir->next;
939 else if (angle_brackets)
940 dir = pfile->bracket_include;
941 else if (type == IT_CMDLINE)
942 /* -include and -imacros use the #include "" chain with the
943 preprocessor's cwd prepended. */
944 return make_cpp_dir (pfile, "./", false);
945 else if (pfile->quote_ignores_source_dir)
946 dir = pfile->quote_include;
947 else
948 return make_cpp_dir (pfile, dir_name_of_file (file),
949 pfile->buffer ? pfile->buffer->sysp : 0);
951 if (dir == NULL)
952 cpp_error (pfile, CPP_DL_ERROR,
953 "no include path in which to search for %s", fname);
955 return dir;
958 /* Strip the basename from the file's path. It ends with a slash if
959 of nonzero length. Note that this procedure also works for
960 <stdin>, which is represented by the empty string. */
961 static const char *
962 dir_name_of_file (_cpp_file *file)
964 if (!file->dir_name)
966 size_t len = lbasename (file->path) - file->path;
967 char *dir_name = XNEWVEC (char, len + 1);
969 memcpy (dir_name, file->path, len);
970 dir_name[len] = '\0';
971 file->dir_name = dir_name;
974 return file->dir_name;
977 /* Handles #include-family directives (distinguished by TYPE),
978 including HEADER, and the command line -imacros and -include.
979 Returns true if a buffer was stacked. */
980 bool
981 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
982 enum include_type type)
984 struct cpp_dir *dir;
985 _cpp_file *file;
986 bool stacked;
988 dir = search_path_head (pfile, fname, angle_brackets, type);
989 if (!dir)
990 return false;
992 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets,
993 type == IT_DEFAULT);
994 if (type == IT_DEFAULT && file == NULL)
995 return false;
997 /* Compensate for the increment in linemap_add that occurs if
998 _cpp_stack_file actually stacks the file. In the case of a
999 normal #include, we're currently at the start of the line
1000 *following* the #include. A separate source_location for this
1001 location makes no sense (until we do the LC_LEAVE), and
1002 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
1003 found a PCH file (in which case linemap_add is not called) or we
1004 were included from the command-line. */
1005 if (file->pchname == NULL && file->err_no == 0
1006 && type != IT_CMDLINE && type != IT_DEFAULT)
1007 pfile->line_table->highest_location--;
1009 stacked = _cpp_stack_file (pfile, file, type == IT_IMPORT);
1011 if (!stacked)
1012 /* _cpp_stack_file didn't stack the file, so let's rollback the
1013 compensation dance we performed above. */
1014 pfile->line_table->highest_location++;
1016 return stacked;
1019 /* Could not open FILE. The complication is dependency output. */
1020 static void
1021 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
1023 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1024 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1026 errno = file->err_no;
1027 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1029 deps_add_dep (pfile->deps, file->name);
1030 /* If the preprocessor output (other than dependency information) is
1031 being used, we must also flag an error. */
1032 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1033 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1035 else
1037 /* If we are not outputting dependencies, or if we are and dependencies
1038 were requested for this file, or if preprocessor output is needed
1039 in addition to dependency information, this is an error.
1041 Otherwise (outputting dependencies but not for this file, and not
1042 using the preprocessor output), we can still produce correct output
1043 so it's only a warning. */
1044 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1045 || print_dep
1046 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1047 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1048 else
1049 cpp_errno (pfile, CPP_DL_WARNING, file->path);
1053 /* Search in the chain beginning at HEAD for a file whose search path
1054 started at START_DIR != NULL. */
1055 static struct file_hash_entry *
1056 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
1058 while (head && head->start_dir != start_dir)
1059 head = head->next;
1061 return head;
1064 /* Allocate a new _cpp_file structure. */
1065 static _cpp_file *
1066 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
1068 _cpp_file *file;
1070 file = XCNEW (_cpp_file);
1071 file->main_file = !pfile->buffer;
1072 file->fd = -1;
1073 file->dir = dir;
1074 file->name = xstrdup (fname);
1076 return file;
1079 /* Release a _cpp_file structure. */
1080 static void
1081 destroy_cpp_file (_cpp_file *file)
1083 free ((void *) file->buffer_start);
1084 free ((void *) file->name);
1085 free (file);
1088 /* Release all the files allocated by this reader. */
1089 static void
1090 destroy_all_cpp_files (cpp_reader *pfile)
1092 _cpp_file *iter = pfile->all_files;
1093 while (iter)
1095 _cpp_file *next = iter->next_file;
1096 destroy_cpp_file (iter);
1097 iter = next;
1101 /* A hash of directory names. The directory names are the path names
1102 of files which contain a #include "", the included file name is
1103 appended to this directories.
1105 To avoid duplicate entries we follow the convention that all
1106 non-empty directory names should end in a '/'. DIR_NAME must be
1107 stored in permanently allocated memory. */
1108 static cpp_dir *
1109 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1111 struct file_hash_entry *entry, **hash_slot;
1112 cpp_dir *dir;
1114 hash_slot = (struct file_hash_entry **)
1115 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1116 htab_hash_string (dir_name),
1117 INSERT);
1119 /* Have we already hashed this directory? */
1120 for (entry = *hash_slot; entry; entry = entry->next)
1121 if (entry->start_dir == NULL)
1122 return entry->u.dir;
1124 dir = XCNEW (cpp_dir);
1125 dir->next = pfile->quote_include;
1126 dir->name = (char *) dir_name;
1127 dir->len = strlen (dir_name);
1128 dir->sysp = sysp;
1129 dir->construct = 0;
1131 /* Store this new result in the hash table. */
1132 entry = new_file_hash_entry (pfile);
1133 entry->next = *hash_slot;
1134 entry->start_dir = NULL;
1135 entry->location = pfile->line_table->highest_location;
1136 entry->u.dir = dir;
1137 *hash_slot = entry;
1139 return dir;
1142 /* Create a new block of memory for file hash entries. */
1143 static void
1144 allocate_file_hash_entries (cpp_reader *pfile)
1146 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1147 pool->file_hash_entries_used = 0;
1148 pool->next = pfile->file_hash_entries;
1149 pfile->file_hash_entries = pool;
1152 /* Return a new file hash entry. */
1153 static struct file_hash_entry *
1154 new_file_hash_entry (cpp_reader *pfile)
1156 unsigned int idx;
1157 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1158 allocate_file_hash_entries (pfile);
1160 idx = pfile->file_hash_entries->file_hash_entries_used++;
1161 return &pfile->file_hash_entries->pool[idx];
1164 /* Free the file hash entry pools. */
1165 static void
1166 free_file_hash_entries (cpp_reader *pfile)
1168 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1169 while (iter)
1171 struct file_hash_entry_pool *next = iter->next;
1172 free (iter);
1173 iter = next;
1177 /* Returns TRUE if a file FNAME has ever been successfully opened.
1178 This routine is not intended to correctly handle filenames aliased
1179 by links or redundant . or .. traversals etc. */
1180 bool
1181 cpp_included (cpp_reader *pfile, const char *fname)
1183 struct file_hash_entry *entry;
1185 entry = (struct file_hash_entry *)
1186 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1188 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1189 entry = entry->next;
1191 return entry != NULL;
1194 /* Returns TRUE if a file FNAME has ever been successfully opened
1195 before LOCATION. This routine is not intended to correctly handle
1196 filenames aliased by links or redundant . or .. traversals etc. */
1197 bool
1198 cpp_included_before (cpp_reader *pfile, const char *fname,
1199 source_location location)
1201 struct file_hash_entry *entry;
1203 entry = (struct file_hash_entry *)
1204 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1206 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1207 || entry->location > location))
1208 entry = entry->next;
1210 return entry != NULL;
1213 /* Calculate the hash value of a file hash entry P. */
1215 static hashval_t
1216 file_hash_hash (const void *p)
1218 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1219 const char *hname;
1220 if (entry->start_dir)
1221 hname = entry->u.file->name;
1222 else
1223 hname = entry->u.dir->name;
1225 return htab_hash_string (hname);
1228 /* Compare a string Q against a file hash entry P. */
1229 static int
1230 file_hash_eq (const void *p, const void *q)
1232 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1233 const char *fname = (const char *) q;
1234 const char *hname;
1236 if (entry->start_dir)
1237 hname = entry->u.file->name;
1238 else
1239 hname = entry->u.dir->name;
1241 return filename_cmp (hname, fname) == 0;
1244 /* Compare entries in the nonexistent file hash table. These are just
1245 strings. */
1246 static int
1247 nonexistent_file_hash_eq (const void *p, const void *q)
1249 return filename_cmp ((const char *) p, (const char *) q) == 0;
1252 /* Initialize everything in this source file. */
1253 void
1254 _cpp_init_files (cpp_reader *pfile)
1256 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1257 NULL, xcalloc, free);
1258 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1259 NULL, xcalloc, free);
1260 allocate_file_hash_entries (pfile);
1261 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1262 nonexistent_file_hash_eq,
1263 NULL, xcalloc, free);
1264 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1265 (void *(*) (long)) xmalloc,
1266 (void (*) (void *)) free);
1269 /* Finalize everything in this source file. */
1270 void
1271 _cpp_cleanup_files (cpp_reader *pfile)
1273 htab_delete (pfile->file_hash);
1274 htab_delete (pfile->dir_hash);
1275 htab_delete (pfile->nonexistent_file_hash);
1276 obstack_free (&pfile->nonexistent_file_ob, 0);
1277 free_file_hash_entries (pfile);
1278 destroy_all_cpp_files (pfile);
1281 /* Make the parser forget about files it has seen. This can be useful
1282 for resetting the parser to start another run. */
1283 void
1284 cpp_clear_file_cache (cpp_reader *pfile)
1286 _cpp_cleanup_files (pfile);
1287 pfile->file_hash_entries = NULL;
1288 pfile->all_files = NULL;
1289 _cpp_init_files (pfile);
1292 /* Enter a file name in the hash for the sake of cpp_included. */
1293 void
1294 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1296 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0, false);
1299 /* Not everyone who wants to set system-header-ness on a buffer can
1300 see the details of a buffer. This is an exported interface because
1301 fix-header needs it. */
1302 void
1303 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1305 int flags = 0;
1306 const struct line_maps *line_table = pfile->line_table;
1307 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1308 /* 1 = system header, 2 = system header to be treated as C. */
1309 if (syshdr)
1310 flags = 1 + (externc != 0);
1311 pfile->buffer->sysp = flags;
1312 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1313 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1316 /* Allow the client to change the current file. Used by the front end
1317 to achieve pseudo-file names like <built-in>.
1318 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1319 void
1320 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1321 const char *new_name)
1323 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1326 struct report_missing_guard_data
1328 const char **paths;
1329 size_t count;
1332 /* Callback function for htab_traverse. */
1333 static int
1334 report_missing_guard (void **slot, void *d)
1336 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1337 struct report_missing_guard_data *data
1338 = (struct report_missing_guard_data *) d;
1340 /* Skip directories. */
1341 if (entry->start_dir != NULL)
1343 _cpp_file *file = entry->u.file;
1345 /* We don't want MI guard advice for the main file. */
1346 if (!file->once_only && file->cmacro == NULL
1347 && file->stack_count == 1 && !file->main_file)
1349 if (data->paths == NULL)
1351 data->paths = XCNEWVEC (const char *, data->count);
1352 data->count = 0;
1355 data->paths[data->count++] = file->path;
1359 /* Keep traversing the hash table. */
1360 return 1;
1363 /* Comparison function for qsort. */
1364 static int
1365 report_missing_guard_cmp (const void *p1, const void *p2)
1367 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1370 /* Report on all files that might benefit from a multiple include guard.
1371 Triggered by -H. */
1372 void
1373 _cpp_report_missing_guards (cpp_reader *pfile)
1375 struct report_missing_guard_data data;
1377 data.paths = NULL;
1378 data.count = htab_elements (pfile->file_hash);
1379 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1381 if (data.paths != NULL)
1383 size_t i;
1385 /* Sort the paths to avoid outputting them in hash table
1386 order. */
1387 qsort (data.paths, data.count, sizeof (const char *),
1388 report_missing_guard_cmp);
1389 fputs (_("Multiple include guards may be useful for:\n"),
1390 stderr);
1391 for (i = 0; i < data.count; i++)
1393 fputs (data.paths[i], stderr);
1394 putc ('\n', stderr);
1396 free (data.paths);
1400 /* Locate HEADER, and determine whether it is newer than the current
1401 file. If it cannot be located or dated, return -1, if it is
1402 newer, return 1, otherwise 0. */
1404 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1405 int angle_brackets)
1407 _cpp_file *file;
1408 struct cpp_dir *dir;
1410 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1411 if (!dir)
1412 return -1;
1414 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, false);
1415 if (file->err_no)
1416 return -1;
1418 if (file->fd != -1)
1420 close (file->fd);
1421 file->fd = -1;
1424 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1427 /* Pushes the given file onto the buffer stack. Returns nonzero if
1428 successful. */
1429 bool
1430 cpp_push_include (cpp_reader *pfile, const char *fname)
1432 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1435 /* Pushes the given file, implicitly included at the start of a
1436 compilation, onto the buffer stack but without any errors if the
1437 file is not found. Returns nonzero if successful. */
1438 bool
1439 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1441 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT);
1444 /* Do appropriate cleanup when a file INC's buffer is popped off the
1445 input stack. */
1446 void
1447 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1448 const unsigned char *to_free)
1450 /* Record the inclusion-preventing macro, which could be NULL
1451 meaning no controlling macro. */
1452 if (pfile->mi_valid && file->cmacro == NULL)
1453 file->cmacro = pfile->mi_cmacro;
1455 /* Invalidate control macros in the #including file. */
1456 pfile->mi_valid = false;
1458 if (to_free)
1460 if (to_free == file->buffer_start)
1462 file->buffer_start = NULL;
1463 file->buffer = NULL;
1464 file->buffer_valid = false;
1466 free ((void *) to_free);
1470 /* Return the file name associated with FILE. */
1471 const char *
1472 _cpp_get_file_name (_cpp_file *file)
1474 return file->name;
1477 /* Inteface to file statistics record in _cpp_file structure. */
1478 struct stat *
1479 _cpp_get_file_stat (_cpp_file *file)
1481 return &file->st;
1484 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1485 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1486 directory of the including file.
1488 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1489 void
1490 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1491 int quote_ignores_source_dir)
1493 pfile->quote_include = quote;
1494 pfile->bracket_include = quote;
1495 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1497 for (; quote; quote = quote->next)
1499 quote->name_map = NULL;
1500 quote->len = strlen (quote->name);
1501 if (quote == bracket)
1502 pfile->bracket_include = bracket;
1506 /* Append the file name to the directory to create the path, but don't
1507 turn / into // or // into ///; // may be a namespace escape. */
1508 static char *
1509 append_file_to_dir (const char *fname, cpp_dir *dir)
1511 size_t dlen, flen;
1512 char *path;
1514 dlen = dir->len;
1515 flen = strlen (fname);
1516 path = XNEWVEC (char, dlen + 1 + flen + 1);
1517 memcpy (path, dir->name, dlen);
1518 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1519 path[dlen++] = '/';
1520 memcpy (&path[dlen], fname, flen + 1);
1522 return path;
1525 /* Read a space delimited string of unlimited length from a stdio
1526 file F. */
1527 static char *
1528 read_filename_string (int ch, FILE *f)
1530 char *alloc, *set;
1531 int len;
1533 len = 20;
1534 set = alloc = XNEWVEC (char, len + 1);
1535 if (! is_space (ch))
1537 *set++ = ch;
1538 while ((ch = getc (f)) != EOF && ! is_space (ch))
1540 if (set - alloc == len)
1542 len *= 2;
1543 alloc = XRESIZEVEC (char, alloc, len + 1);
1544 set = alloc + len / 2;
1546 *set++ = ch;
1549 *set = '\0';
1550 ungetc (ch, f);
1551 return alloc;
1554 /* Read the file name map file for DIR. */
1555 static void
1556 read_name_map (cpp_dir *dir)
1558 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1559 char *name;
1560 FILE *f;
1561 size_t len, count = 0, room = 9;
1563 len = dir->len;
1564 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1565 memcpy (name, dir->name, len);
1566 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1567 name[len++] = '/';
1568 strcpy (name + len, FILE_NAME_MAP_FILE);
1569 f = fopen (name, "r");
1571 dir->name_map = XNEWVEC (const char *, room);
1573 /* Silently return NULL if we cannot open. */
1574 if (f)
1576 int ch;
1578 while ((ch = getc (f)) != EOF)
1580 char *to;
1582 if (is_space (ch))
1583 continue;
1585 if (count + 2 > room)
1587 room += 8;
1588 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1591 dir->name_map[count] = read_filename_string (ch, f);
1592 while ((ch = getc (f)) != EOF && is_hspace (ch))
1595 to = read_filename_string (ch, f);
1596 if (IS_ABSOLUTE_PATH (to))
1597 dir->name_map[count + 1] = to;
1598 else
1600 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1601 free (to);
1604 count += 2;
1605 while ((ch = getc (f)) != '\n')
1606 if (ch == EOF)
1607 break;
1610 fclose (f);
1613 /* Terminate the list of maps. */
1614 dir->name_map[count] = NULL;
1617 /* Remap a FILE's name based on the file_name_map, if any, for
1618 FILE->dir. If the file name has any directory separators,
1619 recursively check those directories too. */
1620 static char *
1621 remap_filename (cpp_reader *pfile, _cpp_file *file)
1623 const char *fname, *p;
1624 char *new_dir;
1625 cpp_dir *dir;
1626 size_t index, len;
1628 dir = file->dir;
1629 fname = file->name;
1631 for (;;)
1633 if (!dir->name_map)
1634 read_name_map (dir);
1636 for (index = 0; dir->name_map[index]; index += 2)
1637 if (!filename_cmp (dir->name_map[index], fname))
1638 return xstrdup (dir->name_map[index + 1]);
1639 if (IS_ABSOLUTE_PATH (fname))
1640 return NULL;
1641 p = strchr (fname, '/');
1642 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1644 char *p2 = strchr (fname, '\\');
1645 if (!p || (p > p2))
1646 p = p2;
1648 #endif
1649 if (!p || p == fname)
1650 return NULL;
1652 len = dir->len + (p - fname + 1);
1653 new_dir = XNEWVEC (char, len + 1);
1654 memcpy (new_dir, dir->name, dir->len);
1655 memcpy (new_dir + dir->len, fname, p - fname + 1);
1656 new_dir[len] = '\0';
1658 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1659 fname = p + 1;
1663 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1664 static bool
1665 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1667 const char *saved_path = file->path;
1668 bool valid = false;
1670 file->path = pchname;
1671 if (open_file (file))
1673 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1675 if (!valid)
1677 close (file->fd);
1678 file->fd = -1;
1681 if (CPP_OPTION (pfile, print_include_names))
1683 unsigned int i;
1684 for (i = 1; i < pfile->line_table->depth; i++)
1685 putc ('.', stderr);
1686 fprintf (stderr, "%c %s\n",
1687 valid ? '!' : 'x', pchname);
1691 file->path = saved_path;
1692 return valid;
1695 /* Get the path associated with the _cpp_file F. The path includes
1696 the base name from the include directive and the directory it was
1697 found in via the search path. */
1699 const char *
1700 cpp_get_path (struct _cpp_file *f)
1702 return f->path;
1705 /* Get the directory associated with the _cpp_file F. */
1707 cpp_dir *
1708 cpp_get_dir (struct _cpp_file *f)
1710 return f->dir;
1713 /* Get the cpp_buffer currently associated with the cpp_reader
1714 PFILE. */
1716 cpp_buffer *
1717 cpp_get_buffer (cpp_reader *pfile)
1719 return pfile->buffer;
1722 /* Get the _cpp_file associated with the cpp_buffer B. */
1724 _cpp_file *
1725 cpp_get_file (cpp_buffer *b)
1727 return b->file;
1730 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1731 buffer is the buffer that included the given buffer. */
1733 cpp_buffer *
1734 cpp_get_prev (cpp_buffer *b)
1736 return b->prev;
1739 /* This data structure holds the list of header files that were seen
1740 while the PCH was being built. The 'entries' field is kept sorted
1741 in memcmp() order; yes, this means that on little-endian systems,
1742 it's sorted initially by the least-significant byte of 'size', but
1743 that's OK. The code does rely on having entries with the same size
1744 next to each other. */
1746 struct pchf_entry {
1747 /* The size of this file. This is used to save running a MD5 checksum
1748 if the sizes don't match. */
1749 off_t size;
1750 /* The MD5 checksum of this file. */
1751 unsigned char sum[16];
1752 /* Is this file to be included only once? */
1753 bool once_only;
1756 struct pchf_data {
1757 /* Number of pchf_entry structures. */
1758 size_t count;
1760 /* Are there any values with once_only set?
1761 This is used as an optimisation, it means we don't have to search
1762 the structure if we're processing a regular #include. */
1763 bool have_once_only;
1765 struct pchf_entry entries[1];
1768 static struct pchf_data *pchf;
1770 /* A qsort ordering function for pchf_entry structures. */
1772 static int
1773 pchf_save_compare (const void *e1, const void *e2)
1775 return memcmp (e1, e2, sizeof (struct pchf_entry));
1778 /* Create and write to F a pchf_data structure. */
1780 bool
1781 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1783 size_t count = 0;
1784 struct pchf_data *result;
1785 size_t result_size;
1786 _cpp_file *f;
1787 bool ret;
1789 for (f = pfile->all_files; f; f = f->next_file)
1790 ++count;
1792 result_size = (sizeof (struct pchf_data)
1793 + sizeof (struct pchf_entry) * (count - 1));
1794 result = XCNEWVAR (struct pchf_data, result_size);
1796 result->count = 0;
1797 result->have_once_only = false;
1799 for (f = pfile->all_files; f; f = f->next_file)
1801 size_t count;
1803 /* This should probably never happen, since if a read error occurred
1804 the PCH file shouldn't be written... */
1805 if (f->dont_read || f->err_no)
1806 continue;
1808 if (f->stack_count == 0)
1809 continue;
1811 count = result->count++;
1813 result->entries[count].once_only = f->once_only;
1814 /* |= is avoided in the next line because of an HP C compiler bug */
1815 result->have_once_only = result->have_once_only | f->once_only;
1816 if (f->buffer_valid)
1817 md5_buffer ((const char *)f->buffer,
1818 f->st.st_size, result->entries[count].sum);
1819 else
1821 FILE *ff;
1822 int oldfd = f->fd;
1824 if (!open_file (f))
1826 open_file_failed (pfile, f, 0);
1827 free (result);
1828 return false;
1830 ff = fdopen (f->fd, "rb");
1831 md5_stream (ff, result->entries[count].sum);
1832 fclose (ff);
1833 f->fd = oldfd;
1835 result->entries[count].size = f->st.st_size;
1838 result_size = (sizeof (struct pchf_data)
1839 + sizeof (struct pchf_entry) * (result->count - 1));
1841 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1842 pchf_save_compare);
1844 ret = fwrite (result, result_size, 1, fp) == 1;
1845 free (result);
1846 return ret;
1849 /* Read the pchf_data structure from F. */
1851 bool
1852 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1854 struct pchf_data d;
1856 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1857 != 1)
1858 return false;
1860 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1861 + sizeof (struct pchf_entry) * (d.count - 1));
1862 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1863 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1864 != d.count)
1865 return false;
1866 return true;
1869 /* The parameters for pchf_compare. */
1871 struct pchf_compare_data
1873 /* The size of the file we're looking for. */
1874 off_t size;
1876 /* The MD5 checksum of the file, if it's been computed. */
1877 unsigned char sum[16];
1879 /* Is SUM valid? */
1880 bool sum_computed;
1882 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1883 bool check_included;
1885 /* The file that we're searching for. */
1886 _cpp_file *f;
1889 /* bsearch comparison function; look for D_P in E_P. */
1891 static int
1892 pchf_compare (const void *d_p, const void *e_p)
1894 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1895 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1896 int result;
1898 result = memcmp (&d->size, &e->size, sizeof (off_t));
1899 if (result != 0)
1900 return result;
1902 if (! d->sum_computed)
1904 _cpp_file *const f = d->f;
1906 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1907 d->sum_computed = true;
1910 result = memcmp (d->sum, e->sum, 16);
1911 if (result != 0)
1912 return result;
1914 if (d->check_included || e->once_only)
1915 return 0;
1916 else
1917 return 1;
1920 /* Check that F is not in a list read from a PCH file (if any).
1921 Assumes that f->buffer_valid is true. Return TRUE if the file
1922 should not be read. */
1924 static bool
1925 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1926 _cpp_file *f,
1927 bool check_included)
1929 struct pchf_compare_data d;
1931 if (pchf == NULL
1932 || (! check_included && ! pchf->have_once_only))
1933 return false;
1935 d.size = f->st.st_size;
1936 d.sum_computed = false;
1937 d.f = f;
1938 d.check_included = check_included;
1939 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1940 pchf_compare) != NULL;