1 /* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
8 Split out of cpplib.c, Zack Weinberg, Oct 1998
9 Reimplemented, Neil Booth, Jul 2003
11 This program is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by the
13 Free Software Foundation; either version 2, or (at your option) any
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
35 /* Variable length record files on VMS will have a stat size that includes
36 record control characters that won't be included in the read size. */
38 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
39 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
41 # define STAT_SIZE_RELIABLE(ST) true
46 /* For DJGPP redirected input is opened in text mode. */
47 # define set_stdin_to_binary_mode() \
48 if (! isatty (0)) setmode (0, O_BINARY)
50 # define set_stdin_to_binary_mode() /* Nothing */
53 /* This structure represents a file searched for by CPP, whether it
54 exists or not. An instance may be pointed to by more than one
55 file_hash_entry; at present no reference count is kept. */
58 /* Filename as given to #include or command line switch. */
61 /* The full path used to find the file. */
64 /* The full path of the pch file. */
67 /* The file's path with the basename stripped. NULL if it hasn't
68 been calculated yet. */
71 /* Chain through all files. */
72 struct _cpp_file
*next_file
;
74 /* The contents of NAME after calling read_file(). */
77 /* The macro, if any, preventing re-inclusion. */
78 const cpp_hashnode
*cmacro
;
80 /* The directory in the search path where FILE was found. Used for
81 #include_next and determining whether a header is a system
85 /* As filled in by stat(2) for the file. */
88 /* File descriptor. Invalid if -1, otherwise open. */
91 /* Zero if this file was successfully opened and stat()-ed,
92 otherwise errno obtained from failure. */
95 /* Number of times the file has been stacked for preprocessing. */
96 unsigned short stack_count
;
98 /* If opened with #import or contains #pragma once. */
101 /* If read() failed before. */
104 /* If this file is the main file. */
107 /* If BUFFER above contains the true contents of the file. */
111 /* A singly-linked list for all searches for a given file name, with
112 its head pointed to by a slot in FILE_HASH. The file name is what
113 appeared between the quotes in a #include directive; it can be
114 determined implicitly from the hash table location or explicitly
117 FILE is a structure containing details about the file that was
118 found with that search, or details of how the search failed.
120 START_DIR is the starting location of the search in the include
121 chain. The current directories for "" includes are also hashed in
122 the hash table and therefore unique. Files that are looked up
123 without using a search path, such as absolute filenames and file
124 names from the command line share a special starting directory so
125 they don't cause cache hits with normal include-chain lookups.
127 If START_DIR is NULL then the entry is for a directory, not a file,
128 and the directory is in DIR. Since the starting point in a file
129 lookup chain is never NULL, this means that simple pointer
130 comparisons against START_DIR can be made to determine cache hits
133 If a cache lookup fails because of e.g. an extra "./" in the path,
134 then nothing will break. It is just less efficient as CPP will
135 have to do more work re-preprocessing the file, and/or comparing
136 its contents against earlier once-only files.
138 struct file_hash_entry
140 struct file_hash_entry
*next
;
142 source_location location
;
150 /* Number of entries to put in a file_hash_entry pool. */
151 #define FILE_HASH_POOL_SIZE 127
153 /* A file hash entry pool. We allocate file_hash_entry object from
155 struct file_hash_entry_pool
157 /* Number of entries used from this pool. */
158 unsigned int file_hash_entries_used
;
159 /* Next pool in the chain; used when freeing. */
160 struct file_hash_entry_pool
*next
;
161 /* The memory pool. */
162 struct file_hash_entry pool
[FILE_HASH_POOL_SIZE
];
165 static bool open_file (_cpp_file
*file
);
166 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
168 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
170 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
171 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
172 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
173 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
174 int angle_brackets
, enum include_type
);
175 static const char *dir_name_of_file (_cpp_file
*file
);
176 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int);
177 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
178 const cpp_dir
*start_dir
);
179 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
180 static void destroy_cpp_file (_cpp_file
*);
181 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
182 static void allocate_file_hash_entries (cpp_reader
*pfile
);
183 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
184 static int report_missing_guard (void **slot
, void *b
);
185 static hashval_t
file_hash_hash (const void *p
);
186 static int file_hash_eq (const void *p
, const void *q
);
187 static char *read_filename_string (int ch
, FILE *f
);
188 static void read_name_map (cpp_dir
*dir
);
189 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
190 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
191 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
192 static int pchf_save_compare (const void *e1
, const void *e2
);
193 static int pchf_compare (const void *d_p
, const void *e_p
);
194 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
196 /* Given a filename in FILE->PATH, with the empty string interpreted
199 On success FILE contains an open file descriptor and stat
200 information for the file. On failure the file descriptor is -1 and
201 the appropriate errno is also stored in FILE. Returns TRUE iff
204 We used to open files in nonblocking mode, but that caused more
205 problems than it solved. Do take care not to acquire a controlling
206 terminal by mistake (this can't happen on sane systems, but
207 paranoia is a virtue).
209 Use the three-argument form of open even though we aren't
210 specifying O_CREAT, to defend against broken system headers.
212 O_BINARY tells some runtime libraries (notably DJGPP) not to do
213 newline translation; we can handle DOS line breaks just fine
216 open_file (_cpp_file
*file
)
218 if (file
->path
[0] == '\0')
221 set_stdin_to_binary_mode ();
224 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
228 if (fstat (file
->fd
, &file
->st
) == 0)
230 if (!S_ISDIR (file
->st
.st_mode
))
236 /* Ignore a directory and continue the search. The file we're
237 looking for may be elsewhere in the search path. */
244 #if defined(_WIN32) && !defined(__CYGWIN__)
245 else if (errno
== EACCES
)
247 /* On most UNIX systems, open succeeds on a directory. Above,
248 we check if we have opened a directory and if so, set errno
249 to ENOENT. However, on Windows, opening a directory
250 fails with EACCES. We want to return ENOENT in that
252 if (stat (file
->path
, &file
->st
) == 0
253 && S_ISDIR (file
->st
.st_mode
))
256 /* The call to stat may have reset errno. */
260 else if (errno
== ENOTDIR
)
263 file
->err_no
= errno
;
268 /* Temporary PCH intercept of opening a file. Try to find a PCH file
269 based on FILE->name and FILE->dir, and test those found for
270 validity using PFILE->cb.valid_pch. Return true iff a valid file is
271 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
274 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
276 static const char extension
[] = ".gch";
277 const char *path
= file
->path
;
283 /* No PCH on <stdin> or if not requested. */
284 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
287 flen
= strlen (path
);
288 len
= flen
+ sizeof (extension
);
289 pchname
= XNEWVEC (char, len
);
290 memcpy (pchname
, path
, flen
);
291 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
293 if (stat (pchname
, &st
) == 0)
297 size_t dlen
, plen
= len
;
299 if (!S_ISDIR (st
.st_mode
))
300 valid
= validate_pch (pfile
, file
, pchname
);
301 else if ((pchdir
= opendir (pchname
)) != NULL
)
303 pchname
[plen
- 1] = '/';
304 while ((d
= readdir (pchdir
)) != NULL
)
306 dlen
= strlen (d
->d_name
) + 1;
307 if ((strcmp (d
->d_name
, ".") == 0)
308 || (strcmp (d
->d_name
, "..") == 0))
310 if (dlen
+ plen
> len
)
313 pchname
= XRESIZEVEC (char, pchname
, len
);
315 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
316 valid
= validate_pch (pfile
, file
, pchname
);
327 file
->pchname
= pchname
;
334 /* Try to open the path FILE->name appended to FILE->dir. This is
335 where remap and PCH intercept the file lookup process. Return true
336 if the file was found, whether or not the open was successful.
337 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
340 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
344 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
347 if (file
->dir
->construct
)
348 path
= file
->dir
->construct (file
->name
, file
->dir
);
350 path
= append_file_to_dir (file
->name
, file
->dir
);
354 hashval_t hv
= htab_hash_string (path
);
358 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
360 file
->err_no
= ENOENT
;
365 if (pch_open_file (pfile
, file
, invalid_pch
))
368 if (open_file (file
))
371 if (file
->err_no
!= ENOENT
)
373 open_file_failed (pfile
, file
, 0);
377 /* We copy the path name onto an obstack partly so that we don't
378 leak the memory, but mostly so that we don't fragment the
380 copy
= obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
383 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
387 file
->path
= file
->name
;
391 file
->err_no
= ENOENT
;
398 /* Return tue iff the missing_header callback found the given HEADER. */
400 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
402 missing_header_cb func
= pfile
->cb
.missing_header
;
404 /* When the regular search path doesn't work, try context dependent
405 headers search paths. */
407 && file
->dir
== NULL
)
409 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
411 if (open_file (file
))
413 free ((void *)file
->path
);
415 file
->path
= file
->name
;
422 _cpp_find_failed (_cpp_file
*file
)
424 return file
->err_no
!= 0;
427 /* Given a filename FNAME search for such a file in the include path
428 starting from START_DIR. If FNAME is the empty string it is
429 interpreted as STDIN if START_DIR is PFILE->no_search_path.
431 If the file is not found in the file cache fall back to the O/S and
432 add the result to our cache.
434 If the file was not found in the filesystem, or there was an error
435 opening it, then ERR_NO is nonzero and FD is -1. If the file was
436 found, then ERR_NO is zero and FD could be -1 or an open file
437 descriptor. FD can be -1 if the file was found in the cache and
438 had previously been closed. To open it again pass the return value
442 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
, int angle_brackets
)
444 struct file_hash_entry
*entry
, **hash_slot
;
446 bool invalid_pch
= false;
447 bool saw_bracket_include
= false;
448 bool saw_quote_include
= false;
449 struct cpp_dir
*found_in_cache
= NULL
;
451 /* Ensure we get no confusion between cached files and directories. */
452 if (start_dir
== NULL
)
453 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
455 hash_slot
= (struct file_hash_entry
**)
456 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
457 htab_hash_string (fname
),
460 /* First check the cache before we resort to memory allocation. */
461 entry
= search_cache (*hash_slot
, start_dir
);
463 return entry
->u
.file
;
465 file
= make_cpp_file (pfile
, start_dir
, fname
);
467 /* Try each path in the include chain. */
470 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
473 file
->dir
= file
->dir
->next
;
474 if (file
->dir
== NULL
)
476 if (search_path_exhausted (pfile
, fname
, file
))
478 /* Although this file must not go in the cache, because
479 the file found might depend on things (like the current file)
480 that aren't represented in the cache, it still has to go in
481 the list of all files so that #import works. */
482 file
->next_file
= pfile
->all_files
;
483 pfile
->all_files
= file
;
487 open_file_failed (pfile
, file
, angle_brackets
);
490 cpp_error (pfile
, CPP_DL_ERROR
,
491 "one or more PCH files were found, but they were invalid");
492 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
493 cpp_error (pfile
, CPP_DL_ERROR
,
494 "use -Winvalid-pch for more information");
499 /* Only check the cache for the starting location (done above)
500 and the quote and bracket chain heads because there are no
501 other possible starting points for searches. */
502 if (file
->dir
== pfile
->bracket_include
)
503 saw_bracket_include
= true;
504 else if (file
->dir
== pfile
->quote_include
)
505 saw_quote_include
= true;
509 entry
= search_cache (*hash_slot
, file
->dir
);
512 found_in_cache
= file
->dir
;
519 /* Cache for START_DIR too, sharing the _cpp_file structure. */
520 free ((char *) file
->name
);
522 file
= entry
->u
.file
;
526 /* This is a new file; put it in the list. */
527 file
->next_file
= pfile
->all_files
;
528 pfile
->all_files
= file
;
531 /* Store this new result in the hash table. */
532 entry
= new_file_hash_entry (pfile
);
533 entry
->next
= *hash_slot
;
534 entry
->start_dir
= start_dir
;
535 entry
->location
= pfile
->line_table
->highest_location
;
536 entry
->u
.file
= file
;
539 /* If we passed the quote or bracket chain heads, cache them also.
540 This speeds up processing if there are lots of -I options. */
541 if (saw_bracket_include
542 && pfile
->bracket_include
!= start_dir
543 && found_in_cache
!= pfile
->bracket_include
)
545 entry
= new_file_hash_entry (pfile
);
546 entry
->next
= *hash_slot
;
547 entry
->start_dir
= pfile
->bracket_include
;
548 entry
->location
= pfile
->line_table
->highest_location
;
549 entry
->u
.file
= file
;
552 if (saw_quote_include
553 && pfile
->quote_include
!= start_dir
554 && found_in_cache
!= pfile
->quote_include
)
556 entry
= new_file_hash_entry (pfile
);
557 entry
->next
= *hash_slot
;
558 entry
->start_dir
= pfile
->quote_include
;
559 entry
->location
= pfile
->line_table
->highest_location
;
560 entry
->u
.file
= file
;
567 /* Read a file into FILE->buffer, returning true on success.
569 If FILE->fd is something weird, like a block device, we don't want
570 to read it at all. Don't even try to figure out what something is,
571 except for plain files and block devices, since there is no
572 reliable portable way of doing this.
574 FIXME: Flush file cache and try again if we run out of memory. */
576 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
578 ssize_t size
, total
, count
;
582 if (S_ISBLK (file
->st
.st_mode
))
584 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
588 regular
= S_ISREG (file
->st
.st_mode
);
591 /* off_t might have a wider range than ssize_t - in other words,
592 the max size of a file might be bigger than the address
593 space. We can't handle a file that large. (Anyone with
594 a single source file bigger than 2GB needs to rethink
595 their coding style.) Some systems (e.g. AIX 4.1) define
596 SSIZE_MAX to be much smaller than the actual range of the
597 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
599 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
601 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
605 size
= file
->st
.st_size
;
608 /* 8 kilobytes is a sensible starting size. It ought to be bigger
609 than the kernel pipe buffer, and it's definitely bigger than
610 the majority of C source files. */
613 buf
= XNEWVEC (uchar
, size
+ 1);
615 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
624 buf
= XRESIZEVEC (uchar
, buf
, size
+ 1);
630 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
634 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
635 cpp_error (pfile
, CPP_DL_WARNING
,
636 "%s is shorter than expected", file
->path
);
638 file
->buffer
= _cpp_convert_input (pfile
, CPP_OPTION (pfile
, input_charset
),
639 buf
, size
, total
, &file
->st
.st_size
);
640 file
->buffer_valid
= true;
645 /* Convenience wrapper around read_file_guts that opens the file if
646 necessary and closes the file descriptor after reading. FILE must
647 have been passed through find_file() at some stage. */
649 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
651 /* If we already have its contents in memory, succeed immediately. */
652 if (file
->buffer_valid
)
655 /* If an earlier read failed for some reason don't try again. */
656 if (file
->dont_read
|| file
->err_no
)
659 if (file
->fd
== -1 && !open_file (file
))
661 open_file_failed (pfile
, file
, 0);
665 file
->dont_read
= !read_file_guts (pfile
, file
);
669 return !file
->dont_read
;
672 /* Returns TRUE if FILE's contents have been successfully placed in
673 FILE->buffer and the file should be stacked, otherwise false. */
675 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
679 /* Skip once-only files. */
683 /* We must mark the file once-only if #import now, before header
684 guard checks. Otherwise, undefining the header guard might
685 cause the file to be re-stacked. */
688 _cpp_mark_file_once_only (pfile
, file
);
690 /* Don't stack files that have been stacked before. */
691 if (file
->stack_count
)
695 /* Skip if the file had a header guard and the macro is defined.
696 PCH relies on this appearing before the PCH handler below. */
697 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
700 /* Handle PCH files immediately; don't stack them. */
703 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
705 free ((void *) file
->pchname
);
706 file
->pchname
= NULL
;
710 if (!read_file (pfile
, file
))
713 /* Check the file against the PCH file. This is done before
714 checking against files we've already seen, since it may save on
716 if (check_file_against_entries (pfile
, file
, import
))
718 /* If this isn't a #import, but yet we can't include the file,
719 that means that it was #import-ed in the PCH file,
720 so we can never include it again. */
722 _cpp_mark_file_once_only (pfile
, file
);
726 /* Now we've read the file's contents, we can stack it if there
727 are no once-only files. */
728 if (!pfile
->seen_once_only
)
731 /* We may have read the file under a different name. Look
732 for likely candidates and compare file contents to be sure. */
733 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
738 if ((import
|| f
->once_only
)
740 && f
->st
.st_mtime
== file
->st
.st_mtime
741 && f
->st
.st_size
== file
->st
.st_size
)
744 bool same_file_p
= false;
746 if (f
->buffer
&& !f
->buffer_valid
)
748 /* We already have a buffer but it is not valid, because
749 the file is still stacked. Make a new one. */
750 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
751 ref_file
->path
= f
->path
;
754 /* The file is not stacked anymore. We can reuse it. */
757 same_file_p
= read_file (pfile
, ref_file
)
758 /* Size might have changed in read_file(). */
759 && ref_file
->st
.st_size
== file
->st
.st_size
760 && !memcmp (ref_file
->buffer
,
764 if (f
->buffer
&& !f
->buffer_valid
)
767 destroy_cpp_file (ref_file
);
778 /* Place the file referenced by FILE into a new buffer on the buffer
779 stack if possible. IMPORT is true if this stacking attempt is
780 because of a #import directive. Returns true if a buffer is
783 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
788 if (!should_stack_file (pfile
, file
, import
))
791 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
794 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
796 /* Add the file to the dependencies on its first inclusion. */
797 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
799 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
800 deps_add_dep (pfile
->deps
, file
->path
);
803 /* Clear buffer_valid since _cpp_clean_line messes it up. */
804 file
->buffer_valid
= false;
807 /* Stack the buffer. */
808 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
809 CPP_OPTION (pfile
, preprocessed
)
810 && !CPP_OPTION (pfile
, directives_only
));
814 /* Initialize controlling macro state. */
815 pfile
->mi_valid
= true;
816 pfile
->mi_cmacro
= 0;
818 /* Generate the call back. */
819 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
824 /* Mark FILE to be included once only. */
826 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
828 pfile
->seen_once_only
= true;
829 file
->once_only
= true;
832 /* Return the directory from which searching for FNAME should start,
833 considering the directive TYPE and ANGLE_BRACKETS. If there is
834 nothing left in the path, returns NULL. */
835 static struct cpp_dir
*
836 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
837 enum include_type type
)
842 if (IS_ABSOLUTE_PATH (fname
))
843 return &pfile
->no_search_path
;
845 /* pfile->buffer is NULL when processing an -include command-line flag. */
846 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
848 /* For #include_next, skip in the search path past the dir in which
849 the current file was found, but if it was found via an absolute
850 path use the normal search logic. */
851 if (type
== IT_INCLUDE_NEXT
&& file
->dir
852 && file
->dir
!= &pfile
->no_search_path
)
853 dir
= file
->dir
->next
;
854 else if (angle_brackets
)
855 dir
= pfile
->bracket_include
;
856 else if (type
== IT_CMDLINE
)
857 /* -include and -imacros use the #include "" chain with the
858 preprocessor's cwd prepended. */
859 return make_cpp_dir (pfile
, "./", false);
860 else if (pfile
->quote_ignores_source_dir
)
861 dir
= pfile
->quote_include
;
863 return make_cpp_dir (pfile
, dir_name_of_file (file
),
864 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
867 cpp_error (pfile
, CPP_DL_ERROR
,
868 "no include path in which to search for %s", fname
);
873 /* Strip the basename from the file's path. It ends with a slash if
874 of nonzero length. Note that this procedure also works for
875 <stdin>, which is represented by the empty string. */
877 dir_name_of_file (_cpp_file
*file
)
881 size_t len
= lbasename (file
->path
) - file
->path
;
882 char *dir_name
= XNEWVEC (char, len
+ 1);
884 memcpy (dir_name
, file
->path
, len
);
885 dir_name
[len
] = '\0';
886 file
->dir_name
= dir_name
;
889 return file
->dir_name
;
892 /* Handles #include-family directives (distinguished by TYPE),
893 including HEADER, and the command line -imacros and -include.
894 Returns true if a buffer was stacked. */
896 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
897 enum include_type type
)
902 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
906 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
908 /* Compensate for the increment in linemap_add. In the case of a
909 normal #include, we're currently at the start of the line
910 *following* the #include. A separate source_location for this
911 location makes no sense (until we do the LC_LEAVE), and
912 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
913 found a PCH file (in which case linemap_add is not called) or we
914 were included from the command-line. */
915 if (file
->pchname
== NULL
&& file
->err_no
== 0 && type
!= IT_CMDLINE
)
916 pfile
->line_table
->highest_location
--;
918 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
921 /* Could not open FILE. The complication is dependency output. */
923 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
)
925 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
926 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
928 errno
= file
->err_no
;
929 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
930 deps_add_dep (pfile
->deps
, file
->name
);
933 /* If we are outputting dependencies but not for this file then
934 don't error because we can still produce correct output. */
935 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
936 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
938 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
942 /* Search in the chain beginning at HEAD for a file whose search path
943 started at START_DIR != NULL. */
944 static struct file_hash_entry
*
945 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
947 while (head
&& head
->start_dir
!= start_dir
)
953 /* Allocate a new _cpp_file structure. */
955 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
959 file
= XCNEW (_cpp_file
);
960 file
->main_file
= !pfile
->buffer
;
963 file
->name
= xstrdup (fname
);
968 /* Release a _cpp_file structure. */
970 destroy_cpp_file (_cpp_file
*file
)
973 free ((void *) file
->buffer
);
974 free ((void *) file
->name
);
978 /* Release all the files allocated by this reader. */
980 destroy_all_cpp_files (cpp_reader
*pfile
)
982 _cpp_file
*iter
= pfile
->all_files
;
985 _cpp_file
*next
= iter
->next_file
;
986 destroy_cpp_file (iter
);
991 /* A hash of directory names. The directory names are the path names
992 of files which contain a #include "", the included file name is
993 appended to this directories.
995 To avoid duplicate entries we follow the convention that all
996 non-empty directory names should end in a '/'. DIR_NAME must be
997 stored in permanently allocated memory. */
999 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
1001 struct file_hash_entry
*entry
, **hash_slot
;
1004 hash_slot
= (struct file_hash_entry
**)
1005 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
1006 htab_hash_string (dir_name
),
1009 /* Have we already hashed this directory? */
1010 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
1011 if (entry
->start_dir
== NULL
)
1012 return entry
->u
.dir
;
1014 dir
= XCNEW (cpp_dir
);
1015 dir
->next
= pfile
->quote_include
;
1016 dir
->name
= (char *) dir_name
;
1017 dir
->len
= strlen (dir_name
);
1021 /* Store this new result in the hash table. */
1022 entry
= new_file_hash_entry (pfile
);
1023 entry
->next
= *hash_slot
;
1024 entry
->start_dir
= NULL
;
1025 entry
->location
= pfile
->line_table
->highest_location
;
1032 /* Create a new block of memory for file hash entries. */
1034 allocate_file_hash_entries (cpp_reader
*pfile
)
1036 struct file_hash_entry_pool
*pool
= XNEW (struct file_hash_entry_pool
);
1037 pool
->file_hash_entries_used
= 0;
1038 pool
->next
= pfile
->file_hash_entries
;
1039 pfile
->file_hash_entries
= pool
;
1042 /* Return a new file hash entry. */
1043 static struct file_hash_entry
*
1044 new_file_hash_entry (cpp_reader
*pfile
)
1047 if (pfile
->file_hash_entries
->file_hash_entries_used
== FILE_HASH_POOL_SIZE
)
1048 allocate_file_hash_entries (pfile
);
1050 idx
= pfile
->file_hash_entries
->file_hash_entries_used
++;
1051 return &pfile
->file_hash_entries
->pool
[idx
];
1054 /* Free the file hash entry pools. */
1056 free_file_hash_entries (cpp_reader
*pfile
)
1058 struct file_hash_entry_pool
*iter
= pfile
->file_hash_entries
;
1061 struct file_hash_entry_pool
*next
= iter
->next
;
1067 /* Returns TRUE if a file FNAME has ever been successfully opened.
1068 This routine is not intended to correctly handle filenames aliased
1069 by links or redundant . or .. traversals etc. */
1071 cpp_included (cpp_reader
*pfile
, const char *fname
)
1073 struct file_hash_entry
*entry
;
1075 entry
= (struct file_hash_entry
*)
1076 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1078 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1079 entry
= entry
->next
;
1081 return entry
!= NULL
;
1084 /* Returns TRUE if a file FNAME has ever been successfully opened
1085 before LOCATION. This routine is not intended to correctly handle
1086 filenames aliased by links or redundant . or .. traversals etc. */
1088 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1089 source_location location
)
1091 struct file_hash_entry
*entry
;
1093 entry
= (struct file_hash_entry
*)
1094 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1096 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1097 || entry
->location
> location
))
1098 entry
= entry
->next
;
1100 return entry
!= NULL
;
1103 /* Calculate the hash value of a file hash entry P. */
1106 file_hash_hash (const void *p
)
1108 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1110 if (entry
->start_dir
)
1111 hname
= entry
->u
.file
->name
;
1113 hname
= entry
->u
.dir
->name
;
1115 return htab_hash_string (hname
);
1118 /* Compare a string Q against a file hash entry P. */
1120 file_hash_eq (const void *p
, const void *q
)
1122 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1123 const char *fname
= (const char *) q
;
1126 if (entry
->start_dir
)
1127 hname
= entry
->u
.file
->name
;
1129 hname
= entry
->u
.dir
->name
;
1131 return strcmp (hname
, fname
) == 0;
1134 /* Compare entries in the nonexistent file hash table. These are just
1137 nonexistent_file_hash_eq (const void *p
, const void *q
)
1139 return strcmp (p
, q
) == 0;
1142 /* Initialize everything in this source file. */
1144 _cpp_init_files (cpp_reader
*pfile
)
1146 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1147 NULL
, xcalloc
, free
);
1148 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1149 NULL
, xcalloc
, free
);
1150 allocate_file_hash_entries (pfile
);
1151 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1152 nonexistent_file_hash_eq
,
1153 NULL
, xcalloc
, free
);
1154 _obstack_begin (&pfile
->nonexistent_file_ob
, 0, 0,
1155 (void *(*) (long)) xmalloc
,
1156 (void (*) (void *)) free
);
1159 /* Finalize everything in this source file. */
1161 _cpp_cleanup_files (cpp_reader
*pfile
)
1163 htab_delete (pfile
->file_hash
);
1164 htab_delete (pfile
->dir_hash
);
1165 htab_delete (pfile
->nonexistent_file_hash
);
1166 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1167 free_file_hash_entries (pfile
);
1168 destroy_all_cpp_files (pfile
);
1171 /* Make the parser forget about files it has seen. This can be useful
1172 for resetting the parser to start another run. */
1174 cpp_clear_file_cache (cpp_reader
*pfile
)
1176 _cpp_cleanup_files (pfile
);
1177 pfile
->file_hash_entries
= NULL
;
1178 pfile
->all_files
= NULL
;
1179 _cpp_init_files (pfile
);
1182 /* Enter a file name in the hash for the sake of cpp_included. */
1184 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1186 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0);
1189 /* Not everyone who wants to set system-header-ness on a buffer can
1190 see the details of a buffer. This is an exported interface because
1191 fix-header needs it. */
1193 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1196 const struct line_maps
*line_table
= pfile
->line_table
;
1197 const struct line_map
*map
= &line_table
->maps
[line_table
->used
-1];
1199 /* 1 = system header, 2 = system header to be treated as C. */
1201 flags
= 1 + (externc
!= 0);
1202 pfile
->buffer
->sysp
= flags
;
1203 _cpp_do_file_change (pfile
, LC_RENAME
, map
->to_file
,
1204 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1207 /* Allow the client to change the current file. Used by the front end
1208 to achieve pseudo-file names like <built-in>.
1209 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1211 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1212 const char *new_name
)
1214 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1217 /* Callback function for htab_traverse. */
1219 report_missing_guard (void **slot
, void *b
)
1221 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
1222 int *bannerp
= (int *) b
;
1224 /* Skip directories. */
1225 if (entry
->start_dir
!= NULL
)
1227 _cpp_file
*file
= entry
->u
.file
;
1229 /* We don't want MI guard advice for the main file. */
1230 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
1234 fputs (_("Multiple include guards may be useful for:\n"),
1239 fputs (entry
->u
.file
->path
, stderr
);
1240 putc ('\n', stderr
);
1247 /* Report on all files that might benefit from a multiple include guard.
1250 _cpp_report_missing_guards (cpp_reader
*pfile
)
1254 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
1257 /* Locate HEADER, and determine whether it is newer than the current
1258 file. If it cannot be located or dated, return -1, if it is
1259 newer, return 1, otherwise 0. */
1261 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1265 struct cpp_dir
*dir
;
1267 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1271 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
1281 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1284 /* Pushes the given file onto the buffer stack. Returns nonzero if
1287 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1289 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1292 /* Do appropriate cleanup when a file INC's buffer is popped off the
1295 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1297 /* Record the inclusion-preventing macro, which could be NULL
1298 meaning no controlling macro. */
1299 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1300 file
->cmacro
= pfile
->mi_cmacro
;
1302 /* Invalidate control macros in the #including file. */
1303 pfile
->mi_valid
= false;
1307 free ((void *) file
->buffer
);
1308 file
->buffer
= NULL
;
1309 file
->buffer_valid
= false;
1313 /* Inteface to file statistics record in _cpp_file structure. */
1315 _cpp_get_file_stat (_cpp_file
*file
)
1320 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1321 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1322 directory of the including file.
1324 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1326 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1327 int quote_ignores_source_dir
)
1329 pfile
->quote_include
= quote
;
1330 pfile
->bracket_include
= quote
;
1331 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1333 for (; quote
; quote
= quote
->next
)
1335 quote
->name_map
= NULL
;
1336 quote
->len
= strlen (quote
->name
);
1337 if (quote
== bracket
)
1338 pfile
->bracket_include
= bracket
;
1342 /* Append the file name to the directory to create the path, but don't
1343 turn / into // or // into ///; // may be a namespace escape. */
1345 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1351 flen
= strlen (fname
);
1352 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1353 memcpy (path
, dir
->name
, dlen
);
1354 if (dlen
&& path
[dlen
- 1] != '/')
1356 memcpy (&path
[dlen
], fname
, flen
+ 1);
1361 /* Read a space delimited string of unlimited length from a stdio
1364 read_filename_string (int ch
, FILE *f
)
1370 set
= alloc
= XNEWVEC (char, len
+ 1);
1371 if (! is_space (ch
))
1374 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1376 if (set
- alloc
== len
)
1379 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1380 set
= alloc
+ len
/ 2;
1390 /* Read the file name map file for DIR. */
1392 read_name_map (cpp_dir
*dir
)
1394 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1397 size_t len
, count
= 0, room
= 9;
1400 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1401 memcpy (name
, dir
->name
, len
);
1402 if (len
&& name
[len
- 1] != '/')
1404 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1405 f
= fopen (name
, "r");
1407 dir
->name_map
= XNEWVEC (const char *, room
);
1409 /* Silently return NULL if we cannot open. */
1414 while ((ch
= getc (f
)) != EOF
)
1421 if (count
+ 2 > room
)
1424 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1427 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1428 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1431 to
= read_filename_string (ch
, f
);
1432 if (IS_ABSOLUTE_PATH (to
))
1433 dir
->name_map
[count
+ 1] = to
;
1436 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1441 while ((ch
= getc (f
)) != '\n')
1449 /* Terminate the list of maps. */
1450 dir
->name_map
[count
] = NULL
;
1453 /* Remap a FILE's name based on the file_name_map, if any, for
1454 FILE->dir. If the file name has any directory separators,
1455 recursively check those directories too. */
1457 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1459 const char *fname
, *p
;
1470 read_name_map (dir
);
1472 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1473 if (!strcmp (dir
->name_map
[index
], fname
))
1474 return xstrdup (dir
->name_map
[index
+ 1]);
1476 p
= strchr (fname
, '/');
1477 if (!p
|| p
== fname
)
1480 len
= dir
->len
+ (p
- fname
+ 1);
1481 new_dir
= XNEWVEC (char, len
+ 1);
1482 memcpy (new_dir
, dir
->name
, dir
->len
);
1483 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1484 new_dir
[len
] = '\0';
1486 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1491 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1493 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1495 const char *saved_path
= file
->path
;
1498 file
->path
= pchname
;
1499 if (open_file (file
))
1501 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1509 if (CPP_OPTION (pfile
, print_include_names
))
1512 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1514 fprintf (stderr
, "%c %s\n",
1515 valid
? '!' : 'x', pchname
);
1519 file
->path
= saved_path
;
1523 /* Get the path associated with the _cpp_file F. The path includes
1524 the base name from the include directive and the directory it was
1525 found in via the search path. */
1528 cpp_get_path (struct _cpp_file
*f
)
1533 /* Get the directory associated with the _cpp_file F. */
1536 cpp_get_dir (struct _cpp_file
*f
)
1541 /* Get the cpp_buffer currently associated with the cpp_reader
1545 cpp_get_buffer (cpp_reader
*pfile
)
1547 return pfile
->buffer
;
1550 /* Get the _cpp_file associated with the cpp_buffer B. */
1553 cpp_get_file (cpp_buffer
*b
)
1558 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1559 buffer is the buffer that included the given buffer. */
1562 cpp_get_prev (cpp_buffer
*b
)
1567 /* This data structure holds the list of header files that were seen
1568 while the PCH was being built. The 'entries' field is kept sorted
1569 in memcmp() order; yes, this means that on little-endian systems,
1570 it's sorted initially by the least-significant byte of 'size', but
1571 that's OK. The code does rely on having entries with the same size
1572 next to each other. */
1575 /* The size of this file. This is used to save running a MD5 checksum
1576 if the sizes don't match. */
1578 /* The MD5 checksum of this file. */
1579 unsigned char sum
[16];
1580 /* Is this file to be included only once? */
1585 /* Number of pchf_entry structures. */
1588 /* Are there any values with once_only set?
1589 This is used as an optimisation, it means we don't have to search
1590 the structure if we're processing a regular #include. */
1591 bool have_once_only
;
1593 struct pchf_entry entries
[1];
1596 static struct pchf_data
*pchf
;
1598 /* A qsort ordering function for pchf_entry structures. */
1601 pchf_save_compare (const void *e1
, const void *e2
)
1603 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1606 /* Create and write to F a pchf_data structure. */
1609 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1612 struct pchf_data
*result
;
1616 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1619 result_size
= (sizeof (struct pchf_data
)
1620 + sizeof (struct pchf_entry
) * (count
- 1));
1621 result
= XCNEWVAR (struct pchf_data
, result_size
);
1624 result
->have_once_only
= false;
1626 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1630 /* This should probably never happen, since if a read error occurred
1631 the PCH file shouldn't be written... */
1632 if (f
->dont_read
|| f
->err_no
)
1635 if (f
->stack_count
== 0)
1638 count
= result
->count
++;
1640 result
->entries
[count
].once_only
= f
->once_only
;
1641 /* |= is avoided in the next line because of an HP C compiler bug */
1642 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1643 if (f
->buffer_valid
)
1644 md5_buffer ((const char *)f
->buffer
,
1645 f
->st
.st_size
, result
->entries
[count
].sum
);
1653 open_file_failed (pfile
, f
, 0);
1656 ff
= fdopen (f
->fd
, "rb");
1657 md5_stream (ff
, result
->entries
[count
].sum
);
1661 result
->entries
[count
].size
= f
->st
.st_size
;
1664 result_size
= (sizeof (struct pchf_data
)
1665 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1667 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1670 return fwrite (result
, result_size
, 1, fp
) == 1;
1673 /* Read the pchf_data structure from F. */
1676 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1680 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1684 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1685 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1686 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1687 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1693 /* The parameters for pchf_compare. */
1695 struct pchf_compare_data
1697 /* The size of the file we're looking for. */
1700 /* The MD5 checksum of the file, if it's been computed. */
1701 unsigned char sum
[16];
1706 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1707 bool check_included
;
1709 /* The file that we're searching for. */
1713 /* bsearch comparison function; look for D_P in E_P. */
1716 pchf_compare (const void *d_p
, const void *e_p
)
1718 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1719 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1722 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1726 if (! d
->sum_computed
)
1728 _cpp_file
*const f
= d
->f
;
1730 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1731 d
->sum_computed
= true;
1734 result
= memcmp (d
->sum
, e
->sum
, 16);
1738 if (d
->check_included
|| e
->once_only
)
1744 /* Check that F is not in a list read from a PCH file (if any).
1745 Assumes that f->buffer_valid is true. Return TRUE if the file
1746 should not be read. */
1749 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1751 bool check_included
)
1753 struct pchf_compare_data d
;
1756 || (! check_included
&& ! pchf
->have_once_only
))
1759 d
.size
= f
->st
.st_size
;
1760 d
.sum_computed
= false;
1762 d
.check_included
= check_included
;
1763 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1764 pchf_compare
) != NULL
;