Daily bump.
[official-gcc.git] / libcpp / files.c
blob91bc9dd078278e6943f3be517592a40de637c157
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2014 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. For DOS based file
391 * system, we always try to shorten non-system headers, as DOS
392 * has a tighter constraint on max path length. */
393 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
394 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
395 || !file->dir->sysp
396 #endif
399 char * canonical_path = maybe_shorter_path (path);
400 if (canonical_path)
402 /* The canonical path was newly allocated. Let's free the
403 non-canonical one. */
404 free (path);
405 path = canonical_path;
409 hv = htab_hash_string (path);
410 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
412 file->err_no = ENOENT;
413 return false;
416 file->path = path;
417 if (pch_open_file (pfile, file, invalid_pch))
418 return true;
420 if (open_file (file))
421 return true;
423 if (file->err_no != ENOENT)
425 open_file_failed (pfile, file, 0);
426 return true;
429 /* We copy the path name onto an obstack partly so that we don't
430 leak the memory, but mostly so that we don't fragment the
431 heap. */
432 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
433 strlen (path));
434 free (path);
435 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
436 copy, hv, INSERT);
437 *pp = copy;
439 file->path = file->name;
441 else
443 file->err_no = ENOENT;
444 file->path = NULL;
447 return false;
450 /* Return tue iff the missing_header callback found the given HEADER. */
451 static bool
452 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
454 missing_header_cb func = pfile->cb.missing_header;
456 /* When the regular search path doesn't work, try context dependent
457 headers search paths. */
458 if (func
459 && file->dir == NULL)
461 if ((file->path = func (pfile, header, &file->dir)) != NULL)
463 if (open_file (file))
464 return true;
465 free ((void *)file->path);
467 file->path = file->name;
470 return false;
473 bool
474 _cpp_find_failed (_cpp_file *file)
476 return file->err_no != 0;
479 /* Given a filename FNAME search for such a file in the include path
480 starting from START_DIR. If FNAME is the empty string it is
481 interpreted as STDIN if START_DIR is PFILE->no_search_path.
483 If the file is not found in the file cache fall back to the O/S and
484 add the result to our cache.
486 If the file was not found in the filesystem, or there was an error
487 opening it, then ERR_NO is nonzero and FD is -1. If the file was
488 found, then ERR_NO is zero and FD could be -1 or an open file
489 descriptor. FD can be -1 if the file was found in the cache and
490 had previously been closed. To open it again pass the return value
491 to open_file().
493 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
494 If present, it is OK for a precompiled header to be included after
497 _cpp_file *
498 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
499 bool fake, int angle_brackets, bool implicit_preinclude)
501 struct file_hash_entry *entry;
502 void **hash_slot;
503 _cpp_file *file;
504 bool invalid_pch = false;
505 bool saw_bracket_include = false;
506 bool saw_quote_include = false;
507 struct cpp_dir *found_in_cache = NULL;
509 /* Ensure we get no confusion between cached files and directories. */
510 if (start_dir == NULL)
511 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
513 hash_slot
514 = htab_find_slot_with_hash (pfile->file_hash, fname,
515 htab_hash_string (fname), INSERT);
517 /* First check the cache before we resort to memory allocation. */
518 entry = search_cache ((struct file_hash_entry *) *hash_slot, start_dir);
519 if (entry)
520 return entry->u.file;
522 file = make_cpp_file (pfile, start_dir, fname);
523 file->implicit_preinclude = implicit_preinclude;
525 /* Try each path in the include chain. */
526 for (; !fake ;)
528 if (find_file_in_dir (pfile, file, &invalid_pch))
529 break;
531 file->dir = file->dir->next;
532 if (file->dir == NULL)
534 if (search_path_exhausted (pfile, fname, file))
536 /* Although this file must not go in the cache, because
537 the file found might depend on things (like the current file)
538 that aren't represented in the cache, it still has to go in
539 the list of all files so that #import works. */
540 file->next_file = pfile->all_files;
541 pfile->all_files = file;
542 if (*hash_slot == NULL)
544 /* If *hash_slot is NULL, the above htab_find_slot_with_hash
545 call just created the slot, but we aren't going to store
546 there anything, so need to remove the newly created entry.
547 htab_clear_slot requires that it is non-NULL, so store
548 there some non-NULL pointer, htab_clear_slot will
549 overwrite it immediately. */
550 *hash_slot = file;
551 htab_clear_slot (pfile->file_hash, hash_slot);
553 return file;
556 if (invalid_pch)
558 cpp_error (pfile, CPP_DL_ERROR,
559 "one or more PCH files were found, but they were invalid");
560 if (!cpp_get_options (pfile)->warn_invalid_pch)
561 cpp_error (pfile, CPP_DL_ERROR,
562 "use -Winvalid-pch for more information");
564 if (implicit_preinclude)
566 free ((char *) file->name);
567 free (file);
568 if (*hash_slot == NULL)
570 /* See comment on the above htab_clear_slot call. */
571 *hash_slot = file;
572 htab_clear_slot (pfile->file_hash, hash_slot);
574 return NULL;
576 else
577 open_file_failed (pfile, file, angle_brackets);
578 break;
581 /* Only check the cache for the starting location (done above)
582 and the quote and bracket chain heads because there are no
583 other possible starting points for searches. */
584 if (file->dir == pfile->bracket_include)
585 saw_bracket_include = true;
586 else if (file->dir == pfile->quote_include)
587 saw_quote_include = true;
588 else
589 continue;
591 entry = search_cache ((struct file_hash_entry *) *hash_slot, file->dir);
592 if (entry)
594 found_in_cache = file->dir;
595 break;
599 if (entry)
601 /* Cache for START_DIR too, sharing the _cpp_file structure. */
602 free ((char *) file->name);
603 free (file);
604 file = entry->u.file;
606 else
608 /* This is a new file; put it in the list. */
609 file->next_file = pfile->all_files;
610 pfile->all_files = file;
613 /* Store this new result in the hash table. */
614 entry = new_file_hash_entry (pfile);
615 entry->next = (struct file_hash_entry *) *hash_slot;
616 entry->start_dir = start_dir;
617 entry->location = pfile->line_table->highest_location;
618 entry->u.file = file;
619 *hash_slot = (void *) entry;
621 /* If we passed the quote or bracket chain heads, cache them also.
622 This speeds up processing if there are lots of -I options. */
623 if (saw_bracket_include
624 && pfile->bracket_include != start_dir
625 && found_in_cache != pfile->bracket_include)
627 entry = new_file_hash_entry (pfile);
628 entry->next = (struct file_hash_entry *) *hash_slot;
629 entry->start_dir = pfile->bracket_include;
630 entry->location = pfile->line_table->highest_location;
631 entry->u.file = file;
632 *hash_slot = (void *) entry;
634 if (saw_quote_include
635 && pfile->quote_include != start_dir
636 && found_in_cache != pfile->quote_include)
638 entry = new_file_hash_entry (pfile);
639 entry->next = (struct file_hash_entry *) *hash_slot;
640 entry->start_dir = pfile->quote_include;
641 entry->location = pfile->line_table->highest_location;
642 entry->u.file = file;
643 *hash_slot = (void *) entry;
646 return file;
649 /* Read a file into FILE->buffer, returning true on success.
651 If FILE->fd is something weird, like a block device, we don't want
652 to read it at all. Don't even try to figure out what something is,
653 except for plain files and block devices, since there is no
654 reliable portable way of doing this.
656 FIXME: Flush file cache and try again if we run out of memory. */
657 static bool
658 read_file_guts (cpp_reader *pfile, _cpp_file *file)
660 ssize_t size, total, count;
661 uchar *buf;
662 bool regular;
664 if (S_ISBLK (file->st.st_mode))
666 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
667 return false;
670 regular = S_ISREG (file->st.st_mode) != 0;
671 if (regular)
673 /* off_t might have a wider range than ssize_t - in other words,
674 the max size of a file might be bigger than the address
675 space. We can't handle a file that large. (Anyone with
676 a single source file bigger than 2GB needs to rethink
677 their coding style.) Some systems (e.g. AIX 4.1) define
678 SSIZE_MAX to be much smaller than the actual range of the
679 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
680 does not bite us. */
681 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
683 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
684 return false;
687 size = file->st.st_size;
689 else
690 /* 8 kilobytes is a sensible starting size. It ought to be bigger
691 than the kernel pipe buffer, and it's definitely bigger than
692 the majority of C source files. */
693 size = 8 * 1024;
695 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
696 used to quiet warnings from valgrind or Address Sanitizer, when the
697 optimized lexer accesses aligned 16-byte memory chunks, including
698 the bytes after the malloced, area, and stops lexing on '\n'. */
699 buf = XNEWVEC (uchar, size + 16);
700 total = 0;
701 while ((count = read (file->fd, buf + total, size - total)) > 0)
703 total += count;
705 if (total == size)
707 if (regular)
708 break;
709 size *= 2;
710 buf = XRESIZEVEC (uchar, buf, size + 16);
714 if (count < 0)
716 cpp_errno (pfile, CPP_DL_ERROR, file->path);
717 free (buf);
718 return false;
721 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
722 cpp_error (pfile, CPP_DL_WARNING,
723 "%s is shorter than expected", file->path);
725 file->buffer = _cpp_convert_input (pfile,
726 CPP_OPTION (pfile, input_charset),
727 buf, size + 16, total,
728 &file->buffer_start,
729 &file->st.st_size);
730 file->buffer_valid = true;
732 return true;
735 /* Convenience wrapper around read_file_guts that opens the file if
736 necessary and closes the file descriptor after reading. FILE must
737 have been passed through find_file() at some stage. */
738 static bool
739 read_file (cpp_reader *pfile, _cpp_file *file)
741 /* If we already have its contents in memory, succeed immediately. */
742 if (file->buffer_valid)
743 return true;
745 /* If an earlier read failed for some reason don't try again. */
746 if (file->dont_read || file->err_no)
747 return false;
749 if (file->fd == -1 && !open_file (file))
751 open_file_failed (pfile, file, 0);
752 return false;
755 file->dont_read = !read_file_guts (pfile, file);
756 close (file->fd);
757 file->fd = -1;
759 return !file->dont_read;
762 /* Returns TRUE if FILE's contents have been successfully placed in
763 FILE->buffer and the file should be stacked, otherwise false. */
764 static bool
765 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
767 _cpp_file *f;
769 /* Skip once-only files. */
770 if (file->once_only)
771 return false;
773 /* We must mark the file once-only if #import now, before header
774 guard checks. Otherwise, undefining the header guard might
775 cause the file to be re-stacked. */
776 if (import)
778 _cpp_mark_file_once_only (pfile, file);
780 /* Don't stack files that have been stacked before. */
781 if (file->stack_count)
782 return false;
785 /* Skip if the file had a header guard and the macro is defined.
786 PCH relies on this appearing before the PCH handler below. */
787 if (file->cmacro && file->cmacro->type == NT_MACRO)
788 return false;
790 /* Handle PCH files immediately; don't stack them. */
791 if (file->pchname)
793 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
794 file->fd = -1;
795 free ((void *) file->pchname);
796 file->pchname = NULL;
797 return false;
800 if (!read_file (pfile, file))
801 return false;
803 /* Check the file against the PCH file. This is done before
804 checking against files we've already seen, since it may save on
805 I/O. */
806 if (check_file_against_entries (pfile, file, import))
808 /* If this isn't a #import, but yet we can't include the file,
809 that means that it was #import-ed in the PCH file,
810 so we can never include it again. */
811 if (! import)
812 _cpp_mark_file_once_only (pfile, file);
813 return false;
816 /* Now we've read the file's contents, we can stack it if there
817 are no once-only files. */
818 if (!pfile->seen_once_only)
819 return true;
821 /* We may have read the file under a different name. Look
822 for likely candidates and compare file contents to be sure. */
823 for (f = pfile->all_files; f; f = f->next_file)
825 if (f == file)
826 continue;
828 if ((import || f->once_only)
829 && f->err_no == 0
830 && f->st.st_mtime == file->st.st_mtime
831 && f->st.st_size == file->st.st_size)
833 _cpp_file *ref_file;
834 bool same_file_p = false;
836 if (f->buffer && !f->buffer_valid)
838 /* We already have a buffer but it is not valid, because
839 the file is still stacked. Make a new one. */
840 ref_file = make_cpp_file (pfile, f->dir, f->name);
841 ref_file->path = f->path;
843 else
844 /* The file is not stacked anymore. We can reuse it. */
845 ref_file = f;
847 same_file_p = read_file (pfile, ref_file)
848 /* Size might have changed in read_file(). */
849 && ref_file->st.st_size == file->st.st_size
850 && !memcmp (ref_file->buffer,
851 file->buffer,
852 file->st.st_size);
854 if (f->buffer && !f->buffer_valid)
856 ref_file->path = 0;
857 destroy_cpp_file (ref_file);
860 if (same_file_p)
861 break;
865 return f == NULL;
868 /* Place the file referenced by FILE into a new buffer on the buffer
869 stack if possible. IMPORT is true if this stacking attempt is
870 because of a #import directive. Returns true if a buffer is
871 stacked. */
872 bool
873 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
875 cpp_buffer *buffer;
876 int sysp;
878 if (!should_stack_file (pfile, file, import))
879 return false;
881 if (pfile->buffer == NULL || file->dir == NULL)
882 sysp = 0;
883 else
884 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
886 /* Add the file to the dependencies on its first inclusion. */
887 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
889 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
890 deps_add_dep (pfile->deps, file->path);
893 /* Clear buffer_valid since _cpp_clean_line messes it up. */
894 file->buffer_valid = false;
895 file->stack_count++;
897 /* Stack the buffer. */
898 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
899 CPP_OPTION (pfile, preprocessed)
900 && !CPP_OPTION (pfile, directives_only));
901 buffer->file = file;
902 buffer->sysp = sysp;
903 buffer->to_free = file->buffer_start;
905 /* Initialize controlling macro state. */
906 pfile->mi_valid = true;
907 pfile->mi_cmacro = 0;
909 /* Generate the call back. */
910 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
912 return true;
915 /* Mark FILE to be included once only. */
916 void
917 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
919 pfile->seen_once_only = true;
920 file->once_only = true;
923 /* Return the directory from which searching for FNAME should start,
924 considering the directive TYPE and ANGLE_BRACKETS. If there is
925 nothing left in the path, returns NULL. */
926 static struct cpp_dir *
927 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
928 enum include_type type)
930 cpp_dir *dir;
931 _cpp_file *file;
933 if (IS_ABSOLUTE_PATH (fname))
934 return &pfile->no_search_path;
936 /* pfile->buffer is NULL when processing an -include command-line flag. */
937 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
939 /* For #include_next, skip in the search path past the dir in which
940 the current file was found, but if it was found via an absolute
941 path use the normal search logic. */
942 if (type == IT_INCLUDE_NEXT && file->dir
943 && file->dir != &pfile->no_search_path)
944 dir = file->dir->next;
945 else if (angle_brackets)
946 dir = pfile->bracket_include;
947 else if (type == IT_CMDLINE)
948 /* -include and -imacros use the #include "" chain with the
949 preprocessor's cwd prepended. */
950 return make_cpp_dir (pfile, "./", false);
951 else if (pfile->quote_ignores_source_dir)
952 dir = pfile->quote_include;
953 else
954 return make_cpp_dir (pfile, dir_name_of_file (file),
955 pfile->buffer ? pfile->buffer->sysp : 0);
957 if (dir == NULL)
958 cpp_error (pfile, CPP_DL_ERROR,
959 "no include path in which to search for %s", fname);
961 return dir;
964 /* Strip the basename from the file's path. It ends with a slash if
965 of nonzero length. Note that this procedure also works for
966 <stdin>, which is represented by the empty string. */
967 static const char *
968 dir_name_of_file (_cpp_file *file)
970 if (!file->dir_name)
972 size_t len = lbasename (file->path) - file->path;
973 char *dir_name = XNEWVEC (char, len + 1);
975 memcpy (dir_name, file->path, len);
976 dir_name[len] = '\0';
977 file->dir_name = dir_name;
980 return file->dir_name;
983 /* Handles #include-family directives (distinguished by TYPE),
984 including HEADER, and the command line -imacros and -include.
985 Returns true if a buffer was stacked. */
986 bool
987 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
988 enum include_type type)
990 struct cpp_dir *dir;
991 _cpp_file *file;
992 bool stacked;
994 dir = search_path_head (pfile, fname, angle_brackets, type);
995 if (!dir)
996 return false;
998 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets,
999 type == IT_DEFAULT);
1000 if (type == IT_DEFAULT && file == NULL)
1001 return false;
1003 /* Compensate for the increment in linemap_add that occurs if
1004 _cpp_stack_file actually stacks the file. In the case of a
1005 normal #include, we're currently at the start of the line
1006 *following* the #include. A separate source_location for this
1007 location makes no sense (until we do the LC_LEAVE), and
1008 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
1009 found a PCH file (in which case linemap_add is not called) or we
1010 were included from the command-line. */
1011 if (file->pchname == NULL && file->err_no == 0
1012 && type != IT_CMDLINE && type != IT_DEFAULT)
1013 pfile->line_table->highest_location--;
1015 stacked = _cpp_stack_file (pfile, file, type == IT_IMPORT);
1017 if (!stacked)
1018 /* _cpp_stack_file didn't stack the file, so let's rollback the
1019 compensation dance we performed above. */
1020 pfile->line_table->highest_location++;
1022 return stacked;
1025 /* Could not open FILE. The complication is dependency output. */
1026 static void
1027 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
1029 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1030 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1032 errno = file->err_no;
1033 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1035 deps_add_dep (pfile->deps, file->name);
1036 /* If the preprocessor output (other than dependency information) is
1037 being used, we must also flag an error. */
1038 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1039 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1041 else
1043 /* If we are not outputting dependencies, or if we are and dependencies
1044 were requested for this file, or if preprocessor output is needed
1045 in addition to dependency information, this is an error.
1047 Otherwise (outputting dependencies but not for this file, and not
1048 using the preprocessor output), we can still produce correct output
1049 so it's only a warning. */
1050 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1051 || print_dep
1052 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1053 cpp_errno (pfile, CPP_DL_FATAL, file->path);
1054 else
1055 cpp_errno (pfile, CPP_DL_WARNING, file->path);
1059 /* Search in the chain beginning at HEAD for a file whose search path
1060 started at START_DIR != NULL. */
1061 static struct file_hash_entry *
1062 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
1064 while (head && head->start_dir != start_dir)
1065 head = head->next;
1067 return head;
1070 /* Allocate a new _cpp_file structure. */
1071 static _cpp_file *
1072 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
1074 _cpp_file *file;
1076 file = XCNEW (_cpp_file);
1077 file->main_file = !pfile->buffer;
1078 file->fd = -1;
1079 file->dir = dir;
1080 file->name = xstrdup (fname);
1082 return file;
1085 /* Release a _cpp_file structure. */
1086 static void
1087 destroy_cpp_file (_cpp_file *file)
1089 free ((void *) file->buffer_start);
1090 free ((void *) file->name);
1091 free (file);
1094 /* Release all the files allocated by this reader. */
1095 static void
1096 destroy_all_cpp_files (cpp_reader *pfile)
1098 _cpp_file *iter = pfile->all_files;
1099 while (iter)
1101 _cpp_file *next = iter->next_file;
1102 destroy_cpp_file (iter);
1103 iter = next;
1107 /* A hash of directory names. The directory names are the path names
1108 of files which contain a #include "", the included file name is
1109 appended to this directories.
1111 To avoid duplicate entries we follow the convention that all
1112 non-empty directory names should end in a '/'. DIR_NAME must be
1113 stored in permanently allocated memory. */
1114 static cpp_dir *
1115 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1117 struct file_hash_entry *entry, **hash_slot;
1118 cpp_dir *dir;
1120 hash_slot = (struct file_hash_entry **)
1121 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1122 htab_hash_string (dir_name),
1123 INSERT);
1125 /* Have we already hashed this directory? */
1126 for (entry = *hash_slot; entry; entry = entry->next)
1127 if (entry->start_dir == NULL)
1128 return entry->u.dir;
1130 dir = XCNEW (cpp_dir);
1131 dir->next = pfile->quote_include;
1132 dir->name = (char *) dir_name;
1133 dir->len = strlen (dir_name);
1134 dir->sysp = sysp;
1135 dir->construct = 0;
1137 /* Store this new result in the hash table. */
1138 entry = new_file_hash_entry (pfile);
1139 entry->next = *hash_slot;
1140 entry->start_dir = NULL;
1141 entry->location = pfile->line_table->highest_location;
1142 entry->u.dir = dir;
1143 *hash_slot = entry;
1145 return dir;
1148 /* Create a new block of memory for file hash entries. */
1149 static void
1150 allocate_file_hash_entries (cpp_reader *pfile)
1152 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1153 pool->file_hash_entries_used = 0;
1154 pool->next = pfile->file_hash_entries;
1155 pfile->file_hash_entries = pool;
1158 /* Return a new file hash entry. */
1159 static struct file_hash_entry *
1160 new_file_hash_entry (cpp_reader *pfile)
1162 unsigned int idx;
1163 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1164 allocate_file_hash_entries (pfile);
1166 idx = pfile->file_hash_entries->file_hash_entries_used++;
1167 return &pfile->file_hash_entries->pool[idx];
1170 /* Free the file hash entry pools. */
1171 static void
1172 free_file_hash_entries (cpp_reader *pfile)
1174 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1175 while (iter)
1177 struct file_hash_entry_pool *next = iter->next;
1178 free (iter);
1179 iter = next;
1183 /* Returns TRUE if a file FNAME has ever been successfully opened.
1184 This routine is not intended to correctly handle filenames aliased
1185 by links or redundant . or .. traversals etc. */
1186 bool
1187 cpp_included (cpp_reader *pfile, const char *fname)
1189 struct file_hash_entry *entry;
1191 entry = (struct file_hash_entry *)
1192 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1194 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1195 entry = entry->next;
1197 return entry != NULL;
1200 /* Returns TRUE if a file FNAME has ever been successfully opened
1201 before LOCATION. This routine is not intended to correctly handle
1202 filenames aliased by links or redundant . or .. traversals etc. */
1203 bool
1204 cpp_included_before (cpp_reader *pfile, const char *fname,
1205 source_location location)
1207 struct file_hash_entry *entry;
1209 entry = (struct file_hash_entry *)
1210 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1212 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1213 || entry->location > location))
1214 entry = entry->next;
1216 return entry != NULL;
1219 /* Calculate the hash value of a file hash entry P. */
1221 static hashval_t
1222 file_hash_hash (const void *p)
1224 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1225 const char *hname;
1226 if (entry->start_dir)
1227 hname = entry->u.file->name;
1228 else
1229 hname = entry->u.dir->name;
1231 return htab_hash_string (hname);
1234 /* Compare a string Q against a file hash entry P. */
1235 static int
1236 file_hash_eq (const void *p, const void *q)
1238 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1239 const char *fname = (const char *) q;
1240 const char *hname;
1242 if (entry->start_dir)
1243 hname = entry->u.file->name;
1244 else
1245 hname = entry->u.dir->name;
1247 return filename_cmp (hname, fname) == 0;
1250 /* Compare entries in the nonexistent file hash table. These are just
1251 strings. */
1252 static int
1253 nonexistent_file_hash_eq (const void *p, const void *q)
1255 return filename_cmp ((const char *) p, (const char *) q) == 0;
1258 /* Initialize everything in this source file. */
1259 void
1260 _cpp_init_files (cpp_reader *pfile)
1262 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1263 NULL, xcalloc, free);
1264 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1265 NULL, xcalloc, free);
1266 allocate_file_hash_entries (pfile);
1267 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1268 nonexistent_file_hash_eq,
1269 NULL, xcalloc, free);
1270 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1271 (void *(*) (long)) xmalloc,
1272 (void (*) (void *)) free);
1275 /* Finalize everything in this source file. */
1276 void
1277 _cpp_cleanup_files (cpp_reader *pfile)
1279 htab_delete (pfile->file_hash);
1280 htab_delete (pfile->dir_hash);
1281 htab_delete (pfile->nonexistent_file_hash);
1282 obstack_free (&pfile->nonexistent_file_ob, 0);
1283 free_file_hash_entries (pfile);
1284 destroy_all_cpp_files (pfile);
1287 /* Make the parser forget about files it has seen. This can be useful
1288 for resetting the parser to start another run. */
1289 void
1290 cpp_clear_file_cache (cpp_reader *pfile)
1292 _cpp_cleanup_files (pfile);
1293 pfile->file_hash_entries = NULL;
1294 pfile->all_files = NULL;
1295 _cpp_init_files (pfile);
1298 /* Enter a file name in the hash for the sake of cpp_included. */
1299 void
1300 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1302 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0, false);
1305 /* Not everyone who wants to set system-header-ness on a buffer can
1306 see the details of a buffer. This is an exported interface because
1307 fix-header needs it. */
1308 void
1309 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1311 int flags = 0;
1312 const struct line_maps *line_table = pfile->line_table;
1313 const struct line_map *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1314 /* 1 = system header, 2 = system header to be treated as C. */
1315 if (syshdr)
1316 flags = 1 + (externc != 0);
1317 pfile->buffer->sysp = flags;
1318 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1319 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1322 /* Allow the client to change the current file. Used by the front end
1323 to achieve pseudo-file names like <built-in>.
1324 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1325 void
1326 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1327 const char *new_name)
1329 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1332 struct report_missing_guard_data
1334 const char **paths;
1335 size_t count;
1338 /* Callback function for htab_traverse. */
1339 static int
1340 report_missing_guard (void **slot, void *d)
1342 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1343 struct report_missing_guard_data *data
1344 = (struct report_missing_guard_data *) d;
1346 /* Skip directories. */
1347 if (entry->start_dir != NULL)
1349 _cpp_file *file = entry->u.file;
1351 /* We don't want MI guard advice for the main file. */
1352 if (!file->once_only && file->cmacro == NULL
1353 && file->stack_count == 1 && !file->main_file)
1355 if (data->paths == NULL)
1357 data->paths = XCNEWVEC (const char *, data->count);
1358 data->count = 0;
1361 data->paths[data->count++] = file->path;
1365 /* Keep traversing the hash table. */
1366 return 1;
1369 /* Comparison function for qsort. */
1370 static int
1371 report_missing_guard_cmp (const void *p1, const void *p2)
1373 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1376 /* Report on all files that might benefit from a multiple include guard.
1377 Triggered by -H. */
1378 void
1379 _cpp_report_missing_guards (cpp_reader *pfile)
1381 struct report_missing_guard_data data;
1383 data.paths = NULL;
1384 data.count = htab_elements (pfile->file_hash);
1385 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1387 if (data.paths != NULL)
1389 size_t i;
1391 /* Sort the paths to avoid outputting them in hash table
1392 order. */
1393 qsort (data.paths, data.count, sizeof (const char *),
1394 report_missing_guard_cmp);
1395 fputs (_("Multiple include guards may be useful for:\n"),
1396 stderr);
1397 for (i = 0; i < data.count; i++)
1399 fputs (data.paths[i], stderr);
1400 putc ('\n', stderr);
1402 free (data.paths);
1406 /* Locate HEADER, and determine whether it is newer than the current
1407 file. If it cannot be located or dated, return -1, if it is
1408 newer, return 1, otherwise 0. */
1410 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1411 int angle_brackets)
1413 _cpp_file *file;
1414 struct cpp_dir *dir;
1416 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1417 if (!dir)
1418 return -1;
1420 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, false);
1421 if (file->err_no)
1422 return -1;
1424 if (file->fd != -1)
1426 close (file->fd);
1427 file->fd = -1;
1430 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1433 /* Pushes the given file onto the buffer stack. Returns nonzero if
1434 successful. */
1435 bool
1436 cpp_push_include (cpp_reader *pfile, const char *fname)
1438 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1441 /* Pushes the given file, implicitly included at the start of a
1442 compilation, onto the buffer stack but without any errors if the
1443 file is not found. Returns nonzero if successful. */
1444 bool
1445 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1447 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT);
1450 /* Do appropriate cleanup when a file INC's buffer is popped off the
1451 input stack. */
1452 void
1453 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1454 const unsigned char *to_free)
1456 /* Record the inclusion-preventing macro, which could be NULL
1457 meaning no controlling macro. */
1458 if (pfile->mi_valid && file->cmacro == NULL)
1459 file->cmacro = pfile->mi_cmacro;
1461 /* Invalidate control macros in the #including file. */
1462 pfile->mi_valid = false;
1464 if (to_free)
1466 if (to_free == file->buffer_start)
1468 file->buffer_start = NULL;
1469 file->buffer = NULL;
1470 file->buffer_valid = false;
1472 free ((void *) to_free);
1476 /* Return the file name associated with FILE. */
1477 const char *
1478 _cpp_get_file_name (_cpp_file *file)
1480 return file->name;
1483 /* Inteface to file statistics record in _cpp_file structure. */
1484 struct stat *
1485 _cpp_get_file_stat (_cpp_file *file)
1487 return &file->st;
1490 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1491 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1492 directory of the including file.
1494 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1495 void
1496 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1497 int quote_ignores_source_dir)
1499 pfile->quote_include = quote;
1500 pfile->bracket_include = quote;
1501 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1503 for (; quote; quote = quote->next)
1505 quote->name_map = NULL;
1506 quote->len = strlen (quote->name);
1507 if (quote == bracket)
1508 pfile->bracket_include = bracket;
1512 /* Append the file name to the directory to create the path, but don't
1513 turn / into // or // into ///; // may be a namespace escape. */
1514 static char *
1515 append_file_to_dir (const char *fname, cpp_dir *dir)
1517 size_t dlen, flen;
1518 char *path;
1520 dlen = dir->len;
1521 flen = strlen (fname);
1522 path = XNEWVEC (char, dlen + 1 + flen + 1);
1523 memcpy (path, dir->name, dlen);
1524 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1525 path[dlen++] = '/';
1526 memcpy (&path[dlen], fname, flen + 1);
1528 return path;
1531 /* Read a space delimited string of unlimited length from a stdio
1532 file F. */
1533 static char *
1534 read_filename_string (int ch, FILE *f)
1536 char *alloc, *set;
1537 int len;
1539 len = 20;
1540 set = alloc = XNEWVEC (char, len + 1);
1541 if (! is_space (ch))
1543 *set++ = ch;
1544 while ((ch = getc (f)) != EOF && ! is_space (ch))
1546 if (set - alloc == len)
1548 len *= 2;
1549 alloc = XRESIZEVEC (char, alloc, len + 1);
1550 set = alloc + len / 2;
1552 *set++ = ch;
1555 *set = '\0';
1556 ungetc (ch, f);
1557 return alloc;
1560 /* Read the file name map file for DIR. */
1561 static void
1562 read_name_map (cpp_dir *dir)
1564 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1565 char *name;
1566 FILE *f;
1567 size_t len, count = 0, room = 9;
1569 len = dir->len;
1570 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1571 memcpy (name, dir->name, len);
1572 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1573 name[len++] = '/';
1574 strcpy (name + len, FILE_NAME_MAP_FILE);
1575 f = fopen (name, "r");
1577 dir->name_map = XNEWVEC (const char *, room);
1579 /* Silently return NULL if we cannot open. */
1580 if (f)
1582 int ch;
1584 while ((ch = getc (f)) != EOF)
1586 char *to;
1588 if (is_space (ch))
1589 continue;
1591 if (count + 2 > room)
1593 room += 8;
1594 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1597 dir->name_map[count] = read_filename_string (ch, f);
1598 while ((ch = getc (f)) != EOF && is_hspace (ch))
1601 to = read_filename_string (ch, f);
1602 if (IS_ABSOLUTE_PATH (to))
1603 dir->name_map[count + 1] = to;
1604 else
1606 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1607 free (to);
1610 count += 2;
1611 while ((ch = getc (f)) != '\n')
1612 if (ch == EOF)
1613 break;
1616 fclose (f);
1619 /* Terminate the list of maps. */
1620 dir->name_map[count] = NULL;
1623 /* Remap a FILE's name based on the file_name_map, if any, for
1624 FILE->dir. If the file name has any directory separators,
1625 recursively check those directories too. */
1626 static char *
1627 remap_filename (cpp_reader *pfile, _cpp_file *file)
1629 const char *fname, *p;
1630 char *new_dir;
1631 cpp_dir *dir;
1632 size_t index, len;
1634 dir = file->dir;
1635 fname = file->name;
1637 for (;;)
1639 if (!dir->name_map)
1640 read_name_map (dir);
1642 for (index = 0; dir->name_map[index]; index += 2)
1643 if (!filename_cmp (dir->name_map[index], fname))
1644 return xstrdup (dir->name_map[index + 1]);
1645 if (IS_ABSOLUTE_PATH (fname))
1646 return NULL;
1647 p = strchr (fname, '/');
1648 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1650 char *p2 = strchr (fname, '\\');
1651 if (!p || (p > p2))
1652 p = p2;
1654 #endif
1655 if (!p || p == fname)
1656 return NULL;
1658 len = dir->len + (p - fname + 1);
1659 new_dir = XNEWVEC (char, len + 1);
1660 memcpy (new_dir, dir->name, dir->len);
1661 memcpy (new_dir + dir->len, fname, p - fname + 1);
1662 new_dir[len] = '\0';
1664 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1665 fname = p + 1;
1669 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1670 static bool
1671 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1673 const char *saved_path = file->path;
1674 bool valid = false;
1676 file->path = pchname;
1677 if (open_file (file))
1679 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1681 if (!valid)
1683 close (file->fd);
1684 file->fd = -1;
1687 if (CPP_OPTION (pfile, print_include_names))
1689 unsigned int i;
1690 for (i = 1; i < pfile->line_table->depth; i++)
1691 putc ('.', stderr);
1692 fprintf (stderr, "%c %s\n",
1693 valid ? '!' : 'x', pchname);
1697 file->path = saved_path;
1698 return valid;
1701 /* Get the path associated with the _cpp_file F. The path includes
1702 the base name from the include directive and the directory it was
1703 found in via the search path. */
1705 const char *
1706 cpp_get_path (struct _cpp_file *f)
1708 return f->path;
1711 /* Get the directory associated with the _cpp_file F. */
1713 cpp_dir *
1714 cpp_get_dir (struct _cpp_file *f)
1716 return f->dir;
1719 /* Get the cpp_buffer currently associated with the cpp_reader
1720 PFILE. */
1722 cpp_buffer *
1723 cpp_get_buffer (cpp_reader *pfile)
1725 return pfile->buffer;
1728 /* Get the _cpp_file associated with the cpp_buffer B. */
1730 _cpp_file *
1731 cpp_get_file (cpp_buffer *b)
1733 return b->file;
1736 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1737 buffer is the buffer that included the given buffer. */
1739 cpp_buffer *
1740 cpp_get_prev (cpp_buffer *b)
1742 return b->prev;
1745 /* This data structure holds the list of header files that were seen
1746 while the PCH was being built. The 'entries' field is kept sorted
1747 in memcmp() order; yes, this means that on little-endian systems,
1748 it's sorted initially by the least-significant byte of 'size', but
1749 that's OK. The code does rely on having entries with the same size
1750 next to each other. */
1752 struct pchf_entry {
1753 /* The size of this file. This is used to save running a MD5 checksum
1754 if the sizes don't match. */
1755 off_t size;
1756 /* The MD5 checksum of this file. */
1757 unsigned char sum[16];
1758 /* Is this file to be included only once? */
1759 bool once_only;
1762 struct pchf_data {
1763 /* Number of pchf_entry structures. */
1764 size_t count;
1766 /* Are there any values with once_only set?
1767 This is used as an optimisation, it means we don't have to search
1768 the structure if we're processing a regular #include. */
1769 bool have_once_only;
1771 struct pchf_entry entries[1];
1774 static struct pchf_data *pchf;
1776 /* A qsort ordering function for pchf_entry structures. */
1778 static int
1779 pchf_save_compare (const void *e1, const void *e2)
1781 return memcmp (e1, e2, sizeof (struct pchf_entry));
1784 /* Create and write to F a pchf_data structure. */
1786 bool
1787 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1789 size_t count = 0;
1790 struct pchf_data *result;
1791 size_t result_size;
1792 _cpp_file *f;
1793 bool ret;
1795 for (f = pfile->all_files; f; f = f->next_file)
1796 ++count;
1798 result_size = (sizeof (struct pchf_data)
1799 + sizeof (struct pchf_entry) * (count - 1));
1800 result = XCNEWVAR (struct pchf_data, result_size);
1802 result->count = 0;
1803 result->have_once_only = false;
1805 for (f = pfile->all_files; f; f = f->next_file)
1807 size_t count;
1809 /* This should probably never happen, since if a read error occurred
1810 the PCH file shouldn't be written... */
1811 if (f->dont_read || f->err_no)
1812 continue;
1814 if (f->stack_count == 0)
1815 continue;
1817 count = result->count++;
1819 result->entries[count].once_only = f->once_only;
1820 /* |= is avoided in the next line because of an HP C compiler bug */
1821 result->have_once_only = result->have_once_only | f->once_only;
1822 if (f->buffer_valid)
1823 md5_buffer ((const char *)f->buffer,
1824 f->st.st_size, result->entries[count].sum);
1825 else
1827 FILE *ff;
1828 int oldfd = f->fd;
1830 if (!open_file (f))
1832 open_file_failed (pfile, f, 0);
1833 free (result);
1834 return false;
1836 ff = fdopen (f->fd, "rb");
1837 md5_stream (ff, result->entries[count].sum);
1838 fclose (ff);
1839 f->fd = oldfd;
1841 result->entries[count].size = f->st.st_size;
1844 result_size = (sizeof (struct pchf_data)
1845 + sizeof (struct pchf_entry) * (result->count - 1));
1847 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1848 pchf_save_compare);
1850 ret = fwrite (result, result_size, 1, fp) == 1;
1851 free (result);
1852 return ret;
1855 /* Read the pchf_data structure from F. */
1857 bool
1858 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1860 struct pchf_data d;
1862 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1863 != 1)
1864 return false;
1866 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1867 + sizeof (struct pchf_entry) * (d.count - 1));
1868 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1869 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1870 != d.count)
1871 return false;
1872 return true;
1875 /* The parameters for pchf_compare. */
1877 struct pchf_compare_data
1879 /* The size of the file we're looking for. */
1880 off_t size;
1882 /* The MD5 checksum of the file, if it's been computed. */
1883 unsigned char sum[16];
1885 /* Is SUM valid? */
1886 bool sum_computed;
1888 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1889 bool check_included;
1891 /* The file that we're searching for. */
1892 _cpp_file *f;
1895 /* bsearch comparison function; look for D_P in E_P. */
1897 static int
1898 pchf_compare (const void *d_p, const void *e_p)
1900 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1901 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1902 int result;
1904 result = memcmp (&d->size, &e->size, sizeof (off_t));
1905 if (result != 0)
1906 return result;
1908 if (! d->sum_computed)
1910 _cpp_file *const f = d->f;
1912 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1913 d->sum_computed = true;
1916 result = memcmp (d->sum, e->sum, 16);
1917 if (result != 0)
1918 return result;
1920 if (d->check_included || e->once_only)
1921 return 0;
1922 else
1923 return 1;
1926 /* Check that F is not in a list read from a PCH file (if any).
1927 Assumes that f->buffer_valid is true. Return TRUE if the file
1928 should not be read. */
1930 static bool
1931 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1932 _cpp_file *f,
1933 bool check_included)
1935 struct pchf_compare_data d;
1937 if (pchf == NULL
1938 || (! check_included && ! pchf->have_once_only))
1939 return false;
1941 d.size = f->st.st_size;
1942 d.sum_computed = false;
1943 d.f = f;
1944 d.check_included = check_included;
1945 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1946 pchf_compare) != NULL;