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. */
32 /* Variable length record files on VMS will have a stat size that includes
33 record control characters that won't be included in the read size. */
35 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
36 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
38 # define STAT_SIZE_RELIABLE(ST) true
42 /* For DJGPP redirected input is opened in text mode. */
43 # define set_stdin_to_binary_mode() \
44 if (! isatty (0)) setmode (0, O_BINARY)
46 # define set_stdin_to_binary_mode() /* Nothing */
56 /* This structure represents a file searched for by CPP, whether it
57 exists or not. An instance may be pointed to by more than one
58 file_hash_entry; at present no reference count is kept. */
59 typedef struct _cpp_file _cpp_file
;
62 /* Filename as given to #include or command line switch. */
65 /* The full path used to find the file. */
68 /* The full path of the pch file. */
71 /* The file's path with the basename stripped, malloced. NULL if it
72 hasn't been calculated yet. */
75 /* Chain through #import-ed files or those containing #pragma once. */
76 struct _cpp_file
*once_only_next
;
78 /* The contents of NAME after calling read_file(). */
81 /* The macro, if any, preventing re-inclusion. */
82 const cpp_hashnode
*cmacro
;
84 /* The directory in the search path where FILE was found. Used for
85 #include_next and determining whether a header is a system
86 header. Is NULL if the file was given as an absolute path, or
87 opened with read_file. */
90 /* As filled in by stat(2) for the file. */
93 /* File descriptor. Invalid if -1, otherwise open. */
96 /* Zero if this file was successfully opened and stat()-ed,
97 otherwise errno obtained from failure. */
100 /* Number of times the file has been stacked for preprocessing. */
101 unsigned short stack_count
;
103 /* If opened with #import. */
106 /* If contains #pragma once. */
109 /* If read() failed before. */
112 /* If this file is the main file. */
115 /* If BUFFER above contains the true contents of the file. */
118 /* 0: file not known to be a PCH.
119 1: file is a PCH (on return from find_include_file).
120 2: file is not and never will be a valid precompiled header.
121 3: file is always a valid precompiled header. */
125 /* A singly-linked list for all searches for a given file name, with
126 its head pointed to by a slot in FILE_HASH. The file name is what
127 appeared between the quotes in a #include directive; it can be
128 determined implicity from the hash table location or explicitly
131 FILE is a structure containing details about the file that was
132 found with that search, or details of how the search failed.
134 START_DIR is the starting location of the search in the include
135 chain. The current directories for "" includes are also hashed in
136 the hash table. Files that are looked up without using a search
137 path, such as absolute filenames and file names from the command
138 line share a special starting directory so they don't get confused
139 with normal include-chain lookups in the cache.
141 If START_DIR is NULL then the entry is for a directory, not a file,
142 and the directory is in DIR. Since the starting point in a file
143 lookup chain is never NULL, this means that simple pointer
144 comparisons against START_DIR can be made to determine cache hits
147 struct file_hash_entry
149 struct file_hash_entry
*next
;
158 static bool open_file (_cpp_file
*file
);
159 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
);
160 static bool open_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
);
161 static _cpp_file
*find_file (cpp_reader
*, const char *fname
,
162 cpp_dir
*start_dir
, bool fake
);
163 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
164 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
165 static bool stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
166 static bool once_only_file_p (cpp_reader
*, _cpp_file
*file
, bool import
);
167 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
168 int angle_brackets
, enum include_type
);
169 static const char *dir_name_of_file (_cpp_file
*file
);
170 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
);
171 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
172 const cpp_dir
*start_dir
);
173 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
174 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
175 static void allocate_file_hash_entries (cpp_reader
*pfile
);
176 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
177 static int report_missing_guard (void **slot
, void *b
);
178 static int hash_string_eq (const void *p
, const void *q
);
179 static char *read_filename_string (int ch
, FILE *f
);
180 static void read_name_map (cpp_dir
*dir
);
181 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
182 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
183 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
184 static bool include_pch_p (_cpp_file
*file
);
186 /* Given a filename in FILE->PATH, with the empty string interpreted
189 On success FILE contains an open file descriptor and stat
190 information for the file. On failure the file descriptor is -1 and
191 the appropriate errno is also stored in FILE. Returns TRUE iff
194 We used to open files in nonblocking mode, but that caused more
195 problems than it solved. Do take care not to acquire a controlling
196 terminal by mistake (this can't happen on sane systems, but
197 paranoia is a virtue).
199 Use the three-argument form of open even though we aren't
200 specifying O_CREAT, to defend against broken system headers.
202 O_BINARY tells some runtime libraries (notably DJGPP) not to do
203 newline translation; we can handle DOS line breaks just fine
206 open_file (_cpp_file
*file
)
208 if (file
->path
[0] == '\0')
211 set_stdin_to_binary_mode ();
214 file
->fd
= open (file
->path
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
218 if (fstat (file
->fd
, &file
->st
) == 0)
220 if (!S_ISDIR (file
->st
.st_mode
))
226 /* Ignore a directory and continue the search. The file we're
227 looking for may be elsewhere in the search path. */
235 file
->err_no
= errno
;
240 /* Temporary PCH intercept of opening a file. */
242 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
)
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 (dlen
+ plen
> len
)
278 pchname
= xrealloc (pchname
, len
);
280 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
281 valid
= validate_pch (pfile
, file
, pchname
);
290 file
->pchname
= pchname
;
297 /* Try to open the path FILE->name appended to FILE->dir. This is
298 where remap and PCH intercept the file lookup process. */
300 open_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
)
304 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
307 path
= append_file_to_dir (file
->name
, file
->dir
);
310 if (pch_open_file (pfile
, file
))
313 if (open_file (file
))
321 /* Given a filename FNAME search for such a file in the include path
322 starting from START_DIR. If FNAME is the empty string it is
323 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
325 If the file is not found in the file cache fall back to the O/S and
326 add the result to our cache.
328 If the file was not found in the filesystem, or there was an error
329 opening it, then ERR_NO is non-zero and FD is -1. If the file was
330 found, then ERR_NO is zero and FD could be -1 or an open file
331 descriptor. FD can be -1 if the file was found in the cache and
332 had previously been closed. To open it again pass the return value
336 find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
)
338 struct file_hash_entry
*entry
, **hash_slot
;
341 /* Ensure we get no confusion between cached files and directories. */
342 if (start_dir
== NULL
)
343 cpp_error (pfile
, DL_ICE
, "NULL directory in find_file");
345 hash_slot
= (struct file_hash_entry
**)
346 htab_find_slot (pfile
->file_hash
, fname
, INSERT
);
348 /* First check the cache before we resort to memory allocation. */
349 entry
= search_cache (*hash_slot
, start_dir
);
351 return entry
->u
.file
;
353 file
= make_cpp_file (pfile
, start_dir
, fname
);
355 /* Try each path in the include chain. */
358 if (open_file_in_dir (pfile
, file
))
361 if (file
->err_no
!= ENOENT
|| (file
->dir
= file
->dir
->next
) == NULL
)
363 open_file_failed (pfile
, file
);
367 /* Only check the cache for the starting location (done above)
368 and the quote and bracket chain heads because there are no
369 other possible starting points for searches. */
370 if (file
->dir
!= pfile
->bracket_include
371 && file
->dir
!= pfile
->quote_include
)
374 entry
= search_cache (*hash_slot
, file
->dir
);
377 /* Cache for START_DIR too, sharing the _cpp_file structure. */
378 free ((char *) file
->name
);
380 file
= entry
->u
.file
;
385 /* Store this new result in the hash table. */
386 entry
= new_file_hash_entry (pfile
);
387 entry
->next
= *hash_slot
;
388 entry
->start_dir
= start_dir
;
389 entry
->u
.file
= file
;
395 /* Read a file into FILE->buffer, returning true on success.
397 If FILE->fd is something weird, like a block device, we don't want
398 to read it at all. Don't even try to figure out what something is,
399 except for plain files and block devices, since there is no
400 reliable portable way of doing this.
402 FIXME: Flush file cache and try again if we run out of memory. */
404 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
406 ssize_t size
, total
, count
;
410 if (S_ISBLK (file
->st
.st_mode
))
412 cpp_error (pfile
, DL_ERROR
, "%s is a block device", file
->name
);
416 regular
= S_ISREG (file
->st
.st_mode
);
419 /* off_t might have a wider range than ssize_t - in other words,
420 the max size of a file might be bigger than the address
421 space. We can't handle a file that large. (Anyone with
422 a single source file bigger than 2GB needs to rethink
423 their coding style.) Some systems (e.g. AIX 4.1) define
424 SSIZE_MAX to be much smaller than the actual range of the
425 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
427 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
429 cpp_error (pfile
, DL_ERROR
, "%s is too large", file
->name
);
433 size
= file
->st
.st_size
;
436 /* 8 kilobytes is a sensible starting size. It ought to be bigger
437 than the kernel pipe buffer, and it's definitely bigger than
438 the majority of C source files. */
441 buf
= xmalloc (size
+ 1);
443 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
452 buf
= xrealloc (buf
, size
+ 1);
458 cpp_errno (pfile
, DL_ERROR
, file
->name
);
462 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
463 cpp_error (pfile
, DL_WARNING
, "%s is shorter than expected", file
->name
);
465 /* Shrink buffer if we allocated substantially too much. */
466 if (total
+ 4096 < size
)
467 buf
= xrealloc (buf
, total
+ 1);
469 /* The lexer requires that the buffer be \n-terminated. */
473 file
->st
.st_size
= total
;
474 file
->buffer_valid
= true;
479 /* Convenience wrapper around read_file_guts that opens the file if
480 necessary and closes the file desciptor after reading. FILE must
481 have been passed through find_file() at some stage. */
483 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
485 /* Skip if the file had a header guard and the macro is defined. */
486 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
489 /* PCH files get dealt with immediately. */
490 if (include_pch_p (file
))
492 pfile
->cb
.read_pch (pfile
, file
->path
, file
->fd
, file
->pchname
);
498 /* If we already have its contents in memory, succeed immediately. */
499 if (file
->buffer_valid
)
502 /* If an earlier read failed for some reason don't try again. */
503 if (file
->dont_read
|| file
->err_no
)
506 if (file
->fd
== -1 && !open_file (file
))
508 open_file_failed (pfile
, file
);
512 file
->dont_read
= !read_file_guts (pfile
, file
);
516 return !file
->dont_read
;
519 /* Place the file referenced by FILE into a new buffer on the buffer
520 stack if possible. IMPORT is true if this stacking attempt is
521 because of a #import directive. Returns true if a buffer is
524 stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
530 if (once_only_file_p (pfile
, file
, import
))
533 sysp
= MAX ((pfile
->map
? pfile
->map
->sysp
: 0),
534 (file
->dir
? file
->dir
->sysp
: 0));
536 /* Add the file to the dependencies on its first inclusion. */
537 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
539 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
540 deps_add_dep (pfile
->deps
, file
->path
);
543 if (!read_file (pfile
, file
))
546 /* Clear buffer_valid since _cpp_clean_line messes it up. */
547 file
->buffer_valid
= false;
550 /* Stack the buffer. */
551 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
552 CPP_OPTION (pfile
, preprocessed
), 0);
555 /* Initialize controlling macro state. */
556 pfile
->mi_valid
= true;
557 pfile
->mi_cmacro
= 0;
559 /* Generate the call back. */
561 _cpp_do_file_change (pfile
, LC_ENTER
, fname
, 1, sysp
);
566 /* Returns TRUE if FILE has been previously read and should not be
569 once_only_file_p (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
573 /* Nothing to check if this isn't #import and there haven't been any
574 #pragma_once directives. */
575 if (!import
&& !pfile
->saw_pragma_once
)
578 /* Did this file contain #pragma once? */
579 if (file
->pragma_once
)
582 /* Are we #import-ing a previously #import-ed file? */
587 _cpp_mark_file_once_only (pfile
, file
, true);
590 /* Read the file contents now. stack_file would do it later, and
591 we're smart enough to not do it twice, so this is no loss. */
592 if (!read_file (pfile
, file
))
595 /* We may have #imported it under a different name, though. Look
596 for likely candidates and compare file contents to be sure. */
597 for (f
= pfile
->once_only_files
; f
; f
= f
->once_only_next
)
602 if (!f
->pragma_once
&& !(f
->import
&& import
))
606 && f
->st
.st_mtime
== file
->st
.st_mtime
607 && f
->st
.st_size
== file
->st
.st_size
608 && read_file (pfile
, f
)
609 /* Size might have changed in read_file(). */
610 && f
->st
.st_size
== file
->st
.st_size
611 && !memcmp (f
->buffer
, file
->buffer
, f
->st
.st_size
))
618 /* Mark FILE to be included once only. IMPORT is true if because of
619 #import, otherwise it is assumed to be #pragma once. */
621 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
627 pfile
->saw_pragma_once
= true;
628 file
->pragma_once
= true;
631 /* Put it on the once-only list if it's not on there already (an
632 earlier #include with a #pragma once might have put it on there
634 if (file
->once_only_next
== NULL
)
636 file
->once_only_next
= pfile
->once_only_files
;
637 pfile
->once_only_files
= file
;
641 /* Return the directory from which searching for FNAME should start,
642 condiering the directive TYPE and ANGLE_BRACKETS. If there is
643 nothing left in the path, returns NULL. */
644 static struct cpp_dir
*
645 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
646 enum include_type type
)
651 if (IS_ABSOLUTE_PATH (fname
))
652 return &pfile
->no_search_path
;
654 file
= pfile
->buffer
->file
;
656 /* For #include_next, skip in the search path past the dir in which
657 the current file was found, but if it was found via an absolute
658 path use the normal search logic. */
659 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
660 dir
= file
->dir
->next
;
661 else if (angle_brackets
)
662 dir
= pfile
->bracket_include
;
663 else if (type
== IT_CMDLINE
)
664 /* -include and -imacros use the #include "" chain with the
665 preprocessor's cwd prepended. */
666 return make_cpp_dir (pfile
, "./", false);
667 else if (pfile
->quote_ignores_source_dir
)
668 dir
= pfile
->quote_include
;
670 return make_cpp_dir (pfile
, dir_name_of_file (file
), pfile
->map
->sysp
);
673 cpp_error (pfile
, DL_ERROR
,
674 "no include path in which to search for %s", fname
);
679 /* Strip the basename from the file's path. It ends with a slash if
680 of non-zero length. Note that this procedure also works for
681 <stdin>, which is represented by the empty string. */
683 dir_name_of_file (_cpp_file
*file
)
687 size_t len
= lbasename (file
->path
) - file
->path
;
688 char *dir_name
= xmalloc (len
+ 1);
690 memcpy (dir_name
, file
->path
, len
);
691 dir_name
[len
] = '\0';
692 file
->dir_name
= dir_name
;
695 return file
->dir_name
;
698 /* Push an input buffer with the contents of FNAME, the empty string
699 for standard input. Return true if a buffer was stacked. */
701 cpp_stack_file (cpp_reader
*pfile
, const char *fname
)
703 struct cpp_dir
*dir
= &pfile
->no_search_path
;
705 return stack_file (pfile
, find_file (pfile
, fname
, dir
, false), false);
708 /* Handles #include-family directives (distinguished by TYPE),
709 including HEADER, and the command line -imacros and -include.
710 Returns true if a buffer was stacked. */
712 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
713 enum include_type type
)
717 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
721 return stack_file (pfile
, find_file (pfile
, fname
, dir
, false),
725 /* Could not open FILE. The complication is dependency output. */
727 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
)
729 int sysp
= pfile
->map
? pfile
->map
->sysp
: 0;
730 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > !!sysp
;
732 errno
= file
->err_no
;
733 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
734 deps_add_dep (pfile
->deps
, file
->path
);
737 /* If we are outputting dependencies but not for this file then
738 don't error because we can still produce correct output. */
739 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
740 cpp_errno (pfile
, DL_WARNING
, file
->name
);
742 cpp_errno (pfile
, DL_ERROR
, file
->name
);
746 /* Search in the chain beginning at HEAD for a file whose search path
747 started at START_DIR != NULL. */
748 static struct file_hash_entry
*
749 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
751 while (head
&& head
->start_dir
!= start_dir
)
757 /* Allocate a new _cpp_file structure. */
759 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
763 file
= xcalloc (1, sizeof (_cpp_file
));
764 file
->main_file
= !pfile
->buffer
;
767 file
->name
= xstrdup (fname
);
772 /* A hash of directory names. The directory names are the path names
773 of files which contain a #include "", the included file name is
774 appended to this directories.
776 To avoid duplicate entries we follow the convention that all
777 non-empty directory names should end in a '/'. DIR_NAME must be
778 stored in permanently allocated memory. */
780 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
782 struct file_hash_entry
*entry
, **hash_slot
;
785 hash_slot
= (struct file_hash_entry
**)
786 htab_find_slot (pfile
->file_hash
, dir_name
, INSERT
);
788 /* Have we already hashed this directory? */
789 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
790 if (entry
->start_dir
== NULL
)
793 dir
= xcalloc (1, sizeof (cpp_dir
));
794 dir
->next
= pfile
->quote_include
;
795 dir
->name
= (char *) dir_name
;
796 dir
->len
= strlen (dir_name
);
799 /* Store this new result in the hash table. */
800 entry
= new_file_hash_entry (pfile
);
801 entry
->next
= *hash_slot
;
802 entry
->start_dir
= NULL
;
809 /* Create a new block of memory for file hash entries. */
811 allocate_file_hash_entries (cpp_reader
*pfile
)
813 pfile
->file_hash_entries_used
= 0;
814 pfile
->file_hash_entries_allocated
= 127;
815 pfile
->file_hash_entries
= xmalloc
816 (pfile
->file_hash_entries_allocated
* sizeof (struct file_hash_entry
));
819 /* Return a new file hash entry. */
820 static struct file_hash_entry
*
821 new_file_hash_entry (cpp_reader
*pfile
)
823 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
824 allocate_file_hash_entries (pfile
);
826 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
829 /* Returns TRUE if a file FNAME has ever been successfully opened.
830 This routine is not intended to correctly handle filenames aliased
831 by links or redundant . or .. traversals etc. */
833 cpp_included (cpp_reader
*pfile
, const char *fname
)
835 struct file_hash_entry
*entry
;
837 entry
= htab_find (pfile
->file_hash
, fname
);
839 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
842 return entry
!= NULL
;
845 /* Compare a string Q against a file hash entry P. */
847 hash_string_eq (const void *p
, const void *q
)
849 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
850 const char *fname
= (const char *) q
;
853 if (entry
->start_dir
)
854 hname
= entry
->u
.file
->name
;
856 hname
= entry
->u
.dir
->name
;
858 return strcmp (hname
, fname
) == 0;
861 /* Initialize everything in this source file. */
863 _cpp_init_files (cpp_reader
*pfile
)
865 pfile
->file_hash
= htab_create_alloc (127, htab_hash_string
, hash_string_eq
,
866 NULL
, xcalloc
, free
);
867 allocate_file_hash_entries (pfile
);
870 /* Finalize everything in this source file. */
872 _cpp_cleanup_files (cpp_reader
*pfile
)
874 htab_delete (pfile
->file_hash
);
877 /* Enter a file name in the hash for the sake of cpp_included. */
879 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
881 find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true);
884 /* Not everyone who wants to set system-header-ness on a buffer can
885 see the details of a buffer. This is an exported interface because
886 fix-header needs it. */
888 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
892 /* 1 = system header, 2 = system header to be treated as C. */
894 flags
= 1 + (externc
!= 0);
895 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
896 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
899 /* Allow the client to change the current file. Used by the front end
900 to achieve pseudo-file names like <built-in>.
901 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
903 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
904 const char *new_name
)
906 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
909 /* Callback function for htab_traverse. */
911 report_missing_guard (void **slot
, void *b
)
913 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
914 int *bannerp
= (int *) b
;
916 /* Skip directories. */
917 if (entry
->start_dir
!= NULL
)
919 _cpp_file
*file
= entry
->u
.file
;
921 /* We don't want MI guard advice for the main file. */
922 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
926 fputs (_("Multiple include guards may be useful for:\n"),
931 fputs (entry
->u
.file
->path
, stderr
);
939 /* Report on all files that might benefit from a multiple include guard.
942 _cpp_report_missing_guards (cpp_reader
*pfile
)
946 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
949 /* Locate HEADER, and determine whether it is newer than the current
950 file. If it cannot be located or dated, return -1, if it is
951 newer, return 1, otherwise 0. */
953 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
959 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
963 file
= find_file (pfile
, fname
, dir
, false);
973 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
976 /* Pushes the given file onto the buffer stack. Returns nonzero if
979 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
981 /* Make the command line directive take up a line. */
983 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
986 /* Do appropriate cleanup when a file INC's buffer is popped off the
989 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
991 /* Record the inclusion-preventing macro, which could be NULL
992 meaning no controlling macro. */
993 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
994 file
->cmacro
= pfile
->mi_cmacro
;
996 /* Invalidate control macros in the #including file. */
997 pfile
->mi_valid
= false;
1001 free ((void *) file
->buffer
);
1002 file
->buffer
= NULL
;
1006 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1007 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1008 directory of the including file.
1010 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1012 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1013 int quote_ignores_source_dir
)
1015 pfile
->quote_include
= quote
;
1016 pfile
->bracket_include
= quote
;
1017 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1019 for (; quote
; quote
= quote
->next
)
1021 quote
->name_map
= NULL
;
1022 quote
->len
= strlen (quote
->name
);
1023 if (quote
== bracket
)
1024 pfile
->bracket_include
= bracket
;
1028 /* Append the file name to the directory to create the path, but don't
1029 turn / into // or // into ///; // may be a namespace escape. */
1031 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1037 flen
= strlen (fname
);
1038 path
= xmalloc (dlen
+ 1 + flen
+ 1);
1039 memcpy (path
, dir
->name
, dlen
);
1040 if (dlen
&& path
[dlen
- 1] != '/')
1042 memcpy (&path
[dlen
], fname
, flen
+ 1);
1047 /* Read a space delimited string of unlimited length from a stdio
1050 read_filename_string (int ch
, FILE *f
)
1056 set
= alloc
= xmalloc (len
+ 1);
1057 if (! is_space (ch
))
1060 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1062 if (set
- alloc
== len
)
1065 alloc
= xrealloc (alloc
, len
+ 1);
1066 set
= alloc
+ len
/ 2;
1076 /* Read the file name map file for DIR. */
1078 read_name_map (cpp_dir
*dir
)
1080 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1083 size_t len
, count
= 0, room
= 9;
1086 name
= alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1087 memcpy (name
, dir
->name
, len
);
1088 if (len
&& name
[len
- 1] != '/')
1090 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1091 f
= fopen (name
, "r");
1093 dir
->name_map
= xmalloc (room
* sizeof (char *));
1095 /* Silently return NULL if we cannot open. */
1100 while ((ch
= getc (f
)) != EOF
)
1107 if (count
+ 2 > room
)
1110 dir
->name_map
= xrealloc (dir
->name_map
, room
* sizeof (char *));
1113 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1114 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1117 to
= read_filename_string (ch
, f
);
1118 if (IS_ABSOLUTE_PATH (to
))
1119 dir
->name_map
[count
+ 1] = to
;
1122 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1127 while ((ch
= getc (f
)) != '\n')
1135 /* Terminate the list of maps. */
1136 dir
->name_map
[count
] = NULL
;
1139 /* Remap a FILE's name based on the file_name_map, if any, for
1140 FILE->dir. If the file name has any directory separators,
1141 recursively check those directories too. */
1143 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1145 const char *fname
, *p
;
1156 read_name_map (dir
);
1158 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1159 if (!strcmp (dir
->name_map
[index
], fname
))
1160 return xstrdup (dir
->name_map
[index
+ 1]);
1162 p
= strchr (fname
, '/');
1163 if (!p
|| p
== fname
)
1166 len
= dir
->len
+ (p
- fname
+ 1);
1167 new_dir
= xmalloc (len
+ 1);
1168 memcpy (new_dir
, dir
->name
, dir
->len
);
1169 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1170 new_dir
[len
] = '\0';
1172 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1177 /* Return true if FILE is usable by PCH. */
1179 include_pch_p (_cpp_file
*file
)
1181 return file
->pch
& 1;
1184 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1186 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1188 const char *saved_path
= file
->path
;
1190 file
->path
= pchname
;
1191 if (open_file (file
))
1193 if ((file
->pch
& 2) == 0)
1194 file
->pch
= pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1196 if (!include_pch_p (file
))
1202 if (CPP_OPTION (pfile
, print_include_names
))
1205 for (i
= 1; i
< pfile
->line_maps
.depth
; i
++)
1207 fprintf (stderr
, "%c %s\n",
1208 include_pch_p (file
) ? '!' : 'x', pchname
);
1214 file
->path
= saved_path
;
1215 return include_pch_p (file
);