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 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. */
34 /* Variable length record files on VMS will have a stat size that includes
35 record control characters that won't be included in the read size. */
37 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
38 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
40 # define STAT_SIZE_RELIABLE(ST) true
44 /* For DJGPP redirected input is opened in text mode. */
45 # define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY)
48 # define set_stdin_to_binary_mode() /* Nothing */
55 /* This structure represents a file searched for by CPP, whether it
56 exists or not. An instance may be pointed to by more than one
57 file_hash_entry; at present no reference count is kept. */
60 /* Filename as given to #include or command line switch. */
63 /* The full path used to find the file. */
66 /* The full path of the pch file. */
69 /* The file's path with the basename stripped. NULL if it hasn't
70 been calculated yet. */
73 /* Chain through all files. */
74 struct _cpp_file
*next_file
;
76 /* The contents of NAME after calling read_file(). */
79 /* The macro, if any, preventing re-inclusion. */
80 const cpp_hashnode
*cmacro
;
82 /* The directory in the search path where FILE was found. Used for
83 #include_next and determining whether a header is a system
87 /* As filled in by stat(2) for the file. */
90 /* File descriptor. Invalid if -1, otherwise open. */
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
97 /* Number of times the file has been stacked for preprocessing. */
98 unsigned short stack_count
;
100 /* If opened with #import or contains #pragma once. */
103 /* If read() failed before. */
106 /* If this file is the main file. */
109 /* If BUFFER above contains the true contents of the file. */
112 /* File is a PCH (on return from find_include_file). */
116 /* A singly-linked list for all searches for a given file name, with
117 its head pointed to by a slot in FILE_HASH. The file name is what
118 appeared between the quotes in a #include directive; it can be
119 determined implicitly from the hash table location or explicitly
122 FILE is a structure containing details about the file that was
123 found with that search, or details of how the search failed.
125 START_DIR is the starting location of the search in the include
126 chain. The current directories for "" includes are also hashed in
127 the hash table and therefore unique. Files that are looked up
128 without using a search path, such as absolute filenames and file
129 names from the command line share a special starting directory so
130 they don't cause cache hits with normal include-chain lookups.
132 If START_DIR is NULL then the entry is for a directory, not a file,
133 and the directory is in DIR. Since the starting point in a file
134 lookup chain is never NULL, this means that simple pointer
135 comparisons against START_DIR can be made to determine cache hits
138 If a cache lookup fails because of e.g. an extra "./" in the path,
139 then nothing will break. It is just less efficient as CPP will
140 have to do more work re-preprocessing the file, and/or comparing
141 its contents against earlier once-only files.
143 struct file_hash_entry
145 struct file_hash_entry
*next
;
154 static bool open_file (_cpp_file
*file
);
155 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
157 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
159 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
160 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
161 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
162 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
163 int angle_brackets
, enum include_type
);
164 static const char *dir_name_of_file (_cpp_file
*file
);
165 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
);
166 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
167 const cpp_dir
*start_dir
);
168 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
169 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
170 static void allocate_file_hash_entries (cpp_reader
*pfile
);
171 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
172 static int report_missing_guard (void **slot
, void *b
);
173 static hashval_t
file_hash_hash (const void *p
);
174 static int file_hash_eq (const void *p
, const void *q
);
175 static char *read_filename_string (int ch
, FILE *f
);
176 static void read_name_map (cpp_dir
*dir
);
177 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
178 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
179 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
180 static int pchf_adder (void **slot
, void *data
);
181 static int pchf_save_compare (const void *e1
, const void *e2
);
182 static int pchf_compare (const void *d_p
, const void *e_p
);
183 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
185 /* Given a filename in FILE->PATH, with the empty string interpreted
188 On success FILE contains an open file descriptor and stat
189 information for the file. On failure the file descriptor is -1 and
190 the appropriate errno is also stored in FILE. Returns TRUE iff
193 We used to open files in nonblocking mode, but that caused more
194 problems than it solved. Do take care not to acquire a controlling
195 terminal by mistake (this can't happen on sane systems, but
196 paranoia is a virtue).
198 Use the three-argument form of open even though we aren't
199 specifying O_CREAT, to defend against broken system headers.
201 O_BINARY tells some runtime libraries (notably DJGPP) not to do
202 newline translation; we can handle DOS line breaks just fine
205 open_file (_cpp_file
*file
)
207 if (file
->path
[0] == '\0')
210 set_stdin_to_binary_mode ();
213 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
217 if (fstat (file
->fd
, &file
->st
) == 0)
219 if (!S_ISDIR (file
->st
.st_mode
))
225 /* Ignore a directory and continue the search. The file we're
226 looking for may be elsewhere in the search path. */
233 else if (errno
== ENOTDIR
)
236 file
->err_no
= errno
;
241 /* Temporary PCH intercept of opening a file. Try to find a PCH file
242 based on FILE->name and FILE->dir, and test those found for
243 validity using PFILE->cb.valid_pch. Return true iff a valid file is
244 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
247 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
249 static const char extension
[] = ".gch";
250 const char *path
= file
->path
;
256 /* No PCH on <stdin> or if not requested. */
257 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
260 flen
= strlen (path
);
261 len
= flen
+ sizeof (extension
);
262 pchname
= xmalloc (len
);
263 memcpy (pchname
, path
, flen
);
264 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
266 if (stat (pchname
, &st
) == 0)
270 size_t dlen
, plen
= len
;
272 if (!S_ISDIR (st
.st_mode
))
273 valid
= validate_pch (pfile
, file
, pchname
);
274 else if ((pchdir
= opendir (pchname
)) != NULL
)
276 pchname
[plen
- 1] = '/';
277 while ((d
= readdir (pchdir
)) != NULL
)
279 dlen
= strlen (d
->d_name
) + 1;
280 if ((strcmp (d
->d_name
, ".") == 0)
281 || (strcmp (d
->d_name
, "..") == 0))
283 if (dlen
+ plen
> len
)
286 pchname
= xrealloc (pchname
, len
);
288 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
289 valid
= validate_pch (pfile
, file
, pchname
);
302 file
->pchname
= pchname
;
309 /* Try to open the path FILE->name appended to FILE->dir. This is
310 where remap and PCH intercept the file lookup process. Return true
311 if the file was found, whether or not the open was successful.
312 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
315 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
319 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
322 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
);
338 file
->path
= file
->name
;
343 _cpp_find_failed (_cpp_file
*file
)
345 return file
->err_no
!= 0;
348 /* Given a filename FNAME search for such a file in the include path
349 starting from START_DIR. If FNAME is the empty string it is
350 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
352 If the file is not found in the file cache fall back to the O/S and
353 add the result to our cache.
355 If the file was not found in the filesystem, or there was an error
356 opening it, then ERR_NO is nonzero and FD is -1. If the file was
357 found, then ERR_NO is zero and FD could be -1 or an open file
358 descriptor. FD can be -1 if the file was found in the cache and
359 had previously been closed. To open it again pass the return value
363 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
)
365 struct file_hash_entry
*entry
, **hash_slot
;
367 bool invalid_pch
= false;
369 /* Ensure we get no confusion between cached files and directories. */
370 if (start_dir
== NULL
)
371 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
373 hash_slot
= (struct file_hash_entry
**)
374 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
375 htab_hash_string (fname
),
378 /* First check the cache before we resort to memory allocation. */
379 entry
= search_cache (*hash_slot
, start_dir
);
381 return entry
->u
.file
;
383 file
= make_cpp_file (pfile
, start_dir
, fname
);
385 /* Try each path in the include chain. */
388 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
391 file
->dir
= file
->dir
->next
;
392 if (file
->dir
== NULL
)
394 open_file_failed (pfile
, file
);
397 cpp_error (pfile
, CPP_DL_ERROR
,
398 "one or more PCH files were found, but they were invalid");
399 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
400 cpp_error (pfile
, CPP_DL_ERROR
,
401 "use -Winvalid-pch for more information");
406 /* Only check the cache for the starting location (done above)
407 and the quote and bracket chain heads because there are no
408 other possible starting points for searches. */
409 if (file
->dir
!= pfile
->bracket_include
410 && file
->dir
!= pfile
->quote_include
)
413 entry
= search_cache (*hash_slot
, file
->dir
);
420 /* Cache for START_DIR too, sharing the _cpp_file structure. */
421 free ((char *) file
->name
);
423 file
= entry
->u
.file
;
427 /* This is a new file; put it in the list. */
428 file
->next_file
= pfile
->all_files
;
429 pfile
->all_files
= file
;
432 /* Store this new result in the hash table. */
433 entry
= new_file_hash_entry (pfile
);
434 entry
->next
= *hash_slot
;
435 entry
->start_dir
= start_dir
;
436 entry
->u
.file
= file
;
442 /* Read a file into FILE->buffer, returning true on success.
444 If FILE->fd is something weird, like a block device, we don't want
445 to read it at all. Don't even try to figure out what something is,
446 except for plain files and block devices, since there is no
447 reliable portable way of doing this.
449 FIXME: Flush file cache and try again if we run out of memory. */
451 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
453 ssize_t size
, total
, count
;
457 if (S_ISBLK (file
->st
.st_mode
))
459 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
463 regular
= S_ISREG (file
->st
.st_mode
);
466 /* off_t might have a wider range than ssize_t - in other words,
467 the max size of a file might be bigger than the address
468 space. We can't handle a file that large. (Anyone with
469 a single source file bigger than 2GB needs to rethink
470 their coding style.) Some systems (e.g. AIX 4.1) define
471 SSIZE_MAX to be much smaller than the actual range of the
472 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
474 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
476 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
480 size
= file
->st
.st_size
;
483 /* 8 kilobytes is a sensible starting size. It ought to be bigger
484 than the kernel pipe buffer, and it's definitely bigger than
485 the majority of C source files. */
488 buf
= xmalloc (size
+ 1);
490 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
499 buf
= xrealloc (buf
, size
+ 1);
505 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
509 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
510 cpp_error (pfile
, CPP_DL_WARNING
,
511 "%s is shorter than expected", file
->path
);
513 file
->buffer
= _cpp_convert_input (pfile
, CPP_OPTION (pfile
, input_charset
),
514 buf
, size
, total
, &file
->st
.st_size
);
515 file
->buffer_valid
= true;
520 /* Convenience wrapper around read_file_guts that opens the file if
521 necessary and closes the file descriptor after reading. FILE must
522 have been passed through find_file() at some stage. */
524 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
526 /* If we already have its contents in memory, succeed immediately. */
527 if (file
->buffer_valid
)
530 /* If an earlier read failed for some reason don't try again. */
531 if (file
->dont_read
|| file
->err_no
)
534 if (file
->fd
== -1 && !open_file (file
))
536 open_file_failed (pfile
, file
);
540 file
->dont_read
= !read_file_guts (pfile
, file
);
544 return !file
->dont_read
;
547 /* Returns TRUE if FILE's contents have been successfully placed in
548 FILE->buffer and the file should be stacked, otherwise false. */
550 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
554 /* Skip once-only files. */
558 /* We must mark the file once-only if #import now, before header
559 guard checks. Otherwise, undefining the header guard might
560 cause the file to be re-stacked. */
563 _cpp_mark_file_once_only (pfile
, file
);
565 /* Don't stack files that have been stacked before. */
566 if (file
->stack_count
)
570 /* Skip if the file had a header guard and the macro is defined.
571 PCH relies on this appearing before the PCH handler below. */
572 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
575 /* Handle PCH files immediately; don't stack them. */
578 pfile
->cb
.read_pch (pfile
, file
->path
, file
->fd
, file
->pchname
);
584 if (!read_file (pfile
, file
))
587 /* Check the file against the PCH file. This is done before
588 checking against files we've already seen, since it may save on
590 if (check_file_against_entries (pfile
, file
, import
))
592 /* If this isn't a #import, but yet we can't include the file,
593 that means that it was #import-ed in the PCH file,
594 so we can never include it again. */
596 _cpp_mark_file_once_only (pfile
, file
);
600 /* Now we've read the file's contents, we can stack it if there
601 are no once-only files. */
602 if (!pfile
->seen_once_only
)
605 /* We may have read the file under a different name. Look
606 for likely candidates and compare file contents to be sure. */
607 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
612 if ((import
|| f
->once_only
)
614 && f
->st
.st_mtime
== file
->st
.st_mtime
615 && f
->st
.st_size
== file
->st
.st_size
616 && read_file (pfile
, f
)
617 /* Size might have changed in read_file(). */
618 && f
->st
.st_size
== file
->st
.st_size
619 && !memcmp (f
->buffer
, file
->buffer
, f
->st
.st_size
))
626 /* Place the file referenced by FILE into a new buffer on the buffer
627 stack if possible. IMPORT is true if this stacking attempt is
628 because of a #import directive. Returns true if a buffer is
631 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
636 if (!should_stack_file (pfile
, file
, import
))
639 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
642 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
644 /* Add the file to the dependencies on its first inclusion. */
645 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
647 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
648 deps_add_dep (pfile
->deps
, file
->path
);
651 /* Clear buffer_valid since _cpp_clean_line messes it up. */
652 file
->buffer_valid
= false;
655 /* Stack the buffer. */
656 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
657 CPP_OPTION (pfile
, preprocessed
));
661 /* Initialize controlling macro state. */
662 pfile
->mi_valid
= true;
663 pfile
->mi_cmacro
= 0;
665 /* Generate the call back. */
666 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
671 /* Mark FILE to be included once only. */
673 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
675 pfile
->seen_once_only
= true;
676 file
->once_only
= true;
679 /* Return the directory from which searching for FNAME should start,
680 considering the directive TYPE and ANGLE_BRACKETS. If there is
681 nothing left in the path, returns NULL. */
682 static struct cpp_dir
*
683 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
684 enum include_type type
)
689 if (IS_ABSOLUTE_PATH (fname
))
690 return &pfile
->no_search_path
;
692 /* pfile->buffer is NULL when processing an -include command-line flag. */
693 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
695 /* For #include_next, skip in the search path past the dir in which
696 the current file was found, but if it was found via an absolute
697 path use the normal search logic. */
698 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
699 dir
= file
->dir
->next
;
700 else if (angle_brackets
)
701 dir
= pfile
->bracket_include
;
702 else if (type
== IT_CMDLINE
)
703 /* -include and -imacros use the #include "" chain with the
704 preprocessor's cwd prepended. */
705 return make_cpp_dir (pfile
, "./", false);
706 else if (pfile
->quote_ignores_source_dir
)
707 dir
= pfile
->quote_include
;
709 return make_cpp_dir (pfile
, dir_name_of_file (file
),
710 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
713 cpp_error (pfile
, CPP_DL_ERROR
,
714 "no include path in which to search for %s", fname
);
719 /* Strip the basename from the file's path. It ends with a slash if
720 of nonzero length. Note that this procedure also works for
721 <stdin>, which is represented by the empty string. */
723 dir_name_of_file (_cpp_file
*file
)
727 size_t len
= lbasename (file
->path
) - file
->path
;
728 char *dir_name
= xmalloc (len
+ 1);
730 memcpy (dir_name
, file
->path
, len
);
731 dir_name
[len
] = '\0';
732 file
->dir_name
= dir_name
;
735 return file
->dir_name
;
738 /* Handles #include-family directives (distinguished by TYPE),
739 including HEADER, and the command line -imacros and -include.
740 Returns true if a buffer was stacked. */
742 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
743 enum include_type type
)
748 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
752 file
= _cpp_find_file (pfile
, fname
, dir
, false);
754 /* Compensate for the increment in linemap_add. In the case of a
755 normal #include, we're currently at the start of the line
756 *following* the #include. A separate source_location for this
757 location makes no sense (until we do the LC_LEAVE), and
758 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
759 found a PCH file (in which case linemap_add is not called) or we
760 were included from the command-line. */
761 if (! file
->pch
&& file
->err_no
== 0 && type
!= IT_CMDLINE
)
762 pfile
->line_table
->highest_location
--;
764 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
767 /* Could not open FILE. The complication is dependency output. */
769 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
)
771 int sysp
= pfile
->line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
772 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > !!sysp
;
774 errno
= file
->err_no
;
775 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
776 deps_add_dep (pfile
->deps
, file
->name
);
779 /* If we are outputting dependencies but not for this file then
780 don't error because we can still produce correct output. */
781 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
782 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
784 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
788 /* Search in the chain beginning at HEAD for a file whose search path
789 started at START_DIR != NULL. */
790 static struct file_hash_entry
*
791 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
793 while (head
&& head
->start_dir
!= start_dir
)
799 /* Allocate a new _cpp_file structure. */
801 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
805 file
= xcalloc (1, sizeof (_cpp_file
));
806 file
->main_file
= !pfile
->buffer
;
809 file
->name
= xstrdup (fname
);
814 /* A hash of directory names. The directory names are the path names
815 of files which contain a #include "", the included file name is
816 appended to this directories.
818 To avoid duplicate entries we follow the convention that all
819 non-empty directory names should end in a '/'. DIR_NAME must be
820 stored in permanently allocated memory. */
822 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
824 struct file_hash_entry
*entry
, **hash_slot
;
827 hash_slot
= (struct file_hash_entry
**)
828 htab_find_slot_with_hash (pfile
->file_hash
, dir_name
,
829 htab_hash_string (dir_name
),
832 /* Have we already hashed this directory? */
833 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
834 if (entry
->start_dir
== NULL
)
837 dir
= xcalloc (1, sizeof (cpp_dir
));
838 dir
->next
= pfile
->quote_include
;
839 dir
->name
= (char *) dir_name
;
840 dir
->len
= strlen (dir_name
);
843 /* Store this new result in the hash table. */
844 entry
= new_file_hash_entry (pfile
);
845 entry
->next
= *hash_slot
;
846 entry
->start_dir
= NULL
;
853 /* Create a new block of memory for file hash entries. */
855 allocate_file_hash_entries (cpp_reader
*pfile
)
857 pfile
->file_hash_entries_used
= 0;
858 pfile
->file_hash_entries_allocated
= 127;
859 pfile
->file_hash_entries
= xmalloc
860 (pfile
->file_hash_entries_allocated
* sizeof (struct file_hash_entry
));
863 /* Return a new file hash entry. */
864 static struct file_hash_entry
*
865 new_file_hash_entry (cpp_reader
*pfile
)
867 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
868 allocate_file_hash_entries (pfile
);
870 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
873 /* Returns TRUE if a file FNAME has ever been successfully opened.
874 This routine is not intended to correctly handle filenames aliased
875 by links or redundant . or .. traversals etc. */
877 cpp_included (cpp_reader
*pfile
, const char *fname
)
879 struct file_hash_entry
*entry
;
881 entry
= htab_find_with_hash (pfile
->file_hash
, fname
,
882 htab_hash_string (fname
));
884 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
887 return entry
!= NULL
;
890 /* Calculate the hash value of a file hash entry P. */
893 file_hash_hash (const void *p
)
895 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
897 if (entry
->start_dir
)
898 hname
= entry
->u
.file
->name
;
900 hname
= entry
->u
.dir
->name
;
902 return htab_hash_string (hname
);
905 /* Compare a string Q against a file hash entry P. */
907 file_hash_eq (const void *p
, const void *q
)
909 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
910 const char *fname
= (const char *) q
;
913 if (entry
->start_dir
)
914 hname
= entry
->u
.file
->name
;
916 hname
= entry
->u
.dir
->name
;
918 return strcmp (hname
, fname
) == 0;
921 /* Initialize everything in this source file. */
923 _cpp_init_files (cpp_reader
*pfile
)
925 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
926 NULL
, xcalloc
, free
);
927 allocate_file_hash_entries (pfile
);
930 /* Finalize everything in this source file. */
932 _cpp_cleanup_files (cpp_reader
*pfile
)
934 htab_delete (pfile
->file_hash
);
937 /* Enter a file name in the hash for the sake of cpp_included. */
939 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
941 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true);
944 /* Not everyone who wants to set system-header-ness on a buffer can
945 see the details of a buffer. This is an exported interface because
946 fix-header needs it. */
948 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
951 const struct line_map
*map
= linemap_lookup (pfile
->line_table
, pfile
->line
);
953 /* 1 = system header, 2 = system header to be treated as C. */
955 flags
= 1 + (externc
!= 0);
956 pfile
->buffer
->sysp
= flags
;
957 _cpp_do_file_change (pfile
, LC_RENAME
, map
->to_file
,
958 SOURCE_LINE (map
, pfile
->line
), flags
);
961 /* Allow the client to change the current file. Used by the front end
962 to achieve pseudo-file names like <built-in>.
963 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
965 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
966 const char *new_name
)
968 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
971 /* Callback function for htab_traverse. */
973 report_missing_guard (void **slot
, void *b
)
975 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
976 int *bannerp
= (int *) b
;
978 /* Skip directories. */
979 if (entry
->start_dir
!= NULL
)
981 _cpp_file
*file
= entry
->u
.file
;
983 /* We don't want MI guard advice for the main file. */
984 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
988 fputs (_("Multiple include guards may be useful for:\n"),
993 fputs (entry
->u
.file
->path
, stderr
);
1001 /* Report on all files that might benefit from a multiple include guard.
1004 _cpp_report_missing_guards (cpp_reader
*pfile
)
1008 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
1011 /* Locate HEADER, and determine whether it is newer than the current
1012 file. If it cannot be located or dated, return -1, if it is
1013 newer, return 1, otherwise 0. */
1015 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1019 struct cpp_dir
*dir
;
1021 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1025 file
= _cpp_find_file (pfile
, fname
, dir
, false);
1035 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1038 /* Pushes the given file onto the buffer stack. Returns nonzero if
1041 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1043 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1046 /* Do appropriate cleanup when a file INC's buffer is popped off the
1049 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1051 /* Record the inclusion-preventing macro, which could be NULL
1052 meaning no controlling macro. */
1053 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1054 file
->cmacro
= pfile
->mi_cmacro
;
1056 /* Invalidate control macros in the #including file. */
1057 pfile
->mi_valid
= false;
1061 free ((void *) file
->buffer
);
1062 file
->buffer
= NULL
;
1066 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1067 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1068 directory of the including file.
1070 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1072 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1073 int quote_ignores_source_dir
)
1075 pfile
->quote_include
= quote
;
1076 pfile
->bracket_include
= quote
;
1077 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1079 for (; quote
; quote
= quote
->next
)
1081 quote
->name_map
= NULL
;
1082 quote
->len
= strlen (quote
->name
);
1083 if (quote
== bracket
)
1084 pfile
->bracket_include
= bracket
;
1088 /* Append the file name to the directory to create the path, but don't
1089 turn / into // or // into ///; // may be a namespace escape. */
1091 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1097 flen
= strlen (fname
);
1098 path
= xmalloc (dlen
+ 1 + flen
+ 1);
1099 memcpy (path
, dir
->name
, dlen
);
1100 if (dlen
&& path
[dlen
- 1] != '/')
1102 memcpy (&path
[dlen
], fname
, flen
+ 1);
1107 /* Read a space delimited string of unlimited length from a stdio
1110 read_filename_string (int ch
, FILE *f
)
1116 set
= alloc
= xmalloc (len
+ 1);
1117 if (! is_space (ch
))
1120 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1122 if (set
- alloc
== len
)
1125 alloc
= xrealloc (alloc
, len
+ 1);
1126 set
= alloc
+ len
/ 2;
1136 /* Read the file name map file for DIR. */
1138 read_name_map (cpp_dir
*dir
)
1140 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1143 size_t len
, count
= 0, room
= 9;
1146 name
= alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1147 memcpy (name
, dir
->name
, len
);
1148 if (len
&& name
[len
- 1] != '/')
1150 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1151 f
= fopen (name
, "r");
1153 dir
->name_map
= xmalloc (room
* sizeof (char *));
1155 /* Silently return NULL if we cannot open. */
1160 while ((ch
= getc (f
)) != EOF
)
1167 if (count
+ 2 > room
)
1170 dir
->name_map
= xrealloc (dir
->name_map
, room
* sizeof (char *));
1173 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1174 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1177 to
= read_filename_string (ch
, f
);
1178 if (IS_ABSOLUTE_PATH (to
))
1179 dir
->name_map
[count
+ 1] = to
;
1182 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1187 while ((ch
= getc (f
)) != '\n')
1195 /* Terminate the list of maps. */
1196 dir
->name_map
[count
] = NULL
;
1199 /* Remap a FILE's name based on the file_name_map, if any, for
1200 FILE->dir. If the file name has any directory separators,
1201 recursively check those directories too. */
1203 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1205 const char *fname
, *p
;
1216 read_name_map (dir
);
1218 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1219 if (!strcmp (dir
->name_map
[index
], fname
))
1220 return xstrdup (dir
->name_map
[index
+ 1]);
1222 p
= strchr (fname
, '/');
1223 if (!p
|| p
== fname
)
1226 len
= dir
->len
+ (p
- fname
+ 1);
1227 new_dir
= xmalloc (len
+ 1);
1228 memcpy (new_dir
, dir
->name
, dir
->len
);
1229 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1230 new_dir
[len
] = '\0';
1232 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1237 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1239 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1241 const char *saved_path
= file
->path
;
1244 file
->path
= pchname
;
1245 if (open_file (file
))
1247 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1255 if (CPP_OPTION (pfile
, print_include_names
))
1258 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1260 fprintf (stderr
, "%c %s\n",
1261 valid
? '!' : 'x', pchname
);
1265 file
->path
= saved_path
;
1269 /* This datastructure holds the list of header files that were seen
1270 while the PCH was being built. The 'entries' field is kept sorted
1271 in memcmp() order; yes, this means that on little-endian systems,
1272 it's sorted initially by the least-significant byte of 'size', but
1273 that's OK. The code does rely on having entries with the same size
1274 next to each other. */
1277 /* Number of pchf_entry structures. */
1280 /* Are there any values with once_only set?
1281 This is used as an optimisation, it means we don't have to search
1282 the structure if we're processing a regular #include. */
1283 bool have_once_only
;
1286 /* The size of this file. This is used to save running a MD5 checksum
1287 if the sizes don't match. */
1289 /* The MD5 checksum of this file. */
1290 unsigned char sum
[16];
1291 /* Is this file to be included only once? */
1296 static struct pchf_data
*pchf
;
1298 /* Data for pchf_addr. */
1299 struct pchf_adder_info
1302 struct pchf_data
*d
;
1305 /* A hash traversal function to add entries into DATA->D. */
1308 pchf_adder (void **slot
, void *data
)
1310 struct file_hash_entry
*h
= (struct file_hash_entry
*) *slot
;
1311 struct pchf_adder_info
*i
= (struct pchf_adder_info
*) data
;
1313 if (h
->start_dir
!= NULL
&& h
->u
.file
->stack_count
!= 0)
1315 struct pchf_data
*d
= i
->d
;
1316 _cpp_file
*f
= h
->u
.file
;
1317 size_t count
= d
->count
++;
1319 /* This should probably never happen, since if a read error occurred
1320 the PCH file shouldn't be written... */
1321 if (f
->dont_read
|| f
->err_no
)
1324 d
->entries
[count
].once_only
= f
->once_only
;
1325 d
->have_once_only
|= f
->once_only
;
1326 if (f
->buffer_valid
)
1327 md5_buffer ((const char *)f
->buffer
,
1328 f
->st
.st_size
, d
->entries
[count
].sum
);
1336 open_file_failed (i
->pfile
, f
);
1339 ff
= fdopen (f
->fd
, "rb");
1340 md5_stream (ff
, d
->entries
[count
].sum
);
1344 d
->entries
[count
].size
= f
->st
.st_size
;
1349 /* A qsort ordering function for pchf_entry structures. */
1352 pchf_save_compare (const void *e1
, const void *e2
)
1354 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1357 /* Create and write to F a pchf_data structure. */
1360 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *f
)
1363 struct pchf_data
*result
;
1365 struct pchf_adder_info pai
;
1367 count
= htab_elements (pfile
->file_hash
);
1368 result_size
= (sizeof (struct pchf_data
)
1369 + sizeof (struct pchf_entry
) * (count
- 1));
1370 result
= xcalloc (result_size
, 1);
1373 result
->have_once_only
= false;
1377 htab_traverse (pfile
->file_hash
, pchf_adder
, &pai
);
1379 result_size
= (sizeof (struct pchf_data
)
1380 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1382 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1385 return fwrite (result
, result_size
, 1, f
) == 1;
1388 /* Read the pchf_data structure from F. */
1391 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1395 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1399 pchf
= xmalloc (sizeof (struct pchf_data
)
1400 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1401 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1402 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1408 /* The parameters for pchf_compare. */
1410 struct pchf_compare_data
1412 /* The size of the file we're looking for. */
1415 /* The MD5 checksum of the file, if it's been computed. */
1416 unsigned char sum
[16];
1421 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1422 bool check_included
;
1424 /* The file that we're searching for. */
1428 /* bsearch comparison function; look for D_P in E_P. */
1431 pchf_compare (const void *d_p
, const void *e_p
)
1433 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1434 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1437 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1441 if (! d
->sum_computed
)
1443 _cpp_file
*const f
= d
->f
;
1445 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1446 d
->sum_computed
= true;
1449 result
= memcmp (d
->sum
, e
->sum
, 16);
1453 if (d
->check_included
|| e
->once_only
)
1459 /* Check that F is not in a list read from a PCH file (if any).
1460 Assumes that f->buffer_valid is true. Return TRUE if the file
1461 should not be read. */
1464 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1466 bool check_included
)
1468 struct pchf_compare_data d
;
1471 || (! check_included
&& ! pchf
->have_once_only
))
1474 d
.size
= f
->st
.st_size
;
1475 d
.sum_computed
= false;
1477 d
.check_included
= check_included
;
1478 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1479 pchf_compare
) != NULL
;