1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2019 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 this file is the main file. */
109 /* If BUFFER above contains the true contents of the file. */
112 /* If this file is implicitly preincluded. */
113 bool implicit_preinclude
;
116 /* A singly-linked list for all searches for a given file name, with
117 its head pointed to by a slot in FILE_HASH. The file name is what
118 appeared between the quotes in a #include directive; it can be
119 determined implicitly from the hash table location or explicitly
122 FILE is a structure containing details about the file that was
123 found with that search, or details of how the search failed.
125 START_DIR is the starting location of the search in the include
126 chain. The current directories for "" includes are also hashed in
127 the hash table and therefore unique. Files that are looked up
128 without using a search path, such as absolute filenames and file
129 names from the command line share a special starting directory so
130 they don't cause cache hits with normal include-chain lookups.
132 If START_DIR is NULL then the entry is for a directory, not a file,
133 and the directory is in DIR. Since the starting point in a file
134 lookup chain is never NULL, this means that simple pointer
135 comparisons against START_DIR can be made to determine cache hits
138 If a cache lookup fails because of e.g. an extra "./" in the path,
139 then nothing will break. It is just less efficient as CPP will
140 have to do more work re-preprocessing the file, and/or comparing
141 its contents against earlier once-only files.
143 struct cpp_file_hash_entry
145 struct cpp_file_hash_entry
*next
;
155 /* Number of entries to put in a cpp_file_hash_entry pool. */
156 #define FILE_HASH_POOL_SIZE 127
158 /* A file hash entry pool. We allocate cpp_file_hash_entry object from
160 struct file_hash_entry_pool
162 /* Number of entries used from this pool. */
163 unsigned int file_hash_entries_used
;
164 /* Next pool in the chain; used when freeing. */
165 struct file_hash_entry_pool
*next
;
166 /* The memory pool. */
167 struct cpp_file_hash_entry pool
[FILE_HASH_POOL_SIZE
];
170 static bool open_file (_cpp_file
*file
);
171 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
173 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
174 bool *invalid_pch
, location_t loc
);
175 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
,
177 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
,
179 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
,
181 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
182 int angle_brackets
, enum include_type
);
183 static const char *dir_name_of_file (_cpp_file
*file
);
184 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int,
186 static struct cpp_file_hash_entry
*search_cache (struct cpp_file_hash_entry
*head
,
187 const cpp_dir
*start_dir
);
188 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
189 static void destroy_cpp_file (_cpp_file
*);
190 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
191 static void allocate_file_hash_entries (cpp_reader
*pfile
);
192 static struct cpp_file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
193 static int report_missing_guard (void **slot
, void *b
);
194 static hashval_t
file_hash_hash (const void *p
);
195 static int file_hash_eq (const void *p
, const void *q
);
196 static char *read_filename_string (int ch
, FILE *f
);
197 static void read_name_map (cpp_dir
*dir
);
198 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
199 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
200 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
201 static int pchf_save_compare (const void *e1
, const void *e2
);
202 static int pchf_compare (const void *d_p
, const void *e_p
);
203 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
205 /* Given a filename in FILE->PATH, with the empty string interpreted
208 On success FILE contains an open file descriptor and stat
209 information for the file. On failure the file descriptor is -1 and
210 the appropriate errno is also stored in FILE. Returns TRUE iff
213 We used to open files in nonblocking mode, but that caused more
214 problems than it solved. Do take care not to acquire a controlling
215 terminal by mistake (this can't happen on sane systems, but
216 paranoia is a virtue).
218 Use the three-argument form of open even though we aren't
219 specifying O_CREAT, to defend against broken system headers.
221 O_BINARY tells some runtime libraries (notably DJGPP) not to do
222 newline translation; we can handle DOS line breaks just fine
225 open_file (_cpp_file
*file
)
227 if (file
->path
[0] == '\0')
230 set_stdin_to_binary_mode ();
233 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
237 if (fstat (file
->fd
, &file
->st
) == 0)
239 if (!S_ISDIR (file
->st
.st_mode
))
245 /* Ignore a directory and continue the search. The file we're
246 looking for may be elsewhere in the search path. */
253 #if defined(_WIN32) && !defined(__CYGWIN__)
254 else if (errno
== EACCES
)
256 /* On most UNIX systems, open succeeds on a directory. Above,
257 we check if we have opened a directory and if so, set errno
258 to ENOENT. However, on Windows, opening a directory
259 fails with EACCES. We want to return ENOENT in that
261 if (stat (file
->path
, &file
->st
) == 0
262 && S_ISDIR (file
->st
.st_mode
))
265 /* The call to stat may have reset errno. */
269 else if (errno
== ENOTDIR
)
272 file
->err_no
= errno
;
277 /* Temporary PCH intercept of opening a file. Try to find a PCH file
278 based on FILE->name and FILE->dir, and test those found for
279 validity using PFILE->cb.valid_pch. Return true iff a valid file is
280 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
283 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
285 static const char extension
[] = ".gch";
286 const char *path
= file
->path
;
292 /* No PCH on <stdin> or if not requested. */
293 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
296 /* If the file is not included as first include from either the toplevel
297 file or the command-line it is not a valid use of PCH. */
298 for (_cpp_file
*f
= pfile
->all_files
; f
; f
= f
->next_file
)
299 if (f
->implicit_preinclude
)
301 else if (f
->main_file
)
306 flen
= strlen (path
);
307 len
= flen
+ sizeof (extension
);
308 pchname
= XNEWVEC (char, len
);
309 memcpy (pchname
, path
, flen
);
310 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
312 if (stat (pchname
, &st
) == 0)
316 size_t dlen
, plen
= len
;
318 if (!S_ISDIR (st
.st_mode
))
319 valid
= validate_pch (pfile
, file
, pchname
);
320 else if ((pchdir
= opendir (pchname
)) != NULL
)
322 pchname
[plen
- 1] = '/';
323 while ((d
= readdir (pchdir
)) != NULL
)
325 dlen
= strlen (d
->d_name
) + 1;
326 if ((strcmp (d
->d_name
, ".") == 0)
327 || (strcmp (d
->d_name
, "..") == 0))
329 if (dlen
+ plen
> len
)
332 pchname
= XRESIZEVEC (char, pchname
, len
);
334 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
335 valid
= validate_pch (pfile
, file
, pchname
);
346 file
->pchname
= pchname
;
353 /* Canonicalize the path to FILE. Return the canonical form if it is
354 shorter, otherwise return NULL. This function does NOT free the
355 memory pointed by FILE. */
358 maybe_shorter_path (const char * file
)
360 char * file2
= lrealpath (file
);
361 if (file2
&& strlen (file2
) < strlen (file
))
372 /* Try to open the path FILE->name appended to FILE->dir. This is
373 where remap and PCH intercept the file lookup process. Return true
374 if the file was found, whether or not the open was successful.
375 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
376 Use LOC when emitting any diagnostics. */
379 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
,
384 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
387 if (file
->dir
->construct
)
388 path
= file
->dir
->construct (file
->name
, file
->dir
);
390 path
= append_file_to_dir (file
->name
, file
->dir
);
398 /* We try to canonicalize system headers. For DOS based file
399 * system, we always try to shorten non-system headers, as DOS
400 * has a tighter constraint on max path length. */
401 if ((CPP_OPTION (pfile
, canonical_system_headers
) && file
->dir
->sysp
)
402 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
407 char * canonical_path
= maybe_shorter_path (path
);
410 /* The canonical path was newly allocated. Let's free the
411 non-canonical one. */
413 path
= canonical_path
;
417 hv
= htab_hash_string (path
);
418 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
420 file
->err_no
= ENOENT
;
425 if (pch_open_file (pfile
, file
, invalid_pch
))
428 if (open_file (file
))
431 if (file
->err_no
!= ENOENT
)
433 open_file_failed (pfile
, file
, 0, loc
);
437 /* We copy the path name onto an obstack partly so that we don't
438 leak the memory, but mostly so that we don't fragment the
440 copy
= (char *) obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
443 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
447 file
->path
= file
->name
;
451 file
->err_no
= ENOENT
;
458 /* Return tue iff the missing_header callback found the given HEADER. */
460 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
462 missing_header_cb func
= pfile
->cb
.missing_header
;
464 /* When the regular search path doesn't work, try context dependent
465 headers search paths. */
467 && file
->dir
== NULL
)
469 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
471 if (open_file (file
))
473 free ((void *)file
->path
);
475 file
->path
= file
->name
;
482 _cpp_find_failed (_cpp_file
*file
)
484 return file
->err_no
!= 0;
487 /* Given a filename FNAME search for such a file in the include path
488 starting from START_DIR. If FNAME is the empty string it is
489 interpreted as STDIN if START_DIR is PFILE->no_search_path.
491 If the file is not found in the file cache fall back to the O/S and
492 add the result to our cache.
494 If the file was not found in the filesystem, or there was an error
495 opening it, then ERR_NO is nonzero and FD is -1. If the file was
496 found, then ERR_NO is zero and FD could be -1 or an open file
497 descriptor. FD can be -1 if the file was found in the cache and
498 had previously been closed. To open it again pass the return value
501 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
502 If present, it is OK for a precompiled header to be included after
505 Use LOC as the location for any errors. */
508 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
,
509 bool fake
, int angle_brackets
, bool implicit_preinclude
,
512 struct cpp_file_hash_entry
*entry
;
515 bool invalid_pch
= false;
516 bool saw_bracket_include
= false;
517 bool saw_quote_include
= false;
518 struct cpp_dir
*found_in_cache
= NULL
;
520 /* Ensure we get no confusion between cached files and directories. */
521 if (start_dir
== NULL
)
522 cpp_error_at (pfile
, CPP_DL_ICE
, loc
, "NULL directory in find_file");
525 = htab_find_slot_with_hash (pfile
->file_hash
, fname
,
526 htab_hash_string (fname
), INSERT
);
528 /* First check the cache before we resort to memory allocation. */
529 entry
= search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, start_dir
);
531 return entry
->u
.file
;
533 file
= make_cpp_file (pfile
, start_dir
, fname
);
534 file
->implicit_preinclude
535 = (implicit_preinclude
537 && pfile
->buffer
->file
->implicit_preinclude
));
539 /* Try each path in the include chain. */
542 if (find_file_in_dir (pfile
, file
, &invalid_pch
, loc
))
545 file
->dir
= file
->dir
->next
;
546 if (file
->dir
== NULL
)
548 if (search_path_exhausted (pfile
, fname
, file
))
550 /* Although this file must not go in the cache, because
551 the file found might depend on things (like the current file)
552 that aren't represented in the cache, it still has to go in
553 the list of all files so that #import works. */
554 file
->next_file
= pfile
->all_files
;
555 pfile
->all_files
= file
;
556 if (*hash_slot
== NULL
)
558 /* If *hash_slot is NULL, the above htab_find_slot_with_hash
559 call just created the slot, but we aren't going to store
560 there anything, so need to remove the newly created entry.
561 htab_clear_slot requires that it is non-NULL, so store
562 there some non-NULL pointer, htab_clear_slot will
563 overwrite it immediately. */
565 htab_clear_slot (pfile
->file_hash
, hash_slot
);
572 cpp_error (pfile
, CPP_DL_ERROR
,
573 "one or more PCH files were found, but they were invalid");
574 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
575 cpp_error (pfile
, CPP_DL_ERROR
,
576 "use -Winvalid-pch for more information");
578 if (implicit_preinclude
)
580 free ((char *) file
->name
);
582 if (*hash_slot
== NULL
)
584 /* See comment on the above htab_clear_slot call. */
586 htab_clear_slot (pfile
->file_hash
, hash_slot
);
591 open_file_failed (pfile
, file
, angle_brackets
, loc
);
595 /* Only check the cache for the starting location (done above)
596 and the quote and bracket chain heads because there are no
597 other possible starting points for searches. */
598 if (file
->dir
== pfile
->bracket_include
)
599 saw_bracket_include
= true;
600 else if (file
->dir
== pfile
->quote_include
)
601 saw_quote_include
= true;
605 entry
= search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, file
->dir
);
608 found_in_cache
= file
->dir
;
615 /* Cache for START_DIR too, sharing the _cpp_file structure. */
616 free ((char *) file
->name
);
618 file
= entry
->u
.file
;
622 /* This is a new file; put it in the list. */
623 file
->next_file
= pfile
->all_files
;
624 pfile
->all_files
= file
;
627 /* Store this new result in the hash table. */
628 entry
= new_file_hash_entry (pfile
);
629 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
630 entry
->start_dir
= start_dir
;
631 entry
->location
= pfile
->line_table
->highest_location
;
632 entry
->u
.file
= file
;
633 *hash_slot
= (void *) entry
;
635 /* If we passed the quote or bracket chain heads, cache them also.
636 This speeds up processing if there are lots of -I options. */
637 if (saw_bracket_include
638 && pfile
->bracket_include
!= start_dir
639 && found_in_cache
!= pfile
->bracket_include
)
641 entry
= new_file_hash_entry (pfile
);
642 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
643 entry
->start_dir
= pfile
->bracket_include
;
644 entry
->location
= pfile
->line_table
->highest_location
;
645 entry
->u
.file
= file
;
646 *hash_slot
= (void *) entry
;
648 if (saw_quote_include
649 && pfile
->quote_include
!= start_dir
650 && found_in_cache
!= pfile
->quote_include
)
652 entry
= new_file_hash_entry (pfile
);
653 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
654 entry
->start_dir
= pfile
->quote_include
;
655 entry
->location
= pfile
->line_table
->highest_location
;
656 entry
->u
.file
= file
;
657 *hash_slot
= (void *) entry
;
663 /* Read a file into FILE->buffer, returning true on success.
665 If FILE->fd is something weird, like a block device, we don't want
666 to read it at all. Don't even try to figure out what something is,
667 except for plain files and block devices, since there is no
668 reliable portable way of doing this.
670 Use LOC for any diagnostics.
672 FIXME: Flush file cache and try again if we run out of memory. */
674 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
)
676 ssize_t size
, total
, count
;
680 if (S_ISBLK (file
->st
.st_mode
))
682 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
683 "%s is a block device", file
->path
);
687 regular
= S_ISREG (file
->st
.st_mode
) != 0;
690 /* off_t might have a wider range than ssize_t - in other words,
691 the max size of a file might be bigger than the address
692 space. We can't handle a file that large. (Anyone with
693 a single source file bigger than 2GB needs to rethink
694 their coding style.) Some systems (e.g. AIX 4.1) define
695 SSIZE_MAX to be much smaller than the actual range of the
696 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
698 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
700 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
701 "%s is too large", file
->path
);
705 size
= file
->st
.st_size
;
708 /* 8 kilobytes is a sensible starting size. It ought to be bigger
709 than the kernel pipe buffer, and it's definitely bigger than
710 the majority of C source files. */
713 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
714 used to quiet warnings from valgrind or Address Sanitizer, when the
715 optimized lexer accesses aligned 16-byte memory chunks, including
716 the bytes after the malloced, area, and stops lexing on '\n'. */
717 buf
= XNEWVEC (uchar
, size
+ 16);
719 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
728 buf
= XRESIZEVEC (uchar
, buf
, size
+ 16);
734 cpp_errno_filename (pfile
, CPP_DL_ERROR
, file
->path
, loc
);
739 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
740 cpp_error_at (pfile
, CPP_DL_WARNING
, loc
,
741 "%s is shorter than expected", file
->path
);
743 file
->buffer
= _cpp_convert_input (pfile
,
744 CPP_OPTION (pfile
, input_charset
),
745 buf
, size
+ 16, total
,
748 file
->buffer_valid
= true;
753 /* Convenience wrapper around read_file_guts that opens the file if
754 necessary and closes the file descriptor after reading. FILE must
755 have been passed through find_file() at some stage. Use LOC for
758 read_file (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
)
760 /* If we already have its contents in memory, succeed immediately. */
761 if (file
->buffer_valid
)
764 /* If an earlier read failed for some reason don't try again. */
765 if (file
->dont_read
|| file
->err_no
)
768 if (file
->fd
== -1 && !open_file (file
))
770 open_file_failed (pfile
, file
, 0, loc
);
774 file
->dont_read
= !read_file_guts (pfile
, file
, loc
);
778 return !file
->dont_read
;
781 /* Returns TRUE if FILE's contents have been successfully placed in
782 FILE->buffer and the file should be stacked, otherwise false.
783 Use LOC for any diagnostics. */
785 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
,
790 /* Skip once-only files. */
794 /* We must mark the file once-only if #import now, before header
795 guard checks. Otherwise, undefining the header guard might
796 cause the file to be re-stacked. */
799 _cpp_mark_file_once_only (pfile
, file
);
801 /* Don't stack files that have been stacked before. */
802 if (file
->stack_count
)
806 /* Skip if the file had a header guard and the macro is defined.
807 PCH relies on this appearing before the PCH handler below. */
808 if (file
->cmacro
&& cpp_macro_p (file
->cmacro
))
811 /* Handle PCH files immediately; don't stack them. */
814 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
816 free ((void *) file
->pchname
);
817 file
->pchname
= NULL
;
821 if (!read_file (pfile
, file
, loc
))
824 /* Check the file against the PCH file. This is done before
825 checking against files we've already seen, since it may save on
827 if (check_file_against_entries (pfile
, file
, import
))
829 /* If this isn't a #import, but yet we can't include the file,
830 that means that it was #import-ed in the PCH file,
831 so we can never include it again. */
833 _cpp_mark_file_once_only (pfile
, file
);
837 /* Now we've read the file's contents, we can stack it if there
838 are no once-only files. */
839 if (!pfile
->seen_once_only
)
842 /* We may have read the file under a different name. Look
843 for likely candidates and compare file contents to be sure. */
844 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
849 if ((import
|| f
->once_only
)
851 && f
->st
.st_mtime
== file
->st
.st_mtime
852 && f
->st
.st_size
== file
->st
.st_size
)
855 bool same_file_p
= false;
857 if (f
->buffer
&& !f
->buffer_valid
)
859 /* We already have a buffer but it is not valid, because
860 the file is still stacked. Make a new one. */
861 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
862 ref_file
->path
= f
->path
;
865 /* The file is not stacked anymore. We can reuse it. */
868 same_file_p
= read_file (pfile
, ref_file
, loc
)
869 /* Size might have changed in read_file(). */
870 && ref_file
->st
.st_size
== file
->st
.st_size
871 && !memcmp (ref_file
->buffer
,
875 if (f
->buffer
&& !f
->buffer_valid
)
878 destroy_cpp_file (ref_file
);
889 /* Place the file referenced by FILE into a new buffer on the buffer
890 stack if possible. IMPORT is true if this stacking attempt is
891 because of a #import directive. Returns true if a buffer is
892 stacked. Use LOC for any diagnostics. */
894 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
,
900 if (!should_stack_file (pfile
, file
, import
, loc
))
903 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
906 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
908 /* Add the file to the dependencies on its first inclusion. */
909 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
911 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
912 deps_add_dep (pfile
->deps
, file
->path
);
915 /* Clear buffer_valid since _cpp_clean_line messes it up. */
916 file
->buffer_valid
= false;
919 /* Stack the buffer. */
920 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
921 CPP_OPTION (pfile
, preprocessed
)
922 && !CPP_OPTION (pfile
, directives_only
));
925 buffer
->to_free
= file
->buffer_start
;
927 /* Initialize controlling macro state. */
928 pfile
->mi_valid
= true;
929 pfile
->mi_cmacro
= 0;
931 /* Generate the call back. */
932 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
937 /* Mark FILE to be included once only. */
939 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
941 pfile
->seen_once_only
= true;
942 file
->once_only
= true;
945 /* Return the directory from which searching for FNAME should start,
946 considering the directive TYPE and ANGLE_BRACKETS. If there is
947 nothing left in the path, returns NULL. */
948 static struct cpp_dir
*
949 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
950 enum include_type type
)
955 if (IS_ABSOLUTE_PATH (fname
))
956 return &pfile
->no_search_path
;
958 /* pfile->buffer is NULL when processing an -include command-line flag. */
959 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
961 /* For #include_next, skip in the search path past the dir in which
962 the current file was found, but if it was found via an absolute
963 path use the normal search logic. */
964 if (type
== IT_INCLUDE_NEXT
&& file
->dir
965 && file
->dir
!= &pfile
->no_search_path
)
966 dir
= file
->dir
->next
;
967 else if (angle_brackets
)
968 dir
= pfile
->bracket_include
;
969 else if (type
== IT_CMDLINE
)
970 /* -include and -imacros use the #include "" chain with the
971 preprocessor's cwd prepended. */
972 return make_cpp_dir (pfile
, "./", false);
973 else if (pfile
->quote_ignores_source_dir
)
974 dir
= pfile
->quote_include
;
976 return make_cpp_dir (pfile
, dir_name_of_file (file
),
977 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
980 cpp_error (pfile
, CPP_DL_ERROR
,
981 "no include path in which to search for %s", fname
);
986 /* Strip the basename from the file's path. It ends with a slash if
987 of nonzero length. Note that this procedure also works for
988 <stdin>, which is represented by the empty string. */
990 dir_name_of_file (_cpp_file
*file
)
994 size_t len
= lbasename (file
->path
) - file
->path
;
995 char *dir_name
= XNEWVEC (char, len
+ 1);
997 memcpy (dir_name
, file
->path
, len
);
998 dir_name
[len
] = '\0';
999 file
->dir_name
= dir_name
;
1002 return file
->dir_name
;
1005 /* Handles #include-family directives (distinguished by TYPE),
1006 including HEADER, and the command line -imacros and -include.
1007 Returns true if a buffer was stacked. */
1009 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
1010 enum include_type type
, location_t loc
)
1012 struct cpp_dir
*dir
;
1015 bool decremented
= false;
1017 /* For -include command-line flags we have type == IT_CMDLINE.
1018 When the first -include file is processed we have the case, where
1019 pfile->cur_token == pfile->cur_run->base, we are directly called up
1020 by the front end. However in the case of the second -include file,
1021 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1022 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1023 and pfile->cur_token[-1].src_loc not (yet) initialized.
1024 However, when the include file cannot be found, we need src_loc to
1025 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1026 if (type
== IT_CMDLINE
&& pfile
->cur_token
!= pfile
->cur_run
->base
)
1027 pfile
->cur_token
[-1].src_loc
= 0;
1029 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
1033 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
,
1034 type
== IT_DEFAULT
, loc
);
1035 if (type
== IT_DEFAULT
&& file
== NULL
)
1038 /* Compensate for the increment in linemap_add that occurs if
1039 _cpp_stack_file actually stacks the file. In the case of a normal
1040 #include, we're currently at the start of the line *following* the
1041 #include. A separate location_t for this location makes no
1042 sense (until we do the LC_LEAVE), and complicates
1043 LAST_SOURCE_LINE_LOCATION. This does not apply if we found a PCH
1044 file (in which case linemap_add is not called) or we were included
1045 from the command-line. In the case that the #include is the last
1046 line in the file, highest_location still points to the current
1047 line, not the start of the next line, so we do not decrement in
1048 this case. See plugin/location-overflow-test-pr83173.h for an
1050 if (file
->pchname
== NULL
&& file
->err_no
== 0
1051 && type
!= IT_CMDLINE
&& type
!= IT_DEFAULT
)
1053 int highest_line
= linemap_get_expansion_line (pfile
->line_table
,
1054 pfile
->line_table
->highest_location
);
1055 int source_line
= linemap_get_expansion_line (pfile
->line_table
, loc
);
1056 if (highest_line
> source_line
)
1058 pfile
->line_table
->highest_location
--;
1063 stacked
= _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
, loc
);
1065 if (decremented
&& !stacked
)
1066 /* _cpp_stack_file didn't stack the file, so let's rollback the
1067 compensation dance we performed above. */
1068 pfile
->line_table
->highest_location
++;
1073 /* Could not open FILE. The complication is dependency output. */
1075 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
,
1078 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
1079 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
1081 if (pfile
->state
.in__has_include__
)
1084 errno
= file
->err_no
;
1085 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
1087 deps_add_dep (pfile
->deps
, file
->name
);
1088 /* If the preprocessor output (other than dependency information) is
1089 being used, we must also flag an error. */
1090 if (CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1091 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1092 file
->path
? file
->path
: file
->name
,
1097 /* If we are not outputting dependencies, or if we are and dependencies
1098 were requested for this file, or if preprocessor output is needed
1099 in addition to dependency information, this is an error.
1101 Otherwise (outputting dependencies but not for this file, and not
1102 using the preprocessor output), we can still produce correct output
1103 so it's only a warning. */
1104 if (CPP_OPTION (pfile
, deps
.style
) == DEPS_NONE
1106 || CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1107 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1108 file
->path
? file
->path
: file
->name
,
1111 cpp_errno_filename (pfile
, CPP_DL_WARNING
,
1112 file
->path
? file
->path
: file
->name
,
1117 /* Search in the chain beginning at HEAD for a file whose search path
1118 started at START_DIR != NULL. */
1119 static struct cpp_file_hash_entry
*
1120 search_cache (struct cpp_file_hash_entry
*head
, const cpp_dir
*start_dir
)
1122 while (head
&& head
->start_dir
!= start_dir
)
1128 /* Allocate a new _cpp_file structure. */
1130 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
1134 file
= XCNEW (_cpp_file
);
1135 file
->main_file
= !pfile
->buffer
;
1138 file
->name
= xstrdup (fname
);
1143 /* Release a _cpp_file structure. */
1145 destroy_cpp_file (_cpp_file
*file
)
1147 free ((void *) file
->buffer_start
);
1148 free ((void *) file
->name
);
1149 free ((void *) file
->path
);
1153 /* Release all the files allocated by this reader. */
1155 destroy_all_cpp_files (cpp_reader
*pfile
)
1157 _cpp_file
*iter
= pfile
->all_files
;
1160 _cpp_file
*next
= iter
->next_file
;
1161 destroy_cpp_file (iter
);
1166 /* A hash of directory names. The directory names are the path names
1167 of files which contain a #include "", the included file name is
1168 appended to this directories.
1170 To avoid duplicate entries we follow the convention that all
1171 non-empty directory names should end in a '/'. DIR_NAME must be
1172 stored in permanently allocated memory. */
1174 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
1176 struct cpp_file_hash_entry
*entry
, **hash_slot
;
1179 hash_slot
= (struct cpp_file_hash_entry
**)
1180 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
1181 htab_hash_string (dir_name
),
1184 /* Have we already hashed this directory? */
1185 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
1186 if (entry
->start_dir
== NULL
)
1187 return entry
->u
.dir
;
1189 dir
= XCNEW (cpp_dir
);
1190 dir
->next
= pfile
->quote_include
;
1191 dir
->name
= (char *) dir_name
;
1192 dir
->len
= strlen (dir_name
);
1196 /* Store this new result in the hash table. */
1197 entry
= new_file_hash_entry (pfile
);
1198 entry
->next
= *hash_slot
;
1199 entry
->start_dir
= NULL
;
1200 entry
->location
= pfile
->line_table
->highest_location
;
1207 /* Create a new block of memory for file hash entries. */
1209 allocate_file_hash_entries (cpp_reader
*pfile
)
1211 struct file_hash_entry_pool
*pool
= XNEW (struct file_hash_entry_pool
);
1212 pool
->file_hash_entries_used
= 0;
1213 pool
->next
= pfile
->file_hash_entries
;
1214 pfile
->file_hash_entries
= pool
;
1217 /* Return a new file hash entry. */
1218 static struct cpp_file_hash_entry
*
1219 new_file_hash_entry (cpp_reader
*pfile
)
1222 if (pfile
->file_hash_entries
->file_hash_entries_used
== FILE_HASH_POOL_SIZE
)
1223 allocate_file_hash_entries (pfile
);
1225 idx
= pfile
->file_hash_entries
->file_hash_entries_used
++;
1226 return &pfile
->file_hash_entries
->pool
[idx
];
1229 /* Free the file hash entry pools. */
1231 free_file_hash_entries (cpp_reader
*pfile
)
1233 struct file_hash_entry_pool
*iter
= pfile
->file_hash_entries
;
1236 struct file_hash_entry_pool
*next
= iter
->next
;
1242 /* Returns TRUE if a file FNAME has ever been successfully opened.
1243 This routine is not intended to correctly handle filenames aliased
1244 by links or redundant . or .. traversals etc. */
1246 cpp_included (cpp_reader
*pfile
, const char *fname
)
1248 struct cpp_file_hash_entry
*entry
;
1250 entry
= (struct cpp_file_hash_entry
*)
1251 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1253 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1254 entry
= entry
->next
;
1256 return entry
!= NULL
;
1259 /* Returns TRUE if a file FNAME has ever been successfully opened
1260 before LOCATION. This routine is not intended to correctly handle
1261 filenames aliased by links or redundant . or .. traversals etc. */
1263 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1264 location_t location
)
1266 struct cpp_file_hash_entry
*entry
1267 = (struct cpp_file_hash_entry
*)
1268 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1270 if (IS_ADHOC_LOC (location
))
1271 location
= get_location_from_adhoc_loc (pfile
->line_table
, location
);
1273 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1274 || entry
->location
> location
))
1275 entry
= entry
->next
;
1277 return entry
!= NULL
;
1280 /* Calculate the hash value of a file hash entry P. */
1283 file_hash_hash (const void *p
)
1285 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1287 if (entry
->start_dir
)
1288 hname
= entry
->u
.file
->name
;
1290 hname
= entry
->u
.dir
->name
;
1292 return htab_hash_string (hname
);
1295 /* Compare a string Q against a file hash entry P. */
1297 file_hash_eq (const void *p
, const void *q
)
1299 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1300 const char *fname
= (const char *) q
;
1303 if (entry
->start_dir
)
1304 hname
= entry
->u
.file
->name
;
1306 hname
= entry
->u
.dir
->name
;
1308 return filename_cmp (hname
, fname
) == 0;
1311 /* Compare entries in the nonexistent file hash table. These are just
1314 nonexistent_file_hash_eq (const void *p
, const void *q
)
1316 return filename_cmp ((const char *) p
, (const char *) q
) == 0;
1319 /* Initialize everything in this source file. */
1321 _cpp_init_files (cpp_reader
*pfile
)
1323 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1324 NULL
, xcalloc
, free
);
1325 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1326 NULL
, xcalloc
, free
);
1327 allocate_file_hash_entries (pfile
);
1328 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1329 nonexistent_file_hash_eq
,
1330 NULL
, xcalloc
, free
);
1331 obstack_specify_allocation (&pfile
->nonexistent_file_ob
, 0, 0,
1335 /* Finalize everything in this source file. */
1337 _cpp_cleanup_files (cpp_reader
*pfile
)
1339 htab_delete (pfile
->file_hash
);
1340 htab_delete (pfile
->dir_hash
);
1341 htab_delete (pfile
->nonexistent_file_hash
);
1342 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1343 free_file_hash_entries (pfile
);
1344 destroy_all_cpp_files (pfile
);
1347 /* Make the parser forget about files it has seen. This can be useful
1348 for resetting the parser to start another run. */
1350 cpp_clear_file_cache (cpp_reader
*pfile
)
1352 _cpp_cleanup_files (pfile
);
1353 pfile
->file_hash_entries
= NULL
;
1354 pfile
->all_files
= NULL
;
1355 _cpp_init_files (pfile
);
1358 /* Enter a file name in the hash for the sake of cpp_included. */
1360 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1362 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0, false, 0);
1365 /* Not everyone who wants to set system-header-ness on a buffer can
1366 see the details of a buffer. This is an exported interface because
1367 fix-header needs it. */
1369 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1372 const struct line_maps
*line_table
= pfile
->line_table
;
1373 const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1374 /* 1 = system header, 2 = system header to be treated as C. */
1376 flags
= 1 + (externc
!= 0);
1377 pfile
->buffer
->sysp
= flags
;
1378 _cpp_do_file_change (pfile
, LC_RENAME
, ORDINARY_MAP_FILE_NAME (map
),
1379 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1382 /* Allow the client to change the current file. Used by the front end
1383 to achieve pseudo-file names like <built-in>.
1384 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1386 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1387 const char *new_name
)
1389 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1392 struct report_missing_guard_data
1398 /* Callback function for htab_traverse. */
1400 report_missing_guard (void **slot
, void *d
)
1402 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) *slot
;
1403 struct report_missing_guard_data
*data
1404 = (struct report_missing_guard_data
*) d
;
1406 /* Skip directories. */
1407 if (entry
->start_dir
!= NULL
)
1409 _cpp_file
*file
= entry
->u
.file
;
1411 /* We don't want MI guard advice for the main file. */
1412 if (!file
->once_only
&& file
->cmacro
== NULL
1413 && file
->stack_count
== 1 && !file
->main_file
)
1415 if (data
->paths
== NULL
)
1417 data
->paths
= XCNEWVEC (const char *, data
->count
);
1421 data
->paths
[data
->count
++] = file
->path
;
1425 /* Keep traversing the hash table. */
1429 /* Comparison function for qsort. */
1431 report_missing_guard_cmp (const void *p1
, const void *p2
)
1433 return strcmp (*(const char *const *) p1
, *(const char *const *) p2
);
1436 /* Report on all files that might benefit from a multiple include guard.
1439 _cpp_report_missing_guards (cpp_reader
*pfile
)
1441 struct report_missing_guard_data data
;
1444 data
.count
= htab_elements (pfile
->file_hash
);
1445 htab_traverse (pfile
->file_hash
, report_missing_guard
, &data
);
1447 if (data
.paths
!= NULL
)
1451 /* Sort the paths to avoid outputting them in hash table
1453 qsort (data
.paths
, data
.count
, sizeof (const char *),
1454 report_missing_guard_cmp
);
1455 fputs (_("Multiple include guards may be useful for:\n"),
1457 for (i
= 0; i
< data
.count
; i
++)
1459 fputs (data
.paths
[i
], stderr
);
1460 putc ('\n', stderr
);
1466 /* Locate HEADER, and determine whether it is newer than the current
1467 file. If it cannot be located or dated, return -1, if it is
1468 newer, return 1, otherwise 0. */
1470 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1474 struct cpp_dir
*dir
;
1476 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1480 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
, false, 0);
1490 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1493 /* Pushes the given file onto the buffer stack. Returns nonzero if
1496 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1498 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
, 0);
1501 /* Pushes the given file, implicitly included at the start of a
1502 compilation, onto the buffer stack but without any errors if the
1503 file is not found. Returns nonzero if successful. */
1505 cpp_push_default_include (cpp_reader
*pfile
, const char *fname
)
1507 return _cpp_stack_include (pfile
, fname
, true, IT_DEFAULT
, 0);
1510 /* Do appropriate cleanup when a file INC's buffer is popped off the
1513 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
,
1514 const unsigned char *to_free
)
1516 /* Record the inclusion-preventing macro, which could be NULL
1517 meaning no controlling macro. */
1518 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1519 file
->cmacro
= pfile
->mi_cmacro
;
1521 /* Invalidate control macros in the #including file. */
1522 pfile
->mi_valid
= false;
1526 if (to_free
== file
->buffer_start
)
1528 file
->buffer_start
= NULL
;
1529 file
->buffer
= NULL
;
1530 file
->buffer_valid
= false;
1532 free ((void *) to_free
);
1536 /* Return the file name associated with FILE. */
1538 _cpp_get_file_name (_cpp_file
*file
)
1543 /* Inteface to file statistics record in _cpp_file structure. */
1545 _cpp_get_file_stat (_cpp_file
*file
)
1550 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1551 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1552 directory of the including file.
1554 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1556 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1557 int quote_ignores_source_dir
)
1559 pfile
->quote_include
= quote
;
1560 pfile
->bracket_include
= quote
;
1561 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1563 for (; quote
; quote
= quote
->next
)
1565 quote
->name_map
= NULL
;
1566 quote
->len
= strlen (quote
->name
);
1567 if (quote
== bracket
)
1568 pfile
->bracket_include
= bracket
;
1572 /* Append the file name to the directory to create the path, but don't
1573 turn / into // or // into ///; // may be a namespace escape. */
1575 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1581 flen
= strlen (fname
);
1582 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1583 memcpy (path
, dir
->name
, dlen
);
1584 if (dlen
&& !IS_DIR_SEPARATOR (path
[dlen
- 1]))
1586 memcpy (&path
[dlen
], fname
, flen
+ 1);
1591 /* Read a space delimited string of unlimited length from a stdio
1594 read_filename_string (int ch
, FILE *f
)
1600 set
= alloc
= XNEWVEC (char, len
+ 1);
1601 if (! is_space (ch
))
1604 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1606 if (set
- alloc
== len
)
1609 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1610 set
= alloc
+ len
/ 2;
1620 /* Read the file name map file for DIR. */
1622 read_name_map (cpp_dir
*dir
)
1624 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1627 size_t len
, count
= 0, room
= 9;
1630 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1631 memcpy (name
, dir
->name
, len
);
1632 if (len
&& !IS_DIR_SEPARATOR (name
[len
- 1]))
1634 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1635 f
= fopen (name
, "r");
1637 dir
->name_map
= XNEWVEC (const char *, room
);
1639 /* Silently return NULL if we cannot open. */
1644 while ((ch
= getc (f
)) != EOF
)
1651 if (count
+ 2 > room
)
1654 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1657 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1658 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1661 to
= read_filename_string (ch
, f
);
1662 if (IS_ABSOLUTE_PATH (to
))
1663 dir
->name_map
[count
+ 1] = to
;
1666 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1671 while ((ch
= getc (f
)) != '\n')
1679 /* Terminate the list of maps. */
1680 dir
->name_map
[count
] = NULL
;
1683 /* Remap a FILE's name based on the file_name_map, if any, for
1684 FILE->dir. If the file name has any directory separators,
1685 recursively check those directories too. */
1687 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1689 const char *fname
, *p
;
1700 read_name_map (dir
);
1702 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1703 if (!filename_cmp (dir
->name_map
[index
], fname
))
1704 return xstrdup (dir
->name_map
[index
+ 1]);
1705 if (IS_ABSOLUTE_PATH (fname
))
1707 p
= strchr (fname
, '/');
1708 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1710 char *p2
= strchr (fname
, '\\');
1715 if (!p
|| p
== fname
)
1718 len
= dir
->len
+ (p
- fname
+ 1);
1719 new_dir
= XNEWVEC (char, len
+ 2);
1720 p3
= new_dir
+ dir
->len
;
1721 memcpy (new_dir
, dir
->name
, dir
->len
);
1722 if (dir
->len
&& !IS_DIR_SEPARATOR (dir
->name
[dir
->len
- 1]))
1727 memcpy (p3
, fname
, p
- fname
+ 1);
1728 new_dir
[len
] = '\0';
1730 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1735 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1737 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1739 const char *saved_path
= file
->path
;
1742 file
->path
= pchname
;
1743 if (open_file (file
))
1745 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1753 if (CPP_OPTION (pfile
, print_include_names
))
1756 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1758 fprintf (stderr
, "%c %s\n",
1759 valid
? '!' : 'x', pchname
);
1763 file
->path
= saved_path
;
1767 /* Get the path associated with the _cpp_file F. The path includes
1768 the base name from the include directive and the directory it was
1769 found in via the search path. */
1772 cpp_get_path (struct _cpp_file
*f
)
1777 /* Get the directory associated with the _cpp_file F. */
1780 cpp_get_dir (struct _cpp_file
*f
)
1785 /* Get the cpp_buffer currently associated with the cpp_reader
1789 cpp_get_buffer (cpp_reader
*pfile
)
1791 return pfile
->buffer
;
1794 /* Get the _cpp_file associated with the cpp_buffer B. */
1797 cpp_get_file (cpp_buffer
*b
)
1802 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1803 buffer is the buffer that included the given buffer. */
1806 cpp_get_prev (cpp_buffer
*b
)
1811 /* This data structure holds the list of header files that were seen
1812 while the PCH was being built. The 'entries' field is kept sorted
1813 in memcmp() order; yes, this means that on little-endian systems,
1814 it's sorted initially by the least-significant byte of 'size', but
1815 that's OK. The code does rely on having entries with the same size
1816 next to each other. */
1819 /* The size of this file. This is used to save running a MD5 checksum
1820 if the sizes don't match. */
1822 /* The MD5 checksum of this file. */
1823 unsigned char sum
[16];
1824 /* Is this file to be included only once? */
1829 /* Number of pchf_entry structures. */
1832 /* Are there any values with once_only set?
1833 This is used as an optimisation, it means we don't have to search
1834 the structure if we're processing a regular #include. */
1835 bool have_once_only
;
1837 struct pchf_entry entries
[1];
1840 static struct pchf_data
*pchf
;
1842 /* A qsort ordering function for pchf_entry structures. */
1845 pchf_save_compare (const void *e1
, const void *e2
)
1847 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1850 /* Create and write to F a pchf_data structure. */
1853 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1856 struct pchf_data
*result
;
1861 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1864 result_size
= (sizeof (struct pchf_data
)
1865 + sizeof (struct pchf_entry
) * (count
- 1));
1866 result
= XCNEWVAR (struct pchf_data
, result_size
);
1869 result
->have_once_only
= false;
1871 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1875 /* This should probably never happen, since if a read error occurred
1876 the PCH file shouldn't be written... */
1877 if (f
->dont_read
|| f
->err_no
)
1880 if (f
->stack_count
== 0)
1883 count
= result
->count
++;
1885 result
->entries
[count
].once_only
= f
->once_only
;
1886 /* |= is avoided in the next line because of an HP C compiler bug */
1887 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1888 if (f
->buffer_valid
)
1889 md5_buffer ((const char *)f
->buffer
,
1890 f
->st
.st_size
, result
->entries
[count
].sum
);
1898 open_file_failed (pfile
, f
, 0, 0);
1902 ff
= fdopen (f
->fd
, "rb");
1903 md5_stream (ff
, result
->entries
[count
].sum
);
1907 result
->entries
[count
].size
= f
->st
.st_size
;
1910 result_size
= (sizeof (struct pchf_data
)
1911 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1913 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1916 ret
= fwrite (result
, result_size
, 1, fp
) == 1;
1921 /* Read the pchf_data structure from F. */
1924 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1928 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1932 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1933 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1934 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1935 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1941 /* The parameters for pchf_compare. */
1943 struct pchf_compare_data
1945 /* The size of the file we're looking for. */
1948 /* The MD5 checksum of the file, if it's been computed. */
1949 unsigned char sum
[16];
1954 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1955 bool check_included
;
1957 /* The file that we're searching for. */
1961 /* bsearch comparison function; look for D_P in E_P. */
1964 pchf_compare (const void *d_p
, const void *e_p
)
1966 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1967 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1970 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1974 if (! d
->sum_computed
)
1976 _cpp_file
*const f
= d
->f
;
1978 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1979 d
->sum_computed
= true;
1982 result
= memcmp (d
->sum
, e
->sum
, 16);
1986 if (d
->check_included
|| e
->once_only
)
1992 /* Check that F is not in a list read from a PCH file (if any).
1993 Assumes that f->buffer_valid is true. Return TRUE if the file
1994 should not be read. */
1997 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1999 bool check_included
)
2001 struct pchf_compare_data d
;
2004 || (! check_included
&& ! pchf
->have_once_only
))
2007 d
.size
= f
->st
.st_size
;
2008 d
.sum_computed
= false;
2010 d
.check_included
= check_included
;
2011 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
2012 pchf_compare
) != NULL
;
2015 /* Return true if the file FNAME is found in the appropriate include file path
2016 as indicated by ANGLE_BRACKETS. */
2019 _cpp_has_header (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
2020 enum include_type type
)
2022 cpp_dir
*start_dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
2023 _cpp_file
*file
= _cpp_find_file (pfile
, fname
, start_dir
,
2024 /*fake=*/false, angle_brackets
,
2025 /*implicit_preinclude=*/false, 0);
2026 return file
->err_no
!= ENOENT
;