1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2024 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
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/>. */
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. */
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)
39 # define STAT_SIZE_RELIABLE(ST) true
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)
48 # define set_stdin_to_binary_mode() /* Nothing */
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. */
56 /* Filename as given to #include or command line switch. */
59 /* The full path used to find the file. */
62 /* The full path of the pch file. */
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
69 /* Chain through all files. */
70 struct _cpp_file
*next_file
;
72 /* The contents of NAME after calling read_file(). */
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
87 /* As filled in by stat(2) for the file. */
90 /* File descriptor. Invalid if -1, otherwise open. */
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
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. */
103 /* If read() failed before. */
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 */
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
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
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
;
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
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
,
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
,
183 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
184 int angle_brackets
, enum include_type
,
185 bool suppress_diagnostic
= false);
186 static const char *dir_name_of_file (_cpp_file
*file
);
187 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int,
189 static struct cpp_file_hash_entry
*search_cache (struct cpp_file_hash_entry
*head
,
190 const cpp_dir
*start_dir
);
191 static _cpp_file
*make_cpp_file (cpp_dir
*, const char *fname
);
192 static void destroy_cpp_file (_cpp_file
*);
193 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
194 static void allocate_file_hash_entries (cpp_reader
*pfile
);
195 static struct cpp_file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
196 static int report_missing_guard (void **slot
, void *b
);
197 static hashval_t
file_hash_hash (const void *p
);
198 static int file_hash_eq (const void *p
, const void *q
);
199 static char *read_filename_string (int ch
, FILE *f
);
200 static void read_name_map (cpp_dir
*dir
);
201 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
202 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
203 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
204 static int pchf_save_compare (const void *e1
, const void *e2
);
205 static int pchf_compare (const void *d_p
, const void *e_p
);
206 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
208 /* Given a filename in FILE->PATH, with the empty string interpreted
211 On success FILE contains an open file descriptor and stat
212 information for the file. On failure the file descriptor is -1 and
213 the appropriate errno is also stored in FILE. Returns TRUE iff
216 We used to open files in nonblocking mode, but that caused more
217 problems than it solved. Do take care not to acquire a controlling
218 terminal by mistake (this can't happen on sane systems, but
219 paranoia is a virtue).
221 Use the three-argument form of open even though we aren't
222 specifying O_CREAT, to defend against broken system headers.
224 O_BINARY tells some runtime libraries (notably DJGPP) not to do
225 newline translation; we can handle DOS line breaks just fine
228 open_file (_cpp_file
*file
)
230 if (file
->path
[0] == '\0')
233 set_stdin_to_binary_mode ();
236 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
240 if (fstat (file
->fd
, &file
->st
) == 0)
242 if (!S_ISDIR (file
->st
.st_mode
))
248 /* Ignore a directory and continue the search. The file we're
249 looking for may be elsewhere in the search path. */
256 #if defined(_WIN32) && !defined(__CYGWIN__)
257 else if (errno
== EACCES
)
259 /* On most UNIX systems, open succeeds on a directory. Above,
260 we check if we have opened a directory and if so, set errno
261 to ENOENT. However, on Windows, opening a directory
262 fails with EACCES. We want to return ENOENT in that
264 if (stat (file
->path
, &file
->st
) == 0
265 && S_ISDIR (file
->st
.st_mode
))
268 /* The call to stat may have reset errno. */
272 else if (errno
== ENOTDIR
)
275 file
->err_no
= errno
;
280 /* Temporary PCH intercept of opening a file. Try to find a PCH file
281 based on FILE->name and FILE->dir, and test those found for
282 validity using PFILE->cb.valid_pch. Return true iff a valid file is
283 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
286 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
288 static const char extension
[] = ".gch";
289 const char *path
= file
->path
;
295 /* No PCH on <stdin> or if not requested. */
296 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
299 /* If the file is not included as first include from either the toplevel
300 file or the command-line it is not a valid use of PCH. */
301 for (_cpp_file
*f
= pfile
->all_files
; f
; f
= f
->next_file
)
302 if (f
->implicit_preinclude
)
304 else if (pfile
->main_file
== f
)
309 flen
= strlen (path
);
310 len
= flen
+ sizeof (extension
);
311 pchname
= XNEWVEC (char, len
);
312 memcpy (pchname
, path
, flen
);
313 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
315 if (stat (pchname
, &st
) == 0)
319 size_t dlen
, plen
= len
;
321 if (!S_ISDIR (st
.st_mode
))
322 valid
= validate_pch (pfile
, file
, pchname
);
323 else if ((pchdir
= opendir (pchname
)) != NULL
)
325 pchname
[plen
- 1] = '/';
326 while ((d
= readdir (pchdir
)) != NULL
)
328 dlen
= strlen (d
->d_name
) + 1;
329 if ((strcmp (d
->d_name
, ".") == 0)
330 || (strcmp (d
->d_name
, "..") == 0))
332 if (dlen
+ plen
> len
)
335 pchname
= XRESIZEVEC (char, pchname
, len
);
337 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
338 valid
= validate_pch (pfile
, file
, pchname
);
349 file
->pchname
= pchname
;
356 /* Canonicalize the path to FILE. Return the canonical form if it is
357 shorter, otherwise return NULL. This function does NOT free the
358 memory pointed by FILE. */
361 maybe_shorter_path (const char * file
)
363 char * file2
= lrealpath (file
);
364 if (file2
&& strlen (file2
) < strlen (file
))
375 /* Try to open the path FILE->name appended to FILE->dir. This is
376 where remap and PCH intercept the file lookup process. Return true
377 if the file was found, whether or not the open was successful.
378 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
379 Use LOC when emitting any diagnostics. */
382 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
,
387 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
390 if (file
->dir
->construct
)
391 path
= file
->dir
->construct (file
->name
, file
->dir
);
393 path
= append_file_to_dir (file
->name
, file
->dir
);
401 /* We try to canonicalize system headers. For DOS based file
402 * system, we always try to shorten non-system headers, as DOS
403 * has a tighter constraint on max path length. */
404 if ((CPP_OPTION (pfile
, canonical_system_headers
) && file
->dir
->sysp
)
405 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
410 char * canonical_path
= maybe_shorter_path (path
);
413 /* The canonical path was newly allocated. Let's free the
414 non-canonical one. */
416 path
= canonical_path
;
420 hv
= htab_hash_string (path
);
421 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
423 file
->err_no
= ENOENT
;
428 if (pch_open_file (pfile
, file
, invalid_pch
))
431 if (open_file (file
))
434 if (file
->err_no
!= ENOENT
)
436 open_file_failed (pfile
, file
, 0, loc
);
440 /* We copy the path name onto an obstack partly so that we don't
441 leak the memory, but mostly so that we don't fragment the
443 copy
= (char *) obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
446 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
450 file
->path
= file
->name
;
454 file
->err_no
= ENOENT
;
461 /* Return true iff the missing_header callback found the given HEADER. */
463 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
465 missing_header_cb func
= pfile
->cb
.missing_header
;
467 /* When the regular search path doesn't work, try context dependent
468 headers search paths. */
470 && file
->dir
== NULL
)
472 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
474 if (open_file (file
))
476 free ((void *)file
->path
);
478 file
->path
= file
->name
;
485 _cpp_find_failed (_cpp_file
*file
)
487 return file
->err_no
!= 0;
490 /* Given a filename FNAME search for such a file in the include path
491 starting from START_DIR. If FNAME is the empty string it is
492 interpreted as STDIN if START_DIR is PFILE->no_search_path.
494 If the file is not found in the file cache fall back to the O/S and
495 add the result to our cache.
497 If the file was not found in the filesystem, or there was an error
498 opening it, then ERR_NO is nonzero and FD is -1. If the file was
499 found, then ERR_NO is zero and FD could be -1 or an open file
500 descriptor. FD can be -1 if the file was found in the cache and
501 had previously been closed. To open it again pass the return value
504 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
505 missing. If present, it is OK for a precompiled header to be
508 Use LOC as the location for any errors. */
511 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
,
512 int angle_brackets
, _cpp_find_file_kind kind
, location_t loc
)
514 bool invalid_pch
= false;
515 bool saw_bracket_include
= false;
516 bool saw_quote_include
= false;
517 struct cpp_dir
*found_in_cache
= NULL
;
519 /* Ensure we get no confusion between cached files and directories. */
520 if (start_dir
== NULL
)
521 cpp_error_at (pfile
, CPP_DL_ICE
, loc
, "NULL directory in find_file");
524 = htab_find_slot_with_hash (pfile
->file_hash
, fname
,
525 htab_hash_string (fname
), INSERT
);
527 /* First check the cache before we resort to memory allocation. */
528 cpp_file_hash_entry
*entry
529 = search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, start_dir
);
532 if (entry
->u
.file
->deferred_error
&& kind
== _cpp_FFK_NORMAL
)
534 open_file_failed (pfile
, entry
->u
.file
, angle_brackets
, loc
);
535 entry
->u
.file
->deferred_error
= false;
537 return entry
->u
.file
;
540 _cpp_file
*file
= make_cpp_file (start_dir
, fname
);
541 file
->implicit_preinclude
542 = (kind
== _cpp_FFK_PRE_INCLUDE
543 || (pfile
->buffer
&& pfile
->buffer
->file
->implicit_preinclude
));
545 if (kind
== _cpp_FFK_FAKE
)
546 file
->dont_read
= true;
548 /* Try each path in the include chain. */
551 if (find_file_in_dir (pfile
, file
, &invalid_pch
, loc
))
554 file
->dir
= file
->dir
->next
;
555 if (file
->dir
== NULL
)
557 if (search_path_exhausted (pfile
, fname
, file
))
559 /* Although this file must not go in the cache,
560 because the file found might depend on things (like
561 the current file) that aren't represented in the
562 cache, it still has to go in the list of all files
563 so that #import works. */
564 file
->next_file
= pfile
->all_files
;
565 pfile
->all_files
= file
;
566 if (*hash_slot
== NULL
)
568 /* If *hash_slot is NULL, the above
569 htab_find_slot_with_hash call just created the
570 slot, but we aren't going to store there anything
571 of use, so need to remove the newly created entry.
572 htab_clear_slot requires that it is non-NULL, so
573 store some non-NULL but valid pointer there,
574 htab_clear_slot will immediately overwrite it. */
576 htab_clear_slot (pfile
->file_hash
, hash_slot
);
583 cpp_error (pfile
, CPP_DL_ERROR
,
584 "one or more PCH files were found,"
585 " but they were invalid");
586 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
587 cpp_error (pfile
, CPP_DL_NOTE
,
588 "use -Winvalid-pch for more information");
591 if (kind
== _cpp_FFK_PRE_INCLUDE
)
593 free ((char *) file
->name
);
595 if (*hash_slot
== NULL
)
597 /* See comment on the above htab_clear_slot call. */
598 *hash_slot
= &hash_slot
;
599 htab_clear_slot (pfile
->file_hash
, hash_slot
);
604 if (kind
!= _cpp_FFK_HAS_INCLUDE
)
605 open_file_failed (pfile
, file
, angle_brackets
, loc
);
607 file
->deferred_error
= true;
611 /* Only check the cache for the starting location (done above)
612 and the quote and bracket chain heads because there are no
613 other possible starting points for searches. */
614 if (file
->dir
== pfile
->bracket_include
)
615 saw_bracket_include
= true;
616 else if (file
->dir
== pfile
->quote_include
)
617 saw_quote_include
= true;
622 = search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, file
->dir
);
625 found_in_cache
= file
->dir
;
632 /* Cache for START_DIR too, sharing the _cpp_file structure. */
633 free ((char *) file
->name
);
635 file
= entry
->u
.file
;
639 /* This is a new file; put it in the list. */
640 file
->next_file
= pfile
->all_files
;
641 pfile
->all_files
= file
;
644 /* Store this new result in the hash table. */
645 entry
= new_file_hash_entry (pfile
);
646 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
647 entry
->start_dir
= start_dir
;
648 entry
->location
= loc
;
649 entry
->u
.file
= file
;
650 *hash_slot
= (void *) entry
;
652 /* If we passed the quote or bracket chain heads, cache them also.
653 This speeds up processing if there are lots of -I options. */
654 if (saw_bracket_include
655 && pfile
->bracket_include
!= start_dir
656 && found_in_cache
!= pfile
->bracket_include
)
658 entry
= new_file_hash_entry (pfile
);
659 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
660 entry
->start_dir
= pfile
->bracket_include
;
661 entry
->location
= loc
;
662 entry
->u
.file
= file
;
663 *hash_slot
= (void *) entry
;
665 if (saw_quote_include
666 && pfile
->quote_include
!= start_dir
667 && found_in_cache
!= pfile
->quote_include
)
669 entry
= new_file_hash_entry (pfile
);
670 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
671 entry
->start_dir
= pfile
->quote_include
;
672 entry
->location
= loc
;
673 entry
->u
.file
= file
;
674 *hash_slot
= (void *) entry
;
680 /* Read a file into FILE->buffer, returning true on success.
682 If FILE->fd is something weird, like a block device, we don't want
683 to read it at all. Don't even try to figure out what something is,
684 except for plain files and block devices, since there is no
685 reliable portable way of doing this.
687 Use LOC for any diagnostics.
689 PFILE may be NULL. In this case, no diagnostics are issued.
691 FIXME: Flush file cache and try again if we run out of memory. */
693 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
,
694 const char *input_charset
)
696 ssize_t size
, total
, count
;
700 if (S_ISBLK (file
->st
.st_mode
))
703 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
704 "%s is a block device", file
->path
);
708 regular
= S_ISREG (file
->st
.st_mode
) != 0;
711 /* off_t might have a wider range than ssize_t - in other words,
712 the max size of a file might be bigger than the address
713 space. We can't handle a file that large. (Anyone with
714 a single source file bigger than 2GB needs to rethink
715 their coding style.) Some systems (e.g. AIX 4.1) define
716 SSIZE_MAX to be much smaller than the actual range of the
717 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
719 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
722 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
723 "%s is too large", file
->path
);
727 size
= file
->st
.st_size
;
730 /* 8 kilobytes is a sensible starting size. It ought to be bigger
731 than the kernel pipe buffer, and it's definitely bigger than
732 the majority of C source files. */
735 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
736 used to quiet warnings from valgrind or Address Sanitizer, when the
737 optimized lexer accesses aligned 16-byte memory chunks, including
738 the bytes after the malloced, area, and stops lexing on '\n'. */
739 buf
= XNEWVEC (uchar
, size
+ 16);
741 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
750 buf
= XRESIZEVEC (uchar
, buf
, size
+ 16);
757 cpp_errno_filename (pfile
, CPP_DL_ERROR
, file
->path
, loc
);
762 if (pfile
&& regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
763 cpp_error_at (pfile
, CPP_DL_WARNING
, loc
,
764 "%s is shorter than expected", file
->path
);
766 file
->buffer
= _cpp_convert_input (pfile
,
768 buf
, size
+ 16, total
,
771 file
->buffer_valid
= file
->buffer
;
772 return file
->buffer_valid
;
775 /* Convenience wrapper around read_file_guts that opens the file if
776 necessary and closes the file descriptor after reading. FILE must
777 have been passed through find_file() at some stage. Use LOC for
778 any diagnostics. Unlike read_file_guts(), PFILE may not be NULL. */
780 read_file (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
)
782 /* If we already have its contents in memory, succeed immediately. */
783 if (file
->buffer_valid
)
786 /* If an earlier read failed for some reason don't try again. */
787 if (file
->dont_read
|| file
->err_no
)
790 if (file
->fd
== -1 && !open_file (file
))
792 open_file_failed (pfile
, file
, 0, loc
);
796 file
->dont_read
= !read_file_guts (pfile
, file
, loc
,
797 CPP_OPTION (pfile
, input_charset
));
801 return !file
->dont_read
;
804 /* Returns TRUE if FILE is already known to be idempotent, and should
805 therefore not be read again. */
807 is_known_idempotent_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
809 /* Skip once-only files. */
813 /* We must mark the file once-only if #import now, before header
814 guard checks. Otherwise, undefining the header guard might
815 cause the file to be re-stacked. */
818 _cpp_mark_file_once_only (pfile
, file
);
820 /* Don't stack files that have been stacked before. */
821 if (file
->stack_count
)
825 /* Skip if the file had a header guard and the macro is defined.
826 PCH relies on this appearing before the PCH handler below. */
827 if (file
->cmacro
&& cpp_macro_p (file
->cmacro
))
830 /* Handle PCH files immediately; don't stack them. */
833 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
835 free ((void *) file
->pchname
);
836 file
->pchname
= NULL
;
843 /* Return TRUE if file has unique contents, so we should read process
844 it. The file's contents must already have been read. */
847 has_unique_contents (cpp_reader
*pfile
, _cpp_file
*file
, bool import
,
850 /* Check the file against the PCH file. This is done before
851 checking against files we've already seen, since it may save on
853 if (check_file_against_entries (pfile
, file
, import
))
855 /* If this isn't a #import, but yet we can't include the file,
856 that means that it was #import-ed in the PCH file,
857 so we can never include it again. */
859 _cpp_mark_file_once_only (pfile
, file
);
863 /* Now we've read the file's contents, we can stack it if there
864 are no once-only files. */
865 if (!pfile
->seen_once_only
)
868 /* We may have read the file under a different name. Look
869 for likely candidates and compare file contents to be sure. */
870 for (_cpp_file
*f
= pfile
->all_files
; f
; f
= f
->next_file
)
873 continue; /* It'sa me! */
875 if ((import
|| f
->once_only
)
877 && f
->st
.st_mtime
== file
->st
.st_mtime
878 && f
->st
.st_size
== file
->st
.st_size
)
882 if (f
->buffer
&& !f
->buffer_valid
)
884 /* We already have a buffer but it is not valid, because
885 the file is still stacked. Make a new one. */
886 ref_file
= make_cpp_file (f
->dir
, f
->name
);
887 ref_file
->path
= f
->path
;
890 /* The file is not stacked anymore. We can reuse it. */
893 bool same_file_p
= (read_file (pfile
, ref_file
, loc
)
894 /* Size might have changed in read_file(). */
895 && ref_file
->st
.st_size
== file
->st
.st_size
896 && !memcmp (ref_file
->buffer
, file
->buffer
,
899 if (f
->buffer
&& !f
->buffer_valid
)
902 destroy_cpp_file (ref_file
);
906 /* Already seen under a different name. */
914 /* Place the file referenced by FILE into a new buffer on the buffer
915 stack if possible. Returns true if a buffer is stacked. Use LOC
916 for any diagnostics. */
919 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, include_type type
,
922 if (is_known_idempotent_file (pfile
, file
, type
== IT_IMPORT
))
928 /* Check C++ module include translation. */
929 if (!file
->header_unit
&& type
< IT_HEADER_HWM
930 /* Do not include translate include-next. */
931 && type
!= IT_INCLUDE_NEXT
932 && pfile
->cb
.translate_include
)
933 buf
= (pfile
->cb
.translate_include
934 (pfile
, pfile
->line_table
, loc
, file
->path
));
938 /* We don't increment the line number at the end of a buffer,
939 because we don't usually need that location (we're popping an
940 include file). However in this case we do want to do the
941 increment. So push a writable buffer of two newlines to acheive
942 that. (We also need an extra newline, so this looks like a regular
943 file, which we do that to to make sure we don't fall off the end in the
945 static uchar newlines
[] = "\n\n\n";
946 cpp_push_buffer (pfile
, newlines
, 2, true);
948 size_t len
= strlen (buf
);
949 buf
[len
] = '\n'; /* See above */
951 = cpp_push_buffer (pfile
, reinterpret_cast<unsigned char *> (buf
),
953 buffer
->to_free
= buffer
->buf
;
955 file
->header_unit
= +1;
956 _cpp_mark_file_once_only (pfile
, file
);
960 /* Not a header unit, and we know it. */
961 file
->header_unit
= -1;
963 if (!read_file (pfile
, file
, loc
))
966 if (!has_unique_contents (pfile
, file
, type
== IT_IMPORT
, loc
))
969 if (pfile
->buffer
&& file
->dir
)
970 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
972 /* Add the file to the dependencies on its first inclusion. */
973 if (CPP_OPTION (pfile
, deps
.style
) > (sysp
!= 0)
974 && !file
->stack_count
976 && !(pfile
->main_file
== file
977 && CPP_OPTION (pfile
, deps
.ignore_main_file
)))
978 deps_add_dep (pfile
->deps
, file
->path
);
980 /* Clear buffer_valid since _cpp_clean_line messes it up. */
981 file
->buffer_valid
= false;
984 /* Stack the buffer. */
986 = cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
987 CPP_OPTION (pfile
, preprocessed
)
988 && !CPP_OPTION (pfile
, directives_only
));
991 buffer
->to_free
= file
->buffer_start
;
993 /* Initialize controlling macro state. */
994 pfile
->mi_valid
= true;
995 pfile
->mi_cmacro
= 0;
998 /* In the case of a normal #include, we're now at the start of the
999 line *following* the #include. A separate location_t for this
1000 location makes no sense, until we do the LC_LEAVE.
1002 This does not apply if we found a PCH file, we're not a regular
1003 include, or we ran out of locations. */
1004 bool decrement
= (file
->pchname
== NULL
1005 && type
< IT_DIRECTIVE_HWM
1006 && (pfile
->line_table
->highest_location
1007 != LINE_MAP_MAX_LOCATION
- 1));
1009 pfile
->line_table
->highest_location
--;
1011 if (file
->header_unit
<= 0)
1012 /* Add line map and do callbacks. */
1013 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
,
1014 /* With preamble injection, start on line zero,
1015 so the preamble doesn't appear to have been
1016 included from line 1. Likewise when
1017 starting preprocessed, we expect an initial
1019 type
== IT_PRE_MAIN
? 0 : 1, sysp
);
1022 /* Adjust the line back one so we appear on the #include line itself. */
1023 const line_map_ordinary
*map
1024 = LINEMAPS_LAST_ORDINARY_MAP (pfile
->line_table
);
1025 linenum_type line
= SOURCE_LINE (map
, pfile
->line_table
->highest_line
);
1026 linemap_line_start (pfile
->line_table
, line
- 1, 0);
1032 /* Mark FILE to be included once only. */
1034 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
1036 pfile
->seen_once_only
= true;
1037 file
->once_only
= true;
1040 /* Return the directory from which searching for FNAME should start,
1041 considering the directive TYPE and ANGLE_BRACKETS. If there is
1042 nothing left in the path, returns NULL. */
1043 static struct cpp_dir
*
1044 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
1045 enum include_type type
, bool suppress_diagnostic
)
1050 if (IS_ABSOLUTE_PATH (fname
))
1051 return &pfile
->no_search_path
;
1053 /* pfile->buffer is NULL when processing an -include command-line flag. */
1054 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
1056 /* For #include_next, skip in the search path past the dir in which
1057 the current file was found, but if it was found via an absolute
1058 path use the normal search logic. */
1059 if (type
== IT_INCLUDE_NEXT
&& file
->dir
1060 && file
->dir
!= &pfile
->no_search_path
)
1061 dir
= file
->dir
->next
;
1062 else if (angle_brackets
)
1063 dir
= pfile
->bracket_include
;
1064 else if (type
== IT_CMDLINE
)
1065 /* -include and -imacros use the #include "" chain with the
1066 preprocessor's cwd prepended. */
1067 return make_cpp_dir (pfile
, "./", false);
1068 else if (pfile
->quote_ignores_source_dir
)
1069 dir
= pfile
->quote_include
;
1071 return make_cpp_dir (pfile
, dir_name_of_file (file
),
1072 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
1074 if (dir
== NULL
&& !suppress_diagnostic
)
1075 cpp_error (pfile
, CPP_DL_ERROR
,
1076 "no include path in which to search for %s", fname
);
1081 /* Strip the basename from the file's path. It ends with a slash if
1082 of nonzero length. Note that this procedure also works for
1083 <stdin>, which is represented by the empty string. */
1085 dir_name_of_file (_cpp_file
*file
)
1087 if (!file
->dir_name
)
1089 size_t len
= lbasename (file
->path
) - file
->path
;
1090 char *dir_name
= XNEWVEC (char, len
+ 1);
1092 memcpy (dir_name
, file
->path
, len
);
1093 dir_name
[len
] = '\0';
1094 file
->dir_name
= dir_name
;
1097 return file
->dir_name
;
1100 /* Handles #include-family directives (distinguished by TYPE),
1101 including HEADER, and the command line -imacros and -include.
1102 Returns true if a buffer was stacked. */
1104 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
1105 enum include_type type
, location_t loc
)
1107 /* For -include command-line flags we have type == IT_CMDLINE.
1108 When the first -include file is processed we have the case, where
1109 pfile->cur_token == pfile->cur_run->base, we are directly called up
1110 by the front end. However in the case of the second -include file,
1111 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1112 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1113 and pfile->cur_token[-1].src_loc not (yet) initialized.
1114 However, when the include file cannot be found, we need src_loc to
1115 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1116 if (type
== IT_CMDLINE
&& pfile
->cur_token
!= pfile
->cur_run
->base
)
1117 pfile
->cur_token
[-1].src_loc
= 0;
1119 cpp_dir
*dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
1123 _cpp_file
*file
= _cpp_find_file (pfile
, fname
, dir
, angle_brackets
,
1124 type
== IT_DEFAULT
? _cpp_FFK_PRE_INCLUDE
1125 : _cpp_FFK_NORMAL
, loc
);
1126 if (type
== IT_DEFAULT
&& file
== NULL
)
1129 return _cpp_stack_file (pfile
, file
, type
, loc
);
1132 /* NAME is a header file name, find the _cpp_file, if any. */
1135 test_header_unit (cpp_reader
*pfile
, const char *name
, bool angle
,
1138 if (cpp_dir
*dir
= search_path_head (pfile
, name
, angle
, IT_INCLUDE
))
1139 return _cpp_find_file (pfile
, name
, dir
, angle
, _cpp_FFK_NORMAL
, loc
);
1144 /* NAME is a header file name, find the path we'll use to open it and infer that
1145 it is a header-unit. */
1148 _cpp_find_header_unit (cpp_reader
*pfile
, const char *name
, bool angle
,
1151 if (_cpp_file
*file
= test_header_unit (pfile
, name
, angle
, loc
))
1155 /* Don't leave it open. */
1160 file
->header_unit
= +1;
1161 _cpp_mark_file_once_only (pfile
, file
);
1169 /* NAME is a header file name, find the path we'll use to open it. But do not
1170 infer it is a header unit. */
1173 cpp_probe_header_unit (cpp_reader
*pfile
, const char *name
, bool angle
,
1176 if (_cpp_file
*file
= test_header_unit (pfile
, name
, angle
, loc
))
1182 /* Retrofit the just-entered main file asif it was an include. This
1183 will permit correct include_next use, and mark it as a system
1184 header if that's where it resides. We use filesystem-appropriate
1185 prefix matching of the include path to locate the main file. */
1187 cpp_retrofit_as_include (cpp_reader
*pfile
)
1189 /* We should be the outermost. */
1190 gcc_assert (!pfile
->buffer
->prev
);
1192 if (const char *name
= pfile
->main_file
->name
)
1194 /* Locate name on the include dir path, using a prefix match. */
1195 size_t name_len
= strlen (name
);
1196 for (cpp_dir
*dir
= pfile
->quote_include
; dir
; dir
= dir
->next
)
1197 if (dir
->len
< name_len
1198 && IS_DIR_SEPARATOR (name
[dir
->len
])
1199 && !filename_ncmp (name
, dir
->name
, dir
->len
))
1201 pfile
->main_file
->dir
= dir
;
1203 cpp_make_system_header (pfile
, 1, 0);
1208 /* Initialize controlling macro state. */
1209 pfile
->mi_valid
= true;
1210 pfile
->mi_cmacro
= 0;
1213 /* Could not open FILE. The complication is dependency output. */
1215 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
,
1218 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
1219 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
1221 errno
= file
->err_no
;
1222 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
1224 deps_add_dep (pfile
->deps
, file
->name
);
1225 /* If the preprocessor output (other than dependency information) is
1226 being used, we must also flag an error. */
1227 if (CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1228 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1229 file
->path
? file
->path
: file
->name
,
1234 /* If we are not outputting dependencies, or if we are and dependencies
1235 were requested for this file, or if preprocessor output is needed
1236 in addition to dependency information, this is an error.
1238 Otherwise (outputting dependencies but not for this file, and not
1239 using the preprocessor output), we can still produce correct output
1240 so it's only a warning. */
1241 if (CPP_OPTION (pfile
, deps
.style
) == DEPS_NONE
1243 || CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1244 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1245 file
->path
? file
->path
: file
->name
,
1248 cpp_errno_filename (pfile
, CPP_DL_WARNING
,
1249 file
->path
? file
->path
: file
->name
,
1254 /* Search in the chain beginning at HEAD for a file whose search path
1255 started at START_DIR != NULL. */
1256 static struct cpp_file_hash_entry
*
1257 search_cache (struct cpp_file_hash_entry
*head
, const cpp_dir
*start_dir
)
1259 while (head
&& head
->start_dir
!= start_dir
)
1265 /* Allocate a new _cpp_file structure. */
1267 make_cpp_file (cpp_dir
*dir
, const char *fname
)
1269 _cpp_file
*file
= XCNEW (_cpp_file
);
1272 file
->name
= xstrdup (fname
);
1277 /* Release a _cpp_file structure. */
1279 destroy_cpp_file (_cpp_file
*file
)
1281 free ((void *) file
->buffer_start
);
1282 free ((void *) file
->name
);
1283 free ((void *) file
->path
);
1287 /* Release all the files allocated by this reader. */
1289 destroy_all_cpp_files (cpp_reader
*pfile
)
1291 _cpp_file
*iter
= pfile
->all_files
;
1294 _cpp_file
*next
= iter
->next_file
;
1295 destroy_cpp_file (iter
);
1300 /* A hash of directory names. The directory names are the path names
1301 of files which contain a #include "", the included file name is
1302 appended to this directories.
1304 To avoid duplicate entries we follow the convention that all
1305 non-empty directory names should end in a '/'. DIR_NAME must be
1306 stored in permanently allocated memory. */
1308 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
1310 struct cpp_file_hash_entry
*entry
, **hash_slot
;
1313 hash_slot
= (struct cpp_file_hash_entry
**)
1314 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
1315 htab_hash_string (dir_name
),
1318 /* Have we already hashed this directory? */
1319 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
1320 if (entry
->start_dir
== NULL
)
1321 return entry
->u
.dir
;
1323 dir
= XCNEW (cpp_dir
);
1324 dir
->next
= pfile
->quote_include
;
1325 dir
->name
= (char *) dir_name
;
1326 dir
->len
= strlen (dir_name
);
1330 /* Store this new result in the hash table. */
1331 entry
= new_file_hash_entry (pfile
);
1332 entry
->next
= *hash_slot
;
1333 entry
->start_dir
= NULL
;
1334 entry
->location
= pfile
->line_table
->highest_location
;
1341 /* Create a new block of memory for file hash entries. */
1343 allocate_file_hash_entries (cpp_reader
*pfile
)
1345 struct file_hash_entry_pool
*pool
= XNEW (struct file_hash_entry_pool
);
1346 pool
->file_hash_entries_used
= 0;
1347 pool
->next
= pfile
->file_hash_entries
;
1348 pfile
->file_hash_entries
= pool
;
1351 /* Return a new file hash entry. */
1352 static struct cpp_file_hash_entry
*
1353 new_file_hash_entry (cpp_reader
*pfile
)
1356 if (pfile
->file_hash_entries
->file_hash_entries_used
== FILE_HASH_POOL_SIZE
)
1357 allocate_file_hash_entries (pfile
);
1359 idx
= pfile
->file_hash_entries
->file_hash_entries_used
++;
1360 return &pfile
->file_hash_entries
->pool
[idx
];
1363 /* Free the file hash entry pools. */
1365 free_file_hash_entries (cpp_reader
*pfile
)
1367 struct file_hash_entry_pool
*iter
= pfile
->file_hash_entries
;
1370 struct file_hash_entry_pool
*next
= iter
->next
;
1376 /* Returns TRUE if a file FNAME has ever been successfully opened.
1377 This routine is not intended to correctly handle filenames aliased
1378 by links or redundant . or .. traversals etc. */
1380 cpp_included (cpp_reader
*pfile
, const char *fname
)
1382 struct cpp_file_hash_entry
*entry
;
1384 entry
= (struct cpp_file_hash_entry
*)
1385 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1387 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1388 entry
= entry
->next
;
1390 return entry
!= NULL
;
1393 /* Returns TRUE if a file FNAME has ever been successfully opened
1394 before LOCATION. This routine is not intended to correctly handle
1395 filenames aliased by links or redundant . or .. traversals etc. */
1397 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1398 location_t location
)
1400 struct cpp_file_hash_entry
*entry
1401 = (struct cpp_file_hash_entry
*)
1402 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1404 if (IS_ADHOC_LOC (location
))
1405 location
= get_location_from_adhoc_loc (pfile
->line_table
, location
);
1407 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1408 || entry
->location
> location
))
1409 entry
= entry
->next
;
1411 return entry
!= NULL
;
1414 /* Calculate the hash value of a file hash entry P. */
1417 file_hash_hash (const void *p
)
1419 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1421 if (entry
->start_dir
)
1422 hname
= entry
->u
.file
->name
;
1424 hname
= entry
->u
.dir
->name
;
1426 return htab_hash_string (hname
);
1429 /* Compare a string Q against a file hash entry P. */
1431 file_hash_eq (const void *p
, const void *q
)
1433 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1434 const char *fname
= (const char *) q
;
1437 if (entry
->start_dir
)
1438 hname
= entry
->u
.file
->name
;
1440 hname
= entry
->u
.dir
->name
;
1442 return filename_cmp (hname
, fname
) == 0;
1445 /* Compare entries in the nonexistent file hash table. These are just
1448 nonexistent_file_hash_eq (const void *p
, const void *q
)
1450 return filename_cmp ((const char *) p
, (const char *) q
) == 0;
1453 /* Initialize everything in this source file. */
1455 _cpp_init_files (cpp_reader
*pfile
)
1457 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1458 NULL
, xcalloc
, free
);
1459 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1460 NULL
, xcalloc
, free
);
1461 allocate_file_hash_entries (pfile
);
1462 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1463 nonexistent_file_hash_eq
,
1464 NULL
, xcalloc
, free
);
1465 obstack_specify_allocation (&pfile
->nonexistent_file_ob
, 0, 0,
1469 /* Finalize everything in this source file. */
1471 _cpp_cleanup_files (cpp_reader
*pfile
)
1473 htab_delete (pfile
->file_hash
);
1474 htab_delete (pfile
->dir_hash
);
1475 htab_delete (pfile
->nonexistent_file_hash
);
1476 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1477 free_file_hash_entries (pfile
);
1478 destroy_all_cpp_files (pfile
);
1481 /* Make the parser forget about files it has seen. This can be useful
1482 for resetting the parser to start another run. */
1484 cpp_clear_file_cache (cpp_reader
*pfile
)
1486 _cpp_cleanup_files (pfile
);
1487 pfile
->file_hash_entries
= NULL
;
1488 pfile
->all_files
= NULL
;
1489 _cpp_init_files (pfile
);
1492 /* Enter a file name in the hash for the sake of cpp_included. */
1494 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1496 /* It does not matter what are the contents of fake_source_dir, it will never
1497 be inspected; we just use its address to uniquely signify that this file
1498 was added as a fake include, so a later call to _cpp_find_file (to include
1499 the file for real) won't find the fake one in the hash table. */
1500 static cpp_dir fake_source_dir
;
1501 _cpp_find_file (pfile
, fname
, &fake_source_dir
, 0, _cpp_FFK_FAKE
, 0);
1504 /* Not everyone who wants to set system-header-ness on a buffer can
1505 see the details of a buffer. This is an exported interface because
1506 fix-header needs it. */
1508 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1511 const class line_maps
*line_table
= pfile
->line_table
;
1512 const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1513 /* 1 = system header, 2 = system header to be treated as C. */
1515 flags
= 1 + (externc
!= 0);
1516 pfile
->buffer
->sysp
= flags
;
1517 _cpp_do_file_change (pfile
, LC_RENAME
, ORDINARY_MAP_FILE_NAME (map
),
1518 SOURCE_LINE (map
, pfile
->line_table
->highest_line
),
1522 /* Allow the client to change the current file. Used by the front end
1523 to achieve pseudo-file names like <built-in>.
1524 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1526 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1527 const char *new_name
)
1529 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1532 struct report_missing_guard_data
1539 /* Callback function for htab_traverse. */
1541 report_missing_guard (void **slot
, void *d
)
1543 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) *slot
;
1544 struct report_missing_guard_data
*data
1545 = (struct report_missing_guard_data
*) d
;
1547 /* Skip directories. */
1548 if (entry
->start_dir
!= NULL
)
1550 _cpp_file
*file
= entry
->u
.file
;
1552 /* We don't want MI guard advice for the main file. */
1553 if (!file
->once_only
1554 && file
->cmacro
== NULL
1555 && file
->stack_count
== 1
1556 && data
->pfile
->main_file
!= file
)
1558 if (data
->paths
== NULL
)
1560 data
->paths
= XCNEWVEC (const char *, data
->count
);
1564 data
->paths
[data
->count
++] = file
->path
;
1568 /* Keep traversing the hash table. */
1572 /* Comparison function for qsort. */
1574 report_missing_guard_cmp (const void *p1
, const void *p2
)
1576 return strcmp (*(const char *const *) p1
, *(const char *const *) p2
);
1579 /* Report on all files that might benefit from a multiple include guard.
1582 _cpp_report_missing_guards (cpp_reader
*pfile
)
1584 struct report_missing_guard_data data
;
1588 data
.count
= htab_elements (pfile
->file_hash
);
1589 htab_traverse (pfile
->file_hash
, report_missing_guard
, &data
);
1591 if (data
.paths
!= NULL
)
1595 /* Sort the paths to avoid outputting them in hash table
1597 qsort (data
.paths
, data
.count
, sizeof (const char *),
1598 report_missing_guard_cmp
);
1599 fputs (_("Multiple include guards may be useful for:\n"),
1601 for (i
= 0; i
< data
.count
; i
++)
1603 fputs (data
.paths
[i
], stderr
);
1604 putc ('\n', stderr
);
1610 /* Locate HEADER, and determine whether it is newer than the current
1611 file. If it cannot be located or dated, return -1, if it is
1612 newer, return 1, otherwise 0. */
1614 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1618 struct cpp_dir
*dir
;
1620 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1624 file
= _cpp_find_file (pfile
, fname
, dir
, angle_brackets
, _cpp_FFK_NORMAL
, 0);
1634 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1637 /* Pushes the given file onto the buffer stack. Returns nonzero if
1640 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1642 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
,
1643 pfile
->line_table
->highest_line
);
1646 /* Pushes the given file, implicitly included at the start of a
1647 compilation, onto the buffer stack but without any errors if the
1648 file is not found. Returns nonzero if successful. */
1650 cpp_push_default_include (cpp_reader
*pfile
, const char *fname
)
1652 return _cpp_stack_include (pfile
, fname
, true, IT_DEFAULT
,
1653 pfile
->line_table
->highest_line
);
1656 /* Do appropriate cleanup when a file INC's buffer is popped off the
1659 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
,
1660 const unsigned char *to_free
)
1662 /* Record the inclusion-preventing macro, which could be NULL
1663 meaning no controlling macro. */
1664 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1665 file
->cmacro
= pfile
->mi_cmacro
;
1667 /* Invalidate control macros in the #including file. */
1668 pfile
->mi_valid
= false;
1672 if (to_free
== file
->buffer_start
)
1674 file
->buffer_start
= NULL
;
1675 file
->buffer
= NULL
;
1676 file
->buffer_valid
= false;
1678 free ((void *) to_free
);
1682 /* Return the file name associated with FILE. */
1684 _cpp_get_file_name (_cpp_file
*file
)
1689 /* Inteface to file statistics record in _cpp_file structure. */
1691 _cpp_get_file_stat (_cpp_file
*file
)
1696 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1697 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1698 directory of the including file.
1700 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1702 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1703 int quote_ignores_source_dir
)
1705 pfile
->quote_include
= quote
;
1706 pfile
->bracket_include
= quote
;
1707 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1709 for (; quote
; quote
= quote
->next
)
1711 quote
->name_map
= NULL
;
1712 quote
->len
= strlen (quote
->name
);
1713 if (quote
== bracket
)
1714 pfile
->bracket_include
= bracket
;
1718 /* Append the file name to the directory to create the path, but don't
1719 turn / into // or // into ///; // may be a namespace escape. */
1721 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1727 flen
= strlen (fname
);
1728 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1729 memcpy (path
, dir
->name
, dlen
);
1730 if (dlen
&& !IS_DIR_SEPARATOR (path
[dlen
- 1]))
1732 memcpy (&path
[dlen
], fname
, flen
+ 1);
1737 /* Read a space delimited string of unlimited length from a stdio
1740 read_filename_string (int ch
, FILE *f
)
1746 set
= alloc
= XNEWVEC (char, len
+ 1);
1747 if (! is_space (ch
))
1750 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1752 if (set
- alloc
== len
)
1755 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1756 set
= alloc
+ len
/ 2;
1766 /* Read the file name map file for DIR. */
1768 read_name_map (cpp_dir
*dir
)
1770 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1773 size_t len
, count
= 0, room
= 9;
1776 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1777 memcpy (name
, dir
->name
, len
);
1778 if (len
&& !IS_DIR_SEPARATOR (name
[len
- 1]))
1780 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1781 f
= fopen (name
, "r");
1783 dir
->name_map
= XNEWVEC (const char *, room
);
1785 /* Silently return NULL if we cannot open. */
1790 while ((ch
= getc (f
)) != EOF
)
1797 if (count
+ 2 > room
)
1800 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1803 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1804 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1807 to
= read_filename_string (ch
, f
);
1808 if (IS_ABSOLUTE_PATH (to
))
1809 dir
->name_map
[count
+ 1] = to
;
1812 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1817 while ((ch
= getc (f
)) != '\n')
1825 /* Terminate the list of maps. */
1826 dir
->name_map
[count
] = NULL
;
1829 /* Remap a FILE's name based on the file_name_map, if any, for
1830 FILE->dir. If the file name has any directory separators,
1831 recursively check those directories too. */
1833 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1835 const char *fname
, *p
;
1846 read_name_map (dir
);
1848 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1849 if (!filename_cmp (dir
->name_map
[index
], fname
))
1850 return xstrdup (dir
->name_map
[index
+ 1]);
1851 if (IS_ABSOLUTE_PATH (fname
))
1853 p
= strchr (fname
, '/');
1854 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1856 const char *p2
= strchr (fname
, '\\');
1857 if (!p
|| (p2
&& p
> p2
))
1861 if (!p
|| p
== fname
)
1864 len
= dir
->len
+ (p
- fname
+ 1);
1865 new_dir
= XNEWVEC (char, len
+ 2);
1866 p3
= new_dir
+ dir
->len
;
1867 memcpy (new_dir
, dir
->name
, dir
->len
);
1868 if (dir
->len
&& !IS_DIR_SEPARATOR (dir
->name
[dir
->len
- 1]))
1873 memcpy (p3
, fname
, p
- fname
+ 1);
1874 new_dir
[len
] = '\0';
1876 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1881 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1883 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1885 const char *saved_path
= file
->path
;
1888 file
->path
= pchname
;
1889 if (open_file (file
))
1891 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1899 if (CPP_OPTION (pfile
, print_include_names
))
1902 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1904 fprintf (stderr
, "%c %s\n",
1905 valid
? '!' : 'x', pchname
);
1909 file
->path
= saved_path
;
1913 /* Get the path associated with the _cpp_file F. The path includes
1914 the base name from the include directive and the directory it was
1915 found in via the search path. */
1918 cpp_get_path (struct _cpp_file
*f
)
1923 /* Get the directory associated with the _cpp_file F. */
1926 cpp_get_dir (struct _cpp_file
*f
)
1931 /* Get the cpp_buffer currently associated with the cpp_reader
1935 cpp_get_buffer (cpp_reader
*pfile
)
1937 return pfile
->buffer
;
1940 /* Get the _cpp_file associated with the cpp_buffer B. */
1943 cpp_get_file (cpp_buffer
*b
)
1948 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1949 buffer is the buffer that included the given buffer. */
1952 cpp_get_prev (cpp_buffer
*b
)
1957 /* This data structure holds the list of header files that were seen
1958 while the PCH was being built. The 'entries' field is kept sorted
1959 in memcmp() order; yes, this means that on little-endian systems,
1960 it's sorted initially by the least-significant byte of 'size', but
1961 that's OK. The code does rely on having entries with the same size
1962 next to each other. */
1965 /* The size of this file. This is used to save running a MD5 checksum
1966 if the sizes don't match. */
1968 /* The MD5 checksum of this file. */
1969 unsigned char sum
[16];
1970 /* Is this file to be included only once? */
1975 /* Number of pchf_entry structures. */
1978 /* Are there any values with once_only set?
1979 This is used as an optimisation, it means we don't have to search
1980 the structure if we're processing a regular #include. */
1981 bool have_once_only
;
1983 struct pchf_entry entries
[1];
1986 static struct pchf_data
*pchf
;
1988 /* A qsort ordering function for pchf_entry structures. */
1991 pchf_save_compare (const void *e1
, const void *e2
)
1993 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1996 /* Create and write to F a pchf_data structure. */
1999 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
2002 struct pchf_data
*result
;
2007 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
2010 result_size
= (sizeof (struct pchf_data
)
2011 + sizeof (struct pchf_entry
) * (count
- 1));
2012 result
= XCNEWVAR (struct pchf_data
, result_size
);
2015 result
->have_once_only
= false;
2017 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
2021 /* This should probably never happen, since if a read error occurred
2022 the PCH file shouldn't be written... */
2023 if (f
->dont_read
|| f
->err_no
)
2026 if (f
->stack_count
== 0)
2029 count
= result
->count
++;
2031 result
->entries
[count
].once_only
= f
->once_only
;
2032 /* |= is avoided in the next line because of an HP C compiler bug */
2033 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
2034 if (f
->buffer_valid
)
2035 md5_buffer ((const char *)f
->buffer
,
2036 f
->st
.st_size
, result
->entries
[count
].sum
);
2044 open_file_failed (pfile
, f
, 0, 0);
2048 ff
= fdopen (f
->fd
, "rb");
2049 md5_stream (ff
, result
->entries
[count
].sum
);
2053 result
->entries
[count
].size
= f
->st
.st_size
;
2056 result_size
= (sizeof (struct pchf_data
)
2057 + sizeof (struct pchf_entry
) * (result
->count
- 1));
2059 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
2062 ret
= fwrite (result
, result_size
, 1, fp
) == 1;
2067 /* Read the pchf_data structure from F. */
2070 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
2074 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
2078 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
2079 + sizeof (struct pchf_entry
) * (d
.count
- 1));
2080 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
2081 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
2087 /* The parameters for pchf_compare. */
2089 struct pchf_compare_data
2091 /* The size of the file we're looking for. */
2094 /* The MD5 checksum of the file, if it's been computed. */
2095 unsigned char sum
[16];
2100 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
2101 bool check_included
;
2103 /* The file that we're searching for. */
2107 /* bsearch comparison function; look for D_P in E_P. */
2110 pchf_compare (const void *d_p
, const void *e_p
)
2112 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
2113 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
2116 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
2120 if (! d
->sum_computed
)
2122 _cpp_file
*const f
= d
->f
;
2124 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
2125 d
->sum_computed
= true;
2128 result
= memcmp (d
->sum
, e
->sum
, 16);
2132 if (d
->check_included
|| e
->once_only
)
2138 /* Check that F is not in a list read from a PCH file (if any).
2139 Assumes that f->buffer_valid is true. Return TRUE if the file
2140 should not be read. */
2143 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
2145 bool check_included
)
2147 struct pchf_compare_data d
;
2150 || (! check_included
&& ! pchf
->have_once_only
))
2153 d
.size
= f
->st
.st_size
;
2154 d
.sum_computed
= false;
2156 d
.check_included
= check_included
;
2157 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
2158 pchf_compare
) != NULL
;
2161 /* Return true if the file FNAME is found in the appropriate include file path
2162 as indicated by ANGLE_BRACKETS. */
2165 _cpp_has_header (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
2166 enum include_type type
)
2168 cpp_dir
*start_dir
= search_path_head (pfile
, fname
, angle_brackets
, type
,
2169 /* suppress_diagnostic = */ true);
2172 _cpp_file
*file
= _cpp_find_file (pfile
, fname
, start_dir
, angle_brackets
,
2173 _cpp_FFK_HAS_INCLUDE
, 0);
2174 return file
->err_no
!= ENOENT
;
2177 /* Read a file and convert to input charset, the same as if it were being read
2180 cpp_converted_source
2181 cpp_get_converted_source (const char *fname
, const char *input_charset
)
2183 cpp_converted_source res
= {};
2184 _cpp_file file
= {};
2186 file
.name
= lbasename (fname
);
2188 if (!open_file (&file
))
2190 const bool ok
= read_file_guts (NULL
, &file
, 0, input_charset
);
2194 res
.to_free
= (char *) file
.buffer_start
;
2195 res
.data
= (char *) file
.buffer
;
2196 res
.len
= file
.st
.st_size
;