Move MEMMODEL_* from coretypes.h to memmodel.h
[official-gcc.git] / libcpp / files.c
blobc8bb637fb58c3700c60ee67c1e629315e3d98f1c
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2016 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Split out of cpplib.c, Zack Weinberg, Oct 1998
7 Reimplemented, Neil Booth, Jul 2003
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
12 later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "cpplib.h"
26 #include "internal.h"
27 #include "mkdeps.h"
28 #include "obstack.h"
29 #include "hashtab.h"
30 #include "md5.h"
31 #include <dirent.h>
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
35 #ifdef VMS
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
38 #else
39 # define STAT_SIZE_RELIABLE(ST) true
40 #endif
42 #ifdef __DJGPP__
43 #include <io.h>
44 /* For DJGPP redirected input is opened in text mode. */
45 # define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY)
47 #else
48 # define set_stdin_to_binary_mode() /* Nothing */
49 #endif
51 /* This structure represents a file searched for by CPP, whether it
52 exists or not. An instance may be pointed to by more than one
53 cpp_file_hash_entry; at present no reference count is kept. */
54 struct _cpp_file
56 /* Filename as given to #include or command line switch. */
57 const char *name;
59 /* The full path used to find the file. */
60 const char *path;
62 /* The full path of the pch file. */
63 const char *pchname;
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
67 const char *dir_name;
69 /* Chain through all files. */
70 struct _cpp_file *next_file;
72 /* The contents of NAME after calling read_file(). */
73 const uchar *buffer;
75 /* Pointer to the real start of BUFFER. read_file() might increment
76 BUFFER; when freeing, this this pointer must be used instead. */
77 const uchar *buffer_start;
79 /* The macro, if any, preventing re-inclusion. */
80 const cpp_hashnode *cmacro;
82 /* The directory in the search path where FILE was found. Used for
83 #include_next and determining whether a header is a system
84 header. */
85 cpp_dir *dir;
87 /* As filled in by stat(2) for the file. */
88 struct stat st;
90 /* File descriptor. Invalid if -1, otherwise open. */
91 int fd;
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
95 int err_no;
97 /* Number of times the file has been stacked for preprocessing. */
98 unsigned short stack_count;
100 /* If opened with #import or contains #pragma once. */
101 bool once_only;
103 /* If read() failed before. */
104 bool dont_read;
106 /* If this file is the main file. */
107 bool main_file;
109 /* If BUFFER above contains the true contents of the file. */
110 bool buffer_valid;
112 /* If this file is implicitly preincluded. */
113 bool implicit_preinclude;
116 /* A singly-linked list for all searches for a given file name, with
117 its head pointed to by a slot in FILE_HASH. The file name is what
118 appeared between the quotes in a #include directive; it can be
119 determined implicitly from the hash table location or explicitly
120 from FILE->name.
122 FILE is a structure containing details about the file that was
123 found with that search, or details of how the search failed.
125 START_DIR is the starting location of the search in the include
126 chain. The current directories for "" includes are also hashed in
127 the hash table and therefore unique. Files that are looked up
128 without using a search path, such as absolute filenames and file
129 names from the command line share a special starting directory so
130 they don't cause cache hits with normal include-chain lookups.
132 If START_DIR is NULL then the entry is for a directory, not a file,
133 and the directory is in DIR. Since the starting point in a file
134 lookup chain is never NULL, this means that simple pointer
135 comparisons against START_DIR can be made to determine cache hits
136 in file lookups.
138 If a cache lookup fails because of e.g. an extra "./" in the path,
139 then nothing will break. It is just less efficient as CPP will
140 have to do more work re-preprocessing the file, and/or comparing
141 its contents against earlier once-only files.
143 struct cpp_file_hash_entry
145 struct cpp_file_hash_entry *next;
146 cpp_dir *start_dir;
147 source_location location;
148 union
150 _cpp_file *file;
151 cpp_dir *dir;
152 } u;
155 /* Number of entries to put in a cpp_file_hash_entry pool. */
156 #define FILE_HASH_POOL_SIZE 127
158 /* A file hash entry pool. We allocate cpp_file_hash_entry object from
159 one of these. */
160 struct file_hash_entry_pool
162 /* Number of entries used from this pool. */
163 unsigned int file_hash_entries_used;
164 /* Next pool in the chain; used when freeing. */
165 struct file_hash_entry_pool *next;
166 /* The memory pool. */
167 struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE];
170 static bool open_file (_cpp_file *file);
171 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
172 bool *invalid_pch);
173 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
174 bool *invalid_pch, source_location loc);
175 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file,
176 source_location loc);
177 static bool read_file (cpp_reader *pfile, _cpp_file *file,
178 source_location loc);
179 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import,
180 source_location loc);
181 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
182 int angle_brackets, enum include_type);
183 static const char *dir_name_of_file (_cpp_file *file);
184 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int,
185 source_location);
186 static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
187 const cpp_dir *start_dir);
188 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
189 static void destroy_cpp_file (_cpp_file *);
190 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
191 static void allocate_file_hash_entries (cpp_reader *pfile);
192 static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
193 static int report_missing_guard (void **slot, void *b);
194 static hashval_t file_hash_hash (const void *p);
195 static int file_hash_eq (const void *p, const void *q);
196 static char *read_filename_string (int ch, FILE *f);
197 static void read_name_map (cpp_dir *dir);
198 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
199 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
200 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
201 static int pchf_save_compare (const void *e1, const void *e2);
202 static int pchf_compare (const void *d_p, const void *e_p);
203 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
205 /* Given a filename in FILE->PATH, with the empty string interpreted
206 as <stdin>, open it.
208 On success FILE contains an open file descriptor and stat
209 information for the file. On failure the file descriptor is -1 and
210 the appropriate errno is also stored in FILE. Returns TRUE iff
211 successful.
213 We used to open files in nonblocking mode, but that caused more
214 problems than it solved. Do take care not to acquire a controlling
215 terminal by mistake (this can't happen on sane systems, but
216 paranoia is a virtue).
218 Use the three-argument form of open even though we aren't
219 specifying O_CREAT, to defend against broken system headers.
221 O_BINARY tells some runtime libraries (notably DJGPP) not to do
222 newline translation; we can handle DOS line breaks just fine
223 ourselves. */
224 static bool
225 open_file (_cpp_file *file)
227 if (file->path[0] == '\0')
229 file->fd = 0;
230 set_stdin_to_binary_mode ();
232 else
233 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
235 if (file->fd != -1)
237 if (fstat (file->fd, &file->st) == 0)
239 if (!S_ISDIR (file->st.st_mode))
241 file->err_no = 0;
242 return true;
245 /* Ignore a directory and continue the search. The file we're
246 looking for may be elsewhere in the search path. */
247 errno = ENOENT;
250 close (file->fd);
251 file->fd = -1;
253 #if defined(_WIN32) && !defined(__CYGWIN__)
254 else if (errno == EACCES)
256 /* On most UNIX systems, open succeeds on a directory. Above,
257 we check if we have opened a directory and if so, set errno
258 to ENOENT. However, on Windows, opening a directory
259 fails with EACCES. We want to return ENOENT in that
260 case too. */
261 if (stat (file->path, &file->st) == 0
262 && S_ISDIR (file->st.st_mode))
263 errno = ENOENT;
264 else
265 /* The call to stat may have reset errno. */
266 errno = EACCES;
268 #endif
269 else if (errno == ENOTDIR)
270 errno = ENOENT;
272 file->err_no = errno;
274 return false;
277 /* Temporary PCH intercept of opening a file. Try to find a PCH file
278 based on FILE->name and FILE->dir, and test those found for
279 validity using PFILE->cb.valid_pch. Return true iff a valid file is
280 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
282 static bool
283 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
285 static const char extension[] = ".gch";
286 const char *path = file->path;
287 size_t len, flen;
288 char *pchname;
289 struct stat st;
290 bool valid = false;
292 /* No PCH on <stdin> or if not requested. */
293 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
294 return false;
296 /* If the file is not included as first include from either the toplevel
297 file or the command-line it is not a valid use of PCH. */
298 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
299 if (f->implicit_preinclude)
300 continue;
301 else if (f->main_file)
302 break;
303 else
304 return false;
306 flen = strlen (path);
307 len = flen + sizeof (extension);
308 pchname = XNEWVEC (char, len);
309 memcpy (pchname, path, flen);
310 memcpy (pchname + flen, extension, sizeof (extension));
312 if (stat (pchname, &st) == 0)
314 DIR *pchdir;
315 struct dirent *d;
316 size_t dlen, plen = len;
318 if (!S_ISDIR (st.st_mode))
319 valid = validate_pch (pfile, file, pchname);
320 else if ((pchdir = opendir (pchname)) != NULL)
322 pchname[plen - 1] = '/';
323 while ((d = readdir (pchdir)) != NULL)
325 dlen = strlen (d->d_name) + 1;
326 if ((strcmp (d->d_name, ".") == 0)
327 || (strcmp (d->d_name, "..") == 0))
328 continue;
329 if (dlen + plen > len)
331 len += dlen + 64;
332 pchname = XRESIZEVEC (char, pchname, len);
334 memcpy (pchname + plen, d->d_name, dlen);
335 valid = validate_pch (pfile, file, pchname);
336 if (valid)
337 break;
339 closedir (pchdir);
341 if (!valid)
342 *invalid_pch = true;
345 if (valid)
346 file->pchname = pchname;
347 else
348 free (pchname);
350 return valid;
353 /* Canonicalize the path to FILE. Return the canonical form if it is
354 shorter, otherwise return NULL. This function does NOT free the
355 memory pointed by FILE. */
357 static char *
358 maybe_shorter_path (const char * file)
360 char * file2 = lrealpath (file);
361 if (file2 && strlen (file2) < strlen (file))
363 return file2;
365 else
367 free (file2);
368 return NULL;
372 /* Try to open the path FILE->name appended to FILE->dir. This is
373 where remap and PCH intercept the file lookup process. Return true
374 if the file was found, whether or not the open was successful.
375 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
376 Use LOC when emitting any diagnostics. */
378 static bool
379 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch,
380 source_location loc)
382 char *path;
384 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
386 else
387 if (file->dir->construct)
388 path = file->dir->construct (file->name, file->dir);
389 else
390 path = append_file_to_dir (file->name, file->dir);
392 if (path)
394 hashval_t hv;
395 char *copy;
396 void **pp;
398 /* We try to canonicalize system headers. For DOS based file
399 * system, we always try to shorten non-system headers, as DOS
400 * has a tighter constraint on max path length. */
401 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
402 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
403 || !file->dir->sysp
404 #endif
407 char * canonical_path = maybe_shorter_path (path);
408 if (canonical_path)
410 /* The canonical path was newly allocated. Let's free the
411 non-canonical one. */
412 free (path);
413 path = canonical_path;
417 hv = htab_hash_string (path);
418 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
420 file->err_no = ENOENT;
421 return false;
424 file->path = path;
425 if (pch_open_file (pfile, file, invalid_pch))
426 return true;
428 if (open_file (file))
429 return true;
431 if (file->err_no != ENOENT)
433 open_file_failed (pfile, file, 0, loc);
434 return true;
437 /* We copy the path name onto an obstack partly so that we don't
438 leak the memory, but mostly so that we don't fragment the
439 heap. */
440 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
441 strlen (path));
442 free (path);
443 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
444 copy, hv, INSERT);
445 *pp = copy;
447 file->path = file->name;
449 else
451 file->err_no = ENOENT;
452 file->path = NULL;
455 return false;
458 /* Return tue iff the missing_header callback found the given HEADER. */
459 static bool
460 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
462 missing_header_cb func = pfile->cb.missing_header;
464 /* When the regular search path doesn't work, try context dependent
465 headers search paths. */
466 if (func
467 && file->dir == NULL)
469 if ((file->path = func (pfile, header, &file->dir)) != NULL)
471 if (open_file (file))
472 return true;
473 free ((void *)file->path);
475 file->path = file->name;
478 return false;
481 bool
482 _cpp_find_failed (_cpp_file *file)
484 return file->err_no != 0;
487 /* Given a filename FNAME search for such a file in the include path
488 starting from START_DIR. If FNAME is the empty string it is
489 interpreted as STDIN if START_DIR is PFILE->no_search_path.
491 If the file is not found in the file cache fall back to the O/S and
492 add the result to our cache.
494 If the file was not found in the filesystem, or there was an error
495 opening it, then ERR_NO is nonzero and FD is -1. If the file was
496 found, then ERR_NO is zero and FD could be -1 or an open file
497 descriptor. FD can be -1 if the file was found in the cache and
498 had previously been closed. To open it again pass the return value
499 to open_file().
501 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
502 If present, it is OK for a precompiled header to be included after
505 Use LOC as the location for any errors. */
507 _cpp_file *
508 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
509 bool fake, int angle_brackets, bool implicit_preinclude,
510 source_location loc)
512 struct cpp_file_hash_entry *entry;
513 void **hash_slot;
514 _cpp_file *file;
515 bool invalid_pch = false;
516 bool saw_bracket_include = false;
517 bool saw_quote_include = false;
518 struct cpp_dir *found_in_cache = NULL;
520 /* Ensure we get no confusion between cached files and directories. */
521 if (start_dir == NULL)
522 cpp_error_at (pfile, CPP_DL_ICE, loc, "NULL directory in find_file");
524 hash_slot
525 = htab_find_slot_with_hash (pfile->file_hash, fname,
526 htab_hash_string (fname), INSERT);
528 /* First check the cache before we resort to memory allocation. */
529 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
530 if (entry)
531 return entry->u.file;
533 file = make_cpp_file (pfile, start_dir, fname);
534 file->implicit_preinclude
535 = (implicit_preinclude
536 || (pfile->buffer
537 && pfile->buffer->file->implicit_preinclude));
539 /* Try each path in the include chain. */
540 for (; !fake ;)
542 if (find_file_in_dir (pfile, file, &invalid_pch, loc))
543 break;
545 file->dir = file->dir->next;
546 if (file->dir == NULL)
548 if (search_path_exhausted (pfile, fname, file))
550 /* Although this file must not go in the cache, because
551 the file found might depend on things (like the current file)
552 that aren't represented in the cache, it still has to go in
553 the list of all files so that #import works. */
554 file->next_file = pfile->all_files;
555 pfile->all_files = file;
556 if (*hash_slot == NULL)
558 /* If *hash_slot is NULL, the above htab_find_slot_with_hash
559 call just created the slot, but we aren't going to store
560 there anything, so need to remove the newly created entry.
561 htab_clear_slot requires that it is non-NULL, so store
562 there some non-NULL pointer, htab_clear_slot will
563 overwrite it immediately. */
564 *hash_slot = file;
565 htab_clear_slot (pfile->file_hash, hash_slot);
567 return file;
570 if (invalid_pch)
572 cpp_error (pfile, CPP_DL_ERROR,
573 "one or more PCH files were found, but they were invalid");
574 if (!cpp_get_options (pfile)->warn_invalid_pch)
575 cpp_error (pfile, CPP_DL_ERROR,
576 "use -Winvalid-pch for more information");
578 if (implicit_preinclude)
580 free ((char *) file->name);
581 free (file);
582 if (*hash_slot == NULL)
584 /* See comment on the above htab_clear_slot call. */
585 *hash_slot = file;
586 htab_clear_slot (pfile->file_hash, hash_slot);
588 return NULL;
590 else
591 open_file_failed (pfile, file, angle_brackets, loc);
592 break;
595 /* Only check the cache for the starting location (done above)
596 and the quote and bracket chain heads because there are no
597 other possible starting points for searches. */
598 if (file->dir == pfile->bracket_include)
599 saw_bracket_include = true;
600 else if (file->dir == pfile->quote_include)
601 saw_quote_include = true;
602 else
603 continue;
605 entry = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
606 if (entry)
608 found_in_cache = file->dir;
609 break;
613 if (entry)
615 /* Cache for START_DIR too, sharing the _cpp_file structure. */
616 free ((char *) file->name);
617 free (file);
618 file = entry->u.file;
620 else
622 /* This is a new file; put it in the list. */
623 file->next_file = pfile->all_files;
624 pfile->all_files = file;
627 /* Store this new result in the hash table. */
628 entry = new_file_hash_entry (pfile);
629 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
630 entry->start_dir = start_dir;
631 entry->location = pfile->line_table->highest_location;
632 entry->u.file = file;
633 *hash_slot = (void *) entry;
635 /* If we passed the quote or bracket chain heads, cache them also.
636 This speeds up processing if there are lots of -I options. */
637 if (saw_bracket_include
638 && pfile->bracket_include != start_dir
639 && found_in_cache != pfile->bracket_include)
641 entry = new_file_hash_entry (pfile);
642 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
643 entry->start_dir = pfile->bracket_include;
644 entry->location = pfile->line_table->highest_location;
645 entry->u.file = file;
646 *hash_slot = (void *) entry;
648 if (saw_quote_include
649 && pfile->quote_include != start_dir
650 && found_in_cache != pfile->quote_include)
652 entry = new_file_hash_entry (pfile);
653 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
654 entry->start_dir = pfile->quote_include;
655 entry->location = pfile->line_table->highest_location;
656 entry->u.file = file;
657 *hash_slot = (void *) entry;
660 return file;
663 /* Read a file into FILE->buffer, returning true on success.
665 If FILE->fd is something weird, like a block device, we don't want
666 to read it at all. Don't even try to figure out what something is,
667 except for plain files and block devices, since there is no
668 reliable portable way of doing this.
670 Use LOC for any diagnostics.
672 FIXME: Flush file cache and try again if we run out of memory. */
673 static bool
674 read_file_guts (cpp_reader *pfile, _cpp_file *file, source_location loc)
676 ssize_t size, total, count;
677 uchar *buf;
678 bool regular;
680 if (S_ISBLK (file->st.st_mode))
682 cpp_error_at (pfile, CPP_DL_ERROR, loc,
683 "%s is a block device", file->path);
684 return false;
687 regular = S_ISREG (file->st.st_mode) != 0;
688 if (regular)
690 /* off_t might have a wider range than ssize_t - in other words,
691 the max size of a file might be bigger than the address
692 space. We can't handle a file that large. (Anyone with
693 a single source file bigger than 2GB needs to rethink
694 their coding style.) Some systems (e.g. AIX 4.1) define
695 SSIZE_MAX to be much smaller than the actual range of the
696 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
697 does not bite us. */
698 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
700 cpp_error_at (pfile, CPP_DL_ERROR, loc,
701 "%s is too large", file->path);
702 return false;
705 size = file->st.st_size;
707 else
708 /* 8 kilobytes is a sensible starting size. It ought to be bigger
709 than the kernel pipe buffer, and it's definitely bigger than
710 the majority of C source files. */
711 size = 8 * 1024;
713 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
714 used to quiet warnings from valgrind or Address Sanitizer, when the
715 optimized lexer accesses aligned 16-byte memory chunks, including
716 the bytes after the malloced, area, and stops lexing on '\n'. */
717 buf = XNEWVEC (uchar, size + 16);
718 total = 0;
719 while ((count = read (file->fd, buf + total, size - total)) > 0)
721 total += count;
723 if (total == size)
725 if (regular)
726 break;
727 size *= 2;
728 buf = XRESIZEVEC (uchar, buf, size + 16);
732 if (count < 0)
734 cpp_errno_filename (pfile, CPP_DL_ERROR, file->path, loc);
735 free (buf);
736 return false;
739 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
740 cpp_error_at (pfile, CPP_DL_WARNING, loc,
741 "%s is shorter than expected", file->path);
743 file->buffer = _cpp_convert_input (pfile,
744 CPP_OPTION (pfile, input_charset),
745 buf, size + 16, total,
746 &file->buffer_start,
747 &file->st.st_size);
748 file->buffer_valid = true;
750 return true;
753 /* Convenience wrapper around read_file_guts that opens the file if
754 necessary and closes the file descriptor after reading. FILE must
755 have been passed through find_file() at some stage. Use LOC for
756 any diagnostics. */
757 static bool
758 read_file (cpp_reader *pfile, _cpp_file *file, source_location loc)
760 /* If we already have its contents in memory, succeed immediately. */
761 if (file->buffer_valid)
762 return true;
764 /* If an earlier read failed for some reason don't try again. */
765 if (file->dont_read || file->err_no)
766 return false;
768 if (file->fd == -1 && !open_file (file))
770 open_file_failed (pfile, file, 0, loc);
771 return false;
774 file->dont_read = !read_file_guts (pfile, file, loc);
775 close (file->fd);
776 file->fd = -1;
778 return !file->dont_read;
781 /* Returns TRUE if FILE's contents have been successfully placed in
782 FILE->buffer and the file should be stacked, otherwise false.
783 Use LOC for any diagnostics. */
784 static bool
785 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import,
786 source_location loc)
788 _cpp_file *f;
790 /* Skip once-only files. */
791 if (file->once_only)
792 return false;
794 /* We must mark the file once-only if #import now, before header
795 guard checks. Otherwise, undefining the header guard might
796 cause the file to be re-stacked. */
797 if (import)
799 _cpp_mark_file_once_only (pfile, file);
801 /* Don't stack files that have been stacked before. */
802 if (file->stack_count)
803 return false;
806 /* Skip if the file had a header guard and the macro is defined.
807 PCH relies on this appearing before the PCH handler below. */
808 if (file->cmacro && file->cmacro->type == NT_MACRO)
809 return false;
811 /* Handle PCH files immediately; don't stack them. */
812 if (file->pchname)
814 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
815 file->fd = -1;
816 free ((void *) file->pchname);
817 file->pchname = NULL;
818 return false;
821 if (!read_file (pfile, file, loc))
822 return false;
824 /* Check the file against the PCH file. This is done before
825 checking against files we've already seen, since it may save on
826 I/O. */
827 if (check_file_against_entries (pfile, file, import))
829 /* If this isn't a #import, but yet we can't include the file,
830 that means that it was #import-ed in the PCH file,
831 so we can never include it again. */
832 if (! import)
833 _cpp_mark_file_once_only (pfile, file);
834 return false;
837 /* Now we've read the file's contents, we can stack it if there
838 are no once-only files. */
839 if (!pfile->seen_once_only)
840 return true;
842 /* We may have read the file under a different name. Look
843 for likely candidates and compare file contents to be sure. */
844 for (f = pfile->all_files; f; f = f->next_file)
846 if (f == file)
847 continue;
849 if ((import || f->once_only)
850 && f->err_no == 0
851 && f->st.st_mtime == file->st.st_mtime
852 && f->st.st_size == file->st.st_size)
854 _cpp_file *ref_file;
855 bool same_file_p = false;
857 if (f->buffer && !f->buffer_valid)
859 /* We already have a buffer but it is not valid, because
860 the file is still stacked. Make a new one. */
861 ref_file = make_cpp_file (pfile, f->dir, f->name);
862 ref_file->path = f->path;
864 else
865 /* The file is not stacked anymore. We can reuse it. */
866 ref_file = f;
868 same_file_p = read_file (pfile, ref_file, loc)
869 /* Size might have changed in read_file(). */
870 && ref_file->st.st_size == file->st.st_size
871 && !memcmp (ref_file->buffer,
872 file->buffer,
873 file->st.st_size);
875 if (f->buffer && !f->buffer_valid)
877 ref_file->path = 0;
878 destroy_cpp_file (ref_file);
881 if (same_file_p)
882 break;
886 return f == NULL;
889 /* Place the file referenced by FILE into a new buffer on the buffer
890 stack if possible. IMPORT is true if this stacking attempt is
891 because of a #import directive. Returns true if a buffer is
892 stacked. Use LOC for any diagnostics. */
893 bool
894 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import,
895 source_location loc)
897 cpp_buffer *buffer;
898 int sysp;
900 if (!should_stack_file (pfile, file, import, loc))
901 return false;
903 if (pfile->buffer == NULL || file->dir == NULL)
904 sysp = 0;
905 else
906 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
908 /* Add the file to the dependencies on its first inclusion. */
909 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
911 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
912 deps_add_dep (pfile->deps, file->path);
915 /* Clear buffer_valid since _cpp_clean_line messes it up. */
916 file->buffer_valid = false;
917 file->stack_count++;
919 /* Stack the buffer. */
920 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
921 CPP_OPTION (pfile, preprocessed)
922 && !CPP_OPTION (pfile, directives_only));
923 buffer->file = file;
924 buffer->sysp = sysp;
925 buffer->to_free = file->buffer_start;
927 /* Initialize controlling macro state. */
928 pfile->mi_valid = true;
929 pfile->mi_cmacro = 0;
931 /* Generate the call back. */
932 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
934 return true;
937 /* Mark FILE to be included once only. */
938 void
939 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
941 pfile->seen_once_only = true;
942 file->once_only = true;
945 /* Return the directory from which searching for FNAME should start,
946 considering the directive TYPE and ANGLE_BRACKETS. If there is
947 nothing left in the path, returns NULL. */
948 static struct cpp_dir *
949 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
950 enum include_type type)
952 cpp_dir *dir;
953 _cpp_file *file;
955 if (IS_ABSOLUTE_PATH (fname))
956 return &pfile->no_search_path;
958 /* pfile->buffer is NULL when processing an -include command-line flag. */
959 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
961 /* For #include_next, skip in the search path past the dir in which
962 the current file was found, but if it was found via an absolute
963 path use the normal search logic. */
964 if (type == IT_INCLUDE_NEXT && file->dir
965 && file->dir != &pfile->no_search_path)
966 dir = file->dir->next;
967 else if (angle_brackets)
968 dir = pfile->bracket_include;
969 else if (type == IT_CMDLINE)
970 /* -include and -imacros use the #include "" chain with the
971 preprocessor's cwd prepended. */
972 return make_cpp_dir (pfile, "./", false);
973 else if (pfile->quote_ignores_source_dir)
974 dir = pfile->quote_include;
975 else
976 return make_cpp_dir (pfile, dir_name_of_file (file),
977 pfile->buffer ? pfile->buffer->sysp : 0);
979 if (dir == NULL)
980 cpp_error (pfile, CPP_DL_ERROR,
981 "no include path in which to search for %s", fname);
983 return dir;
986 /* Strip the basename from the file's path. It ends with a slash if
987 of nonzero length. Note that this procedure also works for
988 <stdin>, which is represented by the empty string. */
989 static const char *
990 dir_name_of_file (_cpp_file *file)
992 if (!file->dir_name)
994 size_t len = lbasename (file->path) - file->path;
995 char *dir_name = XNEWVEC (char, len + 1);
997 memcpy (dir_name, file->path, len);
998 dir_name[len] = '\0';
999 file->dir_name = dir_name;
1002 return file->dir_name;
1005 /* Handles #include-family directives (distinguished by TYPE),
1006 including HEADER, and the command line -imacros and -include.
1007 Returns true if a buffer was stacked. */
1008 bool
1009 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
1010 enum include_type type, source_location loc)
1012 struct cpp_dir *dir;
1013 _cpp_file *file;
1014 bool stacked;
1016 /* For -include command-line flags we have type == IT_CMDLINE.
1017 When the first -include file is processed we have the case, where
1018 pfile->cur_token == pfile->cur_run->base, we are directly called up
1019 by the front end. However in the case of the second -include file,
1020 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1021 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1022 and pfile->cur_token[-1].src_loc not (yet) initialized.
1023 However, when the include file cannot be found, we need src_loc to
1024 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1025 if (type == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
1026 pfile->cur_token[-1].src_loc = 0;
1028 dir = search_path_head (pfile, fname, angle_brackets, type);
1029 if (!dir)
1030 return false;
1032 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets,
1033 type == IT_DEFAULT, loc);
1034 if (type == IT_DEFAULT && file == NULL)
1035 return false;
1037 /* Compensate for the increment in linemap_add that occurs if
1038 _cpp_stack_file actually stacks the file. In the case of a
1039 normal #include, we're currently at the start of the line
1040 *following* the #include. A separate source_location for this
1041 location makes no sense (until we do the LC_LEAVE), and
1042 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
1043 found a PCH file (in which case linemap_add is not called) or we
1044 were included from the command-line. */
1045 if (file->pchname == NULL && file->err_no == 0
1046 && type != IT_CMDLINE && type != IT_DEFAULT)
1047 pfile->line_table->highest_location--;
1049 stacked = _cpp_stack_file (pfile, file, type == IT_IMPORT, loc);
1051 if (!stacked)
1052 /* _cpp_stack_file didn't stack the file, so let's rollback the
1053 compensation dance we performed above. */
1054 pfile->line_table->highest_location++;
1056 return stacked;
1059 /* Could not open FILE. The complication is dependency output. */
1060 static void
1061 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets,
1062 source_location loc)
1064 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1065 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1067 if (pfile->state.in__has_include__)
1068 return;
1070 errno = file->err_no;
1071 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1073 deps_add_dep (pfile->deps, file->name);
1074 /* If the preprocessor output (other than dependency information) is
1075 being used, we must also flag an error. */
1076 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1077 cpp_errno_filename (pfile, CPP_DL_FATAL,
1078 file->path ? file->path : file->name,
1079 loc);
1081 else
1083 /* If we are not outputting dependencies, or if we are and dependencies
1084 were requested for this file, or if preprocessor output is needed
1085 in addition to dependency information, this is an error.
1087 Otherwise (outputting dependencies but not for this file, and not
1088 using the preprocessor output), we can still produce correct output
1089 so it's only a warning. */
1090 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1091 || print_dep
1092 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1093 cpp_errno_filename (pfile, CPP_DL_FATAL,
1094 file->path ? file->path : file->name,
1095 loc);
1096 else
1097 cpp_errno_filename (pfile, CPP_DL_WARNING,
1098 file->path ? file->path : file->name,
1099 loc);
1103 /* Search in the chain beginning at HEAD for a file whose search path
1104 started at START_DIR != NULL. */
1105 static struct cpp_file_hash_entry *
1106 search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir)
1108 while (head && head->start_dir != start_dir)
1109 head = head->next;
1111 return head;
1114 /* Allocate a new _cpp_file structure. */
1115 static _cpp_file *
1116 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
1118 _cpp_file *file;
1120 file = XCNEW (_cpp_file);
1121 file->main_file = !pfile->buffer;
1122 file->fd = -1;
1123 file->dir = dir;
1124 file->name = xstrdup (fname);
1126 return file;
1129 /* Release a _cpp_file structure. */
1130 static void
1131 destroy_cpp_file (_cpp_file *file)
1133 free ((void *) file->buffer_start);
1134 free ((void *) file->name);
1135 free (file);
1138 /* Release all the files allocated by this reader. */
1139 static void
1140 destroy_all_cpp_files (cpp_reader *pfile)
1142 _cpp_file *iter = pfile->all_files;
1143 while (iter)
1145 _cpp_file *next = iter->next_file;
1146 destroy_cpp_file (iter);
1147 iter = next;
1151 /* A hash of directory names. The directory names are the path names
1152 of files which contain a #include "", the included file name is
1153 appended to this directories.
1155 To avoid duplicate entries we follow the convention that all
1156 non-empty directory names should end in a '/'. DIR_NAME must be
1157 stored in permanently allocated memory. */
1158 static cpp_dir *
1159 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1161 struct cpp_file_hash_entry *entry, **hash_slot;
1162 cpp_dir *dir;
1164 hash_slot = (struct cpp_file_hash_entry **)
1165 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1166 htab_hash_string (dir_name),
1167 INSERT);
1169 /* Have we already hashed this directory? */
1170 for (entry = *hash_slot; entry; entry = entry->next)
1171 if (entry->start_dir == NULL)
1172 return entry->u.dir;
1174 dir = XCNEW (cpp_dir);
1175 dir->next = pfile->quote_include;
1176 dir->name = (char *) dir_name;
1177 dir->len = strlen (dir_name);
1178 dir->sysp = sysp;
1179 dir->construct = 0;
1181 /* Store this new result in the hash table. */
1182 entry = new_file_hash_entry (pfile);
1183 entry->next = *hash_slot;
1184 entry->start_dir = NULL;
1185 entry->location = pfile->line_table->highest_location;
1186 entry->u.dir = dir;
1187 *hash_slot = entry;
1189 return dir;
1192 /* Create a new block of memory for file hash entries. */
1193 static void
1194 allocate_file_hash_entries (cpp_reader *pfile)
1196 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1197 pool->file_hash_entries_used = 0;
1198 pool->next = pfile->file_hash_entries;
1199 pfile->file_hash_entries = pool;
1202 /* Return a new file hash entry. */
1203 static struct cpp_file_hash_entry *
1204 new_file_hash_entry (cpp_reader *pfile)
1206 unsigned int idx;
1207 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1208 allocate_file_hash_entries (pfile);
1210 idx = pfile->file_hash_entries->file_hash_entries_used++;
1211 return &pfile->file_hash_entries->pool[idx];
1214 /* Free the file hash entry pools. */
1215 static void
1216 free_file_hash_entries (cpp_reader *pfile)
1218 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1219 while (iter)
1221 struct file_hash_entry_pool *next = iter->next;
1222 free (iter);
1223 iter = next;
1227 /* Returns TRUE if a file FNAME has ever been successfully opened.
1228 This routine is not intended to correctly handle filenames aliased
1229 by links or redundant . or .. traversals etc. */
1230 bool
1231 cpp_included (cpp_reader *pfile, const char *fname)
1233 struct cpp_file_hash_entry *entry;
1235 entry = (struct cpp_file_hash_entry *)
1236 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1238 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1239 entry = entry->next;
1241 return entry != NULL;
1244 /* Returns TRUE if a file FNAME has ever been successfully opened
1245 before LOCATION. This routine is not intended to correctly handle
1246 filenames aliased by links or redundant . or .. traversals etc. */
1247 bool
1248 cpp_included_before (cpp_reader *pfile, const char *fname,
1249 source_location location)
1251 struct cpp_file_hash_entry *entry
1252 = (struct cpp_file_hash_entry *)
1253 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1255 if (IS_ADHOC_LOC (location))
1256 location = get_location_from_adhoc_loc (pfile->line_table, location);
1258 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1259 || entry->location > location))
1260 entry = entry->next;
1262 return entry != NULL;
1265 /* Calculate the hash value of a file hash entry P. */
1267 static hashval_t
1268 file_hash_hash (const void *p)
1270 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1271 const char *hname;
1272 if (entry->start_dir)
1273 hname = entry->u.file->name;
1274 else
1275 hname = entry->u.dir->name;
1277 return htab_hash_string (hname);
1280 /* Compare a string Q against a file hash entry P. */
1281 static int
1282 file_hash_eq (const void *p, const void *q)
1284 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1285 const char *fname = (const char *) q;
1286 const char *hname;
1288 if (entry->start_dir)
1289 hname = entry->u.file->name;
1290 else
1291 hname = entry->u.dir->name;
1293 return filename_cmp (hname, fname) == 0;
1296 /* Compare entries in the nonexistent file hash table. These are just
1297 strings. */
1298 static int
1299 nonexistent_file_hash_eq (const void *p, const void *q)
1301 return filename_cmp ((const char *) p, (const char *) q) == 0;
1304 /* Initialize everything in this source file. */
1305 void
1306 _cpp_init_files (cpp_reader *pfile)
1308 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1309 NULL, xcalloc, free);
1310 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1311 NULL, xcalloc, free);
1312 allocate_file_hash_entries (pfile);
1313 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1314 nonexistent_file_hash_eq,
1315 NULL, xcalloc, free);
1316 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,
1317 xmalloc, free);
1320 /* Finalize everything in this source file. */
1321 void
1322 _cpp_cleanup_files (cpp_reader *pfile)
1324 htab_delete (pfile->file_hash);
1325 htab_delete (pfile->dir_hash);
1326 htab_delete (pfile->nonexistent_file_hash);
1327 obstack_free (&pfile->nonexistent_file_ob, 0);
1328 free_file_hash_entries (pfile);
1329 destroy_all_cpp_files (pfile);
1332 /* Make the parser forget about files it has seen. This can be useful
1333 for resetting the parser to start another run. */
1334 void
1335 cpp_clear_file_cache (cpp_reader *pfile)
1337 _cpp_cleanup_files (pfile);
1338 pfile->file_hash_entries = NULL;
1339 pfile->all_files = NULL;
1340 _cpp_init_files (pfile);
1343 /* Enter a file name in the hash for the sake of cpp_included. */
1344 void
1345 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1347 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0, false, 0);
1350 /* Not everyone who wants to set system-header-ness on a buffer can
1351 see the details of a buffer. This is an exported interface because
1352 fix-header needs it. */
1353 void
1354 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1356 int flags = 0;
1357 const struct line_maps *line_table = pfile->line_table;
1358 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1359 /* 1 = system header, 2 = system header to be treated as C. */
1360 if (syshdr)
1361 flags = 1 + (externc != 0);
1362 pfile->buffer->sysp = flags;
1363 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1364 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1367 /* Allow the client to change the current file. Used by the front end
1368 to achieve pseudo-file names like <built-in>.
1369 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1370 void
1371 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1372 const char *new_name)
1374 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1377 struct report_missing_guard_data
1379 const char **paths;
1380 size_t count;
1383 /* Callback function for htab_traverse. */
1384 static int
1385 report_missing_guard (void **slot, void *d)
1387 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
1388 struct report_missing_guard_data *data
1389 = (struct report_missing_guard_data *) d;
1391 /* Skip directories. */
1392 if (entry->start_dir != NULL)
1394 _cpp_file *file = entry->u.file;
1396 /* We don't want MI guard advice for the main file. */
1397 if (!file->once_only && file->cmacro == NULL
1398 && file->stack_count == 1 && !file->main_file)
1400 if (data->paths == NULL)
1402 data->paths = XCNEWVEC (const char *, data->count);
1403 data->count = 0;
1406 data->paths[data->count++] = file->path;
1410 /* Keep traversing the hash table. */
1411 return 1;
1414 /* Comparison function for qsort. */
1415 static int
1416 report_missing_guard_cmp (const void *p1, const void *p2)
1418 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1421 /* Report on all files that might benefit from a multiple include guard.
1422 Triggered by -H. */
1423 void
1424 _cpp_report_missing_guards (cpp_reader *pfile)
1426 struct report_missing_guard_data data;
1428 data.paths = NULL;
1429 data.count = htab_elements (pfile->file_hash);
1430 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1432 if (data.paths != NULL)
1434 size_t i;
1436 /* Sort the paths to avoid outputting them in hash table
1437 order. */
1438 qsort (data.paths, data.count, sizeof (const char *),
1439 report_missing_guard_cmp);
1440 fputs (_("Multiple include guards may be useful for:\n"),
1441 stderr);
1442 for (i = 0; i < data.count; i++)
1444 fputs (data.paths[i], stderr);
1445 putc ('\n', stderr);
1447 free (data.paths);
1451 /* Locate HEADER, and determine whether it is newer than the current
1452 file. If it cannot be located or dated, return -1, if it is
1453 newer, return 1, otherwise 0. */
1455 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1456 int angle_brackets)
1458 _cpp_file *file;
1459 struct cpp_dir *dir;
1461 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1462 if (!dir)
1463 return -1;
1465 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets, false, 0);
1466 if (file->err_no)
1467 return -1;
1469 if (file->fd != -1)
1471 close (file->fd);
1472 file->fd = -1;
1475 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1478 /* Pushes the given file onto the buffer stack. Returns nonzero if
1479 successful. */
1480 bool
1481 cpp_push_include (cpp_reader *pfile, const char *fname)
1483 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE, 0);
1486 /* Pushes the given file, implicitly included at the start of a
1487 compilation, onto the buffer stack but without any errors if the
1488 file is not found. Returns nonzero if successful. */
1489 bool
1490 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1492 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT, 0);
1495 /* Do appropriate cleanup when a file INC's buffer is popped off the
1496 input stack. */
1497 void
1498 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1499 const unsigned char *to_free)
1501 /* Record the inclusion-preventing macro, which could be NULL
1502 meaning no controlling macro. */
1503 if (pfile->mi_valid && file->cmacro == NULL)
1504 file->cmacro = pfile->mi_cmacro;
1506 /* Invalidate control macros in the #including file. */
1507 pfile->mi_valid = false;
1509 if (to_free)
1511 if (to_free == file->buffer_start)
1513 file->buffer_start = NULL;
1514 file->buffer = NULL;
1515 file->buffer_valid = false;
1517 free ((void *) to_free);
1521 /* Return the file name associated with FILE. */
1522 const char *
1523 _cpp_get_file_name (_cpp_file *file)
1525 return file->name;
1528 /* Inteface to file statistics record in _cpp_file structure. */
1529 struct stat *
1530 _cpp_get_file_stat (_cpp_file *file)
1532 return &file->st;
1535 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1536 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1537 directory of the including file.
1539 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1540 void
1541 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1542 int quote_ignores_source_dir)
1544 pfile->quote_include = quote;
1545 pfile->bracket_include = quote;
1546 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1548 for (; quote; quote = quote->next)
1550 quote->name_map = NULL;
1551 quote->len = strlen (quote->name);
1552 if (quote == bracket)
1553 pfile->bracket_include = bracket;
1557 /* Append the file name to the directory to create the path, but don't
1558 turn / into // or // into ///; // may be a namespace escape. */
1559 static char *
1560 append_file_to_dir (const char *fname, cpp_dir *dir)
1562 size_t dlen, flen;
1563 char *path;
1565 dlen = dir->len;
1566 flen = strlen (fname);
1567 path = XNEWVEC (char, dlen + 1 + flen + 1);
1568 memcpy (path, dir->name, dlen);
1569 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1570 path[dlen++] = '/';
1571 memcpy (&path[dlen], fname, flen + 1);
1573 return path;
1576 /* Read a space delimited string of unlimited length from a stdio
1577 file F. */
1578 static char *
1579 read_filename_string (int ch, FILE *f)
1581 char *alloc, *set;
1582 int len;
1584 len = 20;
1585 set = alloc = XNEWVEC (char, len + 1);
1586 if (! is_space (ch))
1588 *set++ = ch;
1589 while ((ch = getc (f)) != EOF && ! is_space (ch))
1591 if (set - alloc == len)
1593 len *= 2;
1594 alloc = XRESIZEVEC (char, alloc, len + 1);
1595 set = alloc + len / 2;
1597 *set++ = ch;
1600 *set = '\0';
1601 ungetc (ch, f);
1602 return alloc;
1605 /* Read the file name map file for DIR. */
1606 static void
1607 read_name_map (cpp_dir *dir)
1609 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1610 char *name;
1611 FILE *f;
1612 size_t len, count = 0, room = 9;
1614 len = dir->len;
1615 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1616 memcpy (name, dir->name, len);
1617 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1618 name[len++] = '/';
1619 strcpy (name + len, FILE_NAME_MAP_FILE);
1620 f = fopen (name, "r");
1622 dir->name_map = XNEWVEC (const char *, room);
1624 /* Silently return NULL if we cannot open. */
1625 if (f)
1627 int ch;
1629 while ((ch = getc (f)) != EOF)
1631 char *to;
1633 if (is_space (ch))
1634 continue;
1636 if (count + 2 > room)
1638 room += 8;
1639 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1642 dir->name_map[count] = read_filename_string (ch, f);
1643 while ((ch = getc (f)) != EOF && is_hspace (ch))
1646 to = read_filename_string (ch, f);
1647 if (IS_ABSOLUTE_PATH (to))
1648 dir->name_map[count + 1] = to;
1649 else
1651 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1652 free (to);
1655 count += 2;
1656 while ((ch = getc (f)) != '\n')
1657 if (ch == EOF)
1658 break;
1661 fclose (f);
1664 /* Terminate the list of maps. */
1665 dir->name_map[count] = NULL;
1668 /* Remap a FILE's name based on the file_name_map, if any, for
1669 FILE->dir. If the file name has any directory separators,
1670 recursively check those directories too. */
1671 static char *
1672 remap_filename (cpp_reader *pfile, _cpp_file *file)
1674 const char *fname, *p;
1675 char *new_dir;
1676 cpp_dir *dir;
1677 size_t index, len;
1679 dir = file->dir;
1680 fname = file->name;
1682 for (;;)
1684 if (!dir->name_map)
1685 read_name_map (dir);
1687 for (index = 0; dir->name_map[index]; index += 2)
1688 if (!filename_cmp (dir->name_map[index], fname))
1689 return xstrdup (dir->name_map[index + 1]);
1690 if (IS_ABSOLUTE_PATH (fname))
1691 return NULL;
1692 p = strchr (fname, '/');
1693 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1695 char *p2 = strchr (fname, '\\');
1696 if (!p || (p > p2))
1697 p = p2;
1699 #endif
1700 if (!p || p == fname)
1701 return NULL;
1703 len = dir->len + (p - fname + 1);
1704 new_dir = XNEWVEC (char, len + 1);
1705 memcpy (new_dir, dir->name, dir->len);
1706 memcpy (new_dir + dir->len, fname, p - fname + 1);
1707 new_dir[len] = '\0';
1709 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1710 fname = p + 1;
1714 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1715 static bool
1716 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1718 const char *saved_path = file->path;
1719 bool valid = false;
1721 file->path = pchname;
1722 if (open_file (file))
1724 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1726 if (!valid)
1728 close (file->fd);
1729 file->fd = -1;
1732 if (CPP_OPTION (pfile, print_include_names))
1734 unsigned int i;
1735 for (i = 1; i < pfile->line_table->depth; i++)
1736 putc ('.', stderr);
1737 fprintf (stderr, "%c %s\n",
1738 valid ? '!' : 'x', pchname);
1742 file->path = saved_path;
1743 return valid;
1746 /* Get the path associated with the _cpp_file F. The path includes
1747 the base name from the include directive and the directory it was
1748 found in via the search path. */
1750 const char *
1751 cpp_get_path (struct _cpp_file *f)
1753 return f->path;
1756 /* Get the directory associated with the _cpp_file F. */
1758 cpp_dir *
1759 cpp_get_dir (struct _cpp_file *f)
1761 return f->dir;
1764 /* Get the cpp_buffer currently associated with the cpp_reader
1765 PFILE. */
1767 cpp_buffer *
1768 cpp_get_buffer (cpp_reader *pfile)
1770 return pfile->buffer;
1773 /* Get the _cpp_file associated with the cpp_buffer B. */
1775 _cpp_file *
1776 cpp_get_file (cpp_buffer *b)
1778 return b->file;
1781 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1782 buffer is the buffer that included the given buffer. */
1784 cpp_buffer *
1785 cpp_get_prev (cpp_buffer *b)
1787 return b->prev;
1790 /* This data structure holds the list of header files that were seen
1791 while the PCH was being built. The 'entries' field is kept sorted
1792 in memcmp() order; yes, this means that on little-endian systems,
1793 it's sorted initially by the least-significant byte of 'size', but
1794 that's OK. The code does rely on having entries with the same size
1795 next to each other. */
1797 struct pchf_entry {
1798 /* The size of this file. This is used to save running a MD5 checksum
1799 if the sizes don't match. */
1800 off_t size;
1801 /* The MD5 checksum of this file. */
1802 unsigned char sum[16];
1803 /* Is this file to be included only once? */
1804 bool once_only;
1807 struct pchf_data {
1808 /* Number of pchf_entry structures. */
1809 size_t count;
1811 /* Are there any values with once_only set?
1812 This is used as an optimisation, it means we don't have to search
1813 the structure if we're processing a regular #include. */
1814 bool have_once_only;
1816 struct pchf_entry entries[1];
1819 static struct pchf_data *pchf;
1821 /* A qsort ordering function for pchf_entry structures. */
1823 static int
1824 pchf_save_compare (const void *e1, const void *e2)
1826 return memcmp (e1, e2, sizeof (struct pchf_entry));
1829 /* Create and write to F a pchf_data structure. */
1831 bool
1832 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1834 size_t count = 0;
1835 struct pchf_data *result;
1836 size_t result_size;
1837 _cpp_file *f;
1838 bool ret;
1840 for (f = pfile->all_files; f; f = f->next_file)
1841 ++count;
1843 result_size = (sizeof (struct pchf_data)
1844 + sizeof (struct pchf_entry) * (count - 1));
1845 result = XCNEWVAR (struct pchf_data, result_size);
1847 result->count = 0;
1848 result->have_once_only = false;
1850 for (f = pfile->all_files; f; f = f->next_file)
1852 size_t count;
1854 /* This should probably never happen, since if a read error occurred
1855 the PCH file shouldn't be written... */
1856 if (f->dont_read || f->err_no)
1857 continue;
1859 if (f->stack_count == 0)
1860 continue;
1862 count = result->count++;
1864 result->entries[count].once_only = f->once_only;
1865 /* |= is avoided in the next line because of an HP C compiler bug */
1866 result->have_once_only = result->have_once_only | f->once_only;
1867 if (f->buffer_valid)
1868 md5_buffer ((const char *)f->buffer,
1869 f->st.st_size, result->entries[count].sum);
1870 else
1872 FILE *ff;
1873 int oldfd = f->fd;
1875 if (!open_file (f))
1877 open_file_failed (pfile, f, 0, 0);
1878 free (result);
1879 return false;
1881 ff = fdopen (f->fd, "rb");
1882 md5_stream (ff, result->entries[count].sum);
1883 fclose (ff);
1884 f->fd = oldfd;
1886 result->entries[count].size = f->st.st_size;
1889 result_size = (sizeof (struct pchf_data)
1890 + sizeof (struct pchf_entry) * (result->count - 1));
1892 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1893 pchf_save_compare);
1895 ret = fwrite (result, result_size, 1, fp) == 1;
1896 free (result);
1897 return ret;
1900 /* Read the pchf_data structure from F. */
1902 bool
1903 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1905 struct pchf_data d;
1907 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1908 != 1)
1909 return false;
1911 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1912 + sizeof (struct pchf_entry) * (d.count - 1));
1913 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1914 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1915 != d.count)
1916 return false;
1917 return true;
1920 /* The parameters for pchf_compare. */
1922 struct pchf_compare_data
1924 /* The size of the file we're looking for. */
1925 off_t size;
1927 /* The MD5 checksum of the file, if it's been computed. */
1928 unsigned char sum[16];
1930 /* Is SUM valid? */
1931 bool sum_computed;
1933 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1934 bool check_included;
1936 /* The file that we're searching for. */
1937 _cpp_file *f;
1940 /* bsearch comparison function; look for D_P in E_P. */
1942 static int
1943 pchf_compare (const void *d_p, const void *e_p)
1945 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1946 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1947 int result;
1949 result = memcmp (&d->size, &e->size, sizeof (off_t));
1950 if (result != 0)
1951 return result;
1953 if (! d->sum_computed)
1955 _cpp_file *const f = d->f;
1957 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1958 d->sum_computed = true;
1961 result = memcmp (d->sum, e->sum, 16);
1962 if (result != 0)
1963 return result;
1965 if (d->check_included || e->once_only)
1966 return 0;
1967 else
1968 return 1;
1971 /* Check that F is not in a list read from a PCH file (if any).
1972 Assumes that f->buffer_valid is true. Return TRUE if the file
1973 should not be read. */
1975 static bool
1976 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1977 _cpp_file *f,
1978 bool check_included)
1980 struct pchf_compare_data d;
1982 if (pchf == NULL
1983 || (! check_included && ! pchf->have_once_only))
1984 return false;
1986 d.size = f->st.st_size;
1987 d.sum_computed = false;
1988 d.f = f;
1989 d.check_included = check_included;
1990 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1991 pchf_compare) != NULL;
1994 /* Return true if the file FNAME is found in the appropriate include file path
1995 as indicated by ANGLE_BRACKETS. */
1997 bool
1998 _cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
1999 enum include_type type)
2001 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
2002 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir,
2003 /*fake=*/false, angle_brackets,
2004 /*implicit_preinclude=*/false, 0);
2005 return file->err_no != ENOENT;