analyzer: handle INIT_VAL(ELEMENT_REG(STRING_REG), CONSTANT_SVAL) [PR105899]
[official-gcc.git] / libcpp / files.cc
blob43a8894b7deca1bcc3bee277714319512617881a
1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2023 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 /* Set if a header wasn't found with __has_include or __has_include_next
113 and error should be emitted if it is included normally. */
114 bool deferred_error : 1;
116 /* > 0: Known C++ Module header unit, <0: known not. ==0, unknown */
117 int header_unit : 2;
120 /* A singly-linked list for all searches for a given file name, with
121 its head pointed to by a slot in FILE_HASH. The file name is what
122 appeared between the quotes in a #include directive; it can be
123 determined implicitly from the hash table location or explicitly
124 from FILE->name.
126 FILE is a structure containing details about the file that was
127 found with that search, or details of how the search failed.
129 START_DIR is the starting location of the search in the include
130 chain. The current directories for "" includes are also hashed in
131 the hash table and therefore unique. Files that are looked up
132 without using a search path, such as absolute filenames and file
133 names from the command line share a special starting directory so
134 they don't cause cache hits with normal include-chain lookups.
136 If START_DIR is NULL then the entry is for a directory, not a file,
137 and the directory is in DIR. Since the starting point in a file
138 lookup chain is never NULL, this means that simple pointer
139 comparisons against START_DIR can be made to determine cache hits
140 in file lookups.
142 If a cache lookup fails because of e.g. an extra "./" in the path,
143 then nothing will break. It is just less efficient as CPP will
144 have to do more work re-preprocessing the file, and/or comparing
145 its contents against earlier once-only files.
147 struct cpp_file_hash_entry
149 struct cpp_file_hash_entry *next;
150 cpp_dir *start_dir;
151 location_t location;
152 union
154 _cpp_file *file;
155 cpp_dir *dir;
156 } u;
159 /* Number of entries to put in a cpp_file_hash_entry pool. */
160 #define FILE_HASH_POOL_SIZE 127
162 /* A file hash entry pool. We allocate cpp_file_hash_entry object from
163 one of these. */
164 struct file_hash_entry_pool
166 /* Number of entries used from this pool. */
167 unsigned int file_hash_entries_used;
168 /* Next pool in the chain; used when freeing. */
169 struct file_hash_entry_pool *next;
170 /* The memory pool. */
171 struct cpp_file_hash_entry pool[FILE_HASH_POOL_SIZE];
174 static bool open_file (_cpp_file *file);
175 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
176 bool *invalid_pch);
177 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
178 bool *invalid_pch, location_t loc);
179 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file,
180 location_t loc, const char *input_charset);
181 static bool read_file (cpp_reader *pfile, _cpp_file *file,
182 location_t loc);
183 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
184 int angle_brackets, enum include_type);
185 static const char *dir_name_of_file (_cpp_file *file);
186 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int,
187 location_t);
188 static struct cpp_file_hash_entry *search_cache (struct cpp_file_hash_entry *head,
189 const cpp_dir *start_dir);
190 static _cpp_file *make_cpp_file (cpp_dir *, const char *fname);
191 static void destroy_cpp_file (_cpp_file *);
192 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
193 static void allocate_file_hash_entries (cpp_reader *pfile);
194 static struct cpp_file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
195 static int report_missing_guard (void **slot, void *b);
196 static hashval_t file_hash_hash (const void *p);
197 static int file_hash_eq (const void *p, const void *q);
198 static char *read_filename_string (int ch, FILE *f);
199 static void read_name_map (cpp_dir *dir);
200 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
201 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
202 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
203 static int pchf_save_compare (const void *e1, const void *e2);
204 static int pchf_compare (const void *d_p, const void *e_p);
205 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
207 /* Given a filename in FILE->PATH, with the empty string interpreted
208 as <stdin>, open it.
210 On success FILE contains an open file descriptor and stat
211 information for the file. On failure the file descriptor is -1 and
212 the appropriate errno is also stored in FILE. Returns TRUE iff
213 successful.
215 We used to open files in nonblocking mode, but that caused more
216 problems than it solved. Do take care not to acquire a controlling
217 terminal by mistake (this can't happen on sane systems, but
218 paranoia is a virtue).
220 Use the three-argument form of open even though we aren't
221 specifying O_CREAT, to defend against broken system headers.
223 O_BINARY tells some runtime libraries (notably DJGPP) not to do
224 newline translation; we can handle DOS line breaks just fine
225 ourselves. */
226 static bool
227 open_file (_cpp_file *file)
229 if (file->path[0] == '\0')
231 file->fd = 0;
232 set_stdin_to_binary_mode ();
234 else
235 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
237 if (file->fd != -1)
239 if (fstat (file->fd, &file->st) == 0)
241 if (!S_ISDIR (file->st.st_mode))
243 file->err_no = 0;
244 return true;
247 /* Ignore a directory and continue the search. The file we're
248 looking for may be elsewhere in the search path. */
249 errno = ENOENT;
252 close (file->fd);
253 file->fd = -1;
255 #if defined(_WIN32) && !defined(__CYGWIN__)
256 else if (errno == EACCES)
258 /* On most UNIX systems, open succeeds on a directory. Above,
259 we check if we have opened a directory and if so, set errno
260 to ENOENT. However, on Windows, opening a directory
261 fails with EACCES. We want to return ENOENT in that
262 case too. */
263 if (stat (file->path, &file->st) == 0
264 && S_ISDIR (file->st.st_mode))
265 errno = ENOENT;
266 else
267 /* The call to stat may have reset errno. */
268 errno = EACCES;
270 #endif
271 else if (errno == ENOTDIR)
272 errno = ENOENT;
274 file->err_no = errno;
276 return false;
279 /* Temporary PCH intercept of opening a file. Try to find a PCH file
280 based on FILE->name and FILE->dir, and test those found for
281 validity using PFILE->cb.valid_pch. Return true iff a valid file is
282 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
284 static bool
285 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
287 static const char extension[] = ".gch";
288 const char *path = file->path;
289 size_t len, flen;
290 char *pchname;
291 struct stat st;
292 bool valid = false;
294 /* No PCH on <stdin> or if not requested. */
295 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
296 return false;
298 /* If the file is not included as first include from either the toplevel
299 file or the command-line it is not a valid use of PCH. */
300 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
301 if (f->implicit_preinclude)
302 continue;
303 else if (pfile->main_file == f)
304 break;
305 else
306 return false;
308 flen = strlen (path);
309 len = flen + sizeof (extension);
310 pchname = XNEWVEC (char, len);
311 memcpy (pchname, path, flen);
312 memcpy (pchname + flen, extension, sizeof (extension));
314 if (stat (pchname, &st) == 0)
316 DIR *pchdir;
317 struct dirent *d;
318 size_t dlen, plen = len;
320 if (!S_ISDIR (st.st_mode))
321 valid = validate_pch (pfile, file, pchname);
322 else if ((pchdir = opendir (pchname)) != NULL)
324 pchname[plen - 1] = '/';
325 while ((d = readdir (pchdir)) != NULL)
327 dlen = strlen (d->d_name) + 1;
328 if ((strcmp (d->d_name, ".") == 0)
329 || (strcmp (d->d_name, "..") == 0))
330 continue;
331 if (dlen + plen > len)
333 len += dlen + 64;
334 pchname = XRESIZEVEC (char, pchname, len);
336 memcpy (pchname + plen, d->d_name, dlen);
337 valid = validate_pch (pfile, file, pchname);
338 if (valid)
339 break;
341 closedir (pchdir);
343 if (!valid)
344 *invalid_pch = true;
347 if (valid)
348 file->pchname = pchname;
349 else
350 free (pchname);
352 return valid;
355 /* Canonicalize the path to FILE. Return the canonical form if it is
356 shorter, otherwise return NULL. This function does NOT free the
357 memory pointed by FILE. */
359 static char *
360 maybe_shorter_path (const char * file)
362 char * file2 = lrealpath (file);
363 if (file2 && strlen (file2) < strlen (file))
365 return file2;
367 else
369 free (file2);
370 return NULL;
374 /* Try to open the path FILE->name appended to FILE->dir. This is
375 where remap and PCH intercept the file lookup process. Return true
376 if the file was found, whether or not the open was successful.
377 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
378 Use LOC when emitting any diagnostics. */
380 static bool
381 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch,
382 location_t loc)
384 char *path;
386 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
388 else
389 if (file->dir->construct)
390 path = file->dir->construct (file->name, file->dir);
391 else
392 path = append_file_to_dir (file->name, file->dir);
394 if (path)
396 hashval_t hv;
397 char *copy;
398 void **pp;
400 /* We try to canonicalize system headers. For DOS based file
401 * system, we always try to shorten non-system headers, as DOS
402 * has a tighter constraint on max path length. */
403 if ((CPP_OPTION (pfile, canonical_system_headers) && file->dir->sysp)
404 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
405 || !file->dir->sysp
406 #endif
409 char * canonical_path = maybe_shorter_path (path);
410 if (canonical_path)
412 /* The canonical path was newly allocated. Let's free the
413 non-canonical one. */
414 free (path);
415 path = canonical_path;
419 hv = htab_hash_string (path);
420 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
422 file->err_no = ENOENT;
423 return false;
426 file->path = path;
427 if (pch_open_file (pfile, file, invalid_pch))
428 return true;
430 if (open_file (file))
431 return true;
433 if (file->err_no != ENOENT)
435 open_file_failed (pfile, file, 0, loc);
436 return true;
439 /* We copy the path name onto an obstack partly so that we don't
440 leak the memory, but mostly so that we don't fragment the
441 heap. */
442 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
443 strlen (path));
444 free (path);
445 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
446 copy, hv, INSERT);
447 *pp = copy;
449 file->path = file->name;
451 else
453 file->err_no = ENOENT;
454 file->path = NULL;
457 return false;
460 /* Return true iff the missing_header callback found the given HEADER. */
461 static bool
462 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
464 missing_header_cb func = pfile->cb.missing_header;
466 /* When the regular search path doesn't work, try context dependent
467 headers search paths. */
468 if (func
469 && file->dir == NULL)
471 if ((file->path = func (pfile, header, &file->dir)) != NULL)
473 if (open_file (file))
474 return true;
475 free ((void *)file->path);
477 file->path = file->name;
480 return false;
483 bool
484 _cpp_find_failed (_cpp_file *file)
486 return file->err_no != 0;
489 /* Given a filename FNAME search for such a file in the include path
490 starting from START_DIR. If FNAME is the empty string it is
491 interpreted as STDIN if START_DIR is PFILE->no_search_path.
493 If the file is not found in the file cache fall back to the O/S and
494 add the result to our cache.
496 If the file was not found in the filesystem, or there was an error
497 opening it, then ERR_NO is nonzero and FD is -1. If the file was
498 found, then ERR_NO is zero and FD could be -1 or an open file
499 descriptor. FD can be -1 if the file was found in the cache and
500 had previously been closed. To open it again pass the return value
501 to open_file().
503 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
504 missing. If present, it is OK for a precompiled header to be
505 included after it.
507 Use LOC as the location for any errors. */
509 _cpp_file *
510 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir,
511 int angle_brackets, _cpp_find_file_kind kind, location_t loc)
513 bool invalid_pch = false;
514 bool saw_bracket_include = false;
515 bool saw_quote_include = false;
516 struct cpp_dir *found_in_cache = NULL;
518 /* Ensure we get no confusion between cached files and directories. */
519 if (start_dir == NULL)
520 cpp_error_at (pfile, CPP_DL_ICE, loc, "NULL directory in find_file");
522 void **hash_slot
523 = htab_find_slot_with_hash (pfile->file_hash, fname,
524 htab_hash_string (fname), INSERT);
526 /* First check the cache before we resort to memory allocation. */
527 cpp_file_hash_entry *entry
528 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, start_dir);
529 if (entry)
531 if (entry->u.file->deferred_error && kind == _cpp_FFK_NORMAL)
533 open_file_failed (pfile, entry->u.file, angle_brackets, loc);
534 entry->u.file->deferred_error = false;
536 return entry->u.file;
539 _cpp_file *file = make_cpp_file (start_dir, fname);
540 file->implicit_preinclude
541 = (kind == _cpp_FFK_PRE_INCLUDE
542 || (pfile->buffer && pfile->buffer->file->implicit_preinclude));
544 if (kind != _cpp_FFK_FAKE)
545 /* Try each path in the include chain. */
546 for (;;)
548 if (find_file_in_dir (pfile, file, &invalid_pch, loc))
549 break;
551 file->dir = file->dir->next;
552 if (file->dir == NULL)
554 if (search_path_exhausted (pfile, fname, file))
556 /* Although this file must not go in the cache,
557 because the file found might depend on things (like
558 the current file) that aren't represented in the
559 cache, it still has to go in the list of all files
560 so that #import works. */
561 file->next_file = pfile->all_files;
562 pfile->all_files = file;
563 if (*hash_slot == NULL)
565 /* If *hash_slot is NULL, the above
566 htab_find_slot_with_hash call just created the
567 slot, but we aren't going to store there anything
568 of use, so need to remove the newly created entry.
569 htab_clear_slot requires that it is non-NULL, so
570 store some non-NULL but valid pointer there,
571 htab_clear_slot will immediately overwrite it. */
572 *hash_slot = file;
573 htab_clear_slot (pfile->file_hash, hash_slot);
575 return file;
578 if (invalid_pch)
580 cpp_error (pfile, CPP_DL_ERROR,
581 "one or more PCH files were found,"
582 " but they were invalid");
583 if (!cpp_get_options (pfile)->warn_invalid_pch)
584 cpp_error (pfile, CPP_DL_NOTE,
585 "use -Winvalid-pch for more information");
588 if (kind == _cpp_FFK_PRE_INCLUDE)
590 free ((char *) file->name);
591 free (file);
592 if (*hash_slot == NULL)
594 /* See comment on the above htab_clear_slot call. */
595 *hash_slot = &hash_slot;
596 htab_clear_slot (pfile->file_hash, hash_slot);
598 return NULL;
601 if (kind != _cpp_FFK_HAS_INCLUDE)
602 open_file_failed (pfile, file, angle_brackets, loc);
603 else
604 file->deferred_error = true;
605 break;
608 /* Only check the cache for the starting location (done above)
609 and the quote and bracket chain heads because there are no
610 other possible starting points for searches. */
611 if (file->dir == pfile->bracket_include)
612 saw_bracket_include = true;
613 else if (file->dir == pfile->quote_include)
614 saw_quote_include = true;
615 else
616 continue;
618 entry
619 = search_cache ((struct cpp_file_hash_entry *) *hash_slot, file->dir);
620 if (entry)
622 found_in_cache = file->dir;
623 break;
627 if (entry)
629 /* Cache for START_DIR too, sharing the _cpp_file structure. */
630 free ((char *) file->name);
631 free (file);
632 file = entry->u.file;
634 else
636 /* This is a new file; put it in the list. */
637 file->next_file = pfile->all_files;
638 pfile->all_files = file;
641 /* Store this new result in the hash table. */
642 entry = new_file_hash_entry (pfile);
643 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
644 entry->start_dir = start_dir;
645 entry->location = loc;
646 entry->u.file = file;
647 *hash_slot = (void *) entry;
649 /* If we passed the quote or bracket chain heads, cache them also.
650 This speeds up processing if there are lots of -I options. */
651 if (saw_bracket_include
652 && pfile->bracket_include != start_dir
653 && found_in_cache != pfile->bracket_include)
655 entry = new_file_hash_entry (pfile);
656 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
657 entry->start_dir = pfile->bracket_include;
658 entry->location = loc;
659 entry->u.file = file;
660 *hash_slot = (void *) entry;
662 if (saw_quote_include
663 && pfile->quote_include != start_dir
664 && found_in_cache != pfile->quote_include)
666 entry = new_file_hash_entry (pfile);
667 entry->next = (struct cpp_file_hash_entry *) *hash_slot;
668 entry->start_dir = pfile->quote_include;
669 entry->location = loc;
670 entry->u.file = file;
671 *hash_slot = (void *) entry;
674 return file;
677 /* Read a file into FILE->buffer, returning true on success.
679 If FILE->fd is something weird, like a block device, we don't want
680 to read it at all. Don't even try to figure out what something is,
681 except for plain files and block devices, since there is no
682 reliable portable way of doing this.
684 Use LOC for any diagnostics.
686 PFILE may be NULL. In this case, no diagnostics are issued.
688 FIXME: Flush file cache and try again if we run out of memory. */
689 static bool
690 read_file_guts (cpp_reader *pfile, _cpp_file *file, location_t loc,
691 const char *input_charset)
693 ssize_t size, total, count;
694 uchar *buf;
695 bool regular;
697 if (S_ISBLK (file->st.st_mode))
699 if (pfile)
700 cpp_error_at (pfile, CPP_DL_ERROR, loc,
701 "%s is a block device", file->path);
702 return false;
705 regular = S_ISREG (file->st.st_mode) != 0;
706 if (regular)
708 /* off_t might have a wider range than ssize_t - in other words,
709 the max size of a file might be bigger than the address
710 space. We can't handle a file that large. (Anyone with
711 a single source file bigger than 2GB needs to rethink
712 their coding style.) Some systems (e.g. AIX 4.1) define
713 SSIZE_MAX to be much smaller than the actual range of the
714 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
715 does not bite us. */
716 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
718 if (pfile)
719 cpp_error_at (pfile, CPP_DL_ERROR, loc,
720 "%s is too large", file->path);
721 return false;
724 size = file->st.st_size;
726 else
727 /* 8 kilobytes is a sensible starting size. It ought to be bigger
728 than the kernel pipe buffer, and it's definitely bigger than
729 the majority of C source files. */
730 size = 8 * 1024;
732 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
733 used to quiet warnings from valgrind or Address Sanitizer, when the
734 optimized lexer accesses aligned 16-byte memory chunks, including
735 the bytes after the malloced, area, and stops lexing on '\n'. */
736 buf = XNEWVEC (uchar, size + 16);
737 total = 0;
738 while ((count = read (file->fd, buf + total, size - total)) > 0)
740 total += count;
742 if (total == size)
744 if (regular)
745 break;
746 size *= 2;
747 buf = XRESIZEVEC (uchar, buf, size + 16);
751 if (count < 0)
753 if (pfile)
754 cpp_errno_filename (pfile, CPP_DL_ERROR, file->path, loc);
755 free (buf);
756 return false;
759 if (pfile && regular && total != size && STAT_SIZE_RELIABLE (file->st))
760 cpp_error_at (pfile, CPP_DL_WARNING, loc,
761 "%s is shorter than expected", file->path);
763 file->buffer = _cpp_convert_input (pfile,
764 input_charset,
765 buf, size + 16, total,
766 &file->buffer_start,
767 &file->st.st_size);
768 file->buffer_valid = file->buffer;
769 return file->buffer_valid;
772 /* Convenience wrapper around read_file_guts that opens the file if
773 necessary and closes the file descriptor after reading. FILE must
774 have been passed through find_file() at some stage. Use LOC for
775 any diagnostics. Unlike read_file_guts(), PFILE may not be NULL. */
776 static bool
777 read_file (cpp_reader *pfile, _cpp_file *file, location_t loc)
779 /* If we already have its contents in memory, succeed immediately. */
780 if (file->buffer_valid)
781 return true;
783 /* If an earlier read failed for some reason don't try again. */
784 if (file->dont_read || file->err_no)
785 return false;
787 if (file->fd == -1 && !open_file (file))
789 open_file_failed (pfile, file, 0, loc);
790 return false;
793 file->dont_read = !read_file_guts (pfile, file, loc,
794 CPP_OPTION (pfile, input_charset));
795 close (file->fd);
796 file->fd = -1;
798 return !file->dont_read;
801 /* Returns TRUE if FILE is already known to be idempotent, and should
802 therefore not be read again. */
803 static bool
804 is_known_idempotent_file (cpp_reader *pfile, _cpp_file *file, bool import)
806 /* Skip once-only files. */
807 if (file->once_only)
808 return true;
810 /* We must mark the file once-only if #import now, before header
811 guard checks. Otherwise, undefining the header guard might
812 cause the file to be re-stacked. */
813 if (import)
815 _cpp_mark_file_once_only (pfile, file);
817 /* Don't stack files that have been stacked before. */
818 if (file->stack_count)
819 return true;
822 /* Skip if the file had a header guard and the macro is defined.
823 PCH relies on this appearing before the PCH handler below. */
824 if (file->cmacro && cpp_macro_p (file->cmacro))
825 return true;
827 /* Handle PCH files immediately; don't stack them. */
828 if (file->pchname)
830 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
831 file->fd = -1;
832 free ((void *) file->pchname);
833 file->pchname = NULL;
834 return true;
837 return false;
840 /* Return TRUE if file has unique contents, so we should read process
841 it. The file's contents must already have been read. */
843 static bool
844 has_unique_contents (cpp_reader *pfile, _cpp_file *file, bool import,
845 location_t loc)
847 /* Check the file against the PCH file. This is done before
848 checking against files we've already seen, since it may save on
849 I/O. */
850 if (check_file_against_entries (pfile, file, import))
852 /* If this isn't a #import, but yet we can't include the file,
853 that means that it was #import-ed in the PCH file,
854 so we can never include it again. */
855 if (! import)
856 _cpp_mark_file_once_only (pfile, file);
857 return false;
860 /* Now we've read the file's contents, we can stack it if there
861 are no once-only files. */
862 if (!pfile->seen_once_only)
863 return true;
865 /* We may have read the file under a different name. Look
866 for likely candidates and compare file contents to be sure. */
867 for (_cpp_file *f = pfile->all_files; f; f = f->next_file)
869 if (f == file)
870 continue; /* It'sa me! */
872 if ((import || f->once_only)
873 && f->err_no == 0
874 && f->st.st_mtime == file->st.st_mtime
875 && f->st.st_size == file->st.st_size)
877 _cpp_file *ref_file;
879 if (f->buffer && !f->buffer_valid)
881 /* We already have a buffer but it is not valid, because
882 the file is still stacked. Make a new one. */
883 ref_file = make_cpp_file (f->dir, f->name);
884 ref_file->path = f->path;
886 else
887 /* The file is not stacked anymore. We can reuse it. */
888 ref_file = f;
890 bool same_file_p = (read_file (pfile, ref_file, loc)
891 /* Size might have changed in read_file(). */
892 && ref_file->st.st_size == file->st.st_size
893 && !memcmp (ref_file->buffer, file->buffer,
894 file->st.st_size));
896 if (f->buffer && !f->buffer_valid)
898 ref_file->path = 0;
899 destroy_cpp_file (ref_file);
902 if (same_file_p)
903 /* Already seen under a different name. */
904 return false;
908 return true;
911 /* Place the file referenced by FILE into a new buffer on the buffer
912 stack if possible. Returns true if a buffer is stacked. Use LOC
913 for any diagnostics. */
915 bool
916 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, include_type type,
917 location_t loc)
919 if (is_known_idempotent_file (pfile, file, type == IT_IMPORT))
920 return false;
922 int sysp = 0;
923 char *buf = nullptr;
925 /* Check C++ module include translation. */
926 if (!file->header_unit && type < IT_HEADER_HWM
927 /* Do not include translate include-next. */
928 && type != IT_INCLUDE_NEXT
929 && pfile->cb.translate_include)
930 buf = (pfile->cb.translate_include
931 (pfile, pfile->line_table, loc, file->path));
933 if (buf)
935 /* We don't increment the line number at the end of a buffer,
936 because we don't usually need that location (we're popping an
937 include file). However in this case we do want to do the
938 increment. So push a writable buffer of two newlines to acheive
939 that. (We also need an extra newline, so this looks like a regular
940 file, which we do that to to make sure we don't fall off the end in the
941 middle of a line. */
942 static uchar newlines[] = "\n\n\n";
943 cpp_push_buffer (pfile, newlines, 2, true);
945 size_t len = strlen (buf);
946 buf[len] = '\n'; /* See above */
947 cpp_buffer *buffer
948 = cpp_push_buffer (pfile, reinterpret_cast<unsigned char *> (buf),
949 len, true);
950 buffer->to_free = buffer->buf;
952 file->header_unit = +1;
953 _cpp_mark_file_once_only (pfile, file);
955 else
957 /* Not a header unit, and we know it. */
958 file->header_unit = -1;
960 if (!read_file (pfile, file, loc))
961 return false;
963 if (!has_unique_contents (pfile, file, type == IT_IMPORT, loc))
964 return false;
966 if (pfile->buffer && file->dir)
967 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
969 /* Add the file to the dependencies on its first inclusion. */
970 if (CPP_OPTION (pfile, deps.style) > (sysp != 0)
971 && !file->stack_count
972 && file->path[0]
973 && !(pfile->main_file == file
974 && CPP_OPTION (pfile, deps.ignore_main_file)))
975 deps_add_dep (pfile->deps, file->path);
977 /* Clear buffer_valid since _cpp_clean_line messes it up. */
978 file->buffer_valid = false;
979 file->stack_count++;
981 /* Stack the buffer. */
982 cpp_buffer *buffer
983 = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
984 CPP_OPTION (pfile, preprocessed)
985 && !CPP_OPTION (pfile, directives_only));
986 buffer->file = file;
987 buffer->sysp = sysp;
988 buffer->to_free = file->buffer_start;
990 /* Initialize controlling macro state. */
991 pfile->mi_valid = true;
992 pfile->mi_cmacro = 0;
995 /* In the case of a normal #include, we're now at the start of the
996 line *following* the #include. A separate location_t for this
997 location makes no sense, until we do the LC_LEAVE.
999 This does not apply if we found a PCH file, we're not a regular
1000 include, or we ran out of locations. */
1001 bool decrement = (file->pchname == NULL
1002 && type < IT_DIRECTIVE_HWM
1003 && (pfile->line_table->highest_location
1004 != LINE_MAP_MAX_LOCATION - 1));
1005 if (decrement)
1006 pfile->line_table->highest_location--;
1008 if (file->header_unit <= 0)
1009 /* Add line map and do callbacks. */
1010 _cpp_do_file_change (pfile, LC_ENTER, file->path,
1011 /* With preamble injection, start on line zero,
1012 so the preamble doesn't appear to have been
1013 included from line 1. Likewise when
1014 starting preprocessed, we expect an initial
1015 locating line. */
1016 type == IT_PRE_MAIN ? 0 : 1, sysp);
1017 else if (decrement)
1019 /* Adjust the line back one so we appear on the #include line itself. */
1020 const line_map_ordinary *map
1021 = LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table);
1022 linenum_type line = SOURCE_LINE (map, pfile->line_table->highest_line);
1023 linemap_line_start (pfile->line_table, line - 1, 0);
1026 return true;
1029 /* Mark FILE to be included once only. */
1030 void
1031 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
1033 pfile->seen_once_only = true;
1034 file->once_only = true;
1037 /* Return the directory from which searching for FNAME should start,
1038 considering the directive TYPE and ANGLE_BRACKETS. If there is
1039 nothing left in the path, returns NULL. */
1040 static struct cpp_dir *
1041 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
1042 enum include_type type)
1044 cpp_dir *dir;
1045 _cpp_file *file;
1047 if (IS_ABSOLUTE_PATH (fname))
1048 return &pfile->no_search_path;
1050 /* pfile->buffer is NULL when processing an -include command-line flag. */
1051 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
1053 /* For #include_next, skip in the search path past the dir in which
1054 the current file was found, but if it was found via an absolute
1055 path use the normal search logic. */
1056 if (type == IT_INCLUDE_NEXT && file->dir
1057 && file->dir != &pfile->no_search_path)
1058 dir = file->dir->next;
1059 else if (angle_brackets)
1060 dir = pfile->bracket_include;
1061 else if (type == IT_CMDLINE)
1062 /* -include and -imacros use the #include "" chain with the
1063 preprocessor's cwd prepended. */
1064 return make_cpp_dir (pfile, "./", false);
1065 else if (pfile->quote_ignores_source_dir)
1066 dir = pfile->quote_include;
1067 else
1068 return make_cpp_dir (pfile, dir_name_of_file (file),
1069 pfile->buffer ? pfile->buffer->sysp : 0);
1071 if (dir == NULL)
1072 cpp_error (pfile, CPP_DL_ERROR,
1073 "no include path in which to search for %s", fname);
1075 return dir;
1078 /* Strip the basename from the file's path. It ends with a slash if
1079 of nonzero length. Note that this procedure also works for
1080 <stdin>, which is represented by the empty string. */
1081 static const char *
1082 dir_name_of_file (_cpp_file *file)
1084 if (!file->dir_name)
1086 size_t len = lbasename (file->path) - file->path;
1087 char *dir_name = XNEWVEC (char, len + 1);
1089 memcpy (dir_name, file->path, len);
1090 dir_name[len] = '\0';
1091 file->dir_name = dir_name;
1094 return file->dir_name;
1097 /* Handles #include-family directives (distinguished by TYPE),
1098 including HEADER, and the command line -imacros and -include.
1099 Returns true if a buffer was stacked. */
1100 bool
1101 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
1102 enum include_type type, location_t loc)
1104 /* For -include command-line flags we have type == IT_CMDLINE.
1105 When the first -include file is processed we have the case, where
1106 pfile->cur_token == pfile->cur_run->base, we are directly called up
1107 by the front end. However in the case of the second -include file,
1108 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1109 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1110 and pfile->cur_token[-1].src_loc not (yet) initialized.
1111 However, when the include file cannot be found, we need src_loc to
1112 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1113 if (type == IT_CMDLINE && pfile->cur_token != pfile->cur_run->base)
1114 pfile->cur_token[-1].src_loc = 0;
1116 cpp_dir *dir = search_path_head (pfile, fname, angle_brackets, type);
1117 if (!dir)
1118 return false;
1120 _cpp_file *file = _cpp_find_file (pfile, fname, dir, angle_brackets,
1121 type == IT_DEFAULT ? _cpp_FFK_PRE_INCLUDE
1122 : _cpp_FFK_NORMAL, loc);
1123 if (type == IT_DEFAULT && file == NULL)
1124 return false;
1126 return _cpp_stack_file (pfile, file, type, loc);
1129 /* NAME is a header file name, find the _cpp_file, if any. */
1131 static _cpp_file *
1132 test_header_unit (cpp_reader *pfile, const char *name, bool angle,
1133 location_t loc)
1135 if (cpp_dir *dir = search_path_head (pfile, name, angle, IT_INCLUDE))
1136 return _cpp_find_file (pfile, name, dir, angle, _cpp_FFK_NORMAL, loc);
1138 return nullptr;
1141 /* NAME is a header file name, find the path we'll use to open it and infer that
1142 it is a header-unit. */
1144 const char *
1145 _cpp_find_header_unit (cpp_reader *pfile, const char *name, bool angle,
1146 location_t loc)
1148 if (_cpp_file *file = test_header_unit (pfile, name, angle, loc))
1150 if (file->fd > 0)
1152 /* Don't leave it open. */
1153 close (file->fd);
1154 file->fd = 0;
1157 file->header_unit = +1;
1158 _cpp_mark_file_once_only (pfile, file);
1160 return file->path;
1163 return nullptr;
1166 /* NAME is a header file name, find the path we'll use to open it. But do not
1167 infer it is a header unit. */
1169 const char *
1170 cpp_probe_header_unit (cpp_reader *pfile, const char *name, bool angle,
1171 location_t loc)
1173 if (_cpp_file *file = test_header_unit (pfile, name, angle, loc))
1174 return file->path;
1176 return nullptr;
1179 /* Retrofit the just-entered main file asif it was an include. This
1180 will permit correct include_next use, and mark it as a system
1181 header if that's where it resides. We use filesystem-appropriate
1182 prefix matching of the include path to locate the main file. */
1183 void
1184 cpp_retrofit_as_include (cpp_reader *pfile)
1186 /* We should be the outermost. */
1187 gcc_assert (!pfile->buffer->prev);
1189 if (const char *name = pfile->main_file->name)
1191 /* Locate name on the include dir path, using a prefix match. */
1192 size_t name_len = strlen (name);
1193 for (cpp_dir *dir = pfile->quote_include; dir; dir = dir->next)
1194 if (dir->len < name_len
1195 && IS_DIR_SEPARATOR (name[dir->len])
1196 && !filename_ncmp (name, dir->name, dir->len))
1198 pfile->main_file->dir = dir;
1199 if (dir->sysp)
1200 cpp_make_system_header (pfile, 1, 0);
1201 break;
1205 /* Initialize controlling macro state. */
1206 pfile->mi_valid = true;
1207 pfile->mi_cmacro = 0;
1210 /* Could not open FILE. The complication is dependency output. */
1211 static void
1212 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets,
1213 location_t loc)
1215 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
1216 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
1218 errno = file->err_no;
1219 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
1221 deps_add_dep (pfile->deps, file->name);
1222 /* If the preprocessor output (other than dependency information) is
1223 being used, we must also flag an error. */
1224 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
1225 cpp_errno_filename (pfile, CPP_DL_FATAL,
1226 file->path ? file->path : file->name,
1227 loc);
1229 else
1231 /* If we are not outputting dependencies, or if we are and dependencies
1232 were requested for this file, or if preprocessor output is needed
1233 in addition to dependency information, this is an error.
1235 Otherwise (outputting dependencies but not for this file, and not
1236 using the preprocessor output), we can still produce correct output
1237 so it's only a warning. */
1238 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
1239 || print_dep
1240 || CPP_OPTION (pfile, deps.need_preprocessor_output))
1241 cpp_errno_filename (pfile, CPP_DL_FATAL,
1242 file->path ? file->path : file->name,
1243 loc);
1244 else
1245 cpp_errno_filename (pfile, CPP_DL_WARNING,
1246 file->path ? file->path : file->name,
1247 loc);
1251 /* Search in the chain beginning at HEAD for a file whose search path
1252 started at START_DIR != NULL. */
1253 static struct cpp_file_hash_entry *
1254 search_cache (struct cpp_file_hash_entry *head, const cpp_dir *start_dir)
1256 while (head && head->start_dir != start_dir)
1257 head = head->next;
1259 return head;
1262 /* Allocate a new _cpp_file structure. */
1263 static _cpp_file *
1264 make_cpp_file (cpp_dir *dir, const char *fname)
1266 _cpp_file *file = XCNEW (_cpp_file);
1267 file->fd = -1;
1268 file->dir = dir;
1269 file->name = xstrdup (fname);
1271 return file;
1274 /* Release a _cpp_file structure. */
1275 static void
1276 destroy_cpp_file (_cpp_file *file)
1278 free ((void *) file->buffer_start);
1279 free ((void *) file->name);
1280 free ((void *) file->path);
1281 free (file);
1284 /* Release all the files allocated by this reader. */
1285 static void
1286 destroy_all_cpp_files (cpp_reader *pfile)
1288 _cpp_file *iter = pfile->all_files;
1289 while (iter)
1291 _cpp_file *next = iter->next_file;
1292 destroy_cpp_file (iter);
1293 iter = next;
1297 /* A hash of directory names. The directory names are the path names
1298 of files which contain a #include "", the included file name is
1299 appended to this directories.
1301 To avoid duplicate entries we follow the convention that all
1302 non-empty directory names should end in a '/'. DIR_NAME must be
1303 stored in permanently allocated memory. */
1304 static cpp_dir *
1305 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1307 struct cpp_file_hash_entry *entry, **hash_slot;
1308 cpp_dir *dir;
1310 hash_slot = (struct cpp_file_hash_entry **)
1311 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1312 htab_hash_string (dir_name),
1313 INSERT);
1315 /* Have we already hashed this directory? */
1316 for (entry = *hash_slot; entry; entry = entry->next)
1317 if (entry->start_dir == NULL)
1318 return entry->u.dir;
1320 dir = XCNEW (cpp_dir);
1321 dir->next = pfile->quote_include;
1322 dir->name = (char *) dir_name;
1323 dir->len = strlen (dir_name);
1324 dir->sysp = sysp;
1325 dir->construct = 0;
1327 /* Store this new result in the hash table. */
1328 entry = new_file_hash_entry (pfile);
1329 entry->next = *hash_slot;
1330 entry->start_dir = NULL;
1331 entry->location = pfile->line_table->highest_location;
1332 entry->u.dir = dir;
1333 *hash_slot = entry;
1335 return dir;
1338 /* Create a new block of memory for file hash entries. */
1339 static void
1340 allocate_file_hash_entries (cpp_reader *pfile)
1342 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1343 pool->file_hash_entries_used = 0;
1344 pool->next = pfile->file_hash_entries;
1345 pfile->file_hash_entries = pool;
1348 /* Return a new file hash entry. */
1349 static struct cpp_file_hash_entry *
1350 new_file_hash_entry (cpp_reader *pfile)
1352 unsigned int idx;
1353 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1354 allocate_file_hash_entries (pfile);
1356 idx = pfile->file_hash_entries->file_hash_entries_used++;
1357 return &pfile->file_hash_entries->pool[idx];
1360 /* Free the file hash entry pools. */
1361 static void
1362 free_file_hash_entries (cpp_reader *pfile)
1364 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1365 while (iter)
1367 struct file_hash_entry_pool *next = iter->next;
1368 free (iter);
1369 iter = next;
1373 /* Returns TRUE if a file FNAME has ever been successfully opened.
1374 This routine is not intended to correctly handle filenames aliased
1375 by links or redundant . or .. traversals etc. */
1376 bool
1377 cpp_included (cpp_reader *pfile, const char *fname)
1379 struct cpp_file_hash_entry *entry;
1381 entry = (struct cpp_file_hash_entry *)
1382 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1384 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1385 entry = entry->next;
1387 return entry != NULL;
1390 /* Returns TRUE if a file FNAME has ever been successfully opened
1391 before LOCATION. This routine is not intended to correctly handle
1392 filenames aliased by links or redundant . or .. traversals etc. */
1393 bool
1394 cpp_included_before (cpp_reader *pfile, const char *fname,
1395 location_t location)
1397 struct cpp_file_hash_entry *entry
1398 = (struct cpp_file_hash_entry *)
1399 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1401 if (IS_ADHOC_LOC (location))
1402 location = get_location_from_adhoc_loc (pfile->line_table, location);
1404 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1405 || entry->location > location))
1406 entry = entry->next;
1408 return entry != NULL;
1411 /* Calculate the hash value of a file hash entry P. */
1413 static hashval_t
1414 file_hash_hash (const void *p)
1416 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1417 const char *hname;
1418 if (entry->start_dir)
1419 hname = entry->u.file->name;
1420 else
1421 hname = entry->u.dir->name;
1423 return htab_hash_string (hname);
1426 /* Compare a string Q against a file hash entry P. */
1427 static int
1428 file_hash_eq (const void *p, const void *q)
1430 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) p;
1431 const char *fname = (const char *) q;
1432 const char *hname;
1434 if (entry->start_dir)
1435 hname = entry->u.file->name;
1436 else
1437 hname = entry->u.dir->name;
1439 return filename_cmp (hname, fname) == 0;
1442 /* Compare entries in the nonexistent file hash table. These are just
1443 strings. */
1444 static int
1445 nonexistent_file_hash_eq (const void *p, const void *q)
1447 return filename_cmp ((const char *) p, (const char *) q) == 0;
1450 /* Initialize everything in this source file. */
1451 void
1452 _cpp_init_files (cpp_reader *pfile)
1454 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1455 NULL, xcalloc, free);
1456 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1457 NULL, xcalloc, free);
1458 allocate_file_hash_entries (pfile);
1459 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1460 nonexistent_file_hash_eq,
1461 NULL, xcalloc, free);
1462 obstack_specify_allocation (&pfile->nonexistent_file_ob, 0, 0,
1463 xmalloc, free);
1466 /* Finalize everything in this source file. */
1467 void
1468 _cpp_cleanup_files (cpp_reader *pfile)
1470 htab_delete (pfile->file_hash);
1471 htab_delete (pfile->dir_hash);
1472 htab_delete (pfile->nonexistent_file_hash);
1473 obstack_free (&pfile->nonexistent_file_ob, 0);
1474 free_file_hash_entries (pfile);
1475 destroy_all_cpp_files (pfile);
1478 /* Make the parser forget about files it has seen. This can be useful
1479 for resetting the parser to start another run. */
1480 void
1481 cpp_clear_file_cache (cpp_reader *pfile)
1483 _cpp_cleanup_files (pfile);
1484 pfile->file_hash_entries = NULL;
1485 pfile->all_files = NULL;
1486 _cpp_init_files (pfile);
1489 /* Enter a file name in the hash for the sake of cpp_included. */
1490 void
1491 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1493 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, 0, _cpp_FFK_FAKE, 0);
1496 /* Not everyone who wants to set system-header-ness on a buffer can
1497 see the details of a buffer. This is an exported interface because
1498 fix-header needs it. */
1499 void
1500 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1502 int flags = 0;
1503 const class line_maps *line_table = pfile->line_table;
1504 const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1505 /* 1 = system header, 2 = system header to be treated as C. */
1506 if (syshdr)
1507 flags = 1 + (externc != 0);
1508 pfile->buffer->sysp = flags;
1509 _cpp_do_file_change (pfile, LC_RENAME, ORDINARY_MAP_FILE_NAME (map),
1510 SOURCE_LINE (map, pfile->line_table->highest_line),
1511 flags);
1514 /* Allow the client to change the current file. Used by the front end
1515 to achieve pseudo-file names like <built-in>.
1516 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1517 void
1518 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1519 const char *new_name)
1521 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1524 struct report_missing_guard_data
1526 cpp_reader *pfile;
1527 const char **paths;
1528 size_t count;
1531 /* Callback function for htab_traverse. */
1532 static int
1533 report_missing_guard (void **slot, void *d)
1535 struct cpp_file_hash_entry *entry = (struct cpp_file_hash_entry *) *slot;
1536 struct report_missing_guard_data *data
1537 = (struct report_missing_guard_data *) d;
1539 /* Skip directories. */
1540 if (entry->start_dir != NULL)
1542 _cpp_file *file = entry->u.file;
1544 /* We don't want MI guard advice for the main file. */
1545 if (!file->once_only
1546 && file->cmacro == NULL
1547 && file->stack_count == 1
1548 && data->pfile->main_file != file)
1550 if (data->paths == NULL)
1552 data->paths = XCNEWVEC (const char *, data->count);
1553 data->count = 0;
1556 data->paths[data->count++] = file->path;
1560 /* Keep traversing the hash table. */
1561 return 1;
1564 /* Comparison function for qsort. */
1565 static int
1566 report_missing_guard_cmp (const void *p1, const void *p2)
1568 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1571 /* Report on all files that might benefit from a multiple include guard.
1572 Triggered by -H. */
1573 void
1574 _cpp_report_missing_guards (cpp_reader *pfile)
1576 struct report_missing_guard_data data;
1578 data.pfile = pfile;
1579 data.paths = NULL;
1580 data.count = htab_elements (pfile->file_hash);
1581 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1583 if (data.paths != NULL)
1585 size_t i;
1587 /* Sort the paths to avoid outputting them in hash table
1588 order. */
1589 qsort (data.paths, data.count, sizeof (const char *),
1590 report_missing_guard_cmp);
1591 fputs (_("Multiple include guards may be useful for:\n"),
1592 stderr);
1593 for (i = 0; i < data.count; i++)
1595 fputs (data.paths[i], stderr);
1596 putc ('\n', stderr);
1598 free (data.paths);
1602 /* Locate HEADER, and determine whether it is newer than the current
1603 file. If it cannot be located or dated, return -1, if it is
1604 newer, return 1, otherwise 0. */
1606 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1607 int angle_brackets)
1609 _cpp_file *file;
1610 struct cpp_dir *dir;
1612 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1613 if (!dir)
1614 return -1;
1616 file = _cpp_find_file (pfile, fname, dir, angle_brackets, _cpp_FFK_NORMAL, 0);
1617 if (file->err_no)
1618 return -1;
1620 if (file->fd != -1)
1622 close (file->fd);
1623 file->fd = -1;
1626 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1629 /* Pushes the given file onto the buffer stack. Returns nonzero if
1630 successful. */
1631 bool
1632 cpp_push_include (cpp_reader *pfile, const char *fname)
1634 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE,
1635 pfile->line_table->highest_line);
1638 /* Pushes the given file, implicitly included at the start of a
1639 compilation, onto the buffer stack but without any errors if the
1640 file is not found. Returns nonzero if successful. */
1641 bool
1642 cpp_push_default_include (cpp_reader *pfile, const char *fname)
1644 return _cpp_stack_include (pfile, fname, true, IT_DEFAULT,
1645 pfile->line_table->highest_line);
1648 /* Do appropriate cleanup when a file INC's buffer is popped off the
1649 input stack. */
1650 void
1651 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file,
1652 const unsigned char *to_free)
1654 /* Record the inclusion-preventing macro, which could be NULL
1655 meaning no controlling macro. */
1656 if (pfile->mi_valid && file->cmacro == NULL)
1657 file->cmacro = pfile->mi_cmacro;
1659 /* Invalidate control macros in the #including file. */
1660 pfile->mi_valid = false;
1662 if (to_free)
1664 if (to_free == file->buffer_start)
1666 file->buffer_start = NULL;
1667 file->buffer = NULL;
1668 file->buffer_valid = false;
1670 free ((void *) to_free);
1674 /* Return the file name associated with FILE. */
1675 const char *
1676 _cpp_get_file_name (_cpp_file *file)
1678 return file->name;
1681 /* Inteface to file statistics record in _cpp_file structure. */
1682 struct stat *
1683 _cpp_get_file_stat (_cpp_file *file)
1685 return &file->st;
1688 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1689 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1690 directory of the including file.
1692 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1693 void
1694 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1695 int quote_ignores_source_dir)
1697 pfile->quote_include = quote;
1698 pfile->bracket_include = quote;
1699 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1701 for (; quote; quote = quote->next)
1703 quote->name_map = NULL;
1704 quote->len = strlen (quote->name);
1705 if (quote == bracket)
1706 pfile->bracket_include = bracket;
1710 /* Append the file name to the directory to create the path, but don't
1711 turn / into // or // into ///; // may be a namespace escape. */
1712 static char *
1713 append_file_to_dir (const char *fname, cpp_dir *dir)
1715 size_t dlen, flen;
1716 char *path;
1718 dlen = dir->len;
1719 flen = strlen (fname);
1720 path = XNEWVEC (char, dlen + 1 + flen + 1);
1721 memcpy (path, dir->name, dlen);
1722 if (dlen && !IS_DIR_SEPARATOR (path[dlen - 1]))
1723 path[dlen++] = '/';
1724 memcpy (&path[dlen], fname, flen + 1);
1726 return path;
1729 /* Read a space delimited string of unlimited length from a stdio
1730 file F. */
1731 static char *
1732 read_filename_string (int ch, FILE *f)
1734 char *alloc, *set;
1735 int len;
1737 len = 20;
1738 set = alloc = XNEWVEC (char, len + 1);
1739 if (! is_space (ch))
1741 *set++ = ch;
1742 while ((ch = getc (f)) != EOF && ! is_space (ch))
1744 if (set - alloc == len)
1746 len *= 2;
1747 alloc = XRESIZEVEC (char, alloc, len + 1);
1748 set = alloc + len / 2;
1750 *set++ = ch;
1753 *set = '\0';
1754 ungetc (ch, f);
1755 return alloc;
1758 /* Read the file name map file for DIR. */
1759 static void
1760 read_name_map (cpp_dir *dir)
1762 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1763 char *name;
1764 FILE *f;
1765 size_t len, count = 0, room = 9;
1767 len = dir->len;
1768 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1769 memcpy (name, dir->name, len);
1770 if (len && !IS_DIR_SEPARATOR (name[len - 1]))
1771 name[len++] = '/';
1772 strcpy (name + len, FILE_NAME_MAP_FILE);
1773 f = fopen (name, "r");
1775 dir->name_map = XNEWVEC (const char *, room);
1777 /* Silently return NULL if we cannot open. */
1778 if (f)
1780 int ch;
1782 while ((ch = getc (f)) != EOF)
1784 char *to;
1786 if (is_space (ch))
1787 continue;
1789 if (count + 2 > room)
1791 room += 8;
1792 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1795 dir->name_map[count] = read_filename_string (ch, f);
1796 while ((ch = getc (f)) != EOF && is_hspace (ch))
1799 to = read_filename_string (ch, f);
1800 if (IS_ABSOLUTE_PATH (to))
1801 dir->name_map[count + 1] = to;
1802 else
1804 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1805 free (to);
1808 count += 2;
1809 while ((ch = getc (f)) != '\n')
1810 if (ch == EOF)
1811 break;
1814 fclose (f);
1817 /* Terminate the list of maps. */
1818 dir->name_map[count] = NULL;
1821 /* Remap a FILE's name based on the file_name_map, if any, for
1822 FILE->dir. If the file name has any directory separators,
1823 recursively check those directories too. */
1824 static char *
1825 remap_filename (cpp_reader *pfile, _cpp_file *file)
1827 const char *fname, *p;
1828 char *new_dir, *p3;
1829 cpp_dir *dir;
1830 size_t index, len;
1832 dir = file->dir;
1833 fname = file->name;
1835 for (;;)
1837 if (!dir->name_map)
1838 read_name_map (dir);
1840 for (index = 0; dir->name_map[index]; index += 2)
1841 if (!filename_cmp (dir->name_map[index], fname))
1842 return xstrdup (dir->name_map[index + 1]);
1843 if (IS_ABSOLUTE_PATH (fname))
1844 return NULL;
1845 p = strchr (fname, '/');
1846 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1848 const char *p2 = strchr (fname, '\\');
1849 if (!p || (p2 && p > p2))
1850 p = p2;
1852 #endif
1853 if (!p || p == fname)
1854 return NULL;
1856 len = dir->len + (p - fname + 1);
1857 new_dir = XNEWVEC (char, len + 2);
1858 p3 = new_dir + dir->len;
1859 memcpy (new_dir, dir->name, dir->len);
1860 if (dir->len && !IS_DIR_SEPARATOR (dir->name[dir->len - 1]))
1862 *p3++ = '/';
1863 len++;
1865 memcpy (p3, fname, p - fname + 1);
1866 new_dir[len] = '\0';
1868 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1869 fname = p + 1;
1873 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1874 static bool
1875 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1877 const char *saved_path = file->path;
1878 bool valid = false;
1880 file->path = pchname;
1881 if (open_file (file))
1883 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1885 if (!valid)
1887 close (file->fd);
1888 file->fd = -1;
1891 if (CPP_OPTION (pfile, print_include_names))
1893 unsigned int i;
1894 for (i = 1; i < pfile->line_table->depth; i++)
1895 putc ('.', stderr);
1896 fprintf (stderr, "%c %s\n",
1897 valid ? '!' : 'x', pchname);
1901 file->path = saved_path;
1902 return valid;
1905 /* Get the path associated with the _cpp_file F. The path includes
1906 the base name from the include directive and the directory it was
1907 found in via the search path. */
1909 const char *
1910 cpp_get_path (struct _cpp_file *f)
1912 return f->path;
1915 /* Get the directory associated with the _cpp_file F. */
1917 cpp_dir *
1918 cpp_get_dir (struct _cpp_file *f)
1920 return f->dir;
1923 /* Get the cpp_buffer currently associated with the cpp_reader
1924 PFILE. */
1926 cpp_buffer *
1927 cpp_get_buffer (cpp_reader *pfile)
1929 return pfile->buffer;
1932 /* Get the _cpp_file associated with the cpp_buffer B. */
1934 _cpp_file *
1935 cpp_get_file (cpp_buffer *b)
1937 return b->file;
1940 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1941 buffer is the buffer that included the given buffer. */
1943 cpp_buffer *
1944 cpp_get_prev (cpp_buffer *b)
1946 return b->prev;
1949 /* This data structure holds the list of header files that were seen
1950 while the PCH was being built. The 'entries' field is kept sorted
1951 in memcmp() order; yes, this means that on little-endian systems,
1952 it's sorted initially by the least-significant byte of 'size', but
1953 that's OK. The code does rely on having entries with the same size
1954 next to each other. */
1956 struct pchf_entry {
1957 /* The size of this file. This is used to save running a MD5 checksum
1958 if the sizes don't match. */
1959 off_t size;
1960 /* The MD5 checksum of this file. */
1961 unsigned char sum[16];
1962 /* Is this file to be included only once? */
1963 bool once_only;
1966 struct pchf_data {
1967 /* Number of pchf_entry structures. */
1968 size_t count;
1970 /* Are there any values with once_only set?
1971 This is used as an optimisation, it means we don't have to search
1972 the structure if we're processing a regular #include. */
1973 bool have_once_only;
1975 struct pchf_entry entries[1];
1978 static struct pchf_data *pchf;
1980 /* A qsort ordering function for pchf_entry structures. */
1982 static int
1983 pchf_save_compare (const void *e1, const void *e2)
1985 return memcmp (e1, e2, sizeof (struct pchf_entry));
1988 /* Create and write to F a pchf_data structure. */
1990 bool
1991 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1993 size_t count = 0;
1994 struct pchf_data *result;
1995 size_t result_size;
1996 _cpp_file *f;
1997 bool ret;
1999 for (f = pfile->all_files; f; f = f->next_file)
2000 ++count;
2002 result_size = (sizeof (struct pchf_data)
2003 + sizeof (struct pchf_entry) * (count - 1));
2004 result = XCNEWVAR (struct pchf_data, result_size);
2006 result->count = 0;
2007 result->have_once_only = false;
2009 for (f = pfile->all_files; f; f = f->next_file)
2011 size_t count;
2013 /* This should probably never happen, since if a read error occurred
2014 the PCH file shouldn't be written... */
2015 if (f->dont_read || f->err_no)
2016 continue;
2018 if (f->stack_count == 0)
2019 continue;
2021 count = result->count++;
2023 result->entries[count].once_only = f->once_only;
2024 /* |= is avoided in the next line because of an HP C compiler bug */
2025 result->have_once_only = result->have_once_only | f->once_only;
2026 if (f->buffer_valid)
2027 md5_buffer ((const char *)f->buffer,
2028 f->st.st_size, result->entries[count].sum);
2029 else
2031 FILE *ff;
2032 int oldfd = f->fd;
2034 if (!open_file (f))
2036 open_file_failed (pfile, f, 0, 0);
2037 free (result);
2038 return false;
2040 ff = fdopen (f->fd, "rb");
2041 md5_stream (ff, result->entries[count].sum);
2042 fclose (ff);
2043 f->fd = oldfd;
2045 result->entries[count].size = f->st.st_size;
2048 result_size = (sizeof (struct pchf_data)
2049 + sizeof (struct pchf_entry) * (result->count - 1));
2051 qsort (result->entries, result->count, sizeof (struct pchf_entry),
2052 pchf_save_compare);
2054 ret = fwrite (result, result_size, 1, fp) == 1;
2055 free (result);
2056 return ret;
2059 /* Read the pchf_data structure from F. */
2061 bool
2062 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
2064 struct pchf_data d;
2066 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
2067 != 1)
2068 return false;
2070 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
2071 + sizeof (struct pchf_entry) * (d.count - 1));
2072 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
2073 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
2074 != d.count)
2075 return false;
2076 return true;
2079 /* The parameters for pchf_compare. */
2081 struct pchf_compare_data
2083 /* The size of the file we're looking for. */
2084 off_t size;
2086 /* The MD5 checksum of the file, if it's been computed. */
2087 unsigned char sum[16];
2089 /* Is SUM valid? */
2090 bool sum_computed;
2092 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
2093 bool check_included;
2095 /* The file that we're searching for. */
2096 _cpp_file *f;
2099 /* bsearch comparison function; look for D_P in E_P. */
2101 static int
2102 pchf_compare (const void *d_p, const void *e_p)
2104 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
2105 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
2106 int result;
2108 result = memcmp (&d->size, &e->size, sizeof (off_t));
2109 if (result != 0)
2110 return result;
2112 if (! d->sum_computed)
2114 _cpp_file *const f = d->f;
2116 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
2117 d->sum_computed = true;
2120 result = memcmp (d->sum, e->sum, 16);
2121 if (result != 0)
2122 return result;
2124 if (d->check_included || e->once_only)
2125 return 0;
2126 else
2127 return 1;
2130 /* Check that F is not in a list read from a PCH file (if any).
2131 Assumes that f->buffer_valid is true. Return TRUE if the file
2132 should not be read. */
2134 static bool
2135 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
2136 _cpp_file *f,
2137 bool check_included)
2139 struct pchf_compare_data d;
2141 if (pchf == NULL
2142 || (! check_included && ! pchf->have_once_only))
2143 return false;
2145 d.size = f->st.st_size;
2146 d.sum_computed = false;
2147 d.f = f;
2148 d.check_included = check_included;
2149 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
2150 pchf_compare) != NULL;
2153 /* Return true if the file FNAME is found in the appropriate include file path
2154 as indicated by ANGLE_BRACKETS. */
2156 bool
2157 _cpp_has_header (cpp_reader *pfile, const char *fname, int angle_brackets,
2158 enum include_type type)
2160 cpp_dir *start_dir = search_path_head (pfile, fname, angle_brackets, type);
2161 _cpp_file *file = _cpp_find_file (pfile, fname, start_dir, angle_brackets,
2162 _cpp_FFK_HAS_INCLUDE, 0);
2163 return file->err_no != ENOENT;
2166 /* Read a file and convert to input charset, the same as if it were being read
2167 by a cpp_reader. */
2169 cpp_converted_source
2170 cpp_get_converted_source (const char *fname, const char *input_charset)
2172 cpp_converted_source res = {};
2173 _cpp_file file = {};
2174 file.fd = -1;
2175 file.name = lbasename (fname);
2176 file.path = fname;
2177 if (!open_file (&file))
2178 return res;
2179 const bool ok = read_file_guts (NULL, &file, 0, input_charset);
2180 close (file.fd);
2181 if (!ok)
2182 return res;
2183 res.to_free = (char *) file.buffer_start;
2184 res.data = (char *) file.buffer;
2185 res.len = file.st.st_size;
2186 return res;