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
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. */
110 /* File is a PCH (on return from find_include_file). */
114 /* A singly-linked list for all searches for a given file name, with
115 its head pointed to by a slot in FILE_HASH. The file name is what
116 appeared between the quotes in a #include directive; it can be
117 determined implicitly from the hash table location or explicitly
120 FILE is a structure containing details about the file that was
121 found with that search, or details of how the search failed.
123 START_DIR is the starting location of the search in the include
124 chain. The current directories for "" includes are also hashed in
125 the hash table and therefore unique. Files that are looked up
126 without using a search path, such as absolute filenames and file
127 names from the command line share a special starting directory so
128 they don't cause cache hits with normal include-chain lookups.
130 If START_DIR is NULL then the entry is for a directory, not a file,
131 and the directory is in DIR. Since the starting point in a file
132 lookup chain is never NULL, this means that simple pointer
133 comparisons against START_DIR can be made to determine cache hits
136 If a cache lookup fails because of e.g. an extra "./" in the path,
137 then nothing will break. It is just less efficient as CPP will
138 have to do more work re-preprocessing the file, and/or comparing
139 its contents against earlier once-only files.
141 struct file_hash_entry
143 struct file_hash_entry
*next
;
152 static bool open_file (_cpp_file
*file
);
153 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
155 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
157 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
158 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
159 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
160 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
161 int angle_brackets
, enum include_type
);
162 static const char *dir_name_of_file (_cpp_file
*file
);
163 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int);
164 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
165 const cpp_dir
*start_dir
);
166 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
167 static void destroy_cpp_file (_cpp_file
*);
168 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
169 static void allocate_file_hash_entries (cpp_reader
*pfile
);
170 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
171 static int report_missing_guard (void **slot
, void *b
);
172 static hashval_t
file_hash_hash (const void *p
);
173 static int file_hash_eq (const void *p
, const void *q
);
174 static char *read_filename_string (int ch
, FILE *f
);
175 static void read_name_map (cpp_dir
*dir
);
176 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
177 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
178 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
179 static int pchf_save_compare (const void *e1
, const void *e2
);
180 static int pchf_compare (const void *d_p
, const void *e_p
);
181 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
183 /* Given a filename in FILE->PATH, with the empty string interpreted
186 On success FILE contains an open file descriptor and stat
187 information for the file. On failure the file descriptor is -1 and
188 the appropriate errno is also stored in FILE. Returns TRUE iff
191 We used to open files in nonblocking mode, but that caused more
192 problems than it solved. Do take care not to acquire a controlling
193 terminal by mistake (this can't happen on sane systems, but
194 paranoia is a virtue).
196 Use the three-argument form of open even though we aren't
197 specifying O_CREAT, to defend against broken system headers.
199 O_BINARY tells some runtime libraries (notably DJGPP) not to do
200 newline translation; we can handle DOS line breaks just fine
203 open_file (_cpp_file
*file
)
205 if (file
->path
[0] == '\0')
208 set_stdin_to_binary_mode ();
211 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
215 if (fstat (file
->fd
, &file
->st
) == 0)
217 if (!S_ISDIR (file
->st
.st_mode
))
223 /* Ignore a directory and continue the search. The file we're
224 looking for may be elsewhere in the search path. */
231 #if defined(_WIN32) && !defined(__CYGWIN__)
232 else if (errno
== EACCES
)
234 /* On most UNIX systems, open succeeds on a directory. Above,
235 we check if we have opened a directory and if so, set errno
236 to ENOENT. However, on Windows, opening a directory
237 fails with EACCES. We want to return ENOENT in that
239 if (stat (file
->path
, &file
->st
) == 0
240 && S_ISDIR (file
->st
.st_mode
))
243 /* The call to stat may have reset errno. */
247 else if (errno
== ENOTDIR
)
250 file
->err_no
= errno
;
255 /* Temporary PCH intercept of opening a file. Try to find a PCH file
256 based on FILE->name and FILE->dir, and test those found for
257 validity using PFILE->cb.valid_pch. Return true iff a valid file is
258 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
261 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
263 static const char extension
[] = ".gch";
264 const char *path
= file
->path
;
270 /* No PCH on <stdin> or if not requested. */
271 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
274 flen
= strlen (path
);
275 len
= flen
+ sizeof (extension
);
276 pchname
= XNEWVEC (char, len
);
277 memcpy (pchname
, path
, flen
);
278 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
280 if (stat (pchname
, &st
) == 0)
284 size_t dlen
, plen
= len
;
286 if (!S_ISDIR (st
.st_mode
))
287 valid
= validate_pch (pfile
, file
, pchname
);
288 else if ((pchdir
= opendir (pchname
)) != NULL
)
290 pchname
[plen
- 1] = '/';
291 while ((d
= readdir (pchdir
)) != NULL
)
293 dlen
= strlen (d
->d_name
) + 1;
294 if ((strcmp (d
->d_name
, ".") == 0)
295 || (strcmp (d
->d_name
, "..") == 0))
297 if (dlen
+ plen
> len
)
300 pchname
= XRESIZEVEC (char, pchname
, len
);
302 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
303 valid
= validate_pch (pfile
, file
, pchname
);
316 file
->pchname
= pchname
;
323 /* Try to open the path FILE->name appended to FILE->dir. This is
324 where remap and PCH intercept the file lookup process. Return true
325 if the file was found, whether or not the open was successful.
326 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
329 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
333 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
336 if (file
->dir
->construct
)
337 path
= file
->dir
->construct (file
->name
, file
->dir
);
339 path
= append_file_to_dir (file
->name
, file
->dir
);
343 hashval_t hv
= htab_hash_string (path
);
347 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
349 file
->err_no
= ENOENT
;
354 if (pch_open_file (pfile
, file
, invalid_pch
))
357 if (open_file (file
))
360 if (file
->err_no
!= ENOENT
)
362 open_file_failed (pfile
, file
, 0);
366 /* We copy the path name onto an obstack partly so that we don't
367 leak the memory, but mostly so that we don't fragment the
369 copy
= obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
372 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
376 file
->path
= file
->name
;
380 file
->err_no
= ENOENT
;
387 /* Return tue iff the missing_header callback found the given HEADER. */
389 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
391 missing_header_cb func
= pfile
->cb
.missing_header
;
393 /* When the regular search path doesn't work, try context dependent
394 headers search paths. */
396 && file
->dir
== NULL
)
398 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
400 if (open_file (file
))
402 free ((void *)file
->path
);
404 file
->path
= file
->name
;
411 _cpp_find_failed (_cpp_file
*file
)
413 return file
->err_no
!= 0;
416 /* Given a filename FNAME search for such a file in the include path
417 starting from START_DIR. If FNAME is the empty string it is
418 interpreted as STDIN if START_DIR is PFILE->no_search_path.
420 If the file is not found in the file cache fall back to the O/S and
421 add the result to our cache.
423 If the file was not found in the filesystem, or there was an error
424 opening it, then ERR_NO is nonzero and FD is -1. If the file was
425 found, then ERR_NO is zero and FD could be -1 or an open file
426 descriptor. FD can be -1 if the file was found in the cache and
427 had previously been closed. To open it again pass the return value
431 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
, int angle_brackets
)
433 struct file_hash_entry
*entry
, **hash_slot
;
435 bool invalid_pch
= false;
436 bool saw_bracket_include
= false;
437 bool saw_quote_include
= false;
438 struct cpp_dir
*found_in_cache
= NULL
;
440 /* Ensure we get no confusion between cached files and directories. */
441 if (start_dir
== NULL
)
442 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
444 hash_slot
= (struct file_hash_entry
**)
445 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
446 htab_hash_string (fname
),
449 /* First check the cache before we resort to memory allocation. */
450 entry
= search_cache (*hash_slot
, start_dir
);
452 return entry
->u
.file
;
454 file
= make_cpp_file (pfile
, start_dir
, fname
);
456 /* Try each path in the include chain. */
459 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
462 file
->dir
= file
->dir
->next
;
463 if (file
->dir
== NULL
)
465 if (search_path_exhausted (pfile
, fname
, file
))
467 /* Although this file must not go in the cache, because
468 the file found might depend on things (like the current file)
469 that aren't represented in the cache, it still has to go in
470 the list of all files so that #import works. */
471 file
->next_file
= pfile
->all_files
;
472 pfile
->all_files
= file
;
476 open_file_failed (pfile
, file
, angle_brackets
);
479 cpp_error (pfile
, CPP_DL_ERROR
,
480 "one or more PCH files were found, but they were invalid");
481 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
482 cpp_error (pfile
, CPP_DL_ERROR
,
483 "use -Winvalid-pch for more information");
488 /* Only check the cache for the starting location (done above)
489 and the quote and bracket chain heads because there are no
490 other possible starting points for searches. */
491 if (file
->dir
== pfile
->bracket_include
)
492 saw_bracket_include
= true;
493 else if (file
->dir
== pfile
->quote_include
)
494 saw_quote_include
= true;
498 entry
= search_cache (*hash_slot
, file
->dir
);
501 found_in_cache
= file
->dir
;
508 /* Cache for START_DIR too, sharing the _cpp_file structure. */
509 free ((char *) file
->name
);
511 file
= entry
->u
.file
;
515 /* This is a new file; put it in the list. */
516 file
->next_file
= pfile
->all_files
;
517 pfile
->all_files
= file
;
520 /* Store this new result in the hash table. */
521 entry
= new_file_hash_entry (pfile
);
522 entry
->next
= *hash_slot
;
523 entry
->start_dir
= start_dir
;
524 entry
->u
.file
= file
;
527 /* If we passed the quote or bracket chain heads, cache them also.
528 This speeds up processing if there are lots of -I options. */
529 if (saw_bracket_include
530 && pfile
->bracket_include
!= start_dir
531 && found_in_cache
!= pfile
->bracket_include
)
533 entry
= new_file_hash_entry (pfile
);
534 entry
->next
= *hash_slot
;
535 entry
->start_dir
= pfile
->bracket_include
;
536 entry
->u
.file
= file
;
539 if (saw_quote_include
540 && pfile
->quote_include
!= start_dir
541 && found_in_cache
!= pfile
->quote_include
)
543 entry
= new_file_hash_entry (pfile
);
544 entry
->next
= *hash_slot
;
545 entry
->start_dir
= pfile
->quote_include
;
546 entry
->u
.file
= file
;
553 /* Read a file into FILE->buffer, returning true on success.
555 If FILE->fd is something weird, like a block device, we don't want
556 to read it at all. Don't even try to figure out what something is,
557 except for plain files and block devices, since there is no
558 reliable portable way of doing this.
560 FIXME: Flush file cache and try again if we run out of memory. */
562 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
564 ssize_t size
, total
, count
;
568 if (S_ISBLK (file
->st
.st_mode
))
570 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
574 regular
= S_ISREG (file
->st
.st_mode
);
577 /* off_t might have a wider range than ssize_t - in other words,
578 the max size of a file might be bigger than the address
579 space. We can't handle a file that large. (Anyone with
580 a single source file bigger than 2GB needs to rethink
581 their coding style.) Some systems (e.g. AIX 4.1) define
582 SSIZE_MAX to be much smaller than the actual range of the
583 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
585 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
587 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
591 size
= file
->st
.st_size
;
594 /* 8 kilobytes is a sensible starting size. It ought to be bigger
595 than the kernel pipe buffer, and it's definitely bigger than
596 the majority of C source files. */
599 buf
= XNEWVEC (uchar
, size
+ 1);
601 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
610 buf
= XRESIZEVEC (uchar
, buf
, size
+ 1);
616 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
620 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
621 cpp_error (pfile
, CPP_DL_WARNING
,
622 "%s is shorter than expected", file
->path
);
624 file
->buffer
= _cpp_convert_input (pfile
, CPP_OPTION (pfile
, input_charset
),
625 buf
, size
, total
, &file
->st
.st_size
);
626 file
->buffer_valid
= true;
631 /* Convenience wrapper around read_file_guts that opens the file if
632 necessary and closes the file descriptor after reading. FILE must
633 have been passed through find_file() at some stage. */
635 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
637 /* If we already have its contents in memory, succeed immediately. */
638 if (file
->buffer_valid
)
641 /* If an earlier read failed for some reason don't try again. */
642 if (file
->dont_read
|| file
->err_no
)
645 if (file
->fd
== -1 && !open_file (file
))
647 open_file_failed (pfile
, file
, 0);
651 file
->dont_read
= !read_file_guts (pfile
, file
);
655 return !file
->dont_read
;
658 /* Returns TRUE if FILE's contents have been successfully placed in
659 FILE->buffer and the file should be stacked, otherwise false. */
661 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
665 /* Skip once-only files. */
669 /* We must mark the file once-only if #import now, before header
670 guard checks. Otherwise, undefining the header guard might
671 cause the file to be re-stacked. */
674 _cpp_mark_file_once_only (pfile
, file
);
676 /* Don't stack files that have been stacked before. */
677 if (file
->stack_count
)
681 /* Skip if the file had a header guard and the macro is defined.
682 PCH relies on this appearing before the PCH handler below. */
683 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
686 /* Handle PCH files immediately; don't stack them. */
689 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
695 if (!read_file (pfile
, file
))
698 /* Check the file against the PCH file. This is done before
699 checking against files we've already seen, since it may save on
701 if (check_file_against_entries (pfile
, file
, import
))
703 /* If this isn't a #import, but yet we can't include the file,
704 that means that it was #import-ed in the PCH file,
705 so we can never include it again. */
707 _cpp_mark_file_once_only (pfile
, file
);
711 /* Now we've read the file's contents, we can stack it if there
712 are no once-only files. */
713 if (!pfile
->seen_once_only
)
716 /* We may have read the file under a different name. Look
717 for likely candidates and compare file contents to be sure. */
718 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
723 if ((import
|| f
->once_only
)
725 && f
->st
.st_mtime
== file
->st
.st_mtime
726 && f
->st
.st_size
== file
->st
.st_size
)
729 bool same_file_p
= false;
731 if (f
->buffer
&& !f
->buffer_valid
)
733 /* We already have a buffer but it is not valid, because
734 the file is still stacked. Make a new one. */
735 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
736 ref_file
->path
= f
->path
;
739 /* The file is not stacked anymore. We can reuse it. */
742 same_file_p
= read_file (pfile
, ref_file
)
743 /* Size might have changed in read_file(). */
744 && ref_file
->st
.st_size
== file
->st
.st_size
745 && !memcmp (ref_file
->buffer
,
749 if (f
->buffer
&& !f
->buffer_valid
)
752 destroy_cpp_file (ref_file
);
763 /* Place the file referenced by FILE into a new buffer on the buffer
764 stack if possible. IMPORT is true if this stacking attempt is
765 because of a #import directive. Returns true if a buffer is
768 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
773 if (!should_stack_file (pfile
, file
, import
))
776 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
779 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
781 /* Add the file to the dependencies on its first inclusion. */
782 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
784 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
785 deps_add_dep (pfile
->deps
, file
->path
);
788 /* Clear buffer_valid since _cpp_clean_line messes it up. */
789 file
->buffer_valid
= false;
792 /* Stack the buffer. */
793 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
794 CPP_OPTION (pfile
, preprocessed
)
795 && !CPP_OPTION (pfile
, directives_only
));
799 /* Initialize controlling macro state. */
800 pfile
->mi_valid
= true;
801 pfile
->mi_cmacro
= 0;
803 /* Generate the call back. */
804 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
809 /* Mark FILE to be included once only. */
811 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
813 pfile
->seen_once_only
= true;
814 file
->once_only
= true;
817 /* Return the directory from which searching for FNAME should start,
818 considering the directive TYPE and ANGLE_BRACKETS. If there is
819 nothing left in the path, returns NULL. */
820 static struct cpp_dir
*
821 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
822 enum include_type type
)
827 if (IS_ABSOLUTE_PATH (fname
))
828 return &pfile
->no_search_path
;
830 /* pfile->buffer is NULL when processing an -include command-line flag. */
831 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
833 /* For #include_next, skip in the search path past the dir in which
834 the current file was found, but if it was found via an absolute
835 path use the normal search logic. */
836 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
837 dir
= file
->dir
->next
;
838 else if (angle_brackets
)
839 dir
= pfile
->bracket_include
;
840 else if (type
== IT_CMDLINE
)
841 /* -include and -imacros use the #include "" chain with the
842 preprocessor's cwd prepended. */
843 return make_cpp_dir (pfile
, "./", false);
844 else if (pfile
->quote_ignores_source_dir
)
845 dir
= pfile
->quote_include
;
847 return make_cpp_dir (pfile
, dir_name_of_file (file
),
848 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
851 cpp_error (pfile
, CPP_DL_ERROR
,
852 "no include path in which to search for %s", fname
);
857 /* Strip the basename from the file's path. It ends with a slash if
858 of nonzero length. Note that this procedure also works for
859 <stdin>, which is represented by the empty string. */
861 dir_name_of_file (_cpp_file
*file
)
865 size_t len
= lbasename (file
->path
) - file
->path
;
866 char *dir_name
= XNEWVEC (char, len
+ 1);
868 memcpy (dir_name
, file
->path
, len
);
869 dir_name
[len
] = '\0';
870 file
->dir_name
= dir_name
;
873 return file
->dir_name
;
876 /* Handles #include-family directives (distinguished by TYPE),
877 including HEADER, and the command line -imacros and -include.
878 Returns true if a buffer was stacked. */
880 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
881 enum include_type type
)
886 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
890 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
892 /* Compensate for the increment in linemap_add. In the case of a
893 normal #include, we're currently at the start of the line
894 *following* the #include. A separate source_location for this
895 location makes no sense (until we do the LC_LEAVE), and
896 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
897 found a PCH file (in which case linemap_add is not called) or we
898 were included from the command-line. */
899 if (! file
->pch
&& file
->err_no
== 0 && type
!= IT_CMDLINE
)
900 pfile
->line_table
->highest_location
--;
902 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
905 /* Could not open FILE. The complication is dependency output. */
907 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
)
909 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
910 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
912 errno
= file
->err_no
;
913 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
914 deps_add_dep (pfile
->deps
, file
->name
);
917 /* If we are outputting dependencies but not for this file then
918 don't error because we can still produce correct output. */
919 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
920 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
922 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
926 /* Search in the chain beginning at HEAD for a file whose search path
927 started at START_DIR != NULL. */
928 static struct file_hash_entry
*
929 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
931 while (head
&& head
->start_dir
!= start_dir
)
937 /* Allocate a new _cpp_file structure. */
939 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
943 file
= XCNEW (_cpp_file
);
944 file
->main_file
= !pfile
->buffer
;
947 file
->name
= xstrdup (fname
);
952 /* Release a _cpp_file structure. */
954 destroy_cpp_file (_cpp_file
*file
)
957 free ((void *) file
->buffer
);
958 free ((void *) file
->name
);
962 /* A hash of directory names. The directory names are the path names
963 of files which contain a #include "", the included file name is
964 appended to this directories.
966 To avoid duplicate entries we follow the convention that all
967 non-empty directory names should end in a '/'. DIR_NAME must be
968 stored in permanently allocated memory. */
970 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
972 struct file_hash_entry
*entry
, **hash_slot
;
975 hash_slot
= (struct file_hash_entry
**)
976 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
977 htab_hash_string (dir_name
),
980 /* Have we already hashed this directory? */
981 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
982 if (entry
->start_dir
== NULL
)
985 dir
= XCNEW (cpp_dir
);
986 dir
->next
= pfile
->quote_include
;
987 dir
->name
= (char *) dir_name
;
988 dir
->len
= strlen (dir_name
);
992 /* Store this new result in the hash table. */
993 entry
= new_file_hash_entry (pfile
);
994 entry
->next
= *hash_slot
;
995 entry
->start_dir
= NULL
;
1002 /* Create a new block of memory for file hash entries. */
1004 allocate_file_hash_entries (cpp_reader
*pfile
)
1006 pfile
->file_hash_entries_used
= 0;
1007 pfile
->file_hash_entries_allocated
= 127;
1008 pfile
->file_hash_entries
= XNEWVEC (struct file_hash_entry
,
1009 pfile
->file_hash_entries_allocated
);
1012 /* Return a new file hash entry. */
1013 static struct file_hash_entry
*
1014 new_file_hash_entry (cpp_reader
*pfile
)
1016 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
1017 allocate_file_hash_entries (pfile
);
1019 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
1022 /* Returns TRUE if a file FNAME has ever been successfully opened.
1023 This routine is not intended to correctly handle filenames aliased
1024 by links or redundant . or .. traversals etc. */
1026 cpp_included (cpp_reader
*pfile
, const char *fname
)
1028 struct file_hash_entry
*entry
;
1030 entry
= (struct file_hash_entry
*)
1031 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1033 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1034 entry
= entry
->next
;
1036 return entry
!= NULL
;
1039 /* Calculate the hash value of a file hash entry P. */
1042 file_hash_hash (const void *p
)
1044 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1046 if (entry
->start_dir
)
1047 hname
= entry
->u
.file
->name
;
1049 hname
= entry
->u
.dir
->name
;
1051 return htab_hash_string (hname
);
1054 /* Compare a string Q against a file hash entry P. */
1056 file_hash_eq (const void *p
, const void *q
)
1058 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1059 const char *fname
= (const char *) q
;
1062 if (entry
->start_dir
)
1063 hname
= entry
->u
.file
->name
;
1065 hname
= entry
->u
.dir
->name
;
1067 return strcmp (hname
, fname
) == 0;
1070 /* Compare entries in the nonexistent file hash table. These are just
1073 nonexistent_file_hash_eq (const void *p
, const void *q
)
1075 return strcmp (p
, q
) == 0;
1078 /* Initialize everything in this source file. */
1080 _cpp_init_files (cpp_reader
*pfile
)
1082 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1083 NULL
, xcalloc
, free
);
1084 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1085 NULL
, xcalloc
, free
);
1086 allocate_file_hash_entries (pfile
);
1087 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1088 nonexistent_file_hash_eq
,
1089 NULL
, xcalloc
, free
);
1090 _obstack_begin (&pfile
->nonexistent_file_ob
, 0, 0,
1091 (void *(*) (long)) xmalloc
,
1092 (void (*) (void *)) free
);
1095 /* Finalize everything in this source file. */
1097 _cpp_cleanup_files (cpp_reader
*pfile
)
1099 htab_delete (pfile
->file_hash
);
1100 htab_delete (pfile
->dir_hash
);
1101 htab_delete (pfile
->nonexistent_file_hash
);
1102 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1105 /* Enter a file name in the hash for the sake of cpp_included. */
1107 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1109 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0);
1112 /* Not everyone who wants to set system-header-ness on a buffer can
1113 see the details of a buffer. This is an exported interface because
1114 fix-header needs it. */
1116 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1119 const struct line_maps
*line_table
= pfile
->line_table
;
1120 const struct line_map
*map
= &line_table
->maps
[line_table
->used
-1];
1122 /* 1 = system header, 2 = system header to be treated as C. */
1124 flags
= 1 + (externc
!= 0);
1125 pfile
->buffer
->sysp
= flags
;
1126 _cpp_do_file_change (pfile
, LC_RENAME
, map
->to_file
,
1127 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1130 /* Allow the client to change the current file. Used by the front end
1131 to achieve pseudo-file names like <built-in>.
1132 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1134 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1135 const char *new_name
)
1137 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1140 /* Callback function for htab_traverse. */
1142 report_missing_guard (void **slot
, void *b
)
1144 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
1145 int *bannerp
= (int *) b
;
1147 /* Skip directories. */
1148 if (entry
->start_dir
!= NULL
)
1150 _cpp_file
*file
= entry
->u
.file
;
1152 /* We don't want MI guard advice for the main file. */
1153 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
1157 fputs (_("Multiple include guards may be useful for:\n"),
1162 fputs (entry
->u
.file
->path
, stderr
);
1163 putc ('\n', stderr
);
1170 /* Report on all files that might benefit from a multiple include guard.
1173 _cpp_report_missing_guards (cpp_reader
*pfile
)
1177 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
1180 /* Locate HEADER, and determine whether it is newer than the current
1181 file. If it cannot be located or dated, return -1, if it is
1182 newer, return 1, otherwise 0. */
1184 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1188 struct cpp_dir
*dir
;
1190 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1194 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
1204 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1207 /* Pushes the given file onto the buffer stack. Returns nonzero if
1210 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1212 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1215 /* Do appropriate cleanup when a file INC's buffer is popped off the
1218 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1220 /* Record the inclusion-preventing macro, which could be NULL
1221 meaning no controlling macro. */
1222 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1223 file
->cmacro
= pfile
->mi_cmacro
;
1225 /* Invalidate control macros in the #including file. */
1226 pfile
->mi_valid
= false;
1230 free ((void *) file
->buffer
);
1231 file
->buffer
= NULL
;
1232 file
->buffer_valid
= false;
1236 /* Inteface to file statistics record in _cpp_file structure. */
1238 _cpp_get_file_stat (_cpp_file
*file
)
1243 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1244 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1245 directory of the including file.
1247 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1249 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1250 int quote_ignores_source_dir
)
1252 pfile
->quote_include
= quote
;
1253 pfile
->bracket_include
= quote
;
1254 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1256 for (; quote
; quote
= quote
->next
)
1258 quote
->name_map
= NULL
;
1259 quote
->len
= strlen (quote
->name
);
1260 if (quote
== bracket
)
1261 pfile
->bracket_include
= bracket
;
1265 /* Append the file name to the directory to create the path, but don't
1266 turn / into // or // into ///; // may be a namespace escape. */
1268 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1274 flen
= strlen (fname
);
1275 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1276 memcpy (path
, dir
->name
, dlen
);
1277 if (dlen
&& path
[dlen
- 1] != '/')
1279 memcpy (&path
[dlen
], fname
, flen
+ 1);
1284 /* Read a space delimited string of unlimited length from a stdio
1287 read_filename_string (int ch
, FILE *f
)
1293 set
= alloc
= XNEWVEC (char, len
+ 1);
1294 if (! is_space (ch
))
1297 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1299 if (set
- alloc
== len
)
1302 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1303 set
= alloc
+ len
/ 2;
1313 /* Read the file name map file for DIR. */
1315 read_name_map (cpp_dir
*dir
)
1317 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1320 size_t len
, count
= 0, room
= 9;
1323 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1324 memcpy (name
, dir
->name
, len
);
1325 if (len
&& name
[len
- 1] != '/')
1327 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1328 f
= fopen (name
, "r");
1330 dir
->name_map
= XNEWVEC (const char *, room
);
1332 /* Silently return NULL if we cannot open. */
1337 while ((ch
= getc (f
)) != EOF
)
1344 if (count
+ 2 > room
)
1347 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1350 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1351 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1354 to
= read_filename_string (ch
, f
);
1355 if (IS_ABSOLUTE_PATH (to
))
1356 dir
->name_map
[count
+ 1] = to
;
1359 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1364 while ((ch
= getc (f
)) != '\n')
1372 /* Terminate the list of maps. */
1373 dir
->name_map
[count
] = NULL
;
1376 /* Remap a FILE's name based on the file_name_map, if any, for
1377 FILE->dir. If the file name has any directory separators,
1378 recursively check those directories too. */
1380 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1382 const char *fname
, *p
;
1393 read_name_map (dir
);
1395 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1396 if (!strcmp (dir
->name_map
[index
], fname
))
1397 return xstrdup (dir
->name_map
[index
+ 1]);
1399 p
= strchr (fname
, '/');
1400 if (!p
|| p
== fname
)
1403 len
= dir
->len
+ (p
- fname
+ 1);
1404 new_dir
= XNEWVEC (char, len
+ 1);
1405 memcpy (new_dir
, dir
->name
, dir
->len
);
1406 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1407 new_dir
[len
] = '\0';
1409 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1414 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1416 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1418 const char *saved_path
= file
->path
;
1421 file
->path
= pchname
;
1422 if (open_file (file
))
1424 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1432 if (CPP_OPTION (pfile
, print_include_names
))
1435 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1437 fprintf (stderr
, "%c %s\n",
1438 valid
? '!' : 'x', pchname
);
1442 file
->path
= saved_path
;
1446 /* Get the path associated with the _cpp_file F. The path includes
1447 the base name from the include directive and the directory it was
1448 found in via the search path. */
1451 cpp_get_path (struct _cpp_file
*f
)
1456 /* Get the directory associated with the _cpp_file F. */
1459 cpp_get_dir (struct _cpp_file
*f
)
1464 /* Get the cpp_buffer currently associated with the cpp_reader
1468 cpp_get_buffer (cpp_reader
*pfile
)
1470 return pfile
->buffer
;
1473 /* Get the _cpp_file associated with the cpp_buffer B. */
1476 cpp_get_file (cpp_buffer
*b
)
1481 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1482 buffer is the buffer that included the given buffer. */
1485 cpp_get_prev (cpp_buffer
*b
)
1490 /* This data structure holds the list of header files that were seen
1491 while the PCH was being built. The 'entries' field is kept sorted
1492 in memcmp() order; yes, this means that on little-endian systems,
1493 it's sorted initially by the least-significant byte of 'size', but
1494 that's OK. The code does rely on having entries with the same size
1495 next to each other. */
1498 /* The size of this file. This is used to save running a MD5 checksum
1499 if the sizes don't match. */
1501 /* The MD5 checksum of this file. */
1502 unsigned char sum
[16];
1503 /* Is this file to be included only once? */
1508 /* Number of pchf_entry structures. */
1511 /* Are there any values with once_only set?
1512 This is used as an optimisation, it means we don't have to search
1513 the structure if we're processing a regular #include. */
1514 bool have_once_only
;
1516 struct pchf_entry entries
[1];
1519 static struct pchf_data
*pchf
;
1521 /* A qsort ordering function for pchf_entry structures. */
1524 pchf_save_compare (const void *e1
, const void *e2
)
1526 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1529 /* Create and write to F a pchf_data structure. */
1532 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1535 struct pchf_data
*result
;
1539 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1542 result_size
= (sizeof (struct pchf_data
)
1543 + sizeof (struct pchf_entry
) * (count
- 1));
1544 result
= XCNEWVAR (struct pchf_data
, result_size
);
1547 result
->have_once_only
= false;
1549 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1553 /* This should probably never happen, since if a read error occurred
1554 the PCH file shouldn't be written... */
1555 if (f
->dont_read
|| f
->err_no
)
1558 if (f
->stack_count
== 0)
1561 count
= result
->count
++;
1563 result
->entries
[count
].once_only
= f
->once_only
;
1564 /* |= is avoided in the next line because of an HP C compiler bug */
1565 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1566 if (f
->buffer_valid
)
1567 md5_buffer ((const char *)f
->buffer
,
1568 f
->st
.st_size
, result
->entries
[count
].sum
);
1576 open_file_failed (pfile
, f
, 0);
1579 ff
= fdopen (f
->fd
, "rb");
1580 md5_stream (ff
, result
->entries
[count
].sum
);
1584 result
->entries
[count
].size
= f
->st
.st_size
;
1587 result_size
= (sizeof (struct pchf_data
)
1588 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1590 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1593 return fwrite (result
, result_size
, 1, fp
) == 1;
1596 /* Read the pchf_data structure from F. */
1599 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1603 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1607 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1608 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1609 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1610 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1616 /* The parameters for pchf_compare. */
1618 struct pchf_compare_data
1620 /* The size of the file we're looking for. */
1623 /* The MD5 checksum of the file, if it's been computed. */
1624 unsigned char sum
[16];
1629 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1630 bool check_included
;
1632 /* The file that we're searching for. */
1636 /* bsearch comparison function; look for D_P in E_P. */
1639 pchf_compare (const void *d_p
, const void *e_p
)
1641 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1642 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1645 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1649 if (! d
->sum_computed
)
1651 _cpp_file
*const f
= d
->f
;
1653 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1654 d
->sum_computed
= true;
1657 result
= memcmp (d
->sum
, e
->sum
, 16);
1661 if (d
->check_included
|| e
->once_only
)
1667 /* Check that F is not in a list read from a PCH file (if any).
1668 Assumes that f->buffer_valid is true. Return TRUE if the file
1669 should not be read. */
1672 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1674 bool check_included
)
1676 struct pchf_compare_data d
;
1679 || (! check_included
&& ! pchf
->have_once_only
))
1682 d
.size
= f
->st
.st_size
;
1683 d
.sum_computed
= false;
1685 d
.check_included
= check_included
;
1686 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1687 pchf_compare
) != NULL
;