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. */
57 typedef struct _cpp_file _cpp_file
;
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 /* 0: file not known to be a PCH.
113 1: file is a PCH (on return from find_include_file).
114 2: file is not and never will be a valid precompiled header.
115 3: file is always a valid precompiled header. */
119 /* A singly-linked list for all searches for a given file name, with
120 its head pointed to by a slot in FILE_HASH. The file name is what
121 appeared between the quotes in a #include directive; it can be
122 determined implicity from the hash table location or explicitly
125 FILE is a structure containing details about the file that was
126 found with that search, or details of how the search failed.
128 START_DIR is the starting location of the search in the include
129 chain. The current directories for "" includes are also hashed in
130 the hash table and therefore unique. Files that are looked up
131 without using a search path, such as absolute filenames and file
132 names from the command line share a special starting directory so
133 they don't cause cache hits with normal include-chain lookups.
135 If START_DIR is NULL then the entry is for a directory, not a file,
136 and the directory is in DIR. Since the starting point in a file
137 lookup chain is never NULL, this means that simple pointer
138 comparisons against START_DIR can be made to determine cache hits
141 If a cache lookup fails because of e.g. an extra "./" in the path,
142 then nothing will break. It is just less efficient as CPP will
143 have to do more work re-preprocessing the file, and/or comparing
144 its contents against earlier once-only files.
146 struct file_hash_entry
148 struct file_hash_entry
*next
;
157 static bool open_file (_cpp_file
*file
);
158 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
);
159 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
);
160 static _cpp_file
*find_file (cpp_reader
*, const char *fname
,
161 cpp_dir
*start_dir
, bool fake
);
162 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
163 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
164 static bool stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
165 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
166 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
167 int angle_brackets
, enum include_type
);
168 static const char *dir_name_of_file (_cpp_file
*file
);
169 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
);
170 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
171 const cpp_dir
*start_dir
);
172 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
173 static cpp_dir
*make_cpp_dir (cpp_reader
*, const char *dir_name
, int sysp
);
174 static void allocate_file_hash_entries (cpp_reader
*pfile
);
175 static struct file_hash_entry
*new_file_hash_entry (cpp_reader
*pfile
);
176 static int report_missing_guard (void **slot
, void *b
);
177 static int hash_string_eq (const void *p
, const void *q
);
178 static char *read_filename_string (int ch
, FILE *f
);
179 static void read_name_map (cpp_dir
*dir
);
180 static char *remap_filename (cpp_reader
*pfile
, _cpp_file
*file
);
181 static char *append_file_to_dir (const char *fname
, cpp_dir
*dir
);
182 static bool validate_pch (cpp_reader
*, _cpp_file
*file
, const char *pchname
);
183 static bool include_pch_p (_cpp_file
*file
);
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. */
243 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
)
245 static const char extension
[] = ".gch";
246 const char *path
= file
->path
;
252 /* No PCH on <stdin> or if not requested. */
253 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
256 flen
= strlen (path
);
257 len
= flen
+ sizeof (extension
);
258 pchname
= xmalloc (len
);
259 memcpy (pchname
, path
, flen
);
260 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
262 if (stat (pchname
, &st
) == 0)
266 size_t dlen
, plen
= len
;
268 if (!S_ISDIR (st
.st_mode
))
269 valid
= validate_pch (pfile
, file
, pchname
);
270 else if ((pchdir
= opendir (pchname
)) != NULL
)
272 pchname
[plen
- 1] = '/';
273 while ((d
= readdir (pchdir
)) != NULL
)
275 dlen
= strlen (d
->d_name
) + 1;
276 if (dlen
+ plen
> len
)
279 pchname
= xrealloc (pchname
, len
);
281 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
282 valid
= validate_pch (pfile
, file
, pchname
);
291 file
->pchname
= pchname
;
298 /* Try to open the path FILE->name appended to FILE->dir. This is
299 where remap and PCH intercept the file lookup process. Return true
300 if the file was found, whether or not the open was successful. */
302 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
)
306 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
309 path
= append_file_to_dir (file
->name
, file
->dir
);
312 if (pch_open_file (pfile
, file
))
315 if (open_file (file
))
318 if (file
->err_no
!= ENOENT
)
320 open_file_failed (pfile
, file
);
325 file
->path
= file
->name
;
329 /* Given a filename FNAME search for such a file in the include path
330 starting from START_DIR. If FNAME is the empty string it is
331 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
333 If the file is not found in the file cache fall back to the O/S and
334 add the result to our cache.
336 If the file was not found in the filesystem, or there was an error
337 opening it, then ERR_NO is non-zero and FD is -1. If the file was
338 found, then ERR_NO is zero and FD could be -1 or an open file
339 descriptor. FD can be -1 if the file was found in the cache and
340 had previously been closed. To open it again pass the return value
344 find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
)
346 struct file_hash_entry
*entry
, **hash_slot
;
349 /* Ensure we get no confusion between cached files and directories. */
350 if (start_dir
== NULL
)
351 cpp_error (pfile
, DL_ICE
, "NULL directory in find_file");
353 hash_slot
= (struct file_hash_entry
**)
354 htab_find_slot (pfile
->file_hash
, fname
, INSERT
);
356 /* First check the cache before we resort to memory allocation. */
357 entry
= search_cache (*hash_slot
, start_dir
);
359 return entry
->u
.file
;
361 file
= make_cpp_file (pfile
, start_dir
, fname
);
363 /* Try each path in the include chain. */
366 if (find_file_in_dir (pfile
, file
))
369 file
->dir
= file
->dir
->next
;
370 if (file
->dir
== NULL
)
372 open_file_failed (pfile
, file
);
376 /* Only check the cache for the starting location (done above)
377 and the quote and bracket chain heads because there are no
378 other possible starting points for searches. */
379 if (file
->dir
!= pfile
->bracket_include
380 && file
->dir
!= pfile
->quote_include
)
383 entry
= search_cache (*hash_slot
, file
->dir
);
390 /* Cache for START_DIR too, sharing the _cpp_file structure. */
391 free ((char *) file
->name
);
393 file
= entry
->u
.file
;
397 /* This is a new file; put it in the list. */
398 file
->next_file
= pfile
->all_files
;
399 pfile
->all_files
= file
;
402 /* Store this new result in the hash table. */
403 entry
= new_file_hash_entry (pfile
);
404 entry
->next
= *hash_slot
;
405 entry
->start_dir
= start_dir
;
406 entry
->u
.file
= file
;
412 /* Read a file into FILE->buffer, returning true on success.
414 If FILE->fd is something weird, like a block device, we don't want
415 to read it at all. Don't even try to figure out what something is,
416 except for plain files and block devices, since there is no
417 reliable portable way of doing this.
419 FIXME: Flush file cache and try again if we run out of memory. */
421 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
423 ssize_t size
, total
, count
;
427 if (S_ISBLK (file
->st
.st_mode
))
429 cpp_error (pfile
, DL_ERROR
, "%s is a block device", file
->path
);
433 regular
= S_ISREG (file
->st
.st_mode
);
436 /* off_t might have a wider range than ssize_t - in other words,
437 the max size of a file might be bigger than the address
438 space. We can't handle a file that large. (Anyone with
439 a single source file bigger than 2GB needs to rethink
440 their coding style.) Some systems (e.g. AIX 4.1) define
441 SSIZE_MAX to be much smaller than the actual range of the
442 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
444 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
446 cpp_error (pfile
, DL_ERROR
, "%s is too large", file
->path
);
450 size
= file
->st
.st_size
;
453 /* 8 kilobytes is a sensible starting size. It ought to be bigger
454 than the kernel pipe buffer, and it's definitely bigger than
455 the majority of C source files. */
458 buf
= xmalloc (size
+ 1);
460 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
469 buf
= xrealloc (buf
, size
+ 1);
475 cpp_errno (pfile
, DL_ERROR
, file
->path
);
479 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
480 cpp_error (pfile
, DL_WARNING
, "%s is shorter than expected", file
->path
);
482 /* Shrink buffer if we allocated substantially too much. */
483 if (total
+ 4096 < size
)
484 buf
= xrealloc (buf
, total
+ 1);
486 /* The lexer requires that the buffer be \n-terminated. */
490 file
->st
.st_size
= total
;
491 file
->buffer_valid
= true;
496 /* Convenience wrapper around read_file_guts that opens the file if
497 necessary and closes the file desciptor after reading. FILE must
498 have been passed through find_file() at some stage. */
500 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
502 /* If we already have its contents in memory, succeed immediately. */
503 if (file
->buffer_valid
)
506 /* If an earlier read failed for some reason don't try again. */
507 if (file
->dont_read
|| file
->err_no
)
510 if (file
->fd
== -1 && !open_file (file
))
512 open_file_failed (pfile
, file
);
516 file
->dont_read
= !read_file_guts (pfile
, file
);
520 return !file
->dont_read
;
523 /* Returns TRUE if FILE's contents have been successfully placed in
524 FILE->buffer and the file should be stacked, otherwise false. */
526 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
530 /* Skip once-only files. */
534 /* We must mark the file once-only if #import now, before header
535 guard checks. Otherwise, undefining the header guard might
536 cause the file to be re-stacked. */
539 _cpp_mark_file_once_only (pfile
, file
);
541 /* Don't stack files that have been stacked before. */
542 if (file
->stack_count
)
546 /* Skip if the file had a header guard and the macro is defined.
547 PCH relies on this appearing before the PCH handler below. */
548 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
551 /* Handle PCH files immediately; don't stack them. */
552 if (include_pch_p (file
))
554 pfile
->cb
.read_pch (pfile
, file
->path
, file
->fd
, file
->pchname
);
560 if (!read_file (pfile
, file
))
563 /* Now we've read the file's contents, we can stack it if there
564 are no once-only files. */
565 if (!pfile
->seen_once_only
)
568 /* We may have read the file under a different name. Look
569 for likely candidates and compare file contents to be sure. */
570 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
575 if ((import
|| f
->once_only
)
577 && f
->st
.st_mtime
== file
->st
.st_mtime
578 && f
->st
.st_size
== file
->st
.st_size
579 && read_file (pfile
, f
)
580 /* Size might have changed in read_file(). */
581 && f
->st
.st_size
== file
->st
.st_size
582 && !memcmp (f
->buffer
, file
->buffer
, f
->st
.st_size
))
589 /* Place the file referenced by FILE into a new buffer on the buffer
590 stack if possible. IMPORT is true if this stacking attempt is
591 because of a #import directive. Returns true if a buffer is
594 stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
599 if (!should_stack_file (pfile
, file
, import
))
602 sysp
= MAX ((pfile
->map
? pfile
->map
->sysp
: 0),
603 (file
->dir
? file
->dir
->sysp
: 0));
605 /* Add the file to the dependencies on its first inclusion. */
606 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
608 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
609 deps_add_dep (pfile
->deps
, file
->path
);
612 /* Clear buffer_valid since _cpp_clean_line messes it up. */
613 file
->buffer_valid
= false;
616 /* Stack the buffer. */
617 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
618 CPP_OPTION (pfile
, preprocessed
), 0);
621 /* Initialize controlling macro state. */
622 pfile
->mi_valid
= true;
623 pfile
->mi_cmacro
= 0;
625 /* Generate the call back. */
626 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
631 /* Mark FILE to be included once only. */
633 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
635 pfile
->seen_once_only
= true;
636 file
->once_only
= true;
639 /* Return the directory from which searching for FNAME should start,
640 condiering the directive TYPE and ANGLE_BRACKETS. If there is
641 nothing left in the path, returns NULL. */
642 static struct cpp_dir
*
643 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
644 enum include_type type
)
649 if (IS_ABSOLUTE_PATH (fname
))
650 return &pfile
->no_search_path
;
652 file
= pfile
->buffer
->file
;
654 /* For #include_next, skip in the search path past the dir in which
655 the current file was found, but if it was found via an absolute
656 path use the normal search logic. */
657 if (type
== IT_INCLUDE_NEXT
&& file
->dir
)
658 dir
= file
->dir
->next
;
659 else if (angle_brackets
)
660 dir
= pfile
->bracket_include
;
661 else if (type
== IT_CMDLINE
)
662 /* -include and -imacros use the #include "" chain with the
663 preprocessor's cwd prepended. */
664 return make_cpp_dir (pfile
, "./", false);
665 else if (pfile
->quote_ignores_source_dir
)
666 dir
= pfile
->quote_include
;
668 return make_cpp_dir (pfile
, dir_name_of_file (file
), pfile
->map
->sysp
);
671 cpp_error (pfile
, DL_ERROR
,
672 "no include path in which to search for %s", fname
);
677 /* Strip the basename from the file's path. It ends with a slash if
678 of non-zero length. Note that this procedure also works for
679 <stdin>, which is represented by the empty string. */
681 dir_name_of_file (_cpp_file
*file
)
685 size_t len
= lbasename (file
->path
) - file
->path
;
686 char *dir_name
= xmalloc (len
+ 1);
688 memcpy (dir_name
, file
->path
, len
);
689 dir_name
[len
] = '\0';
690 file
->dir_name
= dir_name
;
693 return file
->dir_name
;
696 /* Push an input buffer with the contents of FNAME, the empty string
697 for standard input. Return true if a buffer was stacked. */
699 _cpp_stack_file (cpp_reader
*pfile
, const char *fname
)
701 struct cpp_dir
*dir
= &pfile
->no_search_path
;
703 return stack_file (pfile
, find_file (pfile
, fname
, dir
, false), false);
706 /* Handles #include-family directives (distinguished by TYPE),
707 including HEADER, and the command line -imacros and -include.
708 Returns true if a buffer was stacked. */
710 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
711 enum include_type type
)
715 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
719 return stack_file (pfile
, find_file (pfile
, fname
, dir
, false),
723 /* Could not open FILE. The complication is dependency output. */
725 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
)
727 int sysp
= pfile
->map
? pfile
->map
->sysp
: 0;
728 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > !!sysp
;
730 errno
= file
->err_no
;
731 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
732 deps_add_dep (pfile
->deps
, file
->name
);
735 /* If we are outputting dependencies but not for this file then
736 don't error because we can still produce correct output. */
737 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
738 cpp_errno (pfile
, DL_WARNING
, file
->path
);
740 cpp_errno (pfile
, DL_ERROR
, file
->path
);
744 /* Search in the chain beginning at HEAD for a file whose search path
745 started at START_DIR != NULL. */
746 static struct file_hash_entry
*
747 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
749 while (head
&& head
->start_dir
!= start_dir
)
755 /* Allocate a new _cpp_file structure. */
757 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
761 file
= xcalloc (1, sizeof (_cpp_file
));
762 file
->main_file
= !pfile
->buffer
;
765 file
->name
= xstrdup (fname
);
770 /* A hash of directory names. The directory names are the path names
771 of files which contain a #include "", the included file name is
772 appended to this directories.
774 To avoid duplicate entries we follow the convention that all
775 non-empty directory names should end in a '/'. DIR_NAME must be
776 stored in permanently allocated memory. */
778 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
780 struct file_hash_entry
*entry
, **hash_slot
;
783 hash_slot
= (struct file_hash_entry
**)
784 htab_find_slot (pfile
->file_hash
, dir_name
, INSERT
);
786 /* Have we already hashed this directory? */
787 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
788 if (entry
->start_dir
== NULL
)
791 dir
= xcalloc (1, sizeof (cpp_dir
));
792 dir
->next
= pfile
->quote_include
;
793 dir
->name
= (char *) dir_name
;
794 dir
->len
= strlen (dir_name
);
797 /* Store this new result in the hash table. */
798 entry
= new_file_hash_entry (pfile
);
799 entry
->next
= *hash_slot
;
800 entry
->start_dir
= NULL
;
807 /* Create a new block of memory for file hash entries. */
809 allocate_file_hash_entries (cpp_reader
*pfile
)
811 pfile
->file_hash_entries_used
= 0;
812 pfile
->file_hash_entries_allocated
= 127;
813 pfile
->file_hash_entries
= xmalloc
814 (pfile
->file_hash_entries_allocated
* sizeof (struct file_hash_entry
));
817 /* Return a new file hash entry. */
818 static struct file_hash_entry
*
819 new_file_hash_entry (cpp_reader
*pfile
)
821 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
822 allocate_file_hash_entries (pfile
);
824 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
827 /* Returns TRUE if a file FNAME has ever been successfully opened.
828 This routine is not intended to correctly handle filenames aliased
829 by links or redundant . or .. traversals etc. */
831 cpp_included (cpp_reader
*pfile
, const char *fname
)
833 struct file_hash_entry
*entry
;
835 entry
= htab_find (pfile
->file_hash
, fname
);
837 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
840 return entry
!= NULL
;
843 /* Compare a string Q against a file hash entry P. */
845 hash_string_eq (const void *p
, const void *q
)
847 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
848 const char *fname
= (const char *) q
;
851 if (entry
->start_dir
)
852 hname
= entry
->u
.file
->name
;
854 hname
= entry
->u
.dir
->name
;
856 return strcmp (hname
, fname
) == 0;
859 /* Initialize everything in this source file. */
861 _cpp_init_files (cpp_reader
*pfile
)
863 pfile
->file_hash
= htab_create_alloc (127, htab_hash_string
, hash_string_eq
,
864 NULL
, xcalloc
, free
);
865 allocate_file_hash_entries (pfile
);
868 /* Finalize everything in this source file. */
870 _cpp_cleanup_files (cpp_reader
*pfile
)
872 htab_delete (pfile
->file_hash
);
875 /* Enter a file name in the hash for the sake of cpp_included. */
877 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
879 find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true);
882 /* Not everyone who wants to set system-header-ness on a buffer can
883 see the details of a buffer. This is an exported interface because
884 fix-header needs it. */
886 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
890 /* 1 = system header, 2 = system header to be treated as C. */
892 flags
= 1 + (externc
!= 0);
893 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
894 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
897 /* Allow the client to change the current file. Used by the front end
898 to achieve pseudo-file names like <built-in>.
899 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
901 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
902 const char *new_name
)
904 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
907 /* Callback function for htab_traverse. */
909 report_missing_guard (void **slot
, void *b
)
911 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
912 int *bannerp
= (int *) b
;
914 /* Skip directories. */
915 if (entry
->start_dir
!= NULL
)
917 _cpp_file
*file
= entry
->u
.file
;
919 /* We don't want MI guard advice for the main file. */
920 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
924 fputs (_("Multiple include guards may be useful for:\n"),
929 fputs (entry
->u
.file
->path
, stderr
);
937 /* Report on all files that might benefit from a multiple include guard.
940 _cpp_report_missing_guards (cpp_reader
*pfile
)
944 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
947 /* Locate HEADER, and determine whether it is newer than the current
948 file. If it cannot be located or dated, return -1, if it is
949 newer, return 1, otherwise 0. */
951 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
957 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
961 file
= find_file (pfile
, fname
, dir
, false);
971 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
974 /* Pushes the given file onto the buffer stack. Returns nonzero if
977 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
979 /* Make the command line directive take up a line. */
981 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
984 /* Do appropriate cleanup when a file INC's buffer is popped off the
987 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
989 /* Record the inclusion-preventing macro, which could be NULL
990 meaning no controlling macro. */
991 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
992 file
->cmacro
= pfile
->mi_cmacro
;
994 /* Invalidate control macros in the #including file. */
995 pfile
->mi_valid
= false;
999 free ((void *) file
->buffer
);
1000 file
->buffer
= NULL
;
1004 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1005 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1006 directory of the including file.
1008 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1010 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1011 int quote_ignores_source_dir
)
1013 pfile
->quote_include
= quote
;
1014 pfile
->bracket_include
= quote
;
1015 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1017 for (; quote
; quote
= quote
->next
)
1019 quote
->name_map
= NULL
;
1020 quote
->len
= strlen (quote
->name
);
1021 if (quote
== bracket
)
1022 pfile
->bracket_include
= bracket
;
1026 /* Append the file name to the directory to create the path, but don't
1027 turn / into // or // into ///; // may be a namespace escape. */
1029 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1035 flen
= strlen (fname
);
1036 path
= xmalloc (dlen
+ 1 + flen
+ 1);
1037 memcpy (path
, dir
->name
, dlen
);
1038 if (dlen
&& path
[dlen
- 1] != '/')
1040 memcpy (&path
[dlen
], fname
, flen
+ 1);
1045 /* Read a space delimited string of unlimited length from a stdio
1048 read_filename_string (int ch
, FILE *f
)
1054 set
= alloc
= xmalloc (len
+ 1);
1055 if (! is_space (ch
))
1058 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1060 if (set
- alloc
== len
)
1063 alloc
= xrealloc (alloc
, len
+ 1);
1064 set
= alloc
+ len
/ 2;
1074 /* Read the file name map file for DIR. */
1076 read_name_map (cpp_dir
*dir
)
1078 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1081 size_t len
, count
= 0, room
= 9;
1084 name
= alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1085 memcpy (name
, dir
->name
, len
);
1086 if (len
&& name
[len
- 1] != '/')
1088 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1089 f
= fopen (name
, "r");
1091 dir
->name_map
= xmalloc (room
* sizeof (char *));
1093 /* Silently return NULL if we cannot open. */
1098 while ((ch
= getc (f
)) != EOF
)
1105 if (count
+ 2 > room
)
1108 dir
->name_map
= xrealloc (dir
->name_map
, room
* sizeof (char *));
1111 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1112 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1115 to
= read_filename_string (ch
, f
);
1116 if (IS_ABSOLUTE_PATH (to
))
1117 dir
->name_map
[count
+ 1] = to
;
1120 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1125 while ((ch
= getc (f
)) != '\n')
1133 /* Terminate the list of maps. */
1134 dir
->name_map
[count
] = NULL
;
1137 /* Remap a FILE's name based on the file_name_map, if any, for
1138 FILE->dir. If the file name has any directory separators,
1139 recursively check those directories too. */
1141 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1143 const char *fname
, *p
;
1154 read_name_map (dir
);
1156 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1157 if (!strcmp (dir
->name_map
[index
], fname
))
1158 return xstrdup (dir
->name_map
[index
+ 1]);
1160 p
= strchr (fname
, '/');
1161 if (!p
|| p
== fname
)
1164 len
= dir
->len
+ (p
- fname
+ 1);
1165 new_dir
= xmalloc (len
+ 1);
1166 memcpy (new_dir
, dir
->name
, dir
->len
);
1167 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1168 new_dir
[len
] = '\0';
1170 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1175 /* Return true if FILE is usable by PCH. */
1177 include_pch_p (_cpp_file
*file
)
1179 return file
->pch
& 1;
1182 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1184 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1186 const char *saved_path
= file
->path
;
1188 file
->path
= pchname
;
1189 if (open_file (file
))
1191 if ((file
->pch
& 2) == 0)
1192 file
->pch
= pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1194 if (!include_pch_p (file
))
1200 if (CPP_OPTION (pfile
, print_include_names
))
1203 for (i
= 1; i
< pfile
->line_maps
.depth
; i
++)
1205 fprintf (stderr
, "%c %s\n",
1206 include_pch_p (file
) ? '!' : 'x', pchname
);
1212 file
->path
= saved_path
;
1213 return include_pch_p (file
);