1 /* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003 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 */
54 /* This structure represents a file searched for by CPP, whether it
55 exists or not. An instance may be pointed to by more than one
56 file_hash_entry; at present no reference count is kept. */
59 /* Filename as given to #include or command line switch. */
62 /* The full path used to find the file. */
65 /* The full path of the pch file. */
68 /* The file's path with the basename stripped. NULL if it hasn't
69 been calculated yet. */
72 /* Chain through all files. */
73 struct _cpp_file
*next_file
;
75 /* The contents of NAME after calling read_file(). */
78 /* The macro, if any, preventing re-inclusion. */
79 const cpp_hashnode
*cmacro
;
81 /* The directory in the search path where FILE was found. Used for
82 #include_next and determining whether a header is a system
86 /* As filled in by stat(2) for the file. */
89 /* File descriptor. Invalid if -1, otherwise open. */
92 /* Zero if this file was successfully opened and stat()-ed,
93 otherwise errno obtained from failure. */
96 /* Number of times the file has been stacked for preprocessing. */
97 unsigned short stack_count
;
99 /* If opened with #import or contains #pragma once. */
102 /* If read() failed before. */
105 /* If this file is the main file. */
108 /* If BUFFER above contains the true contents of the file. */
111 /* 0: file not known to be a PCH.
112 1: file is a PCH (on return from find_include_file).
113 2: file is not and never will be a valid precompiled header.
114 3: file is always a valid precompiled header. */
118 /* A singly-linked list for all searches for a given file name, with
119 its head pointed to by a slot in FILE_HASH. The file name is what
120 appeared between the quotes in a #include directive; it can be
121 determined implicitly from the hash table location or explicitly
124 FILE is a structure containing details about the file that was
125 found with that search, or details of how the search failed.
127 START_DIR is the starting location of the search in the include
128 chain. The current directories for "" includes are also hashed in
129 the hash table and therefore unique. Files that are looked up
130 without using a search path, such as absolute filenames and file
131 names from the command line share a special starting directory so
132 they don't cause cache hits with normal include-chain lookups.
134 If START_DIR is NULL then the entry is for a directory, not a file,
135 and the directory is in DIR. Since the starting point in a file
136 lookup chain is never NULL, this means that simple pointer
137 comparisons against START_DIR can be made to determine cache hits
140 If a cache lookup fails because of e.g. an extra "./" in the path,
141 then nothing will break. It is just less efficient as CPP will
142 have to do more work re-preprocessing the file, and/or comparing
143 its contents against earlier once-only files.
145 struct file_hash_entry
147 struct file_hash_entry
*next
;
156 static bool open_file (_cpp_file
*file
);
157 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
159 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
161 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
162 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
163 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
164 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
165 int angle_brackets
, enum include_type
);
166 static const char *dir_name_of_file (_cpp_file
*file
);
167 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
);
168 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
169 const cpp_dir
*start_dir
);
170 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
171 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
172 static void allocate_file_hash_entries (cpp_reader
*pfile
);
173 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
174 static int report_missing_guard (void **slot
, void *b
);
175 static hashval_t
file_hash_hash (const void *p
);
176 static int file_hash_eq (const void *p
, const void *q
);
177 static char *read_filename_string (int ch
, FILE *f
);
178 static void read_name_map (cpp_dir
*dir
);
179 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
180 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
181 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
182 static bool include_pch_p (_cpp_file
*file
);
184 /* Given a filename in FILE->PATH, with the empty string interpreted
187 On success FILE contains an open file descriptor and stat
188 information for the file. On failure the file descriptor is -1 and
189 the appropriate errno is also stored in FILE. Returns TRUE iff
192 We used to open files in nonblocking mode, but that caused more
193 problems than it solved. Do take care not to acquire a controlling
194 terminal by mistake (this can't happen on sane systems, but
195 paranoia is a virtue).
197 Use the three-argument form of open even though we aren't
198 specifying O_CREAT, to defend against broken system headers.
200 O_BINARY tells some runtime libraries (notably DJGPP) not to do
201 newline translation; we can handle DOS line breaks just fine
204 open_file (_cpp_file
*file
)
206 if (file
->path
[0] == '\0')
209 set_stdin_to_binary_mode ();
212 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
216 if (fstat (file
->fd
, &file
->st
) == 0)
218 if (!S_ISDIR (file
->st
.st_mode
))
224 /* Ignore a directory and continue the search. The file we're
225 looking for may be elsewhere in the search path. */
232 else if (errno
== ENOTDIR
)
235 file
->err_no
= errno
;
240 /* Temporary PCH intercept of opening a file. Try to find a PCH file
241 based on FILE->name and FILE->dir, and test those found for
242 validity using PFILE->cb.valid_pch. Return true iff a valid file is
243 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
246 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
248 static const char extension
[] = ".gch";
249 const char *path
= file
->path
;
255 /* No PCH on <stdin> or if not requested. */
256 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
259 flen
= strlen (path
);
260 len
= flen
+ sizeof (extension
);
261 pchname
= xmalloc (len
);
262 memcpy (pchname
, path
, flen
);
263 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
265 if (stat (pchname
, &st
) == 0)
269 size_t dlen
, plen
= len
;
271 if (!S_ISDIR (st
.st_mode
))
272 valid
= validate_pch (pfile
, file
, pchname
);
273 else if ((pchdir
= opendir (pchname
)) != NULL
)
275 pchname
[plen
- 1] = '/';
276 while ((d
= readdir (pchdir
)) != NULL
)
278 dlen
= strlen (d
->d_name
) + 1;
279 if ((strcmp (d
->d_name
, ".") == 0)
280 || (strcmp (d
->d_name
, "..") == 0))
282 if (dlen
+ plen
> len
)
285 pchname
= xrealloc (pchname
, len
);
287 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
288 valid
= validate_pch (pfile
, file
, pchname
);
295 *invalid_pch
|= ! valid
;
299 file
->pchname
= pchname
;
306 /* Try to open the path FILE->name appended to FILE->dir. This is
307 where remap and PCH intercept the file lookup process. Return true
308 if the file was found, whether or not the open was successful.
309 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
312 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
316 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
319 path
= append_file_to_dir (file
->name
, file
->dir
);
322 if (pch_open_file (pfile
, file
, invalid_pch
))
325 if (open_file (file
))
328 if (file
->err_no
!= ENOENT
)
330 open_file_failed (pfile
, file
);
335 file
->path
= file
->name
;
340 _cpp_find_failed (_cpp_file
*file
)
342 return file
->err_no
!= 0;
345 /* Given a filename FNAME search for such a file in the include path
346 starting from START_DIR. If FNAME is the empty string it is
347 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
349 If the file is not found in the file cache fall back to the O/S and
350 add the result to our cache.
352 If the file was not found in the filesystem, or there was an error
353 opening it, then ERR_NO is nonzero and FD is -1. If the file was
354 found, then ERR_NO is zero and FD could be -1 or an open file
355 descriptor. FD can be -1 if the file was found in the cache and
356 had previously been closed. To open it again pass the return value
360 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
)
362 struct file_hash_entry
*entry
, **hash_slot
;
364 bool invalid_pch
= false;
366 /* Ensure we get no confusion between cached files and directories. */
367 if (start_dir
== NULL
)
368 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
370 hash_slot
= (struct file_hash_entry
**)
371 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
372 htab_hash_string (fname
),
375 /* First check the cache before we resort to memory allocation. */
376 entry
= search_cache (*hash_slot
, start_dir
);
378 return entry
->u
.file
;
380 file
= make_cpp_file (pfile
, start_dir
, fname
);
382 /* Try each path in the include chain. */
385 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
388 file
->dir
= file
->dir
->next
;
389 if (file
->dir
== NULL
)
391 open_file_failed (pfile
, file
);
394 cpp_error (pfile
, CPP_DL_ERROR
,
395 "one or more PCH files were found, but they were invalid");
396 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
397 cpp_error (pfile
, CPP_DL_ERROR
,
398 "use -Winvalid-pch for more information");
403 /* Only check the cache for the starting location (done above)
404 and the quote and bracket chain heads because there are no
405 other possible starting points for searches. */
406 if (file
->dir
!= pfile
->bracket_include
407 && file
->dir
!= pfile
->quote_include
)
410 entry
= search_cache (*hash_slot
, file
->dir
);
417 /* Cache for START_DIR too, sharing the _cpp_file structure. */
418 free ((char *) file
->name
);
420 file
= entry
->u
.file
;
424 /* This is a new file; put it in the list. */
425 file
->next_file
= pfile
->all_files
;
426 pfile
->all_files
= file
;
429 /* Store this new result in the hash table. */
430 entry
= new_file_hash_entry (pfile
);
431 entry
->next
= *hash_slot
;
432 entry
->start_dir
= start_dir
;
433 entry
->u
.file
= file
;
439 /* Read a file into FILE->buffer, returning true on success.
441 If FILE->fd is something weird, like a block device, we don't want
442 to read it at all. Don't even try to figure out what something is,
443 except for plain files and block devices, since there is no
444 reliable portable way of doing this.
446 FIXME: Flush file cache and try again if we run out of memory. */
448 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
450 ssize_t size
, total
, count
;
454 if (S_ISBLK (file
->st
.st_mode
))
456 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
460 regular
= S_ISREG (file
->st
.st_mode
);
463 /* off_t might have a wider range than ssize_t - in other words,
464 the max size of a file might be bigger than the address
465 space. We can't handle a file that large. (Anyone with
466 a single source file bigger than 2GB needs to rethink
467 their coding style.) Some systems (e.g. AIX 4.1) define
468 SSIZE_MAX to be much smaller than the actual range of the
469 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
471 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
473 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
477 size
= file
->st
.st_size
;
480 /* 8 kilobytes is a sensible starting size. It ought to be bigger
481 than the kernel pipe buffer, and it's definitely bigger than
482 the majority of C source files. */
485 buf
= xmalloc (size
+ 1);
487 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
496 buf
= xrealloc (buf
, size
+ 1);
502 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
506 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
507 cpp_error (pfile
, CPP_DL_WARNING
,
508 "%s is shorter than expected", file
->path
);
510 /* Shrink buffer if we allocated substantially too much. */
511 if (total
+ 4096 < size
)
512 buf
= xrealloc (buf
, total
+ 1);
514 /* The lexer requires that the buffer be \n-terminated. */
518 file
->st
.st_size
= total
;
519 file
->buffer_valid
= true;
524 /* Convenience wrapper around read_file_guts that opens the file if
525 necessary and closes the file descriptor after reading. FILE must
526 have been passed through find_file() at some stage. */
528 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
530 /* If we already have its contents in memory, succeed immediately. */
531 if (file
->buffer_valid
)
534 /* If an earlier read failed for some reason don't try again. */
535 if (file
->dont_read
|| file
->err_no
)
538 if (file
->fd
== -1 && !open_file (file
))
540 open_file_failed (pfile
, file
);
544 file
->dont_read
= !read_file_guts (pfile
, file
);
548 return !file
->dont_read
;
551 /* Returns TRUE if FILE's contents have been successfully placed in
552 FILE->buffer and the file should be stacked, otherwise false. */
554 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
558 /* Skip once-only files. */
562 /* We must mark the file once-only if #import now, before header
563 guard checks. Otherwise, undefining the header guard might
564 cause the file to be re-stacked. */
567 _cpp_mark_file_once_only (pfile
, file
);
569 /* Don't stack files that have been stacked before. */
570 if (file
->stack_count
)
574 /* Skip if the file had a header guard and the macro is defined.
575 PCH relies on this appearing before the PCH handler below. */
576 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
579 /* Handle PCH files immediately; don't stack them. */
580 if (include_pch_p (file
))
582 pfile
->cb
.read_pch (pfile
, file
->path
, file
->fd
, file
->pchname
);
588 if (!read_file (pfile
, file
))
591 /* Now we've read the file's contents, we can stack it if there
592 are no once-only files. */
593 if (!pfile
->seen_once_only
)
596 /* We may have read the file under a different name. Look
597 for likely candidates and compare file contents to be sure. */
598 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
603 if ((import
|| f
->once_only
)
605 && f
->st
.st_mtime
== file
->st
.st_mtime
606 && f
->st
.st_size
== file
->st
.st_size
607 && read_file (pfile
, f
)
608 /* Size might have changed in read_file(). */
609 && f
->st
.st_size
== file
->st
.st_size
610 && !memcmp (f
->buffer
, file
->buffer
, f
->st
.st_size
))
617 /* Place the file referenced by FILE into a new buffer on the buffer
618 stack if possible. IMPORT is true if this stacking attempt is
619 because of a #import directive. Returns true if a buffer is
622 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
627 if (!should_stack_file (pfile
, file
, import
))
630 sysp
= MAX ((pfile
->map
? pfile
->map
->sysp
: 0),
631 (file
->dir
? file
->dir
->sysp
: 0));
633 /* Add the file to the dependencies on its first inclusion. */
634 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
636 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
637 deps_add_dep (pfile
->deps
, file
->path
);
640 /* Clear buffer_valid since _cpp_clean_line messes it up. */
641 file
->buffer_valid
= false;
644 /* Stack the buffer. */
645 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
646 CPP_OPTION (pfile
, preprocessed
));
649 /* Initialize controlling macro state. */
650 pfile
->mi_valid
= true;
651 pfile
->mi_cmacro
= 0;
653 /* Generate the call back. */
654 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
659 /* Mark FILE to be included once only. */
661 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
663 pfile
->seen_once_only
= true;
664 file
->once_only
= true;
667 /* Return the directory from which searching for FNAME should start,
668 considering the directive TYPE and ANGLE_BRACKETS. If there is
669 nothing left in the path, returns NULL. */
670 static struct cpp_dir
*
671 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
672 enum include_type type
)
677 if (IS_ABSOLUTE_PATH (fname
))
678 return &pfile
->no_search_path
;
680 /* pfile->buffer is NULL when processing an -include command-line flag. */
681 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
683 /* For #include_next, skip in the search path past the dir in which
684 the current file was found, but if it was found via an absolute
685 path use the normal search logic. */
686 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
687 dir
= file
->dir
->next
;
688 else if (angle_brackets
)
689 dir
= pfile
->bracket_include
;
690 else if (type
== IT_CMDLINE
)
691 /* -include and -imacros use the #include "" chain with the
692 preprocessor's cwd prepended. */
693 return make_cpp_dir (pfile
, "./", false);
694 else if (pfile
->quote_ignores_source_dir
)
695 dir
= pfile
->quote_include
;
697 return make_cpp_dir (pfile
, dir_name_of_file (file
), pfile
->map
->sysp
);
700 cpp_error (pfile
, CPP_DL_ERROR
,
701 "no include path in which to search for %s", fname
);
706 /* Strip the basename from the file's path. It ends with a slash if
707 of nonzero length. Note that this procedure also works for
708 <stdin>, which is represented by the empty string. */
710 dir_name_of_file (_cpp_file
*file
)
714 size_t len
= lbasename (file
->path
) - file
->path
;
715 char *dir_name
= xmalloc (len
+ 1);
717 memcpy (dir_name
, file
->path
, len
);
718 dir_name
[len
] = '\0';
719 file
->dir_name
= dir_name
;
722 return file
->dir_name
;
725 /* Handles #include-family directives (distinguished by TYPE),
726 including HEADER, and the command line -imacros and -include.
727 Returns true if a buffer was stacked. */
729 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
730 enum include_type type
)
734 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
738 return _cpp_stack_file (pfile
, _cpp_find_file (pfile
, fname
, dir
, false),
742 /* Could not open FILE. The complication is dependency output. */
744 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
)
746 int sysp
= pfile
->map
? pfile
->map
->sysp
: 0;
747 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > !!sysp
;
749 errno
= file
->err_no
;
750 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
751 deps_add_dep (pfile
->deps
, file
->name
);
754 /* If we are outputting dependencies but not for this file then
755 don't error because we can still produce correct output. */
756 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
757 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
759 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
763 /* Search in the chain beginning at HEAD for a file whose search path
764 started at START_DIR != NULL. */
765 static struct file_hash_entry
*
766 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
768 while (head
&& head
->start_dir
!= start_dir
)
774 /* Allocate a new _cpp_file structure. */
776 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
780 file
= xcalloc (1, sizeof (_cpp_file
));
781 file
->main_file
= !pfile
->buffer
;
784 file
->name
= xstrdup (fname
);
789 /* A hash of directory names. The directory names are the path names
790 of files which contain a #include "", the included file name is
791 appended to this directories.
793 To avoid duplicate entries we follow the convention that all
794 non-empty directory names should end in a '/'. DIR_NAME must be
795 stored in permanently allocated memory. */
797 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
799 struct file_hash_entry
*entry
, **hash_slot
;
802 hash_slot
= (struct file_hash_entry
**)
803 htab_find_slot_with_hash (pfile
->file_hash
, dir_name
,
804 htab_hash_string (dir_name
),
807 /* Have we already hashed this directory? */
808 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
809 if (entry
->start_dir
== NULL
)
812 dir
= xcalloc (1, sizeof (cpp_dir
));
813 dir
->next
= pfile
->quote_include
;
814 dir
->name
= (char *) dir_name
;
815 dir
->len
= strlen (dir_name
);
818 /* Store this new result in the hash table. */
819 entry
= new_file_hash_entry (pfile
);
820 entry
->next
= *hash_slot
;
821 entry
->start_dir
= NULL
;
828 /* Create a new block of memory for file hash entries. */
830 allocate_file_hash_entries (cpp_reader
*pfile
)
832 pfile
->file_hash_entries_used
= 0;
833 pfile
->file_hash_entries_allocated
= 127;
834 pfile
->file_hash_entries
= xmalloc
835 (pfile
->file_hash_entries_allocated
* sizeof (struct file_hash_entry
));
838 /* Return a new file hash entry. */
839 static struct file_hash_entry
*
840 new_file_hash_entry (cpp_reader
*pfile
)
842 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
843 allocate_file_hash_entries (pfile
);
845 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
848 /* Returns TRUE if a file FNAME has ever been successfully opened.
849 This routine is not intended to correctly handle filenames aliased
850 by links or redundant . or .. traversals etc. */
852 cpp_included (cpp_reader
*pfile
, const char *fname
)
854 struct file_hash_entry
*entry
;
856 entry
= htab_find_with_hash (pfile
->file_hash
, fname
,
857 htab_hash_string (fname
));
859 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
862 return entry
!= NULL
;
865 /* Calculate the hash value of a file hash entry P. */
868 file_hash_hash (const void *p
)
870 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
872 if (entry
->start_dir
)
873 hname
= entry
->u
.file
->name
;
875 hname
= entry
->u
.dir
->name
;
877 return htab_hash_string (hname
);
880 /* Compare a string Q against a file hash entry P. */
882 file_hash_eq (const void *p
, const void *q
)
884 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
885 const char *fname
= (const char *) q
;
888 if (entry
->start_dir
)
889 hname
= entry
->u
.file
->name
;
891 hname
= entry
->u
.dir
->name
;
893 return strcmp (hname
, fname
) == 0;
896 /* Initialize everything in this source file. */
898 _cpp_init_files (cpp_reader
*pfile
)
900 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
901 NULL
, xcalloc
, free
);
902 allocate_file_hash_entries (pfile
);
905 /* Finalize everything in this source file. */
907 _cpp_cleanup_files (cpp_reader
*pfile
)
909 htab_delete (pfile
->file_hash
);
912 /* Enter a file name in the hash for the sake of cpp_included. */
914 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
916 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true);
919 /* Not everyone who wants to set system-header-ness on a buffer can
920 see the details of a buffer. This is an exported interface because
921 fix-header needs it. */
923 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
927 /* 1 = system header, 2 = system header to be treated as C. */
929 flags
= 1 + (externc
!= 0);
930 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
931 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
934 /* Allow the client to change the current file. Used by the front end
935 to achieve pseudo-file names like <built-in>.
936 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
938 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
939 const char *new_name
)
941 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
944 /* Callback function for htab_traverse. */
946 report_missing_guard (void **slot
, void *b
)
948 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
949 int *bannerp
= (int *) b
;
951 /* Skip directories. */
952 if (entry
->start_dir
!= NULL
)
954 _cpp_file
*file
= entry
->u
.file
;
956 /* We don't want MI guard advice for the main file. */
957 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
961 fputs (_("Multiple include guards may be useful for:\n"),
966 fputs (entry
->u
.file
->path
, stderr
);
974 /* Report on all files that might benefit from a multiple include guard.
977 _cpp_report_missing_guards (cpp_reader
*pfile
)
981 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
984 /* Locate HEADER, and determine whether it is newer than the current
985 file. If it cannot be located or dated, return -1, if it is
986 newer, return 1, otherwise 0. */
988 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
994 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
998 file
= _cpp_find_file (pfile
, fname
, dir
, false);
1008 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1011 /* Pushes the given file onto the buffer stack. Returns nonzero if
1014 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1016 /* Make the command line directive take up a line. */
1018 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1021 /* Do appropriate cleanup when a file INC's buffer is popped off the
1024 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1026 /* Record the inclusion-preventing macro, which could be NULL
1027 meaning no controlling macro. */
1028 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1029 file
->cmacro
= pfile
->mi_cmacro
;
1031 /* Invalidate control macros in the #including file. */
1032 pfile
->mi_valid
= false;
1036 free ((void *) file
->buffer
);
1037 file
->buffer
= NULL
;
1041 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1042 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1043 directory of the including file.
1045 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1047 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1048 int quote_ignores_source_dir
)
1050 pfile
->quote_include
= quote
;
1051 pfile
->bracket_include
= quote
;
1052 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1054 for (; quote
; quote
= quote
->next
)
1056 quote
->name_map
= NULL
;
1057 quote
->len
= strlen (quote
->name
);
1058 if (quote
== bracket
)
1059 pfile
->bracket_include
= bracket
;
1063 /* Append the file name to the directory to create the path, but don't
1064 turn / into // or // into ///; // may be a namespace escape. */
1066 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1072 flen
= strlen (fname
);
1073 path
= xmalloc (dlen
+ 1 + flen
+ 1);
1074 memcpy (path
, dir
->name
, dlen
);
1075 if (dlen
&& path
[dlen
- 1] != '/')
1077 memcpy (&path
[dlen
], fname
, flen
+ 1);
1082 /* Read a space delimited string of unlimited length from a stdio
1085 read_filename_string (int ch
, FILE *f
)
1091 set
= alloc
= xmalloc (len
+ 1);
1092 if (! is_space (ch
))
1095 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1097 if (set
- alloc
== len
)
1100 alloc
= xrealloc (alloc
, len
+ 1);
1101 set
= alloc
+ len
/ 2;
1111 /* Read the file name map file for DIR. */
1113 read_name_map (cpp_dir
*dir
)
1115 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1118 size_t len
, count
= 0, room
= 9;
1121 name
= alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1122 memcpy (name
, dir
->name
, len
);
1123 if (len
&& name
[len
- 1] != '/')
1125 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1126 f
= fopen (name
, "r");
1128 dir
->name_map
= xmalloc (room
* sizeof (char *));
1130 /* Silently return NULL if we cannot open. */
1135 while ((ch
= getc (f
)) != EOF
)
1142 if (count
+ 2 > room
)
1145 dir
->name_map
= xrealloc (dir
->name_map
, room
* sizeof (char *));
1148 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1149 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1152 to
= read_filename_string (ch
, f
);
1153 if (IS_ABSOLUTE_PATH (to
))
1154 dir
->name_map
[count
+ 1] = to
;
1157 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1162 while ((ch
= getc (f
)) != '\n')
1170 /* Terminate the list of maps. */
1171 dir
->name_map
[count
] = NULL
;
1174 /* Remap a FILE's name based on the file_name_map, if any, for
1175 FILE->dir. If the file name has any directory separators,
1176 recursively check those directories too. */
1178 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1180 const char *fname
, *p
;
1191 read_name_map (dir
);
1193 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1194 if (!strcmp (dir
->name_map
[index
], fname
))
1195 return xstrdup (dir
->name_map
[index
+ 1]);
1197 p
= strchr (fname
, '/');
1198 if (!p
|| p
== fname
)
1201 len
= dir
->len
+ (p
- fname
+ 1);
1202 new_dir
= xmalloc (len
+ 1);
1203 memcpy (new_dir
, dir
->name
, dir
->len
);
1204 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1205 new_dir
[len
] = '\0';
1207 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1212 /* Return true if FILE is usable by PCH. */
1214 include_pch_p (_cpp_file
*file
)
1216 return file
->pch
& 1;
1219 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1221 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1223 const char *saved_path
= file
->path
;
1226 file
->path
= pchname
;
1227 if (open_file (file
))
1229 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1237 if (CPP_OPTION (pfile
, print_include_names
))
1240 for (i
= 1; i
< pfile
->line_maps
.depth
; i
++)
1242 fprintf (stderr
, "%c %s\n",
1243 valid
? '!' : 'x', pchname
);
1247 file
->path
= saved_path
;