Daily bump.
[official-gcc.git] / libcpp / files.c
blobc93a03c69ef5b5a5d58feb7615e955e199c7f128
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2021 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 : 1;
103 /* If read() failed before. */
104 bool dont_read : 1;
106 /* If BUFFER above contains the true contents of the file. */
107 bool buffer_valid : 1;
109 /* If this file is implicitly preincluded. */
110 bool implicit_preinclude : 1;
112 /* > 0: Known C++ Module header unit, <0: known not. ==0, unknown */
113 int header_unit : 2;
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 location_t 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, location_t loc);
175 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file,
176 location_t loc, const char *input_charset);
177 static bool read_file (cpp_reader *pfile, _cpp_file *file,
178 location_t loc);
179 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
180 int angle_brackets, enum include_type);
181 static const char *dir_name_of_file (_cpp_file *file);
182 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int,
183 location_t);
184 static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
185 const cpp_dir *start_dir);
186 static _cpp_file *make_cpp_file (cpp_dir *, const char *fname);
187 static void destroy_cpp_file (_cpp_file *);
188 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
189 static void allocate_file_hash_entries (cpp_reader *pfile);
190 static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
191 static int report_missing_guard (void **slot, void *b);
192 static hashval_t file_hash_hash (const void *p);
193 static int file_hash_eq (const void *p, const void *q);
194 static char *read_filename_string (int ch, FILE *f);
195 static void read_name_map (cpp_dir *dir);
196 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
197 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
198 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
199 static int pchf_save_compare (const void *e1, const void *e2);
200 static int pchf_compare (const void *d_p, const void *e_p);
201 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
203 /* Given a filename in FILE->PATH, with the empty string interpreted
204 as <stdin>, open it.
206 On success FILE contains an open file descriptor and stat
207 information for the file. On failure the file descriptor is -1 and
208 the appropriate errno is also stored in FILE. Returns TRUE iff
209 successful.
211 We used to open files in nonblocking mode, but that caused more
212 problems than it solved. Do take care not to acquire a controlling
213 terminal by mistake (this can't happen on sane systems, but
214 paranoia is a virtue).
216 Use the three-argument form of open even though we aren't
217 specifying O_CREAT, to defend against broken system headers.
219 O_BINARY tells some runtime libraries (notably DJGPP) not to do
220 newline translation; we can handle DOS line breaks just fine
221 ourselves. */
222 static bool
223 open_file (_cpp_file *file)
225 if (file->path[0] == '\0')
227 file->fd = 0;
228 set_stdin_to_binary_mode ();
230 else
231 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
233 if (file->fd != -1)
235 if (fstat (file->fd, &file->st) == 0)
237 if (!S_ISDIR (file->st.st_mode))
239 file->err_no = 0;
240 return true;
243 /* Ignore a directory and continue the search. The file we're
244 looking for may be elsewhere in the search path. */
245 errno = ENOENT;
248 close (file->fd);
249 file->fd = -1;
251 #if defined(_WIN32) && !defined(__CYGWIN__)
252 else if (errno == EACCES)
254 /* On most UNIX systems, open succeeds on a directory. Above,
255 we check if we have opened a directory and if so, set errno
256 to ENOENT. However, on Windows, opening a directory
257 fails with EACCES. We want to return ENOENT in that
258 case too. */
259 if (stat (file->path, &file->st) == 0
260 && S_ISDIR (file->st.st_mode))
261 errno = ENOENT;
262 else
263 /* The call to stat may have reset errno. */
264 errno = EACCES;
266 #endif
267 else if (errno == ENOTDIR)
268 errno = ENOENT;
270 file->err_no = errno;
272 return false;
275 /* Temporary PCH intercept of opening a file. Try to find a PCH file
276 based on FILE->name and FILE->dir, and test those found for
277 validity using PFILE->cb.valid_pch. Return true iff a valid file is
278 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
280 static bool
281 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
283 static const char extension[] = ".gch";
284 const char *path = file->path;
285 size_t len, flen;
286 char *pchname;
287 struct stat st;
288 bool valid = false;
290 /* No PCH on <stdin> or if not requested. */
291 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
292 return false;
294 /* If the file is not included as first include from either the toplevel
295 file or the command-line it is not a valid use of PCH. */
296 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
297 if (f->implicit_preinclude)
298 continue;
299 else if (pfile->main_file == f)
300 break;
301 else
302 return false;
304 flen = strlen (path);
305 len = flen + sizeof (extension);
306 pchname = XNEWVEC (char, len);
307 memcpy (pchname, path, flen);
308 memcpy (pchname + flen, extension, sizeof (extension));
310 if (stat (pchname, &st) == 0)
312 DIR *pchdir;
313 struct dirent *d;
314 size_t dlen, plen = len;
316 if (!S_ISDIR (st.st_mode))
317 valid = validate_pch (pfile, file, pchname);
318 else if ((pchdir = opendir (pchname)) != NULL)
320 pchname[plen - 1] = '/';
321 while ((d = readdir (pchdir)) != NULL)
323 dlen = strlen (d->d_name) + 1;
324 if ((strcmp (d->d_name, ".") == 0)
325 || (strcmp (d->d_name, "..") == 0))
326 continue;
327 if (dlen + plen > len)
329 len += dlen + 64;
330 pchname = XRESIZEVEC (char, pchname, len);
332 memcpy (pchname + plen, d->d_name, dlen);
333 valid = validate_pch (pfile, file, pchname);
334 if (valid)
335 break;
337 closedir (pchdir);
339 if (!valid)
340 *invalid_pch = true;
343 if (valid)
344 file->pchname = pchname;
345 else
346 free (pchname);
348 return valid;
351 /* Canonicalize the path to FILE. Return the canonical form if it is
352 shorter, otherwise return NULL. This function does NOT free the
353 memory pointed by FILE. */
355 static char *
356 maybe_shorter_path (const char * file)
358 char * file2 = lrealpath (file);
359 if (file2 && strlen (file2) < strlen (file))
361 return file2;
363 else
365 free (file2);
366 return NULL;
370 /* Try to open the path FILE->name appended to FILE->dir. This is
371 where remap and PCH intercept the file lookup process. Return true
372 if the file was found, whether or not the open was successful.
373 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
374 Use LOC when emitting any diagnostics. */
376 static bool
377 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch,
378 location_t loc)
380 char *path;
382 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
384 else
385 if (file->dir->construct)
386 path = file->dir->construct (file->name, file->dir);
387 else
388 path = append_file_to_dir (file->name, file->dir);
390 if (path)
392 hashval_t hv;
393 char *copy;
394 void **pp;
396 /* We try to canonicalize system headers. For DOS based file
397 * system, we always try to shorten non-system headers, as DOS
398 * has a tighter constraint on max path length. */
399 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
400 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
401 || !file->dir->sysp
402 #endif
405 char * canonical_path = maybe_shorter_path (path);
406 if (canonical_path)
408 /* The canonical path was newly allocated. Let's free the
409 non-canonical one. */
410 free (path);
411 path = canonical_path;
415 hv = htab_hash_string (path);
416 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
418 file->err_no = ENOENT;
419 return false;
422 file->path = path;
423 if (pch_open_file (pfile, file, invalid_pch))
424 return true;
426 if (open_file (file))
427 return true;
429 if (file->err_no != ENOENT)
431 open_file_failed (pfile, file, 0, loc);
432 return true;
435 /* We copy the path name onto an obstack partly so that we don't
436 leak the memory, but mostly so that we don't fragment the
437 heap. */
438 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
439 strlen (path));
440 free (path);
441 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
442 copy, hv, INSERT);
443 *pp = copy;
445 file->path = file->name;
447 else
449 file->err_no = ENOENT;
450 file->path = NULL;
453 return false;
456 /* Return true iff the missing_header callback found the given HEADER. */
457 static bool
458 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
460 missing_header_cb func = pfile->cb.missing_header;
462 /* When the regular search path doesn't work, try context dependent
463 headers search paths. */
464 if (func
465 && file->dir == NULL)
467 if ((file->path = func (pfile, header, &file->dir)) != NULL)
469 if (open_file (file))
470 return true;
471 free ((void *)file->path);
473 file->path = file->name;
476 return false;
479 bool
480 _cpp_find_failed (_cpp_file *file)
482 return file->err_no != 0;
485 /* Given a filename FNAME search for such a file in the include path
486 starting from START_DIR. If FNAME is the empty string it is
487 interpreted as STDIN if START_DIR is PFILE->no_search_path.
489 If the file is not found in the file cache fall back to the O/S and
490 add the result to our cache.
492 If the file was not found in the filesystem, or there was an error
493 opening it, then ERR_NO is nonzero and FD is -1. If the file was
494 found, then ERR_NO is zero and FD could be -1 or an open file
495 descriptor. FD can be -1 if the file was found in the cache and
496 had previously been closed. To open it again pass the return value
497 to open_file().
499 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
500 missing. If present, it is OK for a precompiled header to be
501 included after it.
503 Use LOC as the location for any errors. */
505 _cpp_file *
506 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
507 int angle_brackets, _cpp_find_file_kind kind, location_t loc)
509 bool invalid_pch = false;
510 bool saw_bracket_include = false;
511 bool saw_quote_include = false;
512 struct cpp_dir *found_in_cache = NULL;
514 /* Ensure we get no confusion between cached files and directories. */
515 if (start_dir == NULL)
516 cpp_error_at (pfile, CPP_DL_ICE, loc, "NULL directory in find_file");
518 void **hash_slot
519 = htab_find_slot_with_hash (pfile->file_hash, fname,
520 htab_hash_string (fname), INSERT);
522 /* First check the cache before we resort to memory allocation. */
523 cpp_file_hash_entry *entry
524 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
525 if (entry)
526 return entry->u.file;
528 _cpp_file *file = make_cpp_file (start_dir, fname);
529 file->implicit_preinclude
530 = (kind == _cpp_FFK_PRE_INCLUDE
531 || (pfile->buffer && pfile->buffer->file->implicit_preinclude));
533 if (kind != _cpp_FFK_FAKE)
534 /* Try each path in the include chain. */
535 for (;;)
537 if (find_file_in_dir (pfile, file, &invalid_pch, loc))
538 break;
540 file->dir = file->dir->next;
541 if (file->dir == NULL)
543 if (search_path_exhausted (pfile, fname, file))
545 /* Although this file must not go in the cache,
546 because the file found might depend on things (like
547 the current file) that aren't represented in the
548 cache, it still has to go in the list of all files
549 so that #import works. */
550 file->next_file = pfile->all_files;
551 pfile->all_files = file;
552 if (*hash_slot == NULL)
554 /* If *hash_slot is NULL, the above
555 htab_find_slot_with_hash call just created the
556 slot, but we aren't going to store there
557 anything, so need to remove the newly created
558 entry. htab_clear_slot requires that it is
559 non-NULL, so store there some non-NULL pointer,
560 htab_clear_slot will overwrite it
561 immediately. */
562 *hash_slot = file;
563 htab_clear_slot (pfile->file_hash, hash_slot);
565 return file;
568 if (invalid_pch)
570 cpp_error (pfile, CPP_DL_ERROR,
571 "one or more PCH files were found,"
572 " but they were invalid");
573 if (!cpp_get_options (pfile)->warn_invalid_pch)
574 cpp_error (pfile, CPP_DL_NOTE,
575 "use -Winvalid-pch for more information");
578 if (kind == _cpp_FFK_PRE_INCLUDE)
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;
591 if (kind != _cpp_FFK_HAS_INCLUDE)
592 open_file_failed (pfile, file, angle_brackets, loc);
593 break;
596 /* Only check the cache for the starting location (done above)
597 and the quote and bracket chain heads because there are no
598 other possible starting points for searches. */
599 if (file->dir == pfile->bracket_include)
600 saw_bracket_include = true;
601 else if (file->dir == pfile->quote_include)
602 saw_quote_include = true;
603 else
604 continue;
606 entry
607 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
608 if (entry)
610 found_in_cache = file->dir;
611 break;
615 if (entry)
617 /* Cache for START_DIR too, sharing the _cpp_file structure. */
618 free ((char *) file->name);
619 free (file);
620 file = entry->u.file;
622 else
624 /* This is a new file; put it in the list. */
625 file->next_file = pfile->all_files;
626 pfile->all_files = file;
629 /* Store this new result in the hash table. */
630 entry = new_file_hash_entry (pfile);
631 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
632 entry->start_dir = start_dir;
633 entry->location = loc;
634 entry->u.file = file;
635 *hash_slot = (void *) entry;
637 /* If we passed the quote or bracket chain heads, cache them also.
638 This speeds up processing if there are lots of -I options. */
639 if (saw_bracket_include
640 && pfile->bracket_include != start_dir
641 && found_in_cache != pfile->bracket_include)
643 entry = new_file_hash_entry (pfile);
644 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
645 entry->start_dir = pfile->bracket_include;
646 entry->location = loc;
647 entry->u.file = file;
648 *hash_slot = (void *) entry;
650 if (saw_quote_include
651 && pfile->quote_include != start_dir
652 && found_in_cache != pfile->quote_include)
654 entry = new_file_hash_entry (pfile);
655 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
656 entry->start_dir = pfile->quote_include;
657 entry->location = loc;
658 entry->u.file = file;
659 *hash_slot = (void *) entry;
662 return file;
665 /* Read a file into FILE->buffer, returning true on success.
667 If FILE->fd is something weird, like a block device, we don't want
668 to read it at all. Don't even try to figure out what something is,
669 except for plain files and block devices, since there is no
670 reliable portable way of doing this.
672 Use LOC for any diagnostics.
674 PFILE may be NULL. In this case, no diagnostics are issued.
676 FIXME: Flush file cache and try again if we run out of memory. */
677 static bool
678 read_file_guts (cpp_reader *pfile, _cpp_file *file, location_t loc,
679 const char *input_charset)
681 ssize_t size, total, count;
682 uchar *buf;
683 bool regular;
685 if (S_ISBLK (file->st.st_mode))
687 if (pfile)
688 cpp_error_at (pfile, CPP_DL_ERROR, loc,
689 "%s is a block device", file->path);
690 return false;
693 regular = S_ISREG (file->st.st_mode) != 0;
694 if (regular)
696 /* off_t might have a wider range than ssize_t - in other words,
697 the max size of a file might be bigger than the address
698 space. We can't handle a file that large. (Anyone with
699 a single source file bigger than 2GB needs to rethink
700 their coding style.) Some systems (e.g. AIX 4.1) define
701 SSIZE_MAX to be much smaller than the actual range of the
702 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
703 does not bite us. */
704 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
706 if (pfile)
707 cpp_error_at (pfile, CPP_DL_ERROR, loc,
708 "%s is too large", file->path);
709 return false;
712 size = file->st.st_size;
714 else
715 /* 8 kilobytes is a sensible starting size. It ought to be bigger
716 than the kernel pipe buffer, and it's definitely bigger than
717 the majority of C source files. */
718 size = 8 * 1024;
720 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
721 used to quiet warnings from valgrind or Address Sanitizer, when the
722 optimized lexer accesses aligned 16-byte memory chunks, including
723 the bytes after the malloced, area, and stops lexing on '\n'. */
724 buf = XNEWVEC (uchar, size + 16);
725 total = 0;
726 while ((count = read (file->fd, buf + total, size - total)) > 0)
728 total += count;
730 if (total == size)
732 if (regular)
733 break;
734 size *= 2;
735 buf = XRESIZEVEC (uchar, buf, size + 16);
739 if (count < 0)
741 if (pfile)
742 cpp_errno_filename (pfile, CPP_DL_ERROR, file->path, loc);
743 free (buf);
744 return false;
747 if (pfile && regular && total != size && STAT_SIZE_RELIABLE (file->st))
748 cpp_error_at (pfile, CPP_DL_WARNING, loc,
749 "%s is shorter than expected", file->path);
751 file->buffer = _cpp_convert_input (pfile,
752 input_charset,
753 buf, size + 16, total,
754 &file->buffer_start,
755 &file->st.st_size);
756 file->buffer_valid = file->buffer;
757 return file->buffer_valid;
760 /* Convenience wrapper around read_file_guts that opens the file if
761 necessary and closes the file descriptor after reading. FILE must
762 have been passed through find_file() at some stage. Use LOC for
763 any diagnostics. Unlike read_file_guts(), PFILE may not be NULL. */
764 static bool
765 read_file (cpp_reader *pfile, _cpp_file *file, location_t loc)
767 /* If we already have its contents in memory, succeed immediately. */
768 if (file->buffer_valid)
769 return true;
771 /* If an earlier read failed for some reason don't try again. */
772 if (file->dont_read || file->err_no)
773 return false;
775 if (file->fd == -1 && !open_file (file))
777 open_file_failed (pfile, file, 0, loc);
778 return false;
781 file->dont_read = !read_file_guts (pfile, file, loc,
782 CPP_OPTION (pfile, input_charset));
783 close (file->fd);
784 file->fd = -1;
786 return !file->dont_read;
789 /* Returns TRUE if FILE is already known to be idempotent, and should
790 therefore not be read again. */
791 static bool
792 is_known_idempotent_file (cpp_reader *pfile, _cpp_file *file, bool import)
794 /* Skip once-only files. */
795 if (file->once_only)
796 return true;
798 /* We must mark the file once-only if #import now, before header
799 guard checks. Otherwise, undefining the header guard might
800 cause the file to be re-stacked. */
801 if (import)
803 _cpp_mark_file_once_only (pfile, file);
805 /* Don't stack files that have been stacked before. */
806 if (file->stack_count)
807 return true;
810 /* Skip if the file had a header guard and the macro is defined.
811 PCH relies on this appearing before the PCH handler below. */
812 if (file->cmacro && cpp_macro_p (file->cmacro))
813 return true;
815 /* Handle PCH files immediately; don't stack them. */
816 if (file->pchname)
818 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
819 file->fd = -1;
820 free ((void *) file->pchname);
821 file->pchname = NULL;
822 return true;
825 return false;
828 /* Return TRUE if file has unique contents, so we should read process
829 it. The file's contents must already have been read. */
831 static bool
832 has_unique_contents (cpp_reader *pfile, _cpp_file *file, bool import,
833 location_t loc)
835 /* Check the file against the PCH file. This is done before
836 checking against files we've already seen, since it may save on
837 I/O. */
838 if (check_file_against_entries (pfile, file, import))
840 /* If this isn't a #import, but yet we can't include the file,
841 that means that it was #import-ed in the PCH file,
842 so we can never include it again. */
843 if (! import)
844 _cpp_mark_file_once_only (pfile, file);
845 return false;
848 /* Now we've read the file's contents, we can stack it if there
849 are no once-only files. */
850 if (!pfile->seen_once_only)
851 return true;
853 /* We may have read the file under a different name. Look
854 for likely candidates and compare file contents to be sure. */
855 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
857 if (f == file)
858 continue; /* It'sa me! */
860 if ((import || f->once_only)
861 && f->err_no == 0
862 && f->st.st_mtime == file->st.st_mtime
863 && f->st.st_size == file->st.st_size)
865 _cpp_file *ref_file;
867 if (f->buffer && !f->buffer_valid)
869 /* We already have a buffer but it is not valid, because
870 the file is still stacked. Make a new one. */
871 ref_file = make_cpp_file (f->dir, f->name);
872 ref_file->path = f->path;
874 else
875 /* The file is not stacked anymore. We can reuse it. */
876 ref_file = f;
878 bool same_file_p = (read_file (pfile, ref_file, loc)
879 /* Size might have changed in read_file(). */
880 && ref_file->st.st_size == file->st.st_size
881 && !memcmp (ref_file->buffer, file->buffer,
882 file->st.st_size));
884 if (f->buffer && !f->buffer_valid)
886 ref_file->path = 0;
887 destroy_cpp_file (ref_file);
890 if (same_file_p)
891 /* Already seen under a different name. */
892 return false;
896 return true;
899 /* Place the file referenced by FILE into a new buffer on the buffer
900 stack if possible. Returns true if a buffer is stacked. Use LOC
901 for any diagnostics. */
903 bool
904 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, include_type type,
905 location_t loc)
907 if (is_known_idempotent_file (pfile, file, type == IT_IMPORT))
908 return false;
910 int sysp = 0;
911 char *buf = nullptr;
913 /* Check C++ module include translation. */
914 if (!file->header_unit && type < IT_HEADER_HWM
915 /* Do not include translate include-next. */
916 && type != IT_INCLUDE_NEXT
917 && pfile->cb.translate_include)
918 buf = (pfile->cb.translate_include
919 (pfile, pfile->line_table, loc, file->path));
921 if (buf)
923 /* We don't increment the line number at the end of a buffer,
924 because we don't usually need that location (we're popping an
925 include file). However in this case we do want to do the
926 increment. So push a writable buffer of two newlines to acheive
927 that. (We also need an extra newline, so this looks like a regular
928 file, which we do that to to make sure we don't fall off the end in the
929 middle of a line. */
930 static uchar newlines[] = "\n\n\n";
931 cpp_push_buffer (pfile, newlines, 2, true);
933 size_t len = strlen (buf);
934 buf[len] = '\n'; /* See above */
935 cpp_buffer *buffer
936 = cpp_push_buffer (pfile, reinterpret_cast<unsigned char *> (buf),
937 len, true);
938 buffer->to_free = buffer->buf;
940 file->header_unit = +1;
941 _cpp_mark_file_once_only (pfile, file);
943 else
945 /* Not a header unit, and we know it. */
946 file->header_unit = -1;
948 if (!read_file (pfile, file, loc))
949 return false;
951 if (!has_unique_contents (pfile, file, type == IT_IMPORT, loc))
952 return false;
954 if (pfile->buffer && file->dir)
955 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
957 /* Add the file to the dependencies on its first inclusion. */
958 if (CPP_OPTION (pfile, deps.style) > (sysp != 0)
959 && !file->stack_count
960 && file->path[0]
961 && !(pfile->main_file == file
962 && CPP_OPTION (pfile, deps.ignore_main_file)))
963 deps_add_dep (pfile->deps, file->path);
965 /* Clear buffer_valid since _cpp_clean_line messes it up. */
966 file->buffer_valid = false;
967 file->stack_count++;
969 /* Stack the buffer. */
970 cpp_buffer *buffer
971 = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
972 CPP_OPTION (pfile, preprocessed)
973 && !CPP_OPTION (pfile, directives_only));
974 buffer->file = file;
975 buffer->sysp = sysp;
976 buffer->to_free = file->buffer_start;
978 /* Initialize controlling macro state. */
979 pfile->mi_valid = true;
980 pfile->mi_cmacro = 0;
983 /* In the case of a normal #include, we're now at the start of the
984 line *following* the #include. A separate location_t for this
985 location makes no sense, until we do the LC_LEAVE.
987 This does not apply if we found a PCH file, we're not a regular
988 include, or we ran out of locations. */
989 bool decrement = (file->pchname == NULL
990 && type < IT_DIRECTIVE_HWM
991 && (pfile->line_table->highest_location
992 != LINE_MAP_MAX_LOCATION - 1));
993 if (decrement)
994 pfile->line_table->highest_location--;
996 if (file->header_unit <= 0)
997 /* Add line map and do callbacks. */
998 _cpp_do_file_change (pfile, LC_ENTER, file->path,
999 /* With preamble injection, start on line zero,
1000 so the preamble doesn't appear to have been
1001 included from line 1. Likewise when
1002 starting preprocessed, we expect an initial
1003 locating line. */
1004 type == IT_PRE_MAIN ? 0 : 1, sysp);
1005 else if (decrement)
1007 /* Adjust the line back one so we appear on the #include line itself. */
1008 const line_map_ordinary *map
1009 = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
1010 linenum_type line = SOURCE_LINE (map, pfile->line_table->highest_line);
1011 linemap_line_start (pfile->line_table, line - 1, 0);
1014 return true;
1017 /* Mark FILE to be included once only. */
1018 void
1019 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
1021 pfile->seen_once_only = true;
1022 file->once_only = true;
1025 /* Return the directory from which searching for FNAME should start,
1026 considering the directive TYPE and ANGLE_BRACKETS. If there is
1027 nothing left in the path, returns NULL. */
1028 static struct cpp_dir *
1029 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
1030 enum include_type type)
1032 cpp_dir *dir;
1033 _cpp_file *file;
1035 if (IS_ABSOLUTE_PATH (fname))
1036 return &pfile->no_search_path;
1038 /* pfile->buffer is NULL when processing an -include command-line flag. */
1039 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
1041 /* For #include_next, skip in the search path past the dir in which
1042 the current file was found, but if it was found via an absolute
1043 path use the normal search logic. */
1044 if (type == IT_INCLUDE_NEXT && file->dir
1045 && file->dir != &pfile->no_search_path)
1046 dir = file->dir->next;
1047 else if (angle_brackets)
1048 dir = pfile->bracket_include;
1049 else if (type == IT_CMDLINE)
1050 /* -include and -imacros use the #include "" chain with the
1051 preprocessor's cwd prepended. */
1052 return make_cpp_dir (pfile, "./", false);
1053 else if (pfile->quote_ignores_source_dir)
1054 dir = pfile->quote_include;
1055 else
1056 return make_cpp_dir (pfile, dir_name_of_file (file),
1057 pfile->buffer ? pfile->buffer->sysp : 0);
1059 if (dir == NULL)
1060 cpp_error (pfile, CPP_DL_ERROR,
1061 "no include path in which to search for %s", fname);
1063 return dir;
1066 /* Strip the basename from the file's path. It ends with a slash if
1067 of nonzero length. Note that this procedure also works for
1068 <stdin>, which is represented by the empty string. */
1069 static const char *
1070 dir_name_of_file (_cpp_file *file)
1072 if (!file->dir_name)
1074 size_t len = lbasename (file->path) - file->path;
1075 char *dir_name = XNEWVEC (char, len + 1);
1077 memcpy (dir_name, file->path, len);
1078 dir_name[len] = '\0';
1079 file->dir_name = dir_name;
1082 return file->dir_name;
1085 /* Handles #include-family directives (distinguished by TYPE),
1086 including HEADER, and the command line -imacros and -include.
1087 Returns true if a buffer was stacked. */
1088 bool
1089 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
1090 enum include_type type, location_t loc)
1092 /* For -include command-line flags we have type == IT_CMDLINE.
1093 When the first -include file is processed we have the case, where
1094 pfile->cur_token == pfile->cur_run->base, we are directly called up
1095 by the front end. However in the case of the second -include file,
1096 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1097 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1098 and pfile->cur_token[-1].src_loc not (yet) initialized.
1099 However, when the include file cannot be found, we need src_loc to
1100 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1101 if (type == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
1102 pfile->cur_token[-1].src_loc = 0;
1104 cpp_dir *dir = search_path_head (pfile, fname, angle_brackets, type);
1105 if (!dir)
1106 return false;
1108 _cpp_file *file = _cpp_find_file (pfile, fname, dir, angle_brackets,
1109 type == IT_DEFAULT ? _cpp_FFK_PRE_INCLUDE
1110 : _cpp_FFK_NORMAL, loc);
1111 if (type == IT_DEFAULT && file == NULL)
1112 return false;
1114 return _cpp_stack_file (pfile, file, type, loc);
1117 /* NAME is a header file name, find the _cpp_file, if any. */
1119 static _cpp_file *
1120 test_header_unit (cpp_reader *pfile, const char *name, bool angle,
1121 location_t loc)
1123 if (cpp_dir *dir = search_path_head (pfile, name, angle, IT_INCLUDE))
1124 return _cpp_find_file (pfile, name, dir, angle, _cpp_FFK_NORMAL, loc);
1126 return nullptr;
1129 /* NAME is a header file name, find the path we'll use to open it and infer that
1130 it is a header-unit. */
1132 const char *
1133 _cpp_find_header_unit (cpp_reader *pfile, const char *name, bool angle,
1134 location_t loc)
1136 if (_cpp_file *file = test_header_unit (pfile, name, angle, loc))
1138 if (file->fd > 0)
1140 /* Don't leave it open. */
1141 close (file->fd);
1142 file->fd = 0;
1145 file->header_unit = +1;
1146 _cpp_mark_file_once_only (pfile, file);
1148 return file->path;
1151 return nullptr;
1154 /* NAME is a header file name, find the path we'll use to open it. But do not
1155 infer it is a header unit. */
1157 const char *
1158 cpp_probe_header_unit (cpp_reader *pfile, const char *name, bool angle,
1159 location_t loc)
1161 if (_cpp_file *file = test_header_unit (pfile, name, angle, loc))
1162 return file->path;
1164 return nullptr;
1167 /* Retrofit the just-entered main file asif it was an include. This
1168 will permit correct include_next use, and mark it as a system
1169 header if that's where it resides. We use filesystem-appropriate
1170 prefix matching of the include path to locate the main file. */
1171 void
1172 cpp_retrofit_as_include (cpp_reader *pfile)
1174 /* We should be the outermost. */
1175 gcc_assert (!pfile->buffer->prev);
1177 if (const char *name = pfile->main_file->name)
1179 /* Locate name on the include dir path, using a prefix match. */
1180 size_t name_len = strlen (name);
1181 for (cpp_dir *dir = pfile->quote_include; dir; dir = dir->next)
1182 if (dir->len < name_len
1183 && IS_DIR_SEPARATOR (name[dir->len])
1184 && !filename_ncmp (name, dir->name, dir->len))
1186 pfile->main_file->dir = dir;
1187 if (dir->sysp)
1188 cpp_make_system_header (pfile, 1, 0);
1189 break;
1193 /* Initialize controlling macro state. */
1194 pfile->mi_valid = true;
1195 pfile->mi_cmacro = 0;
1198 /* Could not open FILE. The complication is dependency output. */
1199 static void
1200 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets,
1201 location_t loc)
1203 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1204 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1206 errno = file->err_no;
1207 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1209 deps_add_dep (pfile->deps, file->name);
1210 /* If the preprocessor output (other than dependency information) is
1211 being used, we must also flag an error. */
1212 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1213 cpp_errno_filename (pfile, CPP_DL_FATAL,
1214 file->path ? file->path : file->name,
1215 loc);
1217 else
1219 /* If we are not outputting dependencies, or if we are and dependencies
1220 were requested for this file, or if preprocessor output is needed
1221 in addition to dependency information, this is an error.
1223 Otherwise (outputting dependencies but not for this file, and not
1224 using the preprocessor output), we can still produce correct output
1225 so it's only a warning. */
1226 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1227 || print_dep
1228 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1229 cpp_errno_filename (pfile, CPP_DL_FATAL,
1230 file->path ? file->path : file->name,
1231 loc);
1232 else
1233 cpp_errno_filename (pfile, CPP_DL_WARNING,
1234 file->path ? file->path : file->name,
1235 loc);
1239 /* Search in the chain beginning at HEAD for a file whose search path
1240 started at START_DIR != NULL. */
1241 static struct cpp_file_hash_entry *
1242 search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir)
1244 while (head && head->start_dir != start_dir)
1245 head = head->next;
1247 return head;
1250 /* Allocate a new _cpp_file structure. */
1251 static _cpp_file *
1252 make_cpp_file (cpp_dir *dir, const char *fname)
1254 _cpp_file *file = XCNEW (_cpp_file);
1255 file->fd = -1;
1256 file->dir = dir;
1257 file->name = xstrdup (fname);
1259 return file;
1262 /* Release a _cpp_file structure. */
1263 static void
1264 destroy_cpp_file (_cpp_file *file)
1266 free ((void *) file->buffer_start);
1267 free ((void *) file->name);
1268 free ((void *) file->path);
1269 free (file);
1272 /* Release all the files allocated by this reader. */
1273 static void
1274 destroy_all_cpp_files (cpp_reader *pfile)
1276 _cpp_file *iter = pfile->all_files;
1277 while (iter)
1279 _cpp_file *next = iter->next_file;
1280 destroy_cpp_file (iter);
1281 iter = next;
1285 /* A hash of directory names. The directory names are the path names
1286 of files which contain a #include "", the included file name is
1287 appended to this directories.
1289 To avoid duplicate entries we follow the convention that all
1290 non-empty directory names should end in a '/'. DIR_NAME must be
1291 stored in permanently allocated memory. */
1292 static cpp_dir *
1293 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1295 struct cpp_file_hash_entry *entry, **hash_slot;
1296 cpp_dir *dir;
1298 hash_slot = (struct cpp_file_hash_entry **)
1299 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1300 htab_hash_string (dir_name),
1301 INSERT);
1303 /* Have we already hashed this directory? */
1304 for (entry = *hash_slot; entry; entry = entry->next)
1305 if (entry->start_dir == NULL)
1306 return entry->u.dir;
1308 dir = XCNEW (cpp_dir);
1309 dir->next = pfile->quote_include;
1310 dir->name = (char *) dir_name;
1311 dir->len = strlen (dir_name);
1312 dir->sysp = sysp;
1313 dir->construct = 0;
1315 /* Store this new result in the hash table. */
1316 entry = new_file_hash_entry (pfile);
1317 entry->next = *hash_slot;
1318 entry->start_dir = NULL;
1319 entry->location = pfile->line_table->highest_location;
1320 entry->u.dir = dir;
1321 *hash_slot = entry;
1323 return dir;
1326 /* Create a new block of memory for file hash entries. */
1327 static void
1328 allocate_file_hash_entries (cpp_reader *pfile)
1330 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1331 pool->file_hash_entries_used = 0;
1332 pool->next = pfile->file_hash_entries;
1333 pfile->file_hash_entries = pool;
1336 /* Return a new file hash entry. */
1337 static struct cpp_file_hash_entry *
1338 new_file_hash_entry (cpp_reader *pfile)
1340 unsigned int idx;
1341 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1342 allocate_file_hash_entries (pfile);
1344 idx = pfile->file_hash_entries->file_hash_entries_used++;
1345 return &pfile->file_hash_entries->pool[idx];
1348 /* Free the file hash entry pools. */
1349 static void
1350 free_file_hash_entries (cpp_reader *pfile)
1352 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1353 while (iter)
1355 struct file_hash_entry_pool *next = iter->next;
1356 free (iter);
1357 iter = next;
1361 /* Returns TRUE if a file FNAME has ever been successfully opened.
1362 This routine is not intended to correctly handle filenames aliased
1363 by links or redundant . or .. traversals etc. */
1364 bool
1365 cpp_included (cpp_reader *pfile, const char *fname)
1367 struct cpp_file_hash_entry *entry;
1369 entry = (struct cpp_file_hash_entry *)
1370 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1372 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1373 entry = entry->next;
1375 return entry != NULL;
1378 /* Returns TRUE if a file FNAME has ever been successfully opened
1379 before LOCATION. This routine is not intended to correctly handle
1380 filenames aliased by links or redundant . or .. traversals etc. */
1381 bool
1382 cpp_included_before (cpp_reader *pfile, const char *fname,
1383 location_t location)
1385 struct cpp_file_hash_entry *entry
1386 = (struct cpp_file_hash_entry *)
1387 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1389 if (IS_ADHOC_LOC (location))
1390 location = get_location_from_adhoc_loc (pfile->line_table, location);
1392 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1393 || entry->location > location))
1394 entry = entry->next;
1396 return entry != NULL;
1399 /* Calculate the hash value of a file hash entry P. */
1401 static hashval_t
1402 file_hash_hash (const void *p)
1404 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1405 const char *hname;
1406 if (entry->start_dir)
1407 hname = entry->u.file->name;
1408 else
1409 hname = entry->u.dir->name;
1411 return htab_hash_string (hname);
1414 /* Compare a string Q against a file hash entry P. */
1415 static int
1416 file_hash_eq (const void *p, const void *q)
1418 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1419 const char *fname = (const char *) q;
1420 const char *hname;
1422 if (entry->start_dir)
1423 hname = entry->u.file->name;
1424 else
1425 hname = entry->u.dir->name;
1427 return filename_cmp (hname, fname) == 0;
1430 /* Compare entries in the nonexistent file hash table. These are just
1431 strings. */
1432 static int
1433 nonexistent_file_hash_eq (const void *p, const void *q)
1435 return filename_cmp ((const char *) p, (const char *) q) == 0;
1438 /* Initialize everything in this source file. */
1439 void
1440 _cpp_init_files (cpp_reader *pfile)
1442 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1443 NULL, xcalloc, free);
1444 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1445 NULL, xcalloc, free);
1446 allocate_file_hash_entries (pfile);
1447 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1448 nonexistent_file_hash_eq,
1449 NULL, xcalloc, free);
1450 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,
1451 xmalloc, free);
1454 /* Finalize everything in this source file. */
1455 void
1456 _cpp_cleanup_files (cpp_reader *pfile)
1458 htab_delete (pfile->file_hash);
1459 htab_delete (pfile->dir_hash);
1460 htab_delete (pfile->nonexistent_file_hash);
1461 obstack_free (&pfile->nonexistent_file_ob, 0);
1462 free_file_hash_entries (pfile);
1463 destroy_all_cpp_files (pfile);
1466 /* Make the parser forget about files it has seen. This can be useful
1467 for resetting the parser to start another run. */
1468 void
1469 cpp_clear_file_cache (cpp_reader *pfile)
1471 _cpp_cleanup_files (pfile);
1472 pfile->file_hash_entries = NULL;
1473 pfile->all_files = NULL;
1474 _cpp_init_files (pfile);
1477 /* Enter a file name in the hash for the sake of cpp_included. */
1478 void
1479 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1481 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, 0, _cpp_FFK_FAKE, 0);
1484 /* Not everyone who wants to set system-header-ness on a buffer can
1485 see the details of a buffer. This is an exported interface because
1486 fix-header needs it. */
1487 void
1488 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1490 int flags = 0;
1491 const class line_maps *line_table = pfile->line_table;
1492 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1493 /* 1 = system header, 2 = system header to be treated as C. */
1494 if (syshdr)
1495 flags = 1 + (externc != 0);
1496 pfile->buffer->sysp = flags;
1497 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1498 SOURCE_LINE (map, pfile->line_table->highest_line),
1499 flags);
1502 /* Allow the client to change the current file. Used by the front end
1503 to achieve pseudo-file names like <built-in>.
1504 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1505 void
1506 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1507 const char *new_name)
1509 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1512 struct report_missing_guard_data
1514 cpp_reader *pfile;
1515 const char **paths;
1516 size_t count;
1519 /* Callback function for htab_traverse. */
1520 static int
1521 report_missing_guard (void **slot, void *d)
1523 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
1524 struct report_missing_guard_data *data
1525 = (struct report_missing_guard_data *) d;
1527 /* Skip directories. */
1528 if (entry->start_dir != NULL)
1530 _cpp_file *file = entry->u.file;
1532 /* We don't want MI guard advice for the main file. */
1533 if (!file->once_only
1534 && file->cmacro == NULL
1535 && file->stack_count == 1
1536 && data->pfile->main_file != file)
1538 if (data->paths == NULL)
1540 data->paths = XCNEWVEC (const char *, data->count);
1541 data->count = 0;
1544 data->paths[data->count++] = file->path;
1548 /* Keep traversing the hash table. */
1549 return 1;
1552 /* Comparison function for qsort. */
1553 static int
1554 report_missing_guard_cmp (const void *p1, const void *p2)
1556 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1559 /* Report on all files that might benefit from a multiple include guard.
1560 Triggered by -H. */
1561 void
1562 _cpp_report_missing_guards (cpp_reader *pfile)
1564 struct report_missing_guard_data data;
1566 data.pfile = pfile;
1567 data.paths = NULL;
1568 data.count = htab_elements (pfile->file_hash);
1569 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1571 if (data.paths != NULL)
1573 size_t i;
1575 /* Sort the paths to avoid outputting them in hash table
1576 order. */
1577 qsort (data.paths, data.count, sizeof (const char *),
1578 report_missing_guard_cmp);
1579 fputs (_("Multiple include guards may be useful for:\n"),
1580 stderr);
1581 for (i = 0; i < data.count; i++)
1583 fputs (data.paths[i], stderr);
1584 putc ('\n', stderr);
1586 free (data.paths);
1590 /* Locate HEADER, and determine whether it is newer than the current
1591 file. If it cannot be located or dated, return -1, if it is
1592 newer, return 1, otherwise 0. */
1594 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1595 int angle_brackets)
1597 _cpp_file *file;
1598 struct cpp_dir *dir;
1600 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1601 if (!dir)
1602 return -1;
1604 file = _cpp_find_file (pfile, fname, dir, angle_brackets, _cpp_FFK_NORMAL, 0);
1605 if (file->err_no)
1606 return -1;
1608 if (file->fd != -1)
1610 close (file->fd);
1611 file->fd = -1;
1614 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1617 /* Pushes the given file onto the buffer stack. Returns nonzero if
1618 successful. */
1619 bool
1620 cpp_push_include (cpp_reader *pfile, const char *fname)
1622 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE,
1623 pfile->line_table->highest_line);
1626 /* Pushes the given file, implicitly included at the start of a
1627 compilation, onto the buffer stack but without any errors if the
1628 file is not found. Returns nonzero if successful. */
1629 bool
1630 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1632 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT,
1633 pfile->line_table->highest_line);
1636 /* Do appropriate cleanup when a file INC's buffer is popped off the
1637 input stack. */
1638 void
1639 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1640 const unsigned char *to_free)
1642 /* Record the inclusion-preventing macro, which could be NULL
1643 meaning no controlling macro. */
1644 if (pfile->mi_valid && file->cmacro == NULL)
1645 file->cmacro = pfile->mi_cmacro;
1647 /* Invalidate control macros in the #including file. */
1648 pfile->mi_valid = false;
1650 if (to_free)
1652 if (to_free == file->buffer_start)
1654 file->buffer_start = NULL;
1655 file->buffer = NULL;
1656 file->buffer_valid = false;
1658 free ((void *) to_free);
1662 /* Return the file name associated with FILE. */
1663 const char *
1664 _cpp_get_file_name (_cpp_file *file)
1666 return file->name;
1669 /* Inteface to file statistics record in _cpp_file structure. */
1670 struct stat *
1671 _cpp_get_file_stat (_cpp_file *file)
1673 return &file->st;
1676 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1677 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1678 directory of the including file.
1680 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1681 void
1682 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1683 int quote_ignores_source_dir)
1685 pfile->quote_include = quote;
1686 pfile->bracket_include = quote;
1687 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1689 for (; quote; quote = quote->next)
1691 quote->name_map = NULL;
1692 quote->len = strlen (quote->name);
1693 if (quote == bracket)
1694 pfile->bracket_include = bracket;
1698 /* Append the file name to the directory to create the path, but don't
1699 turn / into // or // into ///; // may be a namespace escape. */
1700 static char *
1701 append_file_to_dir (const char *fname, cpp_dir *dir)
1703 size_t dlen, flen;
1704 char *path;
1706 dlen = dir->len;
1707 flen = strlen (fname);
1708 path = XNEWVEC (char, dlen + 1 + flen + 1);
1709 memcpy (path, dir->name, dlen);
1710 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1711 path[dlen++] = '/';
1712 memcpy (&path[dlen], fname, flen + 1);
1714 return path;
1717 /* Read a space delimited string of unlimited length from a stdio
1718 file F. */
1719 static char *
1720 read_filename_string (int ch, FILE *f)
1722 char *alloc, *set;
1723 int len;
1725 len = 20;
1726 set = alloc = XNEWVEC (char, len + 1);
1727 if (! is_space (ch))
1729 *set++ = ch;
1730 while ((ch = getc (f)) != EOF && ! is_space (ch))
1732 if (set - alloc == len)
1734 len *= 2;
1735 alloc = XRESIZEVEC (char, alloc, len + 1);
1736 set = alloc + len / 2;
1738 *set++ = ch;
1741 *set = '\0';
1742 ungetc (ch, f);
1743 return alloc;
1746 /* Read the file name map file for DIR. */
1747 static void
1748 read_name_map (cpp_dir *dir)
1750 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1751 char *name;
1752 FILE *f;
1753 size_t len, count = 0, room = 9;
1755 len = dir->len;
1756 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1757 memcpy (name, dir->name, len);
1758 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1759 name[len++] = '/';
1760 strcpy (name + len, FILE_NAME_MAP_FILE);
1761 f = fopen (name, "r");
1763 dir->name_map = XNEWVEC (const char *, room);
1765 /* Silently return NULL if we cannot open. */
1766 if (f)
1768 int ch;
1770 while ((ch = getc (f)) != EOF)
1772 char *to;
1774 if (is_space (ch))
1775 continue;
1777 if (count + 2 > room)
1779 room += 8;
1780 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1783 dir->name_map[count] = read_filename_string (ch, f);
1784 while ((ch = getc (f)) != EOF && is_hspace (ch))
1787 to = read_filename_string (ch, f);
1788 if (IS_ABSOLUTE_PATH (to))
1789 dir->name_map[count + 1] = to;
1790 else
1792 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1793 free (to);
1796 count += 2;
1797 while ((ch = getc (f)) != '\n')
1798 if (ch == EOF)
1799 break;
1802 fclose (f);
1805 /* Terminate the list of maps. */
1806 dir->name_map[count] = NULL;
1809 /* Remap a FILE's name based on the file_name_map, if any, for
1810 FILE->dir. If the file name has any directory separators,
1811 recursively check those directories too. */
1812 static char *
1813 remap_filename (cpp_reader *pfile, _cpp_file *file)
1815 const char *fname, *p;
1816 char *new_dir, *p3;
1817 cpp_dir *dir;
1818 size_t index, len;
1820 dir = file->dir;
1821 fname = file->name;
1823 for (;;)
1825 if (!dir->name_map)
1826 read_name_map (dir);
1828 for (index = 0; dir->name_map[index]; index += 2)
1829 if (!filename_cmp (dir->name_map[index], fname))
1830 return xstrdup (dir->name_map[index + 1]);
1831 if (IS_ABSOLUTE_PATH (fname))
1832 return NULL;
1833 p = strchr (fname, '/');
1834 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1836 const char *p2 = strchr (fname, '\\');
1837 if (!p || (p > p2))
1838 p = p2;
1840 #endif
1841 if (!p || p == fname)
1842 return NULL;
1844 len = dir->len + (p - fname + 1);
1845 new_dir = XNEWVEC (char, len + 2);
1846 p3 = new_dir + dir->len;
1847 memcpy (new_dir, dir->name, dir->len);
1848 if (dir->len && !IS_DIR_SEPARATOR (dir->name[dir->len - 1]))
1850 *p3++ = '/';
1851 len++;
1853 memcpy (p3, fname, p - fname + 1);
1854 new_dir[len] = '\0';
1856 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1857 fname = p + 1;
1861 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1862 static bool
1863 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1865 const char *saved_path = file->path;
1866 bool valid = false;
1868 file->path = pchname;
1869 if (open_file (file))
1871 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1873 if (!valid)
1875 close (file->fd);
1876 file->fd = -1;
1879 if (CPP_OPTION (pfile, print_include_names))
1881 unsigned int i;
1882 for (i = 1; i < pfile->line_table->depth; i++)
1883 putc ('.', stderr);
1884 fprintf (stderr, "%c %s\n",
1885 valid ? '!' : 'x', pchname);
1889 file->path = saved_path;
1890 return valid;
1893 /* Get the path associated with the _cpp_file F. The path includes
1894 the base name from the include directive and the directory it was
1895 found in via the search path. */
1897 const char *
1898 cpp_get_path (struct _cpp_file *f)
1900 return f->path;
1903 /* Get the directory associated with the _cpp_file F. */
1905 cpp_dir *
1906 cpp_get_dir (struct _cpp_file *f)
1908 return f->dir;
1911 /* Get the cpp_buffer currently associated with the cpp_reader
1912 PFILE. */
1914 cpp_buffer *
1915 cpp_get_buffer (cpp_reader *pfile)
1917 return pfile->buffer;
1920 /* Get the _cpp_file associated with the cpp_buffer B. */
1922 _cpp_file *
1923 cpp_get_file (cpp_buffer *b)
1925 return b->file;
1928 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1929 buffer is the buffer that included the given buffer. */
1931 cpp_buffer *
1932 cpp_get_prev (cpp_buffer *b)
1934 return b->prev;
1937 /* This data structure holds the list of header files that were seen
1938 while the PCH was being built. The 'entries' field is kept sorted
1939 in memcmp() order; yes, this means that on little-endian systems,
1940 it's sorted initially by the least-significant byte of 'size', but
1941 that's OK. The code does rely on having entries with the same size
1942 next to each other. */
1944 struct pchf_entry {
1945 /* The size of this file. This is used to save running a MD5 checksum
1946 if the sizes don't match. */
1947 off_t size;
1948 /* The MD5 checksum of this file. */
1949 unsigned char sum[16];
1950 /* Is this file to be included only once? */
1951 bool once_only;
1954 struct pchf_data {
1955 /* Number of pchf_entry structures. */
1956 size_t count;
1958 /* Are there any values with once_only set?
1959 This is used as an optimisation, it means we don't have to search
1960 the structure if we're processing a regular #include. */
1961 bool have_once_only;
1963 struct pchf_entry entries[1];
1966 static struct pchf_data *pchf;
1968 /* A qsort ordering function for pchf_entry structures. */
1970 static int
1971 pchf_save_compare (const void *e1, const void *e2)
1973 return memcmp (e1, e2, sizeof (struct pchf_entry));
1976 /* Create and write to F a pchf_data structure. */
1978 bool
1979 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1981 size_t count = 0;
1982 struct pchf_data *result;
1983 size_t result_size;
1984 _cpp_file *f;
1985 bool ret;
1987 for (f = pfile->all_files; f; f = f->next_file)
1988 ++count;
1990 result_size = (sizeof (struct pchf_data)
1991 + sizeof (struct pchf_entry) * (count - 1));
1992 result = XCNEWVAR (struct pchf_data, result_size);
1994 result->count = 0;
1995 result->have_once_only = false;
1997 for (f = pfile->all_files; f; f = f->next_file)
1999 size_t count;
2001 /* This should probably never happen, since if a read error occurred
2002 the PCH file shouldn't be written... */
2003 if (f->dont_read || f->err_no)
2004 continue;
2006 if (f->stack_count == 0)
2007 continue;
2009 count = result->count++;
2011 result->entries[count].once_only = f->once_only;
2012 /* |= is avoided in the next line because of an HP C compiler bug */
2013 result->have_once_only = result->have_once_only | f->once_only;
2014 if (f->buffer_valid)
2015 md5_buffer ((const char *)f->buffer,
2016 f->st.st_size, result->entries[count].sum);
2017 else
2019 FILE *ff;
2020 int oldfd = f->fd;
2022 if (!open_file (f))
2024 open_file_failed (pfile, f, 0, 0);
2025 free (result);
2026 return false;
2028 ff = fdopen (f->fd, "rb");
2029 md5_stream (ff, result->entries[count].sum);
2030 fclose (ff);
2031 f->fd = oldfd;
2033 result->entries[count].size = f->st.st_size;
2036 result_size = (sizeof (struct pchf_data)
2037 + sizeof (struct pchf_entry) * (result->count - 1));
2039 qsort (result->entries, result->count, sizeof (struct pchf_entry),
2040 pchf_save_compare);
2042 ret = fwrite (result, result_size, 1, fp) == 1;
2043 free (result);
2044 return ret;
2047 /* Read the pchf_data structure from F. */
2049 bool
2050 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
2052 struct pchf_data d;
2054 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
2055 != 1)
2056 return false;
2058 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
2059 + sizeof (struct pchf_entry) * (d.count - 1));
2060 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
2061 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
2062 != d.count)
2063 return false;
2064 return true;
2067 /* The parameters for pchf_compare. */
2069 struct pchf_compare_data
2071 /* The size of the file we're looking for. */
2072 off_t size;
2074 /* The MD5 checksum of the file, if it's been computed. */
2075 unsigned char sum[16];
2077 /* Is SUM valid? */
2078 bool sum_computed;
2080 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
2081 bool check_included;
2083 /* The file that we're searching for. */
2084 _cpp_file *f;
2087 /* bsearch comparison function; look for D_P in E_P. */
2089 static int
2090 pchf_compare (const void *d_p, const void *e_p)
2092 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
2093 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
2094 int result;
2096 result = memcmp (&d->size, &e->size, sizeof (off_t));
2097 if (result != 0)
2098 return result;
2100 if (! d->sum_computed)
2102 _cpp_file *const f = d->f;
2104 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
2105 d->sum_computed = true;
2108 result = memcmp (d->sum, e->sum, 16);
2109 if (result != 0)
2110 return result;
2112 if (d->check_included || e->once_only)
2113 return 0;
2114 else
2115 return 1;
2118 /* Check that F is not in a list read from a PCH file (if any).
2119 Assumes that f->buffer_valid is true. Return TRUE if the file
2120 should not be read. */
2122 static bool
2123 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
2124 _cpp_file *f,
2125 bool check_included)
2127 struct pchf_compare_data d;
2129 if (pchf == NULL
2130 || (! check_included && ! pchf->have_once_only))
2131 return false;
2133 d.size = f->st.st_size;
2134 d.sum_computed = false;
2135 d.f = f;
2136 d.check_included = check_included;
2137 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
2138 pchf_compare) != NULL;
2141 /* Return true if the file FNAME is found in the appropriate include file path
2142 as indicated by ANGLE_BRACKETS. */
2144 bool
2145 _cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
2146 enum include_type type)
2148 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
2149 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir, angle_brackets,
2150 _cpp_FFK_HAS_INCLUDE, 0);
2151 return file->err_no != ENOENT;
2154 /* Read a file and convert to input charset, the same as if it were being read
2155 by a cpp_reader. */
2157 cpp_converted_source
2158 cpp_get_converted_source (const char *fname, const char *input_charset)
2160 cpp_converted_source res = {};
2161 _cpp_file file = {};
2162 file.fd = -1;
2163 file.name = lbasename (fname);
2164 file.path = fname;
2165 if (!open_file (&file))
2166 return res;
2167 const bool ok = read_file_guts (NULL, &file, 0, input_charset);
2168 close (file.fd);
2169 if (!ok)
2170 return res;
2171 res.to_free = (char *) file.buffer_start;
2172 res.data = (char *) file.buffer;
2173 res.len = file.st.st_size;
2174 return res;