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,
4 2006, 2007, 2008, 2009, 2010, 2011, 2012 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 3, 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; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
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 /* Pointer to the real start of BUFFER. read_file() might increment
78 BUFFER; when freeing, this this pointer must be used instead. */
79 const uchar
*buffer_start
;
81 /* The macro, if any, preventing re-inclusion. */
82 const cpp_hashnode
*cmacro
;
84 /* The directory in the search path where FILE was found. Used for
85 #include_next and determining whether a header is a system
89 /* As filled in by stat(2) for the file. */
92 /* File descriptor. Invalid if -1, otherwise open. */
95 /* Zero if this file was successfully opened and stat()-ed,
96 otherwise errno obtained from failure. */
99 /* Number of times the file has been stacked for preprocessing. */
100 unsigned short stack_count
;
102 /* If opened with #import or contains #pragma once. */
105 /* If read() failed before. */
108 /* If this file is the main file. */
111 /* If BUFFER above contains the true contents of the file. */
114 /* If this file is implicitly preincluded. */
115 bool implicit_preinclude
;
118 /* A singly-linked list for all searches for a given file name, with
119 its head pointed to by a slot in FILE_HASH. The file name is what
120 appeared between the quotes in a #include directive; it can be
121 determined implicitly from the hash table location or explicitly
124 FILE is a structure containing details about the file that was
125 found with that search, or details of how the search failed.
127 START_DIR is the starting location of the search in the include
128 chain. The current directories for "" includes are also hashed in
129 the hash table and therefore unique. Files that are looked up
130 without using a search path, such as absolute filenames and file
131 names from the command line share a special starting directory so
132 they don't cause cache hits with normal include-chain lookups.
134 If START_DIR is NULL then the entry is for a directory, not a file,
135 and the directory is in DIR. Since the starting point in a file
136 lookup chain is never NULL, this means that simple pointer
137 comparisons against START_DIR can be made to determine cache hits
140 If a cache lookup fails because of e.g. an extra "./" in the path,
141 then nothing will break. It is just less efficient as CPP will
142 have to do more work re-preprocessing the file, and/or comparing
143 its contents against earlier once-only files.
145 struct file_hash_entry
147 struct file_hash_entry
*next
;
149 source_location location
;
157 /* Number of entries to put in a file_hash_entry pool. */
158 #define FILE_HASH_POOL_SIZE 127
160 /* A file hash entry pool. We allocate file_hash_entry object from
162 struct file_hash_entry_pool
164 /* Number of entries used from this pool. */
165 unsigned int file_hash_entries_used
;
166 /* Next pool in the chain; used when freeing. */
167 struct file_hash_entry_pool
*next
;
168 /* The memory pool. */
169 struct file_hash_entry pool
[FILE_HASH_POOL_SIZE
];
172 static bool open_file (_cpp_file
*file
);
173 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
175 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
177 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
178 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
179 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
180 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
181 int angle_brackets
, enum include_type
);
182 static const char *dir_name_of_file (_cpp_file
*file
);
183 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int);
184 static struct file_hash_entry
*search_cache (struct 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 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. */
297 && pfile
->all_files
->next_file
298 && !(pfile
->all_files
->implicit_preinclude
299 || pfile
->all_files
->next_file
->implicit_preinclude
))
302 flen
= strlen (path
);
303 len
= flen
+ sizeof (extension
);
304 pchname
= XNEWVEC (char, len
);
305 memcpy (pchname
, path
, flen
);
306 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
308 if (stat (pchname
, &st
) == 0)
312 size_t dlen
, plen
= len
;
314 if (!S_ISDIR (st
.st_mode
))
315 valid
= validate_pch (pfile
, file
, pchname
);
316 else if ((pchdir
= opendir (pchname
)) != NULL
)
318 pchname
[plen
- 1] = '/';
319 while ((d
= readdir (pchdir
)) != NULL
)
321 dlen
= strlen (d
->d_name
) + 1;
322 if ((strcmp (d
->d_name
, ".") == 0)
323 || (strcmp (d
->d_name
, "..") == 0))
325 if (dlen
+ plen
> len
)
328 pchname
= XRESIZEVEC (char, pchname
, len
);
330 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
331 valid
= validate_pch (pfile
, file
, pchname
);
342 file
->pchname
= pchname
;
349 /* Canonicalize the path to FILE. Return the canonical form if it is
350 shorter, otherwise return NULL. This function does NOT free the
351 memory pointed by FILE. */
354 maybe_shorter_path (const char * file
)
356 char * file2
= lrealpath (file
);
357 if (file2
&& strlen (file2
) < strlen (file
))
368 /* Try to open the path FILE->name appended to FILE->dir. This is
369 where remap and PCH intercept the file lookup process. Return true
370 if the file was found, whether or not the open was successful.
371 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
374 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
378 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
381 if (file
->dir
->construct
)
382 path
= file
->dir
->construct (file
->name
, file
->dir
);
384 path
= append_file_to_dir (file
->name
, file
->dir
);
392 /* We try to canonicalize system headers. */
393 if (CPP_OPTION (pfile
, canonical_system_headers
) && file
->dir
->sysp
)
395 char * canonical_path
= maybe_shorter_path (path
);
398 /* The canonical path was newly allocated. Let's free the
399 non-canonical one. */
401 path
= canonical_path
;
405 hv
= htab_hash_string (path
);
406 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
408 file
->err_no
= ENOENT
;
413 if (pch_open_file (pfile
, file
, invalid_pch
))
416 if (open_file (file
))
419 if (file
->err_no
!= ENOENT
)
421 open_file_failed (pfile
, file
, 0);
425 /* We copy the path name onto an obstack partly so that we don't
426 leak the memory, but mostly so that we don't fragment the
428 copy
= (char *) obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
431 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
435 file
->path
= file
->name
;
439 file
->err_no
= ENOENT
;
446 /* Return tue iff the missing_header callback found the given HEADER. */
448 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
450 missing_header_cb func
= pfile
->cb
.missing_header
;
452 /* When the regular search path doesn't work, try context dependent
453 headers search paths. */
455 && file
->dir
== NULL
)
457 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
459 if (open_file (file
))
461 free ((void *)file
->path
);
463 file
->path
= file
->name
;
470 _cpp_find_failed (_cpp_file
*file
)
472 return file
->err_no
!= 0;
475 /* Given a filename FNAME search for such a file in the include path
476 starting from START_DIR. If FNAME is the empty string it is
477 interpreted as STDIN if START_DIR is PFILE->no_search_path.
479 If the file is not found in the file cache fall back to the O/S and
480 add the result to our cache.
482 If the file was not found in the filesystem, or there was an error
483 opening it, then ERR_NO is nonzero and FD is -1. If the file was
484 found, then ERR_NO is zero and FD could be -1 or an open file
485 descriptor. FD can be -1 if the file was found in the cache and
486 had previously been closed. To open it again pass the return value
489 If IMPLICIT_PREINCLUDE then it is OK for the file to be missing.
490 If present, it is OK for a precompiled header to be included after
494 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
,
495 bool fake
, int angle_brackets
, bool implicit_preinclude
)
497 struct file_hash_entry
*entry
, **hash_slot
;
499 bool invalid_pch
= false;
500 bool saw_bracket_include
= false;
501 bool saw_quote_include
= false;
502 struct cpp_dir
*found_in_cache
= NULL
;
504 /* Ensure we get no confusion between cached files and directories. */
505 if (start_dir
== NULL
)
506 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
508 hash_slot
= (struct file_hash_entry
**)
509 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
510 htab_hash_string (fname
),
513 /* First check the cache before we resort to memory allocation. */
514 entry
= search_cache (*hash_slot
, start_dir
);
516 return entry
->u
.file
;
518 file
= make_cpp_file (pfile
, start_dir
, fname
);
519 file
->implicit_preinclude
= implicit_preinclude
;
521 /* Try each path in the include chain. */
524 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
527 file
->dir
= file
->dir
->next
;
528 if (file
->dir
== NULL
)
530 if (search_path_exhausted (pfile
, fname
, file
))
532 /* Although this file must not go in the cache, because
533 the file found might depend on things (like the current file)
534 that aren't represented in the cache, it still has to go in
535 the list of all files so that #import works. */
536 file
->next_file
= pfile
->all_files
;
537 pfile
->all_files
= file
;
543 cpp_error (pfile
, CPP_DL_ERROR
,
544 "one or more PCH files were found, but they were invalid");
545 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
546 cpp_error (pfile
, CPP_DL_ERROR
,
547 "use -Winvalid-pch for more information");
549 if (implicit_preinclude
)
551 free ((char *) file
->name
);
556 open_file_failed (pfile
, file
, angle_brackets
);
560 /* Only check the cache for the starting location (done above)
561 and the quote and bracket chain heads because there are no
562 other possible starting points for searches. */
563 if (file
->dir
== pfile
->bracket_include
)
564 saw_bracket_include
= true;
565 else if (file
->dir
== pfile
->quote_include
)
566 saw_quote_include
= true;
570 entry
= search_cache (*hash_slot
, file
->dir
);
573 found_in_cache
= file
->dir
;
580 /* Cache for START_DIR too, sharing the _cpp_file structure. */
581 free ((char *) file
->name
);
583 file
= entry
->u
.file
;
587 /* This is a new file; put it in the list. */
588 file
->next_file
= pfile
->all_files
;
589 pfile
->all_files
= file
;
592 /* Store this new result in the hash table. */
593 entry
= new_file_hash_entry (pfile
);
594 entry
->next
= *hash_slot
;
595 entry
->start_dir
= start_dir
;
596 entry
->location
= pfile
->line_table
->highest_location
;
597 entry
->u
.file
= file
;
600 /* If we passed the quote or bracket chain heads, cache them also.
601 This speeds up processing if there are lots of -I options. */
602 if (saw_bracket_include
603 && pfile
->bracket_include
!= start_dir
604 && found_in_cache
!= pfile
->bracket_include
)
606 entry
= new_file_hash_entry (pfile
);
607 entry
->next
= *hash_slot
;
608 entry
->start_dir
= pfile
->bracket_include
;
609 entry
->location
= pfile
->line_table
->highest_location
;
610 entry
->u
.file
= file
;
613 if (saw_quote_include
614 && pfile
->quote_include
!= start_dir
615 && found_in_cache
!= pfile
->quote_include
)
617 entry
= new_file_hash_entry (pfile
);
618 entry
->next
= *hash_slot
;
619 entry
->start_dir
= pfile
->quote_include
;
620 entry
->location
= pfile
->line_table
->highest_location
;
621 entry
->u
.file
= file
;
628 /* Read a file into FILE->buffer, returning true on success.
630 If FILE->fd is something weird, like a block device, we don't want
631 to read it at all. Don't even try to figure out what something is,
632 except for plain files and block devices, since there is no
633 reliable portable way of doing this.
635 FIXME: Flush file cache and try again if we run out of memory. */
637 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
639 ssize_t size
, total
, count
;
643 if (S_ISBLK (file
->st
.st_mode
))
645 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
649 regular
= S_ISREG (file
->st
.st_mode
) != 0;
652 /* off_t might have a wider range than ssize_t - in other words,
653 the max size of a file might be bigger than the address
654 space. We can't handle a file that large. (Anyone with
655 a single source file bigger than 2GB needs to rethink
656 their coding style.) Some systems (e.g. AIX 4.1) define
657 SSIZE_MAX to be much smaller than the actual range of the
658 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
660 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
662 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
666 size
= file
->st
.st_size
;
669 /* 8 kilobytes is a sensible starting size. It ought to be bigger
670 than the kernel pipe buffer, and it's definitely bigger than
671 the majority of C source files. */
674 /* The + 16 here is space for the final '\n' and 15 bytes of padding,
675 used to quiet warnings from valgrind or Address Sanitizer, when the
676 optimized lexer accesses aligned 16-byte memory chunks, including
677 the bytes after the malloced, area, and stops lexing on '\n'. */
678 buf
= XNEWVEC (uchar
, size
+ 16);
680 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
689 buf
= XRESIZEVEC (uchar
, buf
, size
+ 16);
695 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
700 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
701 cpp_error (pfile
, CPP_DL_WARNING
,
702 "%s is shorter than expected", file
->path
);
704 file
->buffer
= _cpp_convert_input (pfile
,
705 CPP_OPTION (pfile
, input_charset
),
706 buf
, size
+ 16, total
,
709 file
->buffer_valid
= true;
714 /* Convenience wrapper around read_file_guts that opens the file if
715 necessary and closes the file descriptor after reading. FILE must
716 have been passed through find_file() at some stage. */
718 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
720 /* If we already have its contents in memory, succeed immediately. */
721 if (file
->buffer_valid
)
724 /* If an earlier read failed for some reason don't try again. */
725 if (file
->dont_read
|| file
->err_no
)
728 if (file
->fd
== -1 && !open_file (file
))
730 open_file_failed (pfile
, file
, 0);
734 file
->dont_read
= !read_file_guts (pfile
, file
);
738 return !file
->dont_read
;
741 /* Returns TRUE if FILE's contents have been successfully placed in
742 FILE->buffer and the file should be stacked, otherwise false. */
744 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
748 /* Skip once-only files. */
752 /* We must mark the file once-only if #import now, before header
753 guard checks. Otherwise, undefining the header guard might
754 cause the file to be re-stacked. */
757 _cpp_mark_file_once_only (pfile
, file
);
759 /* Don't stack files that have been stacked before. */
760 if (file
->stack_count
)
764 /* Skip if the file had a header guard and the macro is defined.
765 PCH relies on this appearing before the PCH handler below. */
766 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
769 /* Handle PCH files immediately; don't stack them. */
772 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
774 free ((void *) file
->pchname
);
775 file
->pchname
= NULL
;
779 if (!read_file (pfile
, file
))
782 /* Check the file against the PCH file. This is done before
783 checking against files we've already seen, since it may save on
785 if (check_file_against_entries (pfile
, file
, import
))
787 /* If this isn't a #import, but yet we can't include the file,
788 that means that it was #import-ed in the PCH file,
789 so we can never include it again. */
791 _cpp_mark_file_once_only (pfile
, file
);
795 /* Now we've read the file's contents, we can stack it if there
796 are no once-only files. */
797 if (!pfile
->seen_once_only
)
800 /* We may have read the file under a different name. Look
801 for likely candidates and compare file contents to be sure. */
802 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
807 if ((import
|| f
->once_only
)
809 && f
->st
.st_mtime
== file
->st
.st_mtime
810 && f
->st
.st_size
== file
->st
.st_size
)
813 bool same_file_p
= false;
815 if (f
->buffer
&& !f
->buffer_valid
)
817 /* We already have a buffer but it is not valid, because
818 the file is still stacked. Make a new one. */
819 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
820 ref_file
->path
= f
->path
;
823 /* The file is not stacked anymore. We can reuse it. */
826 same_file_p
= read_file (pfile
, ref_file
)
827 /* Size might have changed in read_file(). */
828 && ref_file
->st
.st_size
== file
->st
.st_size
829 && !memcmp (ref_file
->buffer
,
833 if (f
->buffer
&& !f
->buffer_valid
)
836 destroy_cpp_file (ref_file
);
847 /* Place the file referenced by FILE into a new buffer on the buffer
848 stack if possible. IMPORT is true if this stacking attempt is
849 because of a #import directive. Returns true if a buffer is
852 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
857 if (!should_stack_file (pfile
, file
, import
))
860 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
863 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
865 /* Add the file to the dependencies on its first inclusion. */
866 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
868 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
869 deps_add_dep (pfile
->deps
, file
->path
);
872 /* Clear buffer_valid since _cpp_clean_line messes it up. */
873 file
->buffer_valid
= false;
876 /* Stack the buffer. */
877 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
878 CPP_OPTION (pfile
, preprocessed
)
879 && !CPP_OPTION (pfile
, directives_only
));
883 /* Initialize controlling macro state. */
884 pfile
->mi_valid
= true;
885 pfile
->mi_cmacro
= 0;
887 /* Generate the call back. */
888 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
893 /* Mark FILE to be included once only. */
895 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
897 pfile
->seen_once_only
= true;
898 file
->once_only
= true;
901 /* Return the directory from which searching for FNAME should start,
902 considering the directive TYPE and ANGLE_BRACKETS. If there is
903 nothing left in the path, returns NULL. */
904 static struct cpp_dir
*
905 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
906 enum include_type type
)
911 if (IS_ABSOLUTE_PATH (fname
))
912 return &pfile
->no_search_path
;
914 /* pfile->buffer is NULL when processing an -include command-line flag. */
915 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
917 /* For #include_next, skip in the search path past the dir in which
918 the current file was found, but if it was found via an absolute
919 path use the normal search logic. */
920 if (type
== IT_INCLUDE_NEXT
&& file
->dir
921 && file
->dir
!= &pfile
->no_search_path
)
922 dir
= file
->dir
->next
;
923 else if (angle_brackets
)
924 dir
= pfile
->bracket_include
;
925 else if (type
== IT_CMDLINE
)
926 /* -include and -imacros use the #include "" chain with the
927 preprocessor's cwd prepended. */
928 return make_cpp_dir (pfile
, "./", false);
929 else if (pfile
->quote_ignores_source_dir
)
930 dir
= pfile
->quote_include
;
932 return make_cpp_dir (pfile
, dir_name_of_file (file
),
933 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
936 cpp_error (pfile
, CPP_DL_ERROR
,
937 "no include path in which to search for %s", fname
);
942 /* Strip the basename from the file's path. It ends with a slash if
943 of nonzero length. Note that this procedure also works for
944 <stdin>, which is represented by the empty string. */
946 dir_name_of_file (_cpp_file
*file
)
950 size_t len
= lbasename (file
->path
) - file
->path
;
951 char *dir_name
= XNEWVEC (char, len
+ 1);
953 memcpy (dir_name
, file
->path
, len
);
954 dir_name
[len
] = '\0';
955 file
->dir_name
= dir_name
;
958 return file
->dir_name
;
961 /* Handles #include-family directives (distinguished by TYPE),
962 including HEADER, and the command line -imacros and -include.
963 Returns true if a buffer was stacked. */
965 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
966 enum include_type type
)
971 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
975 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
,
977 if (type
== IT_DEFAULT
&& file
== NULL
)
980 /* Compensate for the increment in linemap_add that occurs in
981 _cpp_stack_file. In the case of a normal #include, we're
982 currently at the start of the line *following* the #include. A
983 separate source_location for this location makes no sense (until
984 we do the LC_LEAVE), and complicates LAST_SOURCE_LINE_LOCATION.
985 This does not apply if we found a PCH file (in which case
986 linemap_add is not called) or we were included from the
988 if (file
->pchname
== NULL
&& file
->err_no
== 0
989 && type
!= IT_CMDLINE
&& type
!= IT_DEFAULT
)
990 pfile
->line_table
->highest_location
--;
992 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
995 /* Could not open FILE. The complication is dependency output. */
997 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
)
999 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
1000 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
1002 errno
= file
->err_no
;
1003 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
1005 deps_add_dep (pfile
->deps
, file
->name
);
1006 /* If the preprocessor output (other than dependency information) is
1007 being used, we must also flag an error. */
1008 if (CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1009 cpp_errno (pfile
, CPP_DL_FATAL
, file
->path
);
1013 /* If we are not outputting dependencies, or if we are and dependencies
1014 were requested for this file, or if preprocessor output is needed
1015 in addition to dependency information, this is an error.
1017 Otherwise (outputting dependencies but not for this file, and not
1018 using the preprocessor output), we can still produce correct output
1019 so it's only a warning. */
1020 if (CPP_OPTION (pfile
, deps
.style
) == DEPS_NONE
1022 || CPP_OPTION (pfile
, deps
.need_preprocessor_output
))
1023 cpp_errno (pfile
, CPP_DL_FATAL
, file
->path
);
1025 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
1029 /* Search in the chain beginning at HEAD for a file whose search path
1030 started at START_DIR != NULL. */
1031 static struct file_hash_entry
*
1032 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
1034 while (head
&& head
->start_dir
!= start_dir
)
1040 /* Allocate a new _cpp_file structure. */
1042 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
1046 file
= XCNEW (_cpp_file
);
1047 file
->main_file
= !pfile
->buffer
;
1050 file
->name
= xstrdup (fname
);
1055 /* Release a _cpp_file structure. */
1057 destroy_cpp_file (_cpp_file
*file
)
1059 free ((void *) file
->buffer_start
);
1060 free ((void *) file
->name
);
1064 /* Release all the files allocated by this reader. */
1066 destroy_all_cpp_files (cpp_reader
*pfile
)
1068 _cpp_file
*iter
= pfile
->all_files
;
1071 _cpp_file
*next
= iter
->next_file
;
1072 destroy_cpp_file (iter
);
1077 /* A hash of directory names. The directory names are the path names
1078 of files which contain a #include "", the included file name is
1079 appended to this directories.
1081 To avoid duplicate entries we follow the convention that all
1082 non-empty directory names should end in a '/'. DIR_NAME must be
1083 stored in permanently allocated memory. */
1085 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
1087 struct file_hash_entry
*entry
, **hash_slot
;
1090 hash_slot
= (struct file_hash_entry
**)
1091 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
1092 htab_hash_string (dir_name
),
1095 /* Have we already hashed this directory? */
1096 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
1097 if (entry
->start_dir
== NULL
)
1098 return entry
->u
.dir
;
1100 dir
= XCNEW (cpp_dir
);
1101 dir
->next
= pfile
->quote_include
;
1102 dir
->name
= (char *) dir_name
;
1103 dir
->len
= strlen (dir_name
);
1107 /* Store this new result in the hash table. */
1108 entry
= new_file_hash_entry (pfile
);
1109 entry
->next
= *hash_slot
;
1110 entry
->start_dir
= NULL
;
1111 entry
->location
= pfile
->line_table
->highest_location
;
1118 /* Create a new block of memory for file hash entries. */
1120 allocate_file_hash_entries (cpp_reader
*pfile
)
1122 struct file_hash_entry_pool
*pool
= XNEW (struct file_hash_entry_pool
);
1123 pool
->file_hash_entries_used
= 0;
1124 pool
->next
= pfile
->file_hash_entries
;
1125 pfile
->file_hash_entries
= pool
;
1128 /* Return a new file hash entry. */
1129 static struct file_hash_entry
*
1130 new_file_hash_entry (cpp_reader
*pfile
)
1133 if (pfile
->file_hash_entries
->file_hash_entries_used
== FILE_HASH_POOL_SIZE
)
1134 allocate_file_hash_entries (pfile
);
1136 idx
= pfile
->file_hash_entries
->file_hash_entries_used
++;
1137 return &pfile
->file_hash_entries
->pool
[idx
];
1140 /* Free the file hash entry pools. */
1142 free_file_hash_entries (cpp_reader
*pfile
)
1144 struct file_hash_entry_pool
*iter
= pfile
->file_hash_entries
;
1147 struct file_hash_entry_pool
*next
= iter
->next
;
1153 /* Returns TRUE if a file FNAME has ever been successfully opened.
1154 This routine is not intended to correctly handle filenames aliased
1155 by links or redundant . or .. traversals etc. */
1157 cpp_included (cpp_reader
*pfile
, const char *fname
)
1159 struct file_hash_entry
*entry
;
1161 entry
= (struct file_hash_entry
*)
1162 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1164 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1165 entry
= entry
->next
;
1167 return entry
!= NULL
;
1170 /* Returns TRUE if a file FNAME has ever been successfully opened
1171 before LOCATION. This routine is not intended to correctly handle
1172 filenames aliased by links or redundant . or .. traversals etc. */
1174 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1175 source_location location
)
1177 struct file_hash_entry
*entry
;
1179 entry
= (struct file_hash_entry
*)
1180 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1182 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1183 || entry
->location
> location
))
1184 entry
= entry
->next
;
1186 return entry
!= NULL
;
1189 /* Calculate the hash value of a file hash entry P. */
1192 file_hash_hash (const void *p
)
1194 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1196 if (entry
->start_dir
)
1197 hname
= entry
->u
.file
->name
;
1199 hname
= entry
->u
.dir
->name
;
1201 return htab_hash_string (hname
);
1204 /* Compare a string Q against a file hash entry P. */
1206 file_hash_eq (const void *p
, const void *q
)
1208 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1209 const char *fname
= (const char *) q
;
1212 if (entry
->start_dir
)
1213 hname
= entry
->u
.file
->name
;
1215 hname
= entry
->u
.dir
->name
;
1217 return filename_cmp (hname
, fname
) == 0;
1220 /* Compare entries in the nonexistent file hash table. These are just
1223 nonexistent_file_hash_eq (const void *p
, const void *q
)
1225 return filename_cmp ((const char *) p
, (const char *) q
) == 0;
1228 /* Initialize everything in this source file. */
1230 _cpp_init_files (cpp_reader
*pfile
)
1232 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1233 NULL
, xcalloc
, free
);
1234 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1235 NULL
, xcalloc
, free
);
1236 allocate_file_hash_entries (pfile
);
1237 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1238 nonexistent_file_hash_eq
,
1239 NULL
, xcalloc
, free
);
1240 _obstack_begin (&pfile
->nonexistent_file_ob
, 0, 0,
1241 (void *(*) (long)) xmalloc
,
1242 (void (*) (void *)) free
);
1245 /* Finalize everything in this source file. */
1247 _cpp_cleanup_files (cpp_reader
*pfile
)
1249 htab_delete (pfile
->file_hash
);
1250 htab_delete (pfile
->dir_hash
);
1251 htab_delete (pfile
->nonexistent_file_hash
);
1252 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1253 free_file_hash_entries (pfile
);
1254 destroy_all_cpp_files (pfile
);
1257 /* Make the parser forget about files it has seen. This can be useful
1258 for resetting the parser to start another run. */
1260 cpp_clear_file_cache (cpp_reader
*pfile
)
1262 _cpp_cleanup_files (pfile
);
1263 pfile
->file_hash_entries
= NULL
;
1264 pfile
->all_files
= NULL
;
1265 _cpp_init_files (pfile
);
1268 /* Enter a file name in the hash for the sake of cpp_included. */
1270 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1272 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0, false);
1275 /* Not everyone who wants to set system-header-ness on a buffer can
1276 see the details of a buffer. This is an exported interface because
1277 fix-header needs it. */
1279 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1282 const struct line_maps
*line_table
= pfile
->line_table
;
1283 const struct line_map
*map
= LINEMAPS_LAST_ORDINARY_MAP (line_table
);
1284 /* 1 = system header, 2 = system header to be treated as C. */
1286 flags
= 1 + (externc
!= 0);
1287 pfile
->buffer
->sysp
= flags
;
1288 _cpp_do_file_change (pfile
, LC_RENAME
, ORDINARY_MAP_FILE_NAME (map
),
1289 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1292 /* Allow the client to change the current file. Used by the front end
1293 to achieve pseudo-file names like <built-in>.
1294 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1296 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1297 const char *new_name
)
1299 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1302 struct report_missing_guard_data
1308 /* Callback function for htab_traverse. */
1310 report_missing_guard (void **slot
, void *d
)
1312 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
1313 struct report_missing_guard_data
*data
1314 = (struct report_missing_guard_data
*) d
;
1316 /* Skip directories. */
1317 if (entry
->start_dir
!= NULL
)
1319 _cpp_file
*file
= entry
->u
.file
;
1321 /* We don't want MI guard advice for the main file. */
1322 if (!file
->once_only
&& file
->cmacro
== NULL
1323 && file
->stack_count
== 1 && !file
->main_file
)
1325 if (data
->paths
== NULL
)
1327 data
->paths
= XCNEWVEC (const char *, data
->count
);
1331 data
->paths
[data
->count
++] = file
->path
;
1335 /* Keep traversing the hash table. */
1339 /* Comparison function for qsort. */
1341 report_missing_guard_cmp (const void *p1
, const void *p2
)
1343 return strcmp (*(const char *const *) p1
, *(const char *const *) p2
);
1346 /* Report on all files that might benefit from a multiple include guard.
1349 _cpp_report_missing_guards (cpp_reader
*pfile
)
1351 struct report_missing_guard_data data
;
1354 data
.count
= htab_elements (pfile
->file_hash
);
1355 htab_traverse (pfile
->file_hash
, report_missing_guard
, &data
);
1357 if (data
.paths
!= NULL
)
1361 /* Sort the paths to avoid outputting them in hash table
1363 qsort (data
.paths
, data
.count
, sizeof (const char *),
1364 report_missing_guard_cmp
);
1365 fputs (_("Multiple include guards may be useful for:\n"),
1367 for (i
= 0; i
< data
.count
; i
++)
1369 fputs (data
.paths
[i
], stderr
);
1370 putc ('\n', stderr
);
1376 /* Locate HEADER, and determine whether it is newer than the current
1377 file. If it cannot be located or dated, return -1, if it is
1378 newer, return 1, otherwise 0. */
1380 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1384 struct cpp_dir
*dir
;
1386 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1390 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
, false);
1400 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1403 /* Pushes the given file onto the buffer stack. Returns nonzero if
1406 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1408 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1411 /* Pushes the given file, implicitly included at the start of a
1412 compilation, onto the buffer stack but without any errors if the
1413 file is not found. Returns nonzero if successful. */
1415 cpp_push_default_include (cpp_reader
*pfile
, const char *fname
)
1417 return _cpp_stack_include (pfile
, fname
, true, IT_DEFAULT
);
1420 /* Do appropriate cleanup when a file INC's buffer is popped off the
1423 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1425 /* Record the inclusion-preventing macro, which could be NULL
1426 meaning no controlling macro. */
1427 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1428 file
->cmacro
= pfile
->mi_cmacro
;
1430 /* Invalidate control macros in the #including file. */
1431 pfile
->mi_valid
= false;
1433 if (file
->buffer_start
)
1435 free ((void *) file
->buffer_start
);
1436 file
->buffer_start
= NULL
;
1437 file
->buffer
= NULL
;
1438 file
->buffer_valid
= false;
1442 /* Return the file name associated with FILE. */
1444 _cpp_get_file_name (_cpp_file
*file
)
1449 /* Inteface to file statistics record in _cpp_file structure. */
1451 _cpp_get_file_stat (_cpp_file
*file
)
1456 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1457 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1458 directory of the including file.
1460 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1462 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1463 int quote_ignores_source_dir
)
1465 pfile
->quote_include
= quote
;
1466 pfile
->bracket_include
= quote
;
1467 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1469 for (; quote
; quote
= quote
->next
)
1471 quote
->name_map
= NULL
;
1472 quote
->len
= strlen (quote
->name
);
1473 if (quote
== bracket
)
1474 pfile
->bracket_include
= bracket
;
1478 /* Append the file name to the directory to create the path, but don't
1479 turn / into // or // into ///; // may be a namespace escape. */
1481 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1487 flen
= strlen (fname
);
1488 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1489 memcpy (path
, dir
->name
, dlen
);
1490 if (dlen
&& !IS_DIR_SEPARATOR (path
[dlen
- 1]))
1492 memcpy (&path
[dlen
], fname
, flen
+ 1);
1497 /* Read a space delimited string of unlimited length from a stdio
1500 read_filename_string (int ch
, FILE *f
)
1506 set
= alloc
= XNEWVEC (char, len
+ 1);
1507 if (! is_space (ch
))
1510 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1512 if (set
- alloc
== len
)
1515 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1516 set
= alloc
+ len
/ 2;
1526 /* Read the file name map file for DIR. */
1528 read_name_map (cpp_dir
*dir
)
1530 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1533 size_t len
, count
= 0, room
= 9;
1536 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1537 memcpy (name
, dir
->name
, len
);
1538 if (len
&& !IS_DIR_SEPARATOR (name
[len
- 1]))
1540 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1541 f
= fopen (name
, "r");
1543 dir
->name_map
= XNEWVEC (const char *, room
);
1545 /* Silently return NULL if we cannot open. */
1550 while ((ch
= getc (f
)) != EOF
)
1557 if (count
+ 2 > room
)
1560 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1563 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1564 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1567 to
= read_filename_string (ch
, f
);
1568 if (IS_ABSOLUTE_PATH (to
))
1569 dir
->name_map
[count
+ 1] = to
;
1572 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1577 while ((ch
= getc (f
)) != '\n')
1585 /* Terminate the list of maps. */
1586 dir
->name_map
[count
] = NULL
;
1589 /* Remap a FILE's name based on the file_name_map, if any, for
1590 FILE->dir. If the file name has any directory separators,
1591 recursively check those directories too. */
1593 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1595 const char *fname
, *p
;
1606 read_name_map (dir
);
1608 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1609 if (!filename_cmp (dir
->name_map
[index
], fname
))
1610 return xstrdup (dir
->name_map
[index
+ 1]);
1611 if (IS_ABSOLUTE_PATH (fname
))
1613 p
= strchr (fname
, '/');
1614 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
1616 char *p2
= strchr (fname
, '\\');
1621 if (!p
|| p
== fname
)
1624 len
= dir
->len
+ (p
- fname
+ 1);
1625 new_dir
= XNEWVEC (char, len
+ 1);
1626 memcpy (new_dir
, dir
->name
, dir
->len
);
1627 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1628 new_dir
[len
] = '\0';
1630 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1635 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1637 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1639 const char *saved_path
= file
->path
;
1642 file
->path
= pchname
;
1643 if (open_file (file
))
1645 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1653 if (CPP_OPTION (pfile
, print_include_names
))
1656 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1658 fprintf (stderr
, "%c %s\n",
1659 valid
? '!' : 'x', pchname
);
1663 file
->path
= saved_path
;
1667 /* Get the path associated with the _cpp_file F. The path includes
1668 the base name from the include directive and the directory it was
1669 found in via the search path. */
1672 cpp_get_path (struct _cpp_file
*f
)
1677 /* Get the directory associated with the _cpp_file F. */
1680 cpp_get_dir (struct _cpp_file
*f
)
1685 /* Get the cpp_buffer currently associated with the cpp_reader
1689 cpp_get_buffer (cpp_reader
*pfile
)
1691 return pfile
->buffer
;
1694 /* Get the _cpp_file associated with the cpp_buffer B. */
1697 cpp_get_file (cpp_buffer
*b
)
1702 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1703 buffer is the buffer that included the given buffer. */
1706 cpp_get_prev (cpp_buffer
*b
)
1711 /* This data structure holds the list of header files that were seen
1712 while the PCH was being built. The 'entries' field is kept sorted
1713 in memcmp() order; yes, this means that on little-endian systems,
1714 it's sorted initially by the least-significant byte of 'size', but
1715 that's OK. The code does rely on having entries with the same size
1716 next to each other. */
1719 /* The size of this file. This is used to save running a MD5 checksum
1720 if the sizes don't match. */
1722 /* The MD5 checksum of this file. */
1723 unsigned char sum
[16];
1724 /* Is this file to be included only once? */
1729 /* Number of pchf_entry structures. */
1732 /* Are there any values with once_only set?
1733 This is used as an optimisation, it means we don't have to search
1734 the structure if we're processing a regular #include. */
1735 bool have_once_only
;
1737 struct pchf_entry entries
[1];
1740 static struct pchf_data
*pchf
;
1742 /* A qsort ordering function for pchf_entry structures. */
1745 pchf_save_compare (const void *e1
, const void *e2
)
1747 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1750 /* Create and write to F a pchf_data structure. */
1753 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1756 struct pchf_data
*result
;
1760 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1763 result_size
= (sizeof (struct pchf_data
)
1764 + sizeof (struct pchf_entry
) * (count
- 1));
1765 result
= XCNEWVAR (struct pchf_data
, result_size
);
1768 result
->have_once_only
= false;
1770 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1774 /* This should probably never happen, since if a read error occurred
1775 the PCH file shouldn't be written... */
1776 if (f
->dont_read
|| f
->err_no
)
1779 if (f
->stack_count
== 0)
1782 count
= result
->count
++;
1784 result
->entries
[count
].once_only
= f
->once_only
;
1785 /* |= is avoided in the next line because of an HP C compiler bug */
1786 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1787 if (f
->buffer_valid
)
1788 md5_buffer ((const char *)f
->buffer
,
1789 f
->st
.st_size
, result
->entries
[count
].sum
);
1797 open_file_failed (pfile
, f
, 0);
1801 ff
= fdopen (f
->fd
, "rb");
1802 md5_stream (ff
, result
->entries
[count
].sum
);
1806 result
->entries
[count
].size
= f
->st
.st_size
;
1809 result_size
= (sizeof (struct pchf_data
)
1810 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1812 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1815 return fwrite (result
, result_size
, 1, fp
) == 1;
1818 /* Read the pchf_data structure from F. */
1821 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1825 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1829 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1830 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1831 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1832 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1838 /* The parameters for pchf_compare. */
1840 struct pchf_compare_data
1842 /* The size of the file we're looking for. */
1845 /* The MD5 checksum of the file, if it's been computed. */
1846 unsigned char sum
[16];
1851 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1852 bool check_included
;
1854 /* The file that we're searching for. */
1858 /* bsearch comparison function; look for D_P in E_P. */
1861 pchf_compare (const void *d_p
, const void *e_p
)
1863 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1864 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1867 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1871 if (! d
->sum_computed
)
1873 _cpp_file
*const f
= d
->f
;
1875 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1876 d
->sum_computed
= true;
1879 result
= memcmp (d
->sum
, e
->sum
, 16);
1883 if (d
->check_included
|| e
->once_only
)
1889 /* Check that F is not in a list read from a PCH file (if any).
1890 Assumes that f->buffer_valid is true. Return TRUE if the file
1891 should not be read. */
1894 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1896 bool check_included
)
1898 struct pchf_compare_data d
;
1901 || (! check_included
&& ! pchf
->have_once_only
))
1904 d
.size
= f
->st
.st_size
;
1905 d
.sum_computed
= false;
1907 d
.check_included
= check_included
;
1908 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1909 pchf_compare
) != NULL
;