1 /* Part of CPP library. File handling.
2 Copyright (C) 1986-2020 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. */
110 bool buffer_valid
: 1;
112 /* If this file is implicitly preincluded. */
113 bool implicit_preinclude
: 1;
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 struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
180 int angle_brackets
, enum include_type
);
181 static const char *dir_name_of_file (_cpp_file
*file
);
182 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int,
184 static struct cpp_file_hash_entry
*search_cache (struct cpp_file_hash_entry
*head
,
185 const cpp_dir
*start_dir
);
186 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
187 static void destroy_cpp_file (_cpp_file
*);
188 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
189 static void allocate_file_hash_entries (cpp_reader
*pfile
);
190 static struct cpp_file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
191 static int report_missing_guard (void **slot
, void *b
);
192 static hashval_t
file_hash_hash (const void *p
);
193 static int file_hash_eq (const void *p
, const void *q
);
194 static char *read_filename_string (int ch
, FILE *f
);
195 static void read_name_map (cpp_dir
*dir
);
196 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
197 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
198 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
199 static int pchf_save_compare (const void *e1
, const void *e2
);
200 static int pchf_compare (const void *d_p
, const void *e_p
);
201 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
203 /* Given a filename in FILE->PATH, with the empty string interpreted
206 On success FILE contains an open file descriptor and stat
207 information for the file. On failure the file descriptor is -1 and
208 the appropriate errno is also stored in FILE. Returns TRUE iff
211 We used to open files in nonblocking mode, but that caused more
212 problems than it solved. Do take care not to acquire a controlling
213 terminal by mistake (this can't happen on sane systems, but
214 paranoia is a virtue).
216 Use the three-argument form of open even though we aren't
217 specifying O_CREAT, to defend against broken system headers.
219 O_BINARY tells some runtime libraries (notably DJGPP) not to do
220 newline translation; we can handle DOS line breaks just fine
223 open_file (_cpp_file
*file
)
225 if (file
->path
[0] == '\0')
228 set_stdin_to_binary_mode ();
231 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
235 if (fstat (file
->fd
, &file
->st
) == 0)
237 if (!S_ISDIR (file
->st
.st_mode
))
243 /* Ignore a directory and continue the search. The file we're
244 looking for may be elsewhere in the search path. */
251 #if defined(_WIN32) && !defined(__CYGWIN__)
252 else if (errno
== EACCES
)
254 /* On most UNIX systems, open succeeds on a directory. Above,
255 we check if we have opened a directory and if so, set errno
256 to ENOENT. However, on Windows, opening a directory
257 fails with EACCES. We want to return ENOENT in that
259 if (stat (file
->path
, &file
->st
) == 0
260 && S_ISDIR (file
->st
.st_mode
))
263 /* The call to stat may have reset errno. */
267 else if (errno
== ENOTDIR
)
270 file
->err_no
= errno
;
275 /* Temporary PCH intercept of opening a file. Try to find a PCH file
276 based on FILE->name and FILE->dir, and test those found for
277 validity using PFILE->cb.valid_pch. Return true iff a valid file is
278 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
281 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
283 static const char extension
[] = ".gch";
284 const char *path
= file
->path
;
290 /* No PCH on <stdin> or if not requested. */
291 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
294 /* If the file is not included as first include from either the toplevel
295 file or the command-line it is not a valid use of PCH. */
296 for (_cpp_file
*f
= pfile
->all_files
; f
; f
= f
->next_file
)
297 if (f
->implicit_preinclude
)
299 else if (f
->main_file
)
304 flen
= strlen (path
);
305 len
= flen
+ sizeof (extension
);
306 pchname
= XNEWVEC (char, len
);
307 memcpy (pchname
, path
, flen
);
308 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
310 if (stat (pchname
, &st
) == 0)
314 size_t dlen
, plen
= len
;
316 if (!S_ISDIR (st
.st_mode
))
317 valid
= validate_pch (pfile
, file
, pchname
);
318 else if ((pchdir
= opendir (pchname
)) != NULL
)
320 pchname
[plen
- 1] = '/';
321 while ((d
= readdir (pchdir
)) != NULL
)
323 dlen
= strlen (d
->d_name
) + 1;
324 if ((strcmp (d
->d_name
, ".") == 0)
325 || (strcmp (d
->d_name
, "..") == 0))
327 if (dlen
+ plen
> len
)
330 pchname
= XRESIZEVEC (char, pchname
, len
);
332 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
333 valid
= validate_pch (pfile
, file
, pchname
);
344 file
->pchname
= pchname
;
351 /* Canonicalize the path to FILE. Return the canonical form if it is
352 shorter, otherwise return NULL. This function does NOT free the
353 memory pointed by FILE. */
356 maybe_shorter_path (const char * file
)
358 char * file2
= lrealpath (file
);
359 if (file2
&& strlen (file2
) < strlen (file
))
370 /* Try to open the path FILE->name appended to FILE->dir. This is
371 where remap and PCH intercept the file lookup process. Return true
372 if the file was found, whether or not the open was successful.
373 Set *INVALID_PCH to true if a PCH file is found but wasn't valid.
374 Use LOC when emitting any diagnostics. */
377 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
,
382 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
385 if (file
->dir
->construct
)
386 path
= file
->dir
->construct (file
->name
, file
->dir
);
388 path
= append_file_to_dir (file
->name
, file
->dir
);
396 /* We try to canonicalize system headers. For DOS based file
397 * system, we always try to shorten non-system headers, as DOS
398 * has a tighter constraint on max path length. */
399 if ((CPP_OPTION (pfile
, canonical_system_headers
) && file
->dir
->sysp
)
400 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
405 char * canonical_path
= maybe_shorter_path (path
);
408 /* The canonical path was newly allocated. Let's free the
409 non-canonical one. */
411 path
= canonical_path
;
415 hv
= htab_hash_string (path
);
416 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
418 file
->err_no
= ENOENT
;
423 if (pch_open_file (pfile
, file
, invalid_pch
))
426 if (open_file (file
))
429 if (file
->err_no
!= ENOENT
)
431 open_file_failed (pfile
, file
, 0, loc
);
435 /* We copy the path name onto an obstack partly so that we don't
436 leak the memory, but mostly so that we don't fragment the
438 copy
= (char *) obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
441 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
445 file
->path
= file
->name
;
449 file
->err_no
= ENOENT
;
456 /* Return true iff the missing_header callback found the given HEADER. */
458 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
460 missing_header_cb func
= pfile
->cb
.missing_header
;
462 /* When the regular search path doesn't work, try context dependent
463 headers search paths. */
465 && file
->dir
== NULL
)
467 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
469 if (open_file (file
))
471 free ((void *)file
->path
);
473 file
->path
= file
->name
;
480 _cpp_find_failed (_cpp_file
*file
)
482 return file
->err_no
!= 0;
485 /* Given a filename FNAME search for such a file in the include path
486 starting from START_DIR. If FNAME is the empty string it is
487 interpreted as STDIN if START_DIR is PFILE->no_search_path.
489 If the file is not found in the file cache fall back to the O/S and
490 add the result to our cache.
492 If the file was not found in the filesystem, or there was an error
493 opening it, then ERR_NO is nonzero and FD is -1. If the file was
494 found, then ERR_NO is zero and FD could be -1 or an open file
495 descriptor. FD can be -1 if the file was found in the cache and
496 had previously been closed. To open it again pass the return value
499 If KIND is _cpp_FFK_PRE_INCLUDE then it is OK for the file to be
500 missing. If present, it is OK for a precompiled header to be
503 Use LOC as the location for any errors. */
506 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
,
507 int angle_brackets
, _cpp_find_file_kind kind
, location_t loc
)
509 bool invalid_pch
= false;
510 bool saw_bracket_include
= false;
511 bool saw_quote_include
= false;
512 struct cpp_dir
*found_in_cache
= NULL
;
514 /* Ensure we get no confusion between cached files and directories. */
515 if (start_dir
== NULL
)
516 cpp_error_at (pfile
, CPP_DL_ICE
, loc
, "NULL directory in find_file");
519 = htab_find_slot_with_hash (pfile
->file_hash
, fname
,
520 htab_hash_string (fname
), INSERT
);
522 /* First check the cache before we resort to memory allocation. */
523 cpp_file_hash_entry
*entry
524 = search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, start_dir
);
526 return entry
->u
.file
;
528 _cpp_file
*file
= make_cpp_file (pfile
, start_dir
, fname
);
529 file
->implicit_preinclude
530 = (kind
== _cpp_FFK_PRE_INCLUDE
531 || (pfile
->buffer
&& pfile
->buffer
->file
->implicit_preinclude
));
533 if (kind
!= _cpp_FFK_FAKE
)
534 /* Try each path in the include chain. */
537 if (find_file_in_dir (pfile
, file
, &invalid_pch
, loc
))
540 file
->dir
= file
->dir
->next
;
541 if (file
->dir
== NULL
)
543 if (search_path_exhausted (pfile
, fname
, file
))
545 /* Although this file must not go in the cache,
546 because the file found might depend on things (like
547 the current file) that aren't represented in the
548 cache, it still has to go in the list of all files
549 so that #import works. */
550 file
->next_file
= pfile
->all_files
;
551 pfile
->all_files
= file
;
552 if (*hash_slot
== NULL
)
554 /* If *hash_slot is NULL, the above
555 htab_find_slot_with_hash call just created the
556 slot, but we aren't going to store there
557 anything, so need to remove the newly created
558 entry. htab_clear_slot requires that it is
559 non-NULL, so store there some non-NULL pointer,
560 htab_clear_slot will overwrite it
563 htab_clear_slot (pfile
->file_hash
, hash_slot
);
570 cpp_error (pfile
, CPP_DL_ERROR
,
571 "one or more PCH files were found,"
572 " but they were invalid");
573 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
574 cpp_error (pfile
, CPP_DL_ERROR
,
575 "use -Winvalid-pch for more information");
578 if (kind
== _cpp_FFK_PRE_INCLUDE
)
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 if (kind
!= _cpp_FFK_HAS_INCLUDE
)
592 open_file_failed (pfile
, file
, angle_brackets
, loc
);
596 /* Only check the cache for the starting location (done above)
597 and the quote and bracket chain heads because there are no
598 other possible starting points for searches. */
599 if (file
->dir
== pfile
->bracket_include
)
600 saw_bracket_include
= true;
601 else if (file
->dir
== pfile
->quote_include
)
602 saw_quote_include
= true;
607 = search_cache ((struct cpp_file_hash_entry
*) *hash_slot
, file
->dir
);
610 found_in_cache
= file
->dir
;
617 /* Cache for START_DIR too, sharing the _cpp_file structure. */
618 free ((char *) file
->name
);
620 file
= entry
->u
.file
;
624 /* This is a new file; put it in the list. */
625 file
->next_file
= pfile
->all_files
;
626 pfile
->all_files
= file
;
629 /* Store this new result in the hash table. */
630 entry
= new_file_hash_entry (pfile
);
631 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
632 entry
->start_dir
= start_dir
;
633 entry
->location
= loc
;
634 entry
->u
.file
= file
;
635 *hash_slot
= (void *) entry
;
637 /* If we passed the quote or bracket chain heads, cache them also.
638 This speeds up processing if there are lots of -I options. */
639 if (saw_bracket_include
640 && pfile
->bracket_include
!= start_dir
641 && found_in_cache
!= pfile
->bracket_include
)
643 entry
= new_file_hash_entry (pfile
);
644 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
645 entry
->start_dir
= pfile
->bracket_include
;
646 entry
->location
= loc
;
647 entry
->u
.file
= file
;
648 *hash_slot
= (void *) entry
;
650 if (saw_quote_include
651 && pfile
->quote_include
!= start_dir
652 && found_in_cache
!= pfile
->quote_include
)
654 entry
= new_file_hash_entry (pfile
);
655 entry
->next
= (struct cpp_file_hash_entry
*) *hash_slot
;
656 entry
->start_dir
= pfile
->quote_include
;
657 entry
->location
= loc
;
658 entry
->u
.file
= file
;
659 *hash_slot
= (void *) entry
;
665 /* Read a file into FILE->buffer, returning true on success.
667 If FILE->fd is something weird, like a block device, we don't want
668 to read it at all. Don't even try to figure out what something is,
669 except for plain files and block devices, since there is no
670 reliable portable way of doing this.
672 Use LOC for any diagnostics.
674 FIXME: Flush file cache and try again if we run out of memory. */
676 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
)
678 ssize_t size
, total
, count
;
682 if (S_ISBLK (file
->st
.st_mode
))
684 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
685 "%s is a block device", file
->path
);
689 regular
= S_ISREG (file
->st
.st_mode
) != 0;
692 /* off_t might have a wider range than ssize_t - in other words,
693 the max size of a file might be bigger than the address
694 space. We can't handle a file that large. (Anyone with
695 a single source file bigger than 2GB needs to rethink
696 their coding style.) Some systems (e.g. AIX 4.1) define
697 SSIZE_MAX to be much smaller than the actual range of the
698 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
700 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
702 cpp_error_at (pfile
, CPP_DL_ERROR
, loc
,
703 "%s is too large", file
->path
);
707 size
= file
->st
.st_size
;
710 /* 8 kilobytes is a sensible starting size. It ought to be bigger
711 than the kernel pipe buffer, and it's definitely bigger than
712 the majority of C source files. */
715 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
716 used to quiet warnings from valgrind or Address Sanitizer, when the
717 optimized lexer accesses aligned 16-byte memory chunks, including
718 the bytes after the malloced, area, and stops lexing on '\n'. */
719 buf
= XNEWVEC (uchar
, size
+ 16);
721 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
730 buf
= XRESIZEVEC (uchar
, buf
, size
+ 16);
736 cpp_errno_filename (pfile
, CPP_DL_ERROR
, file
->path
, loc
);
741 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
742 cpp_error_at (pfile
, CPP_DL_WARNING
, loc
,
743 "%s is shorter than expected", file
->path
);
745 file
->buffer
= _cpp_convert_input (pfile
,
746 CPP_OPTION (pfile
, input_charset
),
747 buf
, size
+ 16, total
,
750 file
->buffer_valid
= true;
755 /* Convenience wrapper around read_file_guts that opens the file if
756 necessary and closes the file descriptor after reading. FILE must
757 have been passed through find_file() at some stage. Use LOC for
760 read_file (cpp_reader
*pfile
, _cpp_file
*file
, location_t loc
)
762 /* If we already have its contents in memory, succeed immediately. */
763 if (file
->buffer_valid
)
766 /* If an earlier read failed for some reason don't try again. */
767 if (file
->dont_read
|| file
->err_no
)
770 if (file
->fd
== -1 && !open_file (file
))
772 open_file_failed (pfile
, file
, 0, loc
);
776 file
->dont_read
= !read_file_guts (pfile
, file
, loc
);
780 return !file
->dont_read
;
783 /* Returns TRUE if FILE is already known to be idempotent, and should
784 therefore not be read again. */
786 is_known_idempotent_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
788 /* Skip once-only files. */
792 /* We must mark the file once-only if #import now, before header
793 guard checks. Otherwise, undefining the header guard might
794 cause the file to be re-stacked. */
797 _cpp_mark_file_once_only (pfile
, file
);
799 /* Don't stack files that have been stacked before. */
800 if (file
->stack_count
)
804 /* Skip if the file had a header guard and the macro is defined.
805 PCH relies on this appearing before the PCH handler below. */
806 if (file
->cmacro
&& cpp_macro_p (file
->cmacro
))
809 /* Handle PCH files immediately; don't stack them. */
812 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
814 free ((void *) file
->pchname
);
815 file
->pchname
= NULL
;
822 /* Return TRUE if file has unique contents, so we should read process
823 it. The file's contents must already have been read. */
826 has_unique_contents (cpp_reader
*pfile
, _cpp_file
*file
, bool import
,
829 /* Check the file against the PCH file. This is done before
830 checking against files we've already seen, since it may save on
832 if (check_file_against_entries (pfile
, file
, import
))
834 /* If this isn't a #import, but yet we can't include the file,
835 that means that it was #import-ed in the PCH file,
836 so we can never include it again. */
838 _cpp_mark_file_once_only (pfile
, file
);
842 /* Now we've read the file's contents, we can stack it if there
843 are no once-only files. */
844 if (!pfile
->seen_once_only
)
847 /* We may have read the file under a different name. Look
848 for likely candidates and compare file contents to be sure. */
849 for (_cpp_file
*f
= pfile
->all_files
; f
; f
= f
->next_file
)
852 continue; /* It'sa me! */
854 if ((import
|| f
->once_only
)
856 && f
->st
.st_mtime
== file
->st
.st_mtime
857 && f
->st
.st_size
== file
->st
.st_size
)
861 if (f
->buffer
&& !f
->buffer_valid
)
863 /* We already have a buffer but it is not valid, because
864 the file is still stacked. Make a new one. */
865 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
866 ref_file
->path
= f
->path
;
869 /* The file is not stacked anymore. We can reuse it. */
872 bool same_file_p
= (read_file (pfile
, ref_file
, loc
)
873 /* Size might have changed in read_file(). */
874 && ref_file
->st
.st_size
== file
->st
.st_size
875 && !memcmp (ref_file
->buffer
, file
->buffer
,
878 if (f
->buffer
&& !f
->buffer_valid
)
881 destroy_cpp_file (ref_file
);
885 /* Already seen under a different name. */
893 /* Place the file referenced by FILE into a new buffer on the buffer
894 stack if possible. IMPORT is true if this stacking attempt is
895 because of a #import directive. Returns true if a buffer is
896 stacked. Use LOC for any diagnostics. */
898 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, include_type type
,
901 if (is_known_idempotent_file (pfile
, file
, type
== IT_IMPORT
))
904 if (!read_file (pfile
, file
, loc
))
907 if (!has_unique_contents (pfile
, file
, type
== IT_IMPORT
, loc
))
911 if (pfile
->buffer
&& file
->dir
)
912 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
914 /* Add the file to the dependencies on its first inclusion. */
915 if (CPP_OPTION (pfile
, deps
.style
) > (sysp
!= 0)
916 && !file
->stack_count
918 && !(file
->main_file
&& CPP_OPTION (pfile
, deps
.ignore_main_file
)))
919 deps_add_dep (pfile
->deps
, file
->path
);
921 /* Clear buffer_valid since _cpp_clean_line messes it up. */
922 file
->buffer_valid
= false;
925 /* Stack the buffer. */
927 = cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
928 CPP_OPTION (pfile
, preprocessed
)
929 && !CPP_OPTION (pfile
, directives_only
));
932 buffer
->to_free
= file
->buffer_start
;
934 /* Initialize controlling macro state. */
935 pfile
->mi_valid
= true;
936 pfile
->mi_cmacro
= 0;
938 /* In the case of a normal #include, we're now at the start of the
939 line *following* the #include. A separate location_t for this
940 location makes no sense, until we do the LC_LEAVE.
942 This does not apply if we found a PCH file, we're not a regular
943 include, or we ran out of locations. */
944 if (file
->pchname
== NULL
945 && type
< IT_DIRECTIVE_HWM
946 && pfile
->line_table
->highest_location
!= LINE_MAP_MAX_LOCATION
- 1)
947 pfile
->line_table
->highest_location
--;
949 /* Add line map and do callbacks. */
950 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
,
951 /* With preamble injection, start on line zero, so
952 the preamble doesn't appear to have been
953 included from line 1. */
954 type
== IT_MAIN_INJECT
? 0 : 1, sysp
);
959 /* Mark FILE to be included once only. */
961 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
963 pfile
->seen_once_only
= true;
964 file
->once_only
= true;
967 /* Return the directory from which searching for FNAME should start,
968 considering the directive TYPE and ANGLE_BRACKETS. If there is
969 nothing left in the path, returns NULL. */
970 static struct cpp_dir
*
971 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
972 enum include_type type
)
977 if (IS_ABSOLUTE_PATH (fname
))
978 return &pfile
->no_search_path
;
980 /* pfile->buffer is NULL when processing an -include command-line flag. */
981 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
983 /* For #include_next, skip in the search path past the dir in which
984 the current file was found, but if it was found via an absolute
985 path use the normal search logic. */
986 if (type
== IT_INCLUDE_NEXT
&& file
->dir
987 && file
->dir
!= &pfile
->no_search_path
)
988 dir
= file
->dir
->next
;
989 else if (angle_brackets
)
990 dir
= pfile
->bracket_include
;
991 else if (type
== IT_CMDLINE
)
992 /* -include and -imacros use the #include "" chain with the
993 preprocessor's cwd prepended. */
994 return make_cpp_dir (pfile
, "./", false);
995 else if (pfile
->quote_ignores_source_dir
)
996 dir
= pfile
->quote_include
;
998 return make_cpp_dir (pfile
, dir_name_of_file (file
),
999 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
1002 cpp_error (pfile
, CPP_DL_ERROR
,
1003 "no include path in which to search for %s", fname
);
1008 /* Strip the basename from the file's path. It ends with a slash if
1009 of nonzero length. Note that this procedure also works for
1010 <stdin>, which is represented by the empty string. */
1012 dir_name_of_file (_cpp_file
*file
)
1014 if (!file
->dir_name
)
1016 size_t len
= lbasename (file
->path
) - file
->path
;
1017 char *dir_name
= XNEWVEC (char, len
+ 1);
1019 memcpy (dir_name
, file
->path
, len
);
1020 dir_name
[len
] = '\0';
1021 file
->dir_name
= dir_name
;
1024 return file
->dir_name
;
1027 /* Handles #include-family directives (distinguished by TYPE),
1028 including HEADER, and the command line -imacros and -include.
1029 Returns true if a buffer was stacked. */
1031 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
1032 enum include_type type
, location_t loc
)
1034 /* For -include command-line flags we have type == IT_CMDLINE.
1035 When the first -include file is processed we have the case, where
1036 pfile->cur_token == pfile->cur_run->base, we are directly called up
1037 by the front end. However in the case of the second -include file,
1038 we are called from _cpp_lex_token -> _cpp_get_fresh_line ->
1039 cpp_push_include, with pfile->cur_token != pfile->cur_run->base,
1040 and pfile->cur_token[-1].src_loc not (yet) initialized.
1041 However, when the include file cannot be found, we need src_loc to
1042 be initialized to some safe value: 0 means UNKNOWN_LOCATION. */
1043 if (type
== IT_CMDLINE
&& pfile
->cur_token
!= pfile
->cur_run
->base
)
1044 pfile
->cur_token
[-1].src_loc
= 0;
1046 cpp_dir
*dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
1050 _cpp_file
*file
= _cpp_find_file (pfile
, fname
, dir
, angle_brackets
,
1051 type
== IT_DEFAULT
? _cpp_FFK_PRE_INCLUDE
1052 : _cpp_FFK_NORMAL
, loc
);
1053 if (type
== IT_DEFAULT
&& file
== NULL
)
1056 return _cpp_stack_file (pfile
, file
, type
, loc
);
1059 /* Could not open FILE. The complication is dependency output. */
1061 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
,
1064 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
1065 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
1067 errno
= file
->err_no
;
1068 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
1070 deps_add_dep (pfile
->deps
, file
->name
);
1071 /* If the preprocessor output (other than dependency information) is
1072 being used, we must also flag an error. */
1073 if (CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1074 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1075 file
->path
? file
->path
: file
->name
,
1080 /* If we are not outputting dependencies, or if we are and dependencies
1081 were requested for this file, or if preprocessor output is needed
1082 in addition to dependency information, this is an error.
1084 Otherwise (outputting dependencies but not for this file, and not
1085 using the preprocessor output), we can still produce correct output
1086 so it's only a warning. */
1087 if (CPP_OPTION (pfile
, deps
.style
) == DEPS_NONE
1089 || CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1090 cpp_errno_filename (pfile
, CPP_DL_FATAL
,
1091 file
->path
? file
->path
: file
->name
,
1094 cpp_errno_filename (pfile
, CPP_DL_WARNING
,
1095 file
->path
? file
->path
: file
->name
,
1100 /* Search in the chain beginning at HEAD for a file whose search path
1101 started at START_DIR != NULL. */
1102 static struct cpp_file_hash_entry
*
1103 search_cache (struct cpp_file_hash_entry
*head
, const cpp_dir
*start_dir
)
1105 while (head
&& head
->start_dir
!= start_dir
)
1111 /* Allocate a new _cpp_file structure. */
1113 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
1117 file
= XCNEW (_cpp_file
);
1118 file
->main_file
= !pfile
->buffer
;
1121 file
->name
= xstrdup (fname
);
1126 /* Release a _cpp_file structure. */
1128 destroy_cpp_file (_cpp_file
*file
)
1130 free ((void *) file
->buffer_start
);
1131 free ((void *) file
->name
);
1132 free ((void *) file
->path
);
1136 /* Release all the files allocated by this reader. */
1138 destroy_all_cpp_files (cpp_reader
*pfile
)
1140 _cpp_file
*iter
= pfile
->all_files
;
1143 _cpp_file
*next
= iter
->next_file
;
1144 destroy_cpp_file (iter
);
1149 /* A hash of directory names. The directory names are the path names
1150 of files which contain a #include "", the included file name is
1151 appended to this directories.
1153 To avoid duplicate entries we follow the convention that all
1154 non-empty directory names should end in a '/'. DIR_NAME must be
1155 stored in permanently allocated memory. */
1157 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
1159 struct cpp_file_hash_entry
*entry
, **hash_slot
;
1162 hash_slot
= (struct cpp_file_hash_entry
**)
1163 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
1164 htab_hash_string (dir_name
),
1167 /* Have we already hashed this directory? */
1168 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
1169 if (entry
->start_dir
== NULL
)
1170 return entry
->u
.dir
;
1172 dir
= XCNEW (cpp_dir
);
1173 dir
->next
= pfile
->quote_include
;
1174 dir
->name
= (char *) dir_name
;
1175 dir
->len
= strlen (dir_name
);
1179 /* Store this new result in the hash table. */
1180 entry
= new_file_hash_entry (pfile
);
1181 entry
->next
= *hash_slot
;
1182 entry
->start_dir
= NULL
;
1183 entry
->location
= pfile
->line_table
->highest_location
;
1190 /* Create a new block of memory for file hash entries. */
1192 allocate_file_hash_entries (cpp_reader
*pfile
)
1194 struct file_hash_entry_pool
*pool
= XNEW (struct file_hash_entry_pool
);
1195 pool
->file_hash_entries_used
= 0;
1196 pool
->next
= pfile
->file_hash_entries
;
1197 pfile
->file_hash_entries
= pool
;
1200 /* Return a new file hash entry. */
1201 static struct cpp_file_hash_entry
*
1202 new_file_hash_entry (cpp_reader
*pfile
)
1205 if (pfile
->file_hash_entries
->file_hash_entries_used
== FILE_HASH_POOL_SIZE
)
1206 allocate_file_hash_entries (pfile
);
1208 idx
= pfile
->file_hash_entries
->file_hash_entries_used
++;
1209 return &pfile
->file_hash_entries
->pool
[idx
];
1212 /* Free the file hash entry pools. */
1214 free_file_hash_entries (cpp_reader
*pfile
)
1216 struct file_hash_entry_pool
*iter
= pfile
->file_hash_entries
;
1219 struct file_hash_entry_pool
*next
= iter
->next
;
1225 /* Returns TRUE if a file FNAME has ever been successfully opened.
1226 This routine is not intended to correctly handle filenames aliased
1227 by links or redundant . or .. traversals etc. */
1229 cpp_included (cpp_reader
*pfile
, const char *fname
)
1231 struct cpp_file_hash_entry
*entry
;
1233 entry
= (struct cpp_file_hash_entry
*)
1234 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1236 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1237 entry
= entry
->next
;
1239 return entry
!= NULL
;
1242 /* Returns TRUE if a file FNAME has ever been successfully opened
1243 before LOCATION. This routine is not intended to correctly handle
1244 filenames aliased by links or redundant . or .. traversals etc. */
1246 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1247 location_t location
)
1249 struct cpp_file_hash_entry
*entry
1250 = (struct cpp_file_hash_entry
*)
1251 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1253 if (IS_ADHOC_LOC (location
))
1254 location
= get_location_from_adhoc_loc (pfile
->line_table
, location
);
1256 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1257 || entry
->location
> location
))
1258 entry
= entry
->next
;
1260 return entry
!= NULL
;
1263 /* Calculate the hash value of a file hash entry P. */
1266 file_hash_hash (const void *p
)
1268 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1270 if (entry
->start_dir
)
1271 hname
= entry
->u
.file
->name
;
1273 hname
= entry
->u
.dir
->name
;
1275 return htab_hash_string (hname
);
1278 /* Compare a string Q against a file hash entry P. */
1280 file_hash_eq (const void *p
, const void *q
)
1282 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) p
;
1283 const char *fname
= (const char *) q
;
1286 if (entry
->start_dir
)
1287 hname
= entry
->u
.file
->name
;
1289 hname
= entry
->u
.dir
->name
;
1291 return filename_cmp (hname
, fname
) == 0;
1294 /* Compare entries in the nonexistent file hash table. These are just
1297 nonexistent_file_hash_eq (const void *p
, const void *q
)
1299 return filename_cmp ((const char *) p
, (const char *) q
) == 0;
1302 /* Initialize everything in this source file. */
1304 _cpp_init_files (cpp_reader
*pfile
)
1306 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1307 NULL
, xcalloc
, free
);
1308 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1309 NULL
, xcalloc
, free
);
1310 allocate_file_hash_entries (pfile
);
1311 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1312 nonexistent_file_hash_eq
,
1313 NULL
, xcalloc
, free
);
1314 obstack_specify_allocation (&pfile
->nonexistent_file_ob
, 0, 0,
1318 /* Finalize everything in this source file. */
1320 _cpp_cleanup_files (cpp_reader
*pfile
)
1322 htab_delete (pfile
->file_hash
);
1323 htab_delete (pfile
->dir_hash
);
1324 htab_delete (pfile
->nonexistent_file_hash
);
1325 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1326 free_file_hash_entries (pfile
);
1327 destroy_all_cpp_files (pfile
);
1330 /* Make the parser forget about files it has seen. This can be useful
1331 for resetting the parser to start another run. */
1333 cpp_clear_file_cache (cpp_reader
*pfile
)
1335 _cpp_cleanup_files (pfile
);
1336 pfile
->file_hash_entries
= NULL
;
1337 pfile
->all_files
= NULL
;
1338 _cpp_init_files (pfile
);
1341 /* Enter a file name in the hash for the sake of cpp_included. */
1343 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1345 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, 0, _cpp_FFK_FAKE
, 0);
1348 /* Not everyone who wants to set system-header-ness on a buffer can
1349 see the details of a buffer. This is an exported interface because
1350 fix-header needs it. */
1352 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1355 const class line_maps
*line_table
= pfile
->line_table
;
1356 const line_map_ordinary
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1357 /* 1 = system header, 2 = system header to be treated as C. */
1359 flags
= 1 + (externc
!= 0);
1360 pfile
->buffer
->sysp
= flags
;
1361 _cpp_do_file_change (pfile
, LC_RENAME
, ORDINARY_MAP_FILE_NAME (map
),
1362 SOURCE_LINE (map
, pfile
->line_table
->highest_line
),
1366 /* Allow the client to change the current file. Used by the front end
1367 to achieve pseudo-file names like <built-in>.
1368 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1370 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1371 const char *new_name
)
1373 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1376 struct report_missing_guard_data
1382 /* Callback function for htab_traverse. */
1384 report_missing_guard (void **slot
, void *d
)
1386 struct cpp_file_hash_entry
*entry
= (struct cpp_file_hash_entry
*) *slot
;
1387 struct report_missing_guard_data
*data
1388 = (struct report_missing_guard_data
*) d
;
1390 /* Skip directories. */
1391 if (entry
->start_dir
!= NULL
)
1393 _cpp_file
*file
= entry
->u
.file
;
1395 /* We don't want MI guard advice for the main file. */
1396 if (!file
->once_only
&& file
->cmacro
== NULL
1397 && file
->stack_count
== 1 && !file
->main_file
)
1399 if (data
->paths
== NULL
)
1401 data
->paths
= XCNEWVEC (const char *, data
->count
);
1405 data
->paths
[data
->count
++] = file
->path
;
1409 /* Keep traversing the hash table. */
1413 /* Comparison function for qsort. */
1415 report_missing_guard_cmp (const void *p1
, const void *p2
)
1417 return strcmp (*(const char *const *) p1
, *(const char *const *) p2
);
1420 /* Report on all files that might benefit from a multiple include guard.
1423 _cpp_report_missing_guards (cpp_reader
*pfile
)
1425 struct report_missing_guard_data data
;
1428 data
.count
= htab_elements (pfile
->file_hash
);
1429 htab_traverse (pfile
->file_hash
, report_missing_guard
, &data
);
1431 if (data
.paths
!= NULL
)
1435 /* Sort the paths to avoid outputting them in hash table
1437 qsort (data
.paths
, data
.count
, sizeof (const char *),
1438 report_missing_guard_cmp
);
1439 fputs (_("Multiple include guards may be useful for:\n"),
1441 for (i
= 0; i
< data
.count
; i
++)
1443 fputs (data
.paths
[i
], stderr
);
1444 putc ('\n', stderr
);
1450 /* Locate HEADER, and determine whether it is newer than the current
1451 file. If it cannot be located or dated, return -1, if it is
1452 newer, return 1, otherwise 0. */
1454 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1458 struct cpp_dir
*dir
;
1460 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1464 file
= _cpp_find_file (pfile
, fname
, dir
, angle_brackets
, _cpp_FFK_NORMAL
, 0);
1474 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1477 /* Pushes the given file onto the buffer stack. Returns nonzero if
1480 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1482 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
,
1483 pfile
->line_table
->highest_line
);
1486 /* Pushes the given file, implicitly included at the start of a
1487 compilation, onto the buffer stack but without any errors if the
1488 file is not found. Returns nonzero if successful. */
1490 cpp_push_default_include (cpp_reader
*pfile
, const char *fname
)
1492 return _cpp_stack_include (pfile
, fname
, true, IT_DEFAULT
,
1493 pfile
->line_table
->highest_line
);
1496 /* Do appropriate cleanup when a file INC's buffer is popped off the
1499 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
,
1500 const unsigned char *to_free
)
1502 /* Record the inclusion-preventing macro, which could be NULL
1503 meaning no controlling macro. */
1504 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1505 file
->cmacro
= pfile
->mi_cmacro
;
1507 /* Invalidate control macros in the #including file. */
1508 pfile
->mi_valid
= false;
1512 if (to_free
== file
->buffer_start
)
1514 file
->buffer_start
= NULL
;
1515 file
->buffer
= NULL
;
1516 file
->buffer_valid
= false;
1518 free ((void *) to_free
);
1522 /* Return the file name associated with FILE. */
1524 _cpp_get_file_name (_cpp_file
*file
)
1529 /* Inteface to file statistics record in _cpp_file structure. */
1531 _cpp_get_file_stat (_cpp_file
*file
)
1536 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1537 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1538 directory of the including file.
1540 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1542 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1543 int quote_ignores_source_dir
)
1545 pfile
->quote_include
= quote
;
1546 pfile
->bracket_include
= quote
;
1547 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1549 for (; quote
; quote
= quote
->next
)
1551 quote
->name_map
= NULL
;
1552 quote
->len
= strlen (quote
->name
);
1553 if (quote
== bracket
)
1554 pfile
->bracket_include
= bracket
;
1558 /* Append the file name to the directory to create the path, but don't
1559 turn / into // or // into ///; // may be a namespace escape. */
1561 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1567 flen
= strlen (fname
);
1568 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1569 memcpy (path
, dir
->name
, dlen
);
1570 if (dlen
&& !IS_DIR_SEPARATOR (path
[dlen
- 1]))
1572 memcpy (&path
[dlen
], fname
, flen
+ 1);
1577 /* Read a space delimited string of unlimited length from a stdio
1580 read_filename_string (int ch
, FILE *f
)
1586 set
= alloc
= XNEWVEC (char, len
+ 1);
1587 if (! is_space (ch
))
1590 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1592 if (set
- alloc
== len
)
1595 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1596 set
= alloc
+ len
/ 2;
1606 /* Read the file name map file for DIR. */
1608 read_name_map (cpp_dir
*dir
)
1610 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1613 size_t len
, count
= 0, room
= 9;
1616 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1617 memcpy (name
, dir
->name
, len
);
1618 if (len
&& !IS_DIR_SEPARATOR (name
[len
- 1]))
1620 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1621 f
= fopen (name
, "r");
1623 dir
->name_map
= XNEWVEC (const char *, room
);
1625 /* Silently return NULL if we cannot open. */
1630 while ((ch
= getc (f
)) != EOF
)
1637 if (count
+ 2 > room
)
1640 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1643 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1644 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1647 to
= read_filename_string (ch
, f
);
1648 if (IS_ABSOLUTE_PATH (to
))
1649 dir
->name_map
[count
+ 1] = to
;
1652 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1657 while ((ch
= getc (f
)) != '\n')
1665 /* Terminate the list of maps. */
1666 dir
->name_map
[count
] = NULL
;
1669 /* Remap a FILE's name based on the file_name_map, if any, for
1670 FILE->dir. If the file name has any directory separators,
1671 recursively check those directories too. */
1673 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1675 const char *fname
, *p
;
1686 read_name_map (dir
);
1688 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1689 if (!filename_cmp (dir
->name_map
[index
], fname
))
1690 return xstrdup (dir
->name_map
[index
+ 1]);
1691 if (IS_ABSOLUTE_PATH (fname
))
1693 p
= strchr (fname
, '/');
1694 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1696 char *p2
= strchr (fname
, '\\');
1701 if (!p
|| p
== fname
)
1704 len
= dir
->len
+ (p
- fname
+ 1);
1705 new_dir
= XNEWVEC (char, len
+ 2);
1706 p3
= new_dir
+ dir
->len
;
1707 memcpy (new_dir
, dir
->name
, dir
->len
);
1708 if (dir
->len
&& !IS_DIR_SEPARATOR (dir
->name
[dir
->len
- 1]))
1713 memcpy (p3
, fname
, p
- fname
+ 1);
1714 new_dir
[len
] = '\0';
1716 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1721 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1723 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1725 const char *saved_path
= file
->path
;
1728 file
->path
= pchname
;
1729 if (open_file (file
))
1731 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1739 if (CPP_OPTION (pfile
, print_include_names
))
1742 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1744 fprintf (stderr
, "%c %s\n",
1745 valid
? '!' : 'x', pchname
);
1749 file
->path
= saved_path
;
1753 /* Get the path associated with the _cpp_file F. The path includes
1754 the base name from the include directive and the directory it was
1755 found in via the search path. */
1758 cpp_get_path (struct _cpp_file
*f
)
1763 /* Get the directory associated with the _cpp_file F. */
1766 cpp_get_dir (struct _cpp_file
*f
)
1771 /* Get the cpp_buffer currently associated with the cpp_reader
1775 cpp_get_buffer (cpp_reader
*pfile
)
1777 return pfile
->buffer
;
1780 /* Get the _cpp_file associated with the cpp_buffer B. */
1783 cpp_get_file (cpp_buffer
*b
)
1788 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1789 buffer is the buffer that included the given buffer. */
1792 cpp_get_prev (cpp_buffer
*b
)
1797 /* This data structure holds the list of header files that were seen
1798 while the PCH was being built. The 'entries' field is kept sorted
1799 in memcmp() order; yes, this means that on little-endian systems,
1800 it's sorted initially by the least-significant byte of 'size', but
1801 that's OK. The code does rely on having entries with the same size
1802 next to each other. */
1805 /* The size of this file. This is used to save running a MD5 checksum
1806 if the sizes don't match. */
1808 /* The MD5 checksum of this file. */
1809 unsigned char sum
[16];
1810 /* Is this file to be included only once? */
1815 /* Number of pchf_entry structures. */
1818 /* Are there any values with once_only set?
1819 This is used as an optimisation, it means we don't have to search
1820 the structure if we're processing a regular #include. */
1821 bool have_once_only
;
1823 struct pchf_entry entries
[1];
1826 static struct pchf_data
*pchf
;
1828 /* A qsort ordering function for pchf_entry structures. */
1831 pchf_save_compare (const void *e1
, const void *e2
)
1833 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1836 /* Create and write to F a pchf_data structure. */
1839 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1842 struct pchf_data
*result
;
1847 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1850 result_size
= (sizeof (struct pchf_data
)
1851 + sizeof (struct pchf_entry
) * (count
- 1));
1852 result
= XCNEWVAR (struct pchf_data
, result_size
);
1855 result
->have_once_only
= false;
1857 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1861 /* This should probably never happen, since if a read error occurred
1862 the PCH file shouldn't be written... */
1863 if (f
->dont_read
|| f
->err_no
)
1866 if (f
->stack_count
== 0)
1869 count
= result
->count
++;
1871 result
->entries
[count
].once_only
= f
->once_only
;
1872 /* |= is avoided in the next line because of an HP C compiler bug */
1873 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1874 if (f
->buffer_valid
)
1875 md5_buffer ((const char *)f
->buffer
,
1876 f
->st
.st_size
, result
->entries
[count
].sum
);
1884 open_file_failed (pfile
, f
, 0, 0);
1888 ff
= fdopen (f
->fd
, "rb");
1889 md5_stream (ff
, result
->entries
[count
].sum
);
1893 result
->entries
[count
].size
= f
->st
.st_size
;
1896 result_size
= (sizeof (struct pchf_data
)
1897 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1899 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1902 ret
= fwrite (result
, result_size
, 1, fp
) == 1;
1907 /* Read the pchf_data structure from F. */
1910 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1914 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1918 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1919 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1920 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1921 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1927 /* The parameters for pchf_compare. */
1929 struct pchf_compare_data
1931 /* The size of the file we're looking for. */
1934 /* The MD5 checksum of the file, if it's been computed. */
1935 unsigned char sum
[16];
1940 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1941 bool check_included
;
1943 /* The file that we're searching for. */
1947 /* bsearch comparison function; look for D_P in E_P. */
1950 pchf_compare (const void *d_p
, const void *e_p
)
1952 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1953 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1956 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1960 if (! d
->sum_computed
)
1962 _cpp_file
*const f
= d
->f
;
1964 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1965 d
->sum_computed
= true;
1968 result
= memcmp (d
->sum
, e
->sum
, 16);
1972 if (d
->check_included
|| e
->once_only
)
1978 /* Check that F is not in a list read from a PCH file (if any).
1979 Assumes that f->buffer_valid is true. Return TRUE if the file
1980 should not be read. */
1983 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1985 bool check_included
)
1987 struct pchf_compare_data d
;
1990 || (! check_included
&& ! pchf
->have_once_only
))
1993 d
.size
= f
->st
.st_size
;
1994 d
.sum_computed
= false;
1996 d
.check_included
= check_included
;
1997 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1998 pchf_compare
) != NULL
;
2001 /* Return true if the file FNAME is found in the appropriate include file path
2002 as indicated by ANGLE_BRACKETS. */
2005 _cpp_has_header (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
2006 enum include_type type
)
2008 cpp_dir
*start_dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
2009 _cpp_file
*file
= _cpp_find_file (pfile
, fname
, start_dir
, angle_brackets
,
2010 _cpp_FFK_HAS_INCLUDE
, 0);
2011 return file
->err_no
!= ENOENT
;