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 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
7 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 Reimplemented, Neil Booth, Jul 2003
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
39 # define STAT_SIZE_RELIABLE(ST) true
43 /* For DJGPP redirected input is opened in text mode. */
44 # define set_stdin_to_binary_mode() \
45 if (! isatty (0)) setmode (0, O_BINARY)
47 # define set_stdin_to_binary_mode() /* Nothing */
50 /* This structure represents a file searched for by CPP, whether it
51 exists or not. An instance may be pointed to by more than one
52 file_hash_entry; at present no reference count is kept. */
55 /* Filename as given to #include or command line switch. */
58 /* The full path used to find the file. */
61 /* The full path of the pch file. */
64 /* The file's path with the basename stripped. NULL if it hasn't
65 been calculated yet. */
68 /* Chain through all files. */
69 struct _cpp_file
*next_file
;
71 /* The contents of NAME after calling read_file(). */
74 /* The macro, if any, preventing re-inclusion. */
75 const cpp_hashnode
*cmacro
;
77 /* The directory in the search path where FILE was found. Used for
78 #include_next and determining whether a header is a system
82 /* As filled in by stat(2) for the file. */
85 /* File descriptor. Invalid if -1, otherwise open. */
88 /* Zero if this file was successfully opened and stat()-ed,
89 otherwise errno obtained from failure. */
92 /* Number of times the file has been stacked for preprocessing. */
93 unsigned short stack_count
;
95 /* If opened with #import or contains #pragma once. */
98 /* If read() failed before. */
101 /* If this file is the main file. */
104 /* If BUFFER above contains the true contents of the file. */
107 /* File is a PCH (on return from find_include_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
;
149 static bool open_file (_cpp_file
*file
);
150 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
152 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
154 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
155 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
156 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
157 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
158 int angle_brackets
, enum include_type
);
159 static const char *dir_name_of_file (_cpp_file
*file
);
160 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int);
161 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
162 const cpp_dir
*start_dir
);
163 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
164 static void destroy_cpp_file (_cpp_file
*);
165 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
166 static void allocate_file_hash_entries (cpp_reader
*pfile
);
167 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
168 static int report_missing_guard (void **slot
, void *b
);
169 static hashval_t
file_hash_hash (const void *p
);
170 static int file_hash_eq (const void *p
, const void *q
);
171 static char *read_filename_string (int ch
, FILE *f
);
172 static void read_name_map (cpp_dir
*dir
);
173 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
174 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
175 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
176 static int pchf_save_compare (const void *e1
, const void *e2
);
177 static int pchf_compare (const void *d_p
, const void *e_p
);
178 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
180 /* Given a filename in FILE->PATH, with the empty string interpreted
183 On success FILE contains an open file descriptor and stat
184 information for the file. On failure the file descriptor is -1 and
185 the appropriate errno is also stored in FILE. Returns TRUE iff
188 We used to open files in nonblocking mode, but that caused more
189 problems than it solved. Do take care not to acquire a controlling
190 terminal by mistake (this can't happen on sane systems, but
191 paranoia is a virtue).
193 Use the three-argument form of open even though we aren't
194 specifying O_CREAT, to defend against broken system headers.
196 O_BINARY tells some runtime libraries (notably DJGPP) not to do
197 newline translation; we can handle DOS line breaks just fine
200 open_file (_cpp_file
*file
)
202 if (file
->path
[0] == '\0')
205 set_stdin_to_binary_mode ();
208 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
212 if (fstat (file
->fd
, &file
->st
) == 0)
214 if (!S_ISDIR (file
->st
.st_mode
))
220 /* Ignore a directory and continue the search. The file we're
221 looking for may be elsewhere in the search path. */
228 else if (errno
== ENOTDIR
)
231 file
->err_no
= errno
;
236 /* Temporary PCH intercept of opening a file. Try to find a PCH file
237 based on FILE->name and FILE->dir, and test those found for
238 validity using PFILE->cb.valid_pch. Return true iff a valid file is
239 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
242 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
244 static const char extension
[] = ".gch";
245 const char *path
= file
->path
;
251 /* No PCH on <stdin> or if not requested. */
252 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
255 flen
= strlen (path
);
256 len
= flen
+ sizeof (extension
);
257 pchname
= xmalloc (len
);
258 memcpy (pchname
, path
, flen
);
259 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
261 if (stat (pchname
, &st
) == 0)
265 size_t dlen
, plen
= len
;
267 if (!S_ISDIR (st
.st_mode
))
268 valid
= validate_pch (pfile
, file
, pchname
);
269 else if ((pchdir
= opendir (pchname
)) != NULL
)
271 pchname
[plen
- 1] = '/';
272 while ((d
= readdir (pchdir
)) != NULL
)
274 dlen
= strlen (d
->d_name
) + 1;
275 if ((strcmp (d
->d_name
, ".") == 0)
276 || (strcmp (d
->d_name
, "..") == 0))
278 if (dlen
+ plen
> len
)
281 pchname
= xrealloc (pchname
, len
);
283 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
284 valid
= validate_pch (pfile
, file
, pchname
);
297 file
->pchname
= pchname
;
304 /* Try to open the path FILE->name appended to FILE->dir. This is
305 where remap and PCH intercept the file lookup process. Return true
306 if the file was found, whether or not the open was successful.
307 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
310 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
314 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
317 if (file
->dir
->construct
)
318 path
= file
->dir
->construct (file
->name
, file
->dir
);
320 path
= append_file_to_dir (file
->name
, file
->dir
);
325 if (pch_open_file (pfile
, file
, invalid_pch
))
328 if (open_file (file
))
331 if (file
->err_no
!= ENOENT
)
333 open_file_failed (pfile
, file
, 0);
338 file
->path
= file
->name
;
342 file
->err_no
= ENOENT
;
349 /* Return tue iff the missing_header callback found the given HEADER. */
351 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
353 missing_header_cb func
= pfile
->cb
.missing_header
;
355 /* When the regular search path doesn't work, try context dependent
356 headers search paths. */
358 && file
->dir
== NULL
)
360 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
362 if (open_file (file
))
364 free ((void *)file
->path
);
366 file
->path
= file
->name
;
373 _cpp_find_failed (_cpp_file
*file
)
375 return file
->err_no
!= 0;
378 /* Given a filename FNAME search for such a file in the include path
379 starting from START_DIR. If FNAME is the empty string it is
380 interpreted as STDIN if START_DIR is PFILE->no_search_path.
382 If the file is not found in the file cache fall back to the O/S and
383 add the result to our cache.
385 If the file was not found in the filesystem, or there was an error
386 opening it, then ERR_NO is nonzero and FD is -1. If the file was
387 found, then ERR_NO is zero and FD could be -1 or an open file
388 descriptor. FD can be -1 if the file was found in the cache and
389 had previously been closed. To open it again pass the return value
393 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
, int angle_brackets
)
395 struct file_hash_entry
*entry
, **hash_slot
;
397 bool invalid_pch
= false;
399 /* Ensure we get no confusion between cached files and directories. */
400 if (start_dir
== NULL
)
401 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
403 hash_slot
= (struct file_hash_entry
**)
404 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
405 htab_hash_string (fname
),
408 /* First check the cache before we resort to memory allocation. */
409 entry
= search_cache (*hash_slot
, start_dir
);
411 return entry
->u
.file
;
413 file
= make_cpp_file (pfile
, start_dir
, fname
);
415 /* Try each path in the include chain. */
418 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
421 file
->dir
= file
->dir
->next
;
422 if (file
->dir
== NULL
)
424 if (search_path_exhausted (pfile
, fname
, file
))
426 /* Although this file must not go in the cache, because
427 the file found might depend on things (like the current file)
428 that aren't represented in the cache, it still has to go in
429 the list of all files so that #import works. */
430 file
->next_file
= pfile
->all_files
;
431 pfile
->all_files
= file
;
435 open_file_failed (pfile
, file
, angle_brackets
);
438 cpp_error (pfile
, CPP_DL_ERROR
,
439 "one or more PCH files were found, but they were invalid");
440 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
441 cpp_error (pfile
, CPP_DL_ERROR
,
442 "use -Winvalid-pch for more information");
447 /* Only check the cache for the starting location (done above)
448 and the quote and bracket chain heads because there are no
449 other possible starting points for searches. */
450 if (file
->dir
!= pfile
->bracket_include
451 && file
->dir
!= pfile
->quote_include
)
454 entry
= search_cache (*hash_slot
, file
->dir
);
461 /* Cache for START_DIR too, sharing the _cpp_file structure. */
462 free ((char *) file
->name
);
464 file
= entry
->u
.file
;
468 /* This is a new file; put it in the list. */
469 file
->next_file
= pfile
->all_files
;
470 pfile
->all_files
= file
;
473 /* Store this new result in the hash table. */
474 entry
= new_file_hash_entry (pfile
);
475 entry
->next
= *hash_slot
;
476 entry
->start_dir
= start_dir
;
477 entry
->u
.file
= file
;
483 /* Read a file into FILE->buffer, returning true on success.
485 If FILE->fd is something weird, like a block device, we don't want
486 to read it at all. Don't even try to figure out what something is,
487 except for plain files and block devices, since there is no
488 reliable portable way of doing this.
490 FIXME: Flush file cache and try again if we run out of memory. */
492 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
494 ssize_t size
, total
, count
;
498 if (S_ISBLK (file
->st
.st_mode
))
500 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
504 regular
= S_ISREG (file
->st
.st_mode
);
507 /* off_t might have a wider range than ssize_t - in other words,
508 the max size of a file might be bigger than the address
509 space. We can't handle a file that large. (Anyone with
510 a single source file bigger than 2GB needs to rethink
511 their coding style.) Some systems (e.g. AIX 4.1) define
512 SSIZE_MAX to be much smaller than the actual range of the
513 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
515 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
517 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
521 size
= file
->st
.st_size
;
524 /* 8 kilobytes is a sensible starting size. It ought to be bigger
525 than the kernel pipe buffer, and it's definitely bigger than
526 the majority of C source files. */
529 buf
= xmalloc (size
+ 1);
531 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
540 buf
= xrealloc (buf
, size
+ 1);
546 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
550 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
551 cpp_error (pfile
, CPP_DL_WARNING
,
552 "%s is shorter than expected", file
->path
);
554 file
->buffer
= _cpp_convert_input (pfile
, CPP_OPTION (pfile
, input_charset
),
555 buf
, size
, total
, &file
->st
.st_size
);
556 file
->buffer_valid
= true;
561 /* Convenience wrapper around read_file_guts that opens the file if
562 necessary and closes the file descriptor after reading. FILE must
563 have been passed through find_file() at some stage. */
565 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
567 /* If we already have its contents in memory, succeed immediately. */
568 if (file
->buffer_valid
)
571 /* If an earlier read failed for some reason don't try again. */
572 if (file
->dont_read
|| file
->err_no
)
575 if (file
->fd
== -1 && !open_file (file
))
577 open_file_failed (pfile
, file
, 0);
581 file
->dont_read
= !read_file_guts (pfile
, file
);
585 return !file
->dont_read
;
588 /* Returns TRUE if FILE's contents have been successfully placed in
589 FILE->buffer and the file should be stacked, otherwise false. */
591 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
595 /* Skip once-only files. */
599 /* We must mark the file once-only if #import now, before header
600 guard checks. Otherwise, undefining the header guard might
601 cause the file to be re-stacked. */
604 _cpp_mark_file_once_only (pfile
, file
);
606 /* Don't stack files that have been stacked before. */
607 if (file
->stack_count
)
611 /* Skip if the file had a header guard and the macro is defined.
612 PCH relies on this appearing before the PCH handler below. */
613 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
616 /* Handle PCH files immediately; don't stack them. */
619 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
625 if (!read_file (pfile
, file
))
628 /* Check the file against the PCH file. This is done before
629 checking against files we've already seen, since it may save on
631 if (check_file_against_entries (pfile
, file
, import
))
633 /* If this isn't a #import, but yet we can't include the file,
634 that means that it was #import-ed in the PCH file,
635 so we can never include it again. */
637 _cpp_mark_file_once_only (pfile
, file
);
641 /* Now we've read the file's contents, we can stack it if there
642 are no once-only files. */
643 if (!pfile
->seen_once_only
)
646 /* We may have read the file under a different name. Look
647 for likely candidates and compare file contents to be sure. */
648 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
653 if ((import
|| f
->once_only
)
655 && f
->st
.st_mtime
== file
->st
.st_mtime
656 && f
->st
.st_size
== file
->st
.st_size
)
659 bool same_file_p
= false;
661 if (f
->buffer
&& !f
->buffer_valid
)
663 /* We already have a buffer but it is not valid, because
664 the file is still stacked. Make a new one. */
665 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
666 ref_file
->path
= f
->path
;
669 /* The file is not stacked anymore. We can reuse it. */
672 same_file_p
= read_file (pfile
, ref_file
)
673 /* Size might have changed in read_file(). */
674 && ref_file
->st
.st_size
== file
->st
.st_size
675 && !memcmp (ref_file
->buffer
,
679 if (f
->buffer
&& !f
->buffer_valid
)
682 destroy_cpp_file (ref_file
);
693 /* Place the file referenced by FILE into a new buffer on the buffer
694 stack if possible. IMPORT is true if this stacking attempt is
695 because of a #import directive. Returns true if a buffer is
698 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
703 if (!should_stack_file (pfile
, file
, import
))
706 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
709 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
711 /* Add the file to the dependencies on its first inclusion. */
712 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
714 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
715 deps_add_dep (pfile
->deps
, file
->path
);
718 /* Clear buffer_valid since _cpp_clean_line messes it up. */
719 file
->buffer_valid
= false;
722 /* Stack the buffer. */
723 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
724 CPP_OPTION (pfile
, preprocessed
));
728 /* Initialize controlling macro state. */
729 pfile
->mi_valid
= true;
730 pfile
->mi_cmacro
= 0;
732 /* Generate the call back. */
733 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
738 /* Mark FILE to be included once only. */
740 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
742 pfile
->seen_once_only
= true;
743 file
->once_only
= true;
746 /* Return the directory from which searching for FNAME should start,
747 considering the directive TYPE and ANGLE_BRACKETS. If there is
748 nothing left in the path, returns NULL. */
749 static struct cpp_dir
*
750 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
751 enum include_type type
)
756 if (IS_ABSOLUTE_PATH (fname
))
757 return &pfile
->no_search_path
;
759 /* pfile->buffer is NULL when processing an -include command-line flag. */
760 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
762 /* For #include_next, skip in the search path past the dir in which
763 the current file was found, but if it was found via an absolute
764 path use the normal search logic. */
765 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
766 dir
= file
->dir
->next
;
767 else if (angle_brackets
)
768 dir
= pfile
->bracket_include
;
769 else if (type
== IT_CMDLINE
)
770 /* -include and -imacros use the #include "" chain with the
771 preprocessor's cwd prepended. */
772 return make_cpp_dir (pfile
, "./", false);
773 else if (pfile
->quote_ignores_source_dir
)
774 dir
= pfile
->quote_include
;
776 return make_cpp_dir (pfile
, dir_name_of_file (file
),
777 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
780 cpp_error (pfile
, CPP_DL_ERROR
,
781 "no include path in which to search for %s", fname
);
786 /* Strip the basename from the file's path. It ends with a slash if
787 of nonzero length. Note that this procedure also works for
788 <stdin>, which is represented by the empty string. */
790 dir_name_of_file (_cpp_file
*file
)
794 size_t len
= lbasename (file
->path
) - file
->path
;
795 char *dir_name
= xmalloc (len
+ 1);
797 memcpy (dir_name
, file
->path
, len
);
798 dir_name
[len
] = '\0';
799 file
->dir_name
= dir_name
;
802 return file
->dir_name
;
805 /* Handles #include-family directives (distinguished by TYPE),
806 including HEADER, and the command line -imacros and -include.
807 Returns true if a buffer was stacked. */
809 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
810 enum include_type type
)
815 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
819 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
821 /* Compensate for the increment in linemap_add. In the case of a
822 normal #include, we're currently at the start of the line
823 *following* the #include. A separate source_location for this
824 location makes no sense (until we do the LC_LEAVE), and
825 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
826 found a PCH file (in which case linemap_add is not called) or we
827 were included from the command-line. */
828 if (! file
->pch
&& file
->err_no
== 0 && type
!= IT_CMDLINE
)
829 pfile
->line_table
->highest_location
--;
831 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
834 /* Could not open FILE. The complication is dependency output. */
836 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
)
838 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
839 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
841 errno
= file
->err_no
;
842 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
843 deps_add_dep (pfile
->deps
, file
->name
);
846 /* If we are outputting dependencies but not for this file then
847 don't error because we can still produce correct output. */
848 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
849 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
851 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
855 /* Search in the chain beginning at HEAD for a file whose search path
856 started at START_DIR != NULL. */
857 static struct file_hash_entry
*
858 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
860 while (head
&& head
->start_dir
!= start_dir
)
866 /* Allocate a new _cpp_file structure. */
868 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
872 file
= xcalloc (1, sizeof (_cpp_file
));
873 file
->main_file
= !pfile
->buffer
;
876 file
->name
= xstrdup (fname
);
881 /* Release a _cpp_file structure. */
883 destroy_cpp_file (_cpp_file
*file
)
886 free ((void *) file
->buffer
);
887 free ((void *) file
->name
);
891 /* A hash of directory names. The directory names are the path names
892 of files which contain a #include "", the included file name is
893 appended to this directories.
895 To avoid duplicate entries we follow the convention that all
896 non-empty directory names should end in a '/'. DIR_NAME must be
897 stored in permanently allocated memory. */
899 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
901 struct file_hash_entry
*entry
, **hash_slot
;
904 hash_slot
= (struct file_hash_entry
**)
905 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
906 htab_hash_string (dir_name
),
909 /* Have we already hashed this directory? */
910 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
911 if (entry
->start_dir
== NULL
)
914 dir
= xcalloc (1, sizeof (cpp_dir
));
915 dir
->next
= pfile
->quote_include
;
916 dir
->name
= (char *) dir_name
;
917 dir
->len
= strlen (dir_name
);
921 /* Store this new result in the hash table. */
922 entry
= new_file_hash_entry (pfile
);
923 entry
->next
= *hash_slot
;
924 entry
->start_dir
= NULL
;
931 /* Create a new block of memory for file hash entries. */
933 allocate_file_hash_entries (cpp_reader
*pfile
)
935 pfile
->file_hash_entries_used
= 0;
936 pfile
->file_hash_entries_allocated
= 127;
937 pfile
->file_hash_entries
= xmalloc
938 (pfile
->file_hash_entries_allocated
* sizeof (struct file_hash_entry
));
941 /* Return a new file hash entry. */
942 static struct file_hash_entry
*
943 new_file_hash_entry (cpp_reader
*pfile
)
945 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
946 allocate_file_hash_entries (pfile
);
948 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
951 /* Returns TRUE if a file FNAME has ever been successfully opened.
952 This routine is not intended to correctly handle filenames aliased
953 by links or redundant . or .. traversals etc. */
955 cpp_included (cpp_reader
*pfile
, const char *fname
)
957 struct file_hash_entry
*entry
;
959 entry
= htab_find_with_hash (pfile
->file_hash
, fname
,
960 htab_hash_string (fname
));
962 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
965 return entry
!= NULL
;
968 /* Calculate the hash value of a file hash entry P. */
971 file_hash_hash (const void *p
)
973 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
975 if (entry
->start_dir
)
976 hname
= entry
->u
.file
->name
;
978 hname
= entry
->u
.dir
->name
;
980 return htab_hash_string (hname
);
983 /* Compare a string Q against a file hash entry P. */
985 file_hash_eq (const void *p
, const void *q
)
987 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
988 const char *fname
= (const char *) q
;
991 if (entry
->start_dir
)
992 hname
= entry
->u
.file
->name
;
994 hname
= entry
->u
.dir
->name
;
996 return strcmp (hname
, fname
) == 0;
999 /* Initialize everything in this source file. */
1001 _cpp_init_files (cpp_reader
*pfile
)
1003 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1004 NULL
, xcalloc
, free
);
1005 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1006 NULL
, xcalloc
, free
);
1007 allocate_file_hash_entries (pfile
);
1010 /* Finalize everything in this source file. */
1012 _cpp_cleanup_files (cpp_reader
*pfile
)
1014 htab_delete (pfile
->file_hash
);
1015 htab_delete (pfile
->dir_hash
);
1018 /* Enter a file name in the hash for the sake of cpp_included. */
1020 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1022 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0);
1025 /* Not everyone who wants to set system-header-ness on a buffer can
1026 see the details of a buffer. This is an exported interface because
1027 fix-header needs it. */
1029 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1032 const struct line_maps
*line_table
= pfile
->line_table
;
1033 const struct line_map
*map
= &line_table
->maps
[line_table
->used
-1];
1035 /* 1 = system header, 2 = system header to be treated as C. */
1037 flags
= 1 + (externc
!= 0);
1038 pfile
->buffer
->sysp
= flags
;
1039 _cpp_do_file_change (pfile
, LC_RENAME
, map
->to_file
,
1040 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1043 /* Allow the client to change the current file. Used by the front end
1044 to achieve pseudo-file names like <built-in>.
1045 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1047 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1048 const char *new_name
)
1050 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1053 /* Callback function for htab_traverse. */
1055 report_missing_guard (void **slot
, void *b
)
1057 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
1058 int *bannerp
= (int *) b
;
1060 /* Skip directories. */
1061 if (entry
->start_dir
!= NULL
)
1063 _cpp_file
*file
= entry
->u
.file
;
1065 /* We don't want MI guard advice for the main file. */
1066 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
1070 fputs (_("Multiple include guards may be useful for:\n"),
1075 fputs (entry
->u
.file
->path
, stderr
);
1076 putc ('\n', stderr
);
1083 /* Report on all files that might benefit from a multiple include guard.
1086 _cpp_report_missing_guards (cpp_reader
*pfile
)
1090 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
1093 /* Locate HEADER, and determine whether it is newer than the current
1094 file. If it cannot be located or dated, return -1, if it is
1095 newer, return 1, otherwise 0. */
1097 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1101 struct cpp_dir
*dir
;
1103 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1107 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
1117 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1120 /* Pushes the given file onto the buffer stack. Returns nonzero if
1123 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1125 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1128 /* Do appropriate cleanup when a file INC's buffer is popped off the
1131 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1133 /* Record the inclusion-preventing macro, which could be NULL
1134 meaning no controlling macro. */
1135 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1136 file
->cmacro
= pfile
->mi_cmacro
;
1138 /* Invalidate control macros in the #including file. */
1139 pfile
->mi_valid
= false;
1143 free ((void *) file
->buffer
);
1144 file
->buffer
= NULL
;
1145 file
->buffer_valid
= false;
1149 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1150 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1151 directory of the including file.
1153 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1155 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1156 int quote_ignores_source_dir
)
1158 pfile
->quote_include
= quote
;
1159 pfile
->bracket_include
= quote
;
1160 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1162 for (; quote
; quote
= quote
->next
)
1164 quote
->name_map
= NULL
;
1165 quote
->len
= strlen (quote
->name
);
1166 if (quote
== bracket
)
1167 pfile
->bracket_include
= bracket
;
1171 /* Append the file name to the directory to create the path, but don't
1172 turn / into // or // into ///; // may be a namespace escape. */
1174 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1180 flen
= strlen (fname
);
1181 path
= xmalloc (dlen
+ 1 + flen
+ 1);
1182 memcpy (path
, dir
->name
, dlen
);
1183 if (dlen
&& path
[dlen
- 1] != '/')
1185 memcpy (&path
[dlen
], fname
, flen
+ 1);
1190 /* Read a space delimited string of unlimited length from a stdio
1193 read_filename_string (int ch
, FILE *f
)
1199 set
= alloc
= xmalloc (len
+ 1);
1200 if (! is_space (ch
))
1203 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1205 if (set
- alloc
== len
)
1208 alloc
= xrealloc (alloc
, len
+ 1);
1209 set
= alloc
+ len
/ 2;
1219 /* Read the file name map file for DIR. */
1221 read_name_map (cpp_dir
*dir
)
1223 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1226 size_t len
, count
= 0, room
= 9;
1229 name
= alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1230 memcpy (name
, dir
->name
, len
);
1231 if (len
&& name
[len
- 1] != '/')
1233 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1234 f
= fopen (name
, "r");
1236 dir
->name_map
= xmalloc (room
* sizeof (char *));
1238 /* Silently return NULL if we cannot open. */
1243 while ((ch
= getc (f
)) != EOF
)
1250 if (count
+ 2 > room
)
1253 dir
->name_map
= xrealloc (dir
->name_map
, room
* sizeof (char *));
1256 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1257 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1260 to
= read_filename_string (ch
, f
);
1261 if (IS_ABSOLUTE_PATH (to
))
1262 dir
->name_map
[count
+ 1] = to
;
1265 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1270 while ((ch
= getc (f
)) != '\n')
1278 /* Terminate the list of maps. */
1279 dir
->name_map
[count
] = NULL
;
1282 /* Remap a FILE's name based on the file_name_map, if any, for
1283 FILE->dir. If the file name has any directory separators,
1284 recursively check those directories too. */
1286 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1288 const char *fname
, *p
;
1299 read_name_map (dir
);
1301 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1302 if (!strcmp (dir
->name_map
[index
], fname
))
1303 return xstrdup (dir
->name_map
[index
+ 1]);
1305 p
= strchr (fname
, '/');
1306 if (!p
|| p
== fname
)
1309 len
= dir
->len
+ (p
- fname
+ 1);
1310 new_dir
= xmalloc (len
+ 1);
1311 memcpy (new_dir
, dir
->name
, dir
->len
);
1312 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1313 new_dir
[len
] = '\0';
1315 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1320 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1322 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1324 const char *saved_path
= file
->path
;
1327 file
->path
= pchname
;
1328 if (open_file (file
))
1330 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1338 if (CPP_OPTION (pfile
, print_include_names
))
1341 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1343 fprintf (stderr
, "%c %s\n",
1344 valid
? '!' : 'x', pchname
);
1348 file
->path
= saved_path
;
1352 /* Get the path associated with the _cpp_file F. The path includes
1353 the base name from the include directive and the directory it was
1354 found in via the search path. */
1357 cpp_get_path (struct _cpp_file
*f
)
1362 /* Get the directory associated with the _cpp_file F. */
1365 cpp_get_dir (struct _cpp_file
*f
)
1370 /* Get the cpp_buffer currently associated with the cpp_reader
1374 cpp_get_buffer (cpp_reader
*pfile
)
1376 return pfile
->buffer
;
1379 /* Get the _cpp_file associated with the cpp_buffer B. */
1382 cpp_get_file (cpp_buffer
*b
)
1387 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1388 buffer is the buffer that included the given buffer. */
1391 cpp_get_prev (cpp_buffer
*b
)
1396 /* This data structure holds the list of header files that were seen
1397 while the PCH was being built. The 'entries' field is kept sorted
1398 in memcmp() order; yes, this means that on little-endian systems,
1399 it's sorted initially by the least-significant byte of 'size', but
1400 that's OK. The code does rely on having entries with the same size
1401 next to each other. */
1404 /* Number of pchf_entry structures. */
1407 /* Are there any values with once_only set?
1408 This is used as an optimisation, it means we don't have to search
1409 the structure if we're processing a regular #include. */
1410 bool have_once_only
;
1413 /* The size of this file. This is used to save running a MD5 checksum
1414 if the sizes don't match. */
1416 /* The MD5 checksum of this file. */
1417 unsigned char sum
[16];
1418 /* Is this file to be included only once? */
1423 static struct pchf_data
*pchf
;
1425 /* A qsort ordering function for pchf_entry structures. */
1428 pchf_save_compare (const void *e1
, const void *e2
)
1430 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1433 /* Create and write to F a pchf_data structure. */
1436 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1439 struct pchf_data
*result
;
1443 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1446 result_size
= (sizeof (struct pchf_data
)
1447 + sizeof (struct pchf_entry
) * (count
- 1));
1448 result
= xcalloc (result_size
, 1);
1451 result
->have_once_only
= false;
1453 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1457 /* This should probably never happen, since if a read error occurred
1458 the PCH file shouldn't be written... */
1459 if (f
->dont_read
|| f
->err_no
)
1462 if (f
->stack_count
== 0)
1465 count
= result
->count
++;
1467 result
->entries
[count
].once_only
= f
->once_only
;
1468 /* |= is avoided in the next line because of an HP C compiler bug */
1469 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1470 if (f
->buffer_valid
)
1471 md5_buffer ((const char *)f
->buffer
,
1472 f
->st
.st_size
, result
->entries
[count
].sum
);
1480 open_file_failed (pfile
, f
, 0);
1483 ff
= fdopen (f
->fd
, "rb");
1484 md5_stream (ff
, result
->entries
[count
].sum
);
1488 result
->entries
[count
].size
= f
->st
.st_size
;
1491 result_size
= (sizeof (struct pchf_data
)
1492 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1494 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1497 return fwrite (result
, result_size
, 1, fp
) == 1;
1500 /* Read the pchf_data structure from F. */
1503 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1507 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1511 pchf
= xmalloc (sizeof (struct pchf_data
)
1512 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1513 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1514 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1520 /* The parameters for pchf_compare. */
1522 struct pchf_compare_data
1524 /* The size of the file we're looking for. */
1527 /* The MD5 checksum of the file, if it's been computed. */
1528 unsigned char sum
[16];
1533 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1534 bool check_included
;
1536 /* The file that we're searching for. */
1540 /* bsearch comparison function; look for D_P in E_P. */
1543 pchf_compare (const void *d_p
, const void *e_p
)
1545 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1546 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1549 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1553 if (! d
->sum_computed
)
1555 _cpp_file
*const f
= d
->f
;
1557 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1558 d
->sum_computed
= true;
1561 result
= memcmp (d
->sum
, e
->sum
, 16);
1565 if (d
->check_included
|| e
->once_only
)
1571 /* Check that F is not in a list read from a PCH file (if any).
1572 Assumes that f->buffer_valid is true. Return TRUE if the file
1573 should not be read. */
1576 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1578 bool check_included
)
1580 struct pchf_compare_data d
;
1583 || (! check_included
&& ! pchf
->have_once_only
))
1586 d
.size
= f
->st
.st_size
;
1587 d
.sum_computed
= false;
1589 d
.check_included
= check_included
;
1590 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1591 pchf_compare
) != NULL
;