1 /* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
8 Split out of cpplib.c, Zack Weinberg, Oct 1998
9 Reimplemented, Neil Booth, Jul 2003
11 This program is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by the
13 Free Software Foundation; either version 2, or (at your option) any
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
35 /* Variable length record files on VMS will have a stat size that includes
36 record control characters that won't be included in the read size. */
38 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
39 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
41 # define STAT_SIZE_RELIABLE(ST) true
46 /* For DJGPP redirected input is opened in text mode. */
47 # define set_stdin_to_binary_mode() \
48 if (! isatty (0)) setmode (0, O_BINARY)
50 # define set_stdin_to_binary_mode() /* Nothing */
53 /* This structure represents a file searched for by CPP, whether it
54 exists or not. An instance may be pointed to by more than one
55 file_hash_entry; at present no reference count is kept. */
58 /* Filename as given to #include or command line switch. */
61 /* The full path used to find the file. */
64 /* The full path of the pch file. */
67 /* The file's path with the basename stripped. NULL if it hasn't
68 been calculated yet. */
71 /* Chain through all files. */
72 struct _cpp_file
*next_file
;
74 /* The contents of NAME after calling read_file(). */
77 /* The macro, if any, preventing re-inclusion. */
78 const cpp_hashnode
*cmacro
;
80 /* The directory in the search path where FILE was found. Used for
81 #include_next and determining whether a header is a system
85 /* As filled in by stat(2) for the file. */
88 /* File descriptor. Invalid if -1, otherwise open. */
91 /* Zero if this file was successfully opened and stat()-ed,
92 otherwise errno obtained from failure. */
95 /* Number of times the file has been stacked for preprocessing. */
96 unsigned short stack_count
;
98 /* If opened with #import or contains #pragma once. */
101 /* If read() failed before. */
104 /* If this file is the main file. */
107 /* If BUFFER above contains the true contents of the file. */
110 /* File is a PCH (on return from find_include_file). */
114 /* A singly-linked list for all searches for a given file name, with
115 its head pointed to by a slot in FILE_HASH. The file name is what
116 appeared between the quotes in a #include directive; it can be
117 determined implicitly from the hash table location or explicitly
120 FILE is a structure containing details about the file that was
121 found with that search, or details of how the search failed.
123 START_DIR is the starting location of the search in the include
124 chain. The current directories for "" includes are also hashed in
125 the hash table and therefore unique. Files that are looked up
126 without using a search path, such as absolute filenames and file
127 names from the command line share a special starting directory so
128 they don't cause cache hits with normal include-chain lookups.
130 If START_DIR is NULL then the entry is for a directory, not a file,
131 and the directory is in DIR. Since the starting point in a file
132 lookup chain is never NULL, this means that simple pointer
133 comparisons against START_DIR can be made to determine cache hits
136 If a cache lookup fails because of e.g. an extra "./" in the path,
137 then nothing will break. It is just less efficient as CPP will
138 have to do more work re-preprocessing the file, and/or comparing
139 its contents against earlier once-only files.
141 struct file_hash_entry
143 struct file_hash_entry
*next
;
145 source_location location
;
153 static bool open_file (_cpp_file
*file
);
154 static bool pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
,
156 static bool find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
,
158 static bool read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
);
159 static bool read_file (cpp_reader
*pfile
, _cpp_file
*file
);
160 static bool should_stack_file (cpp_reader
*, _cpp_file
*file
, bool import
);
161 static struct cpp_dir
*search_path_head (cpp_reader
*, const char *fname
,
162 int angle_brackets
, enum include_type
);
163 static const char *dir_name_of_file (_cpp_file
*file
);
164 static void open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int);
165 static struct file_hash_entry
*search_cache (struct file_hash_entry
*head
,
166 const cpp_dir
*start_dir
);
167 static _cpp_file
*make_cpp_file (cpp_reader
*, cpp_dir
*, const char *fname
);
168 static void destroy_cpp_file (_cpp_file
*);
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_save_compare (const void *e1
, const void *e2
);
181 static int pchf_compare (const void *d_p
, const void *e_p
);
182 static bool check_file_against_entries (cpp_reader
*, _cpp_file
*, bool);
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 #if defined(_WIN32) && !defined(__CYGWIN__)
233 else if (errno
== EACCES
)
235 /* On most UNIX systems, open succeeds on a directory. Above,
236 we check if we have opened a directory and if so, set errno
237 to ENOENT. However, on Windows, opening a directory
238 fails with EACCES. We want to return ENOENT in that
240 if (stat (file
->path
, &file
->st
) == 0
241 && S_ISDIR (file
->st
.st_mode
))
244 /* The call to stat may have reset errno. */
248 else if (errno
== ENOTDIR
)
251 file
->err_no
= errno
;
256 /* Temporary PCH intercept of opening a file. Try to find a PCH file
257 based on FILE->name and FILE->dir, and test those found for
258 validity using PFILE->cb.valid_pch. Return true iff a valid file is
259 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
262 pch_open_file (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
264 static const char extension
[] = ".gch";
265 const char *path
= file
->path
;
271 /* No PCH on <stdin> or if not requested. */
272 if (file
->name
[0] == '\0' || !pfile
->cb
.valid_pch
)
275 flen
= strlen (path
);
276 len
= flen
+ sizeof (extension
);
277 pchname
= XNEWVEC (char, len
);
278 memcpy (pchname
, path
, flen
);
279 memcpy (pchname
+ flen
, extension
, sizeof (extension
));
281 if (stat (pchname
, &st
) == 0)
285 size_t dlen
, plen
= len
;
287 if (!S_ISDIR (st
.st_mode
))
288 valid
= validate_pch (pfile
, file
, pchname
);
289 else if ((pchdir
= opendir (pchname
)) != NULL
)
291 pchname
[plen
- 1] = '/';
292 while ((d
= readdir (pchdir
)) != NULL
)
294 dlen
= strlen (d
->d_name
) + 1;
295 if ((strcmp (d
->d_name
, ".") == 0)
296 || (strcmp (d
->d_name
, "..") == 0))
298 if (dlen
+ plen
> len
)
301 pchname
= XRESIZEVEC (char, pchname
, len
);
303 memcpy (pchname
+ plen
, d
->d_name
, dlen
);
304 valid
= validate_pch (pfile
, file
, pchname
);
317 file
->pchname
= pchname
;
324 /* Try to open the path FILE->name appended to FILE->dir. This is
325 where remap and PCH intercept the file lookup process. Return true
326 if the file was found, whether or not the open was successful.
327 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
330 find_file_in_dir (cpp_reader
*pfile
, _cpp_file
*file
, bool *invalid_pch
)
334 if (CPP_OPTION (pfile
, remap
) && (path
= remap_filename (pfile
, file
)))
337 if (file
->dir
->construct
)
338 path
= file
->dir
->construct (file
->name
, file
->dir
);
340 path
= append_file_to_dir (file
->name
, file
->dir
);
344 hashval_t hv
= htab_hash_string (path
);
348 if (htab_find_with_hash (pfile
->nonexistent_file_hash
, path
, hv
) != NULL
)
350 file
->err_no
= ENOENT
;
355 if (pch_open_file (pfile
, file
, invalid_pch
))
358 if (open_file (file
))
361 if (file
->err_no
!= ENOENT
)
363 open_file_failed (pfile
, file
, 0);
367 /* We copy the path name onto an obstack partly so that we don't
368 leak the memory, but mostly so that we don't fragment the
370 copy
= obstack_copy0 (&pfile
->nonexistent_file_ob
, path
,
373 pp
= htab_find_slot_with_hash (pfile
->nonexistent_file_hash
,
377 file
->path
= file
->name
;
381 file
->err_no
= ENOENT
;
388 /* Return tue iff the missing_header callback found the given HEADER. */
390 search_path_exhausted (cpp_reader
*pfile
, const char *header
, _cpp_file
*file
)
392 missing_header_cb func
= pfile
->cb
.missing_header
;
394 /* When the regular search path doesn't work, try context dependent
395 headers search paths. */
397 && file
->dir
== NULL
)
399 if ((file
->path
= func (pfile
, header
, &file
->dir
)) != NULL
)
401 if (open_file (file
))
403 free ((void *)file
->path
);
405 file
->path
= file
->name
;
412 _cpp_find_failed (_cpp_file
*file
)
414 return file
->err_no
!= 0;
417 /* Given a filename FNAME search for such a file in the include path
418 starting from START_DIR. If FNAME is the empty string it is
419 interpreted as STDIN if START_DIR is PFILE->no_search_path.
421 If the file is not found in the file cache fall back to the O/S and
422 add the result to our cache.
424 If the file was not found in the filesystem, or there was an error
425 opening it, then ERR_NO is nonzero and FD is -1. If the file was
426 found, then ERR_NO is zero and FD could be -1 or an open file
427 descriptor. FD can be -1 if the file was found in the cache and
428 had previously been closed. To open it again pass the return value
432 _cpp_find_file (cpp_reader
*pfile
, const char *fname
, cpp_dir
*start_dir
, bool fake
, int angle_brackets
)
434 struct file_hash_entry
*entry
, **hash_slot
;
436 bool invalid_pch
= false;
437 bool saw_bracket_include
= false;
438 bool saw_quote_include
= false;
439 struct cpp_dir
*found_in_cache
= NULL
;
441 /* Ensure we get no confusion between cached files and directories. */
442 if (start_dir
== NULL
)
443 cpp_error (pfile
, CPP_DL_ICE
, "NULL directory in find_file");
445 hash_slot
= (struct file_hash_entry
**)
446 htab_find_slot_with_hash (pfile
->file_hash
, fname
,
447 htab_hash_string (fname
),
450 /* First check the cache before we resort to memory allocation. */
451 entry
= search_cache (*hash_slot
, start_dir
);
453 return entry
->u
.file
;
455 file
= make_cpp_file (pfile
, start_dir
, fname
);
457 /* Try each path in the include chain. */
460 if (find_file_in_dir (pfile
, file
, &invalid_pch
))
463 file
->dir
= file
->dir
->next
;
464 if (file
->dir
== NULL
)
466 if (search_path_exhausted (pfile
, fname
, file
))
468 /* Although this file must not go in the cache, because
469 the file found might depend on things (like the current file)
470 that aren't represented in the cache, it still has to go in
471 the list of all files so that #import works. */
472 file
->next_file
= pfile
->all_files
;
473 pfile
->all_files
= file
;
477 open_file_failed (pfile
, file
, angle_brackets
);
480 cpp_error (pfile
, CPP_DL_ERROR
,
481 "one or more PCH files were found, but they were invalid");
482 if (!cpp_get_options (pfile
)->warn_invalid_pch
)
483 cpp_error (pfile
, CPP_DL_ERROR
,
484 "use -Winvalid-pch for more information");
489 /* Only check the cache for the starting location (done above)
490 and the quote and bracket chain heads because there are no
491 other possible starting points for searches. */
492 if (file
->dir
== pfile
->bracket_include
)
493 saw_bracket_include
= true;
494 else if (file
->dir
== pfile
->quote_include
)
495 saw_quote_include
= true;
499 entry
= search_cache (*hash_slot
, file
->dir
);
502 found_in_cache
= file
->dir
;
509 /* Cache for START_DIR too, sharing the _cpp_file structure. */
510 free ((char *) file
->name
);
512 file
= entry
->u
.file
;
516 /* This is a new file; put it in the list. */
517 file
->next_file
= pfile
->all_files
;
518 pfile
->all_files
= file
;
521 /* Store this new result in the hash table. */
522 entry
= new_file_hash_entry (pfile
);
523 entry
->next
= *hash_slot
;
524 entry
->start_dir
= start_dir
;
525 entry
->location
= pfile
->line_table
->highest_location
;
526 entry
->u
.file
= file
;
529 /* If we passed the quote or bracket chain heads, cache them also.
530 This speeds up processing if there are lots of -I options. */
531 if (saw_bracket_include
532 && pfile
->bracket_include
!= start_dir
533 && found_in_cache
!= pfile
->bracket_include
)
535 entry
= new_file_hash_entry (pfile
);
536 entry
->next
= *hash_slot
;
537 entry
->start_dir
= pfile
->bracket_include
;
538 entry
->location
= pfile
->line_table
->highest_location
;
539 entry
->u
.file
= file
;
542 if (saw_quote_include
543 && pfile
->quote_include
!= start_dir
544 && found_in_cache
!= pfile
->quote_include
)
546 entry
= new_file_hash_entry (pfile
);
547 entry
->next
= *hash_slot
;
548 entry
->start_dir
= pfile
->quote_include
;
549 entry
->location
= pfile
->line_table
->highest_location
;
550 entry
->u
.file
= file
;
557 /* Read a file into FILE->buffer, returning true on success.
559 If FILE->fd is something weird, like a block device, we don't want
560 to read it at all. Don't even try to figure out what something is,
561 except for plain files and block devices, since there is no
562 reliable portable way of doing this.
564 FIXME: Flush file cache and try again if we run out of memory. */
566 read_file_guts (cpp_reader
*pfile
, _cpp_file
*file
)
568 ssize_t size
, total
, count
;
572 if (S_ISBLK (file
->st
.st_mode
))
574 cpp_error (pfile
, CPP_DL_ERROR
, "%s is a block device", file
->path
);
578 regular
= S_ISREG (file
->st
.st_mode
);
581 /* off_t might have a wider range than ssize_t - in other words,
582 the max size of a file might be bigger than the address
583 space. We can't handle a file that large. (Anyone with
584 a single source file bigger than 2GB needs to rethink
585 their coding style.) Some systems (e.g. AIX 4.1) define
586 SSIZE_MAX to be much smaller than the actual range of the
587 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
589 if (file
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
591 cpp_error (pfile
, CPP_DL_ERROR
, "%s is too large", file
->path
);
595 size
= file
->st
.st_size
;
598 /* 8 kilobytes is a sensible starting size. It ought to be bigger
599 than the kernel pipe buffer, and it's definitely bigger than
600 the majority of C source files. */
603 buf
= XNEWVEC (uchar
, size
+ 1);
605 while ((count
= read (file
->fd
, buf
+ total
, size
- total
)) > 0)
614 buf
= XRESIZEVEC (uchar
, buf
, size
+ 1);
620 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
624 if (regular
&& total
!= size
&& STAT_SIZE_RELIABLE (file
->st
))
625 cpp_error (pfile
, CPP_DL_WARNING
,
626 "%s is shorter than expected", file
->path
);
628 file
->buffer
= _cpp_convert_input (pfile
, CPP_OPTION (pfile
, input_charset
),
629 buf
, size
, total
, &file
->st
.st_size
);
630 file
->buffer_valid
= true;
635 /* Convenience wrapper around read_file_guts that opens the file if
636 necessary and closes the file descriptor after reading. FILE must
637 have been passed through find_file() at some stage. */
639 read_file (cpp_reader
*pfile
, _cpp_file
*file
)
641 /* If we already have its contents in memory, succeed immediately. */
642 if (file
->buffer_valid
)
645 /* If an earlier read failed for some reason don't try again. */
646 if (file
->dont_read
|| file
->err_no
)
649 if (file
->fd
== -1 && !open_file (file
))
651 open_file_failed (pfile
, file
, 0);
655 file
->dont_read
= !read_file_guts (pfile
, file
);
659 return !file
->dont_read
;
662 /* Returns TRUE if FILE's contents have been successfully placed in
663 FILE->buffer and the file should be stacked, otherwise false. */
665 should_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
669 /* Skip once-only files. */
673 /* We must mark the file once-only if #import now, before header
674 guard checks. Otherwise, undefining the header guard might
675 cause the file to be re-stacked. */
678 _cpp_mark_file_once_only (pfile
, file
);
680 /* Don't stack files that have been stacked before. */
681 if (file
->stack_count
)
685 /* Skip if the file had a header guard and the macro is defined.
686 PCH relies on this appearing before the PCH handler below. */
687 if (file
->cmacro
&& file
->cmacro
->type
== NT_MACRO
)
690 /* Handle PCH files immediately; don't stack them. */
693 pfile
->cb
.read_pch (pfile
, file
->pchname
, file
->fd
, file
->path
);
699 if (!read_file (pfile
, file
))
702 /* Check the file against the PCH file. This is done before
703 checking against files we've already seen, since it may save on
705 if (check_file_against_entries (pfile
, file
, import
))
707 /* If this isn't a #import, but yet we can't include the file,
708 that means that it was #import-ed in the PCH file,
709 so we can never include it again. */
711 _cpp_mark_file_once_only (pfile
, file
);
715 /* Now we've read the file's contents, we can stack it if there
716 are no once-only files. */
717 if (!pfile
->seen_once_only
)
720 /* We may have read the file under a different name. Look
721 for likely candidates and compare file contents to be sure. */
722 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
727 if ((import
|| f
->once_only
)
729 && f
->st
.st_mtime
== file
->st
.st_mtime
730 && f
->st
.st_size
== file
->st
.st_size
)
733 bool same_file_p
= false;
735 if (f
->buffer
&& !f
->buffer_valid
)
737 /* We already have a buffer but it is not valid, because
738 the file is still stacked. Make a new one. */
739 ref_file
= make_cpp_file (pfile
, f
->dir
, f
->name
);
740 ref_file
->path
= f
->path
;
743 /* The file is not stacked anymore. We can reuse it. */
746 same_file_p
= read_file (pfile
, ref_file
)
747 /* Size might have changed in read_file(). */
748 && ref_file
->st
.st_size
== file
->st
.st_size
749 && !memcmp (ref_file
->buffer
,
753 if (f
->buffer
&& !f
->buffer_valid
)
756 destroy_cpp_file (ref_file
);
767 /* Place the file referenced by FILE into a new buffer on the buffer
768 stack if possible. IMPORT is true if this stacking attempt is
769 because of a #import directive. Returns true if a buffer is
772 _cpp_stack_file (cpp_reader
*pfile
, _cpp_file
*file
, bool import
)
777 if (!should_stack_file (pfile
, file
, import
))
780 if (pfile
->buffer
== NULL
|| file
->dir
== NULL
)
783 sysp
= MAX (pfile
->buffer
->sysp
, file
->dir
->sysp
);
785 /* Add the file to the dependencies on its first inclusion. */
786 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !file
->stack_count
)
788 if (!file
->main_file
|| !CPP_OPTION (pfile
, deps
.ignore_main_file
))
789 deps_add_dep (pfile
->deps
, file
->path
);
792 /* Clear buffer_valid since _cpp_clean_line messes it up. */
793 file
->buffer_valid
= false;
796 /* Stack the buffer. */
797 buffer
= cpp_push_buffer (pfile
, file
->buffer
, file
->st
.st_size
,
798 CPP_OPTION (pfile
, preprocessed
)
799 && !CPP_OPTION (pfile
, directives_only
));
803 /* Initialize controlling macro state. */
804 pfile
->mi_valid
= true;
805 pfile
->mi_cmacro
= 0;
807 /* Generate the call back. */
808 _cpp_do_file_change (pfile
, LC_ENTER
, file
->path
, 1, sysp
);
813 /* Mark FILE to be included once only. */
815 _cpp_mark_file_once_only (cpp_reader
*pfile
, _cpp_file
*file
)
817 pfile
->seen_once_only
= true;
818 file
->once_only
= true;
821 /* Return the directory from which searching for FNAME should start,
822 considering the directive TYPE and ANGLE_BRACKETS. If there is
823 nothing left in the path, returns NULL. */
824 static struct cpp_dir
*
825 search_path_head (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
826 enum include_type type
)
831 if (IS_ABSOLUTE_PATH (fname
))
832 return &pfile
->no_search_path
;
834 /* pfile->buffer is NULL when processing an -include command-line flag. */
835 file
= pfile
->buffer
== NULL
? pfile
->main_file
: pfile
->buffer
->file
;
837 /* For #include_next, skip in the search path past the dir in which
838 the current file was found, but if it was found via an absolute
839 path use the normal search logic. */
840 if (type
== IT_INCLUDE_NEXT
&& file
->dir
841 && file
->dir
!= &pfile
->no_search_path
)
842 dir
= file
->dir
->next
;
843 else if (angle_brackets
)
844 dir
= pfile
->bracket_include
;
845 else if (type
== IT_CMDLINE
)
846 /* -include and -imacros use the #include "" chain with the
847 preprocessor's cwd prepended. */
848 return make_cpp_dir (pfile
, "./", false);
849 else if (pfile
->quote_ignores_source_dir
)
850 dir
= pfile
->quote_include
;
852 return make_cpp_dir (pfile
, dir_name_of_file (file
),
853 pfile
->buffer
? pfile
->buffer
->sysp
: 0);
856 cpp_error (pfile
, CPP_DL_ERROR
,
857 "no include path in which to search for %s", fname
);
862 /* Strip the basename from the file's path. It ends with a slash if
863 of nonzero length. Note that this procedure also works for
864 <stdin>, which is represented by the empty string. */
866 dir_name_of_file (_cpp_file
*file
)
870 size_t len
= lbasename (file
->path
) - file
->path
;
871 char *dir_name
= XNEWVEC (char, len
+ 1);
873 memcpy (dir_name
, file
->path
, len
);
874 dir_name
[len
] = '\0';
875 file
->dir_name
= dir_name
;
878 return file
->dir_name
;
881 /* Handles #include-family directives (distinguished by TYPE),
882 including HEADER, and the command line -imacros and -include.
883 Returns true if a buffer was stacked. */
885 _cpp_stack_include (cpp_reader
*pfile
, const char *fname
, int angle_brackets
,
886 enum include_type type
)
891 dir
= search_path_head (pfile
, fname
, angle_brackets
, type
);
895 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
897 /* Compensate for the increment in linemap_add. In the case of a
898 normal #include, we're currently at the start of the line
899 *following* the #include. A separate source_location for this
900 location makes no sense (until we do the LC_LEAVE), and
901 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
902 found a PCH file (in which case linemap_add is not called) or we
903 were included from the command-line. */
904 if (! file
->pch
&& file
->err_no
== 0 && type
!= IT_CMDLINE
)
905 pfile
->line_table
->highest_location
--;
907 return _cpp_stack_file (pfile
, file
, type
== IT_IMPORT
);
910 /* Could not open FILE. The complication is dependency output. */
912 open_file_failed (cpp_reader
*pfile
, _cpp_file
*file
, int angle_brackets
)
914 int sysp
= pfile
->line_table
->highest_line
> 1 && pfile
->buffer
? pfile
->buffer
->sysp
: 0;
915 bool print_dep
= CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| !!sysp
);
917 errno
= file
->err_no
;
918 if (print_dep
&& CPP_OPTION (pfile
, deps
.missing_files
) && errno
== ENOENT
)
919 deps_add_dep (pfile
->deps
, file
->name
);
922 /* If we are outputting dependencies but not for this file then
923 don't error because we can still produce correct output. */
924 if (CPP_OPTION (pfile
, deps
.style
) && ! print_dep
)
925 cpp_errno (pfile
, CPP_DL_WARNING
, file
->path
);
927 cpp_errno (pfile
, CPP_DL_ERROR
, file
->path
);
931 /* Search in the chain beginning at HEAD for a file whose search path
932 started at START_DIR != NULL. */
933 static struct file_hash_entry
*
934 search_cache (struct file_hash_entry
*head
, const cpp_dir
*start_dir
)
936 while (head
&& head
->start_dir
!= start_dir
)
942 /* Allocate a new _cpp_file structure. */
944 make_cpp_file (cpp_reader
*pfile
, cpp_dir
*dir
, const char *fname
)
948 file
= XCNEW (_cpp_file
);
949 file
->main_file
= !pfile
->buffer
;
952 file
->name
= xstrdup (fname
);
957 /* Release a _cpp_file structure. */
959 destroy_cpp_file (_cpp_file
*file
)
962 free ((void *) file
->buffer
);
963 free ((void *) file
->name
);
967 /* A hash of directory names. The directory names are the path names
968 of files which contain a #include "", the included file name is
969 appended to this directories.
971 To avoid duplicate entries we follow the convention that all
972 non-empty directory names should end in a '/'. DIR_NAME must be
973 stored in permanently allocated memory. */
975 make_cpp_dir (cpp_reader
*pfile
, const char *dir_name
, int sysp
)
977 struct file_hash_entry
*entry
, **hash_slot
;
980 hash_slot
= (struct file_hash_entry
**)
981 htab_find_slot_with_hash (pfile
->dir_hash
, dir_name
,
982 htab_hash_string (dir_name
),
985 /* Have we already hashed this directory? */
986 for (entry
= *hash_slot
; entry
; entry
= entry
->next
)
987 if (entry
->start_dir
== NULL
)
990 dir
= XCNEW (cpp_dir
);
991 dir
->next
= pfile
->quote_include
;
992 dir
->name
= (char *) dir_name
;
993 dir
->len
= strlen (dir_name
);
997 /* Store this new result in the hash table. */
998 entry
= new_file_hash_entry (pfile
);
999 entry
->next
= *hash_slot
;
1000 entry
->start_dir
= NULL
;
1001 entry
->location
= pfile
->line_table
->highest_location
;
1008 /* Create a new block of memory for file hash entries. */
1010 allocate_file_hash_entries (cpp_reader
*pfile
)
1012 pfile
->file_hash_entries_used
= 0;
1013 pfile
->file_hash_entries_allocated
= 127;
1014 pfile
->file_hash_entries
= XNEWVEC (struct file_hash_entry
,
1015 pfile
->file_hash_entries_allocated
);
1018 /* Return a new file hash entry. */
1019 static struct file_hash_entry
*
1020 new_file_hash_entry (cpp_reader
*pfile
)
1022 if (pfile
->file_hash_entries_used
== pfile
->file_hash_entries_allocated
)
1023 allocate_file_hash_entries (pfile
);
1025 return &pfile
->file_hash_entries
[pfile
->file_hash_entries_used
++];
1028 /* Returns TRUE if a file FNAME has ever been successfully opened.
1029 This routine is not intended to correctly handle filenames aliased
1030 by links or redundant . or .. traversals etc. */
1032 cpp_included (cpp_reader
*pfile
, const char *fname
)
1034 struct file_hash_entry
*entry
;
1036 entry
= (struct file_hash_entry
*)
1037 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1039 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
))
1040 entry
= entry
->next
;
1042 return entry
!= NULL
;
1045 /* Returns TRUE if a file FNAME has ever been successfully opened
1046 before LOCATION. This routine is not intended to correctly handle
1047 filenames aliased by links or redundant . or .. traversals etc. */
1049 cpp_included_before (cpp_reader
*pfile
, const char *fname
,
1050 source_location location
)
1052 struct file_hash_entry
*entry
;
1054 entry
= (struct file_hash_entry
*)
1055 htab_find_with_hash (pfile
->file_hash
, fname
, htab_hash_string (fname
));
1057 while (entry
&& (entry
->start_dir
== NULL
|| entry
->u
.file
->err_no
1058 || entry
->location
> location
))
1059 entry
= entry
->next
;
1061 return entry
!= NULL
;
1064 /* Calculate the hash value of a file hash entry P. */
1067 file_hash_hash (const void *p
)
1069 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1071 if (entry
->start_dir
)
1072 hname
= entry
->u
.file
->name
;
1074 hname
= entry
->u
.dir
->name
;
1076 return htab_hash_string (hname
);
1079 /* Compare a string Q against a file hash entry P. */
1081 file_hash_eq (const void *p
, const void *q
)
1083 struct file_hash_entry
*entry
= (struct file_hash_entry
*) p
;
1084 const char *fname
= (const char *) q
;
1087 if (entry
->start_dir
)
1088 hname
= entry
->u
.file
->name
;
1090 hname
= entry
->u
.dir
->name
;
1092 return strcmp (hname
, fname
) == 0;
1095 /* Compare entries in the nonexistent file hash table. These are just
1098 nonexistent_file_hash_eq (const void *p
, const void *q
)
1100 return strcmp (p
, q
) == 0;
1103 /* Initialize everything in this source file. */
1105 _cpp_init_files (cpp_reader
*pfile
)
1107 pfile
->file_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1108 NULL
, xcalloc
, free
);
1109 pfile
->dir_hash
= htab_create_alloc (127, file_hash_hash
, file_hash_eq
,
1110 NULL
, xcalloc
, free
);
1111 allocate_file_hash_entries (pfile
);
1112 pfile
->nonexistent_file_hash
= htab_create_alloc (127, htab_hash_string
,
1113 nonexistent_file_hash_eq
,
1114 NULL
, xcalloc
, free
);
1115 _obstack_begin (&pfile
->nonexistent_file_ob
, 0, 0,
1116 (void *(*) (long)) xmalloc
,
1117 (void (*) (void *)) free
);
1120 /* Finalize everything in this source file. */
1122 _cpp_cleanup_files (cpp_reader
*pfile
)
1124 htab_delete (pfile
->file_hash
);
1125 htab_delete (pfile
->dir_hash
);
1126 htab_delete (pfile
->nonexistent_file_hash
);
1127 obstack_free (&pfile
->nonexistent_file_ob
, 0);
1130 /* Enter a file name in the hash for the sake of cpp_included. */
1132 _cpp_fake_include (cpp_reader
*pfile
, const char *fname
)
1134 _cpp_find_file (pfile
, fname
, pfile
->buffer
->file
->dir
, true, 0);
1137 /* Not everyone who wants to set system-header-ness on a buffer can
1138 see the details of a buffer. This is an exported interface because
1139 fix-header needs it. */
1141 cpp_make_system_header (cpp_reader
*pfile
, int syshdr
, int externc
)
1144 const struct line_maps
*line_table
= pfile
->line_table
;
1145 const struct line_map
*map
= &line_table
->maps
[line_table
->used
-1];
1147 /* 1 = system header, 2 = system header to be treated as C. */
1149 flags
= 1 + (externc
!= 0);
1150 pfile
->buffer
->sysp
= flags
;
1151 _cpp_do_file_change (pfile
, LC_RENAME
, map
->to_file
,
1152 SOURCE_LINE (map
, pfile
->line_table
->highest_line
), flags
);
1155 /* Allow the client to change the current file. Used by the front end
1156 to achieve pseudo-file names like <built-in>.
1157 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1159 cpp_change_file (cpp_reader
*pfile
, enum lc_reason reason
,
1160 const char *new_name
)
1162 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
1165 /* Callback function for htab_traverse. */
1167 report_missing_guard (void **slot
, void *b
)
1169 struct file_hash_entry
*entry
= (struct file_hash_entry
*) *slot
;
1170 int *bannerp
= (int *) b
;
1172 /* Skip directories. */
1173 if (entry
->start_dir
!= NULL
)
1175 _cpp_file
*file
= entry
->u
.file
;
1177 /* We don't want MI guard advice for the main file. */
1178 if (file
->cmacro
== NULL
&& file
->stack_count
== 1 && !file
->main_file
)
1182 fputs (_("Multiple include guards may be useful for:\n"),
1187 fputs (entry
->u
.file
->path
, stderr
);
1188 putc ('\n', stderr
);
1195 /* Report on all files that might benefit from a multiple include guard.
1198 _cpp_report_missing_guards (cpp_reader
*pfile
)
1202 htab_traverse (pfile
->file_hash
, report_missing_guard
, &banner
);
1205 /* Locate HEADER, and determine whether it is newer than the current
1206 file. If it cannot be located or dated, return -1, if it is
1207 newer, return 1, otherwise 0. */
1209 _cpp_compare_file_date (cpp_reader
*pfile
, const char *fname
,
1213 struct cpp_dir
*dir
;
1215 dir
= search_path_head (pfile
, fname
, angle_brackets
, IT_INCLUDE
);
1219 file
= _cpp_find_file (pfile
, fname
, dir
, false, angle_brackets
);
1229 return file
->st
.st_mtime
> pfile
->buffer
->file
->st
.st_mtime
;
1232 /* Pushes the given file onto the buffer stack. Returns nonzero if
1235 cpp_push_include (cpp_reader
*pfile
, const char *fname
)
1237 return _cpp_stack_include (pfile
, fname
, false, IT_CMDLINE
);
1240 /* Do appropriate cleanup when a file INC's buffer is popped off the
1243 _cpp_pop_file_buffer (cpp_reader
*pfile
, _cpp_file
*file
)
1245 /* Record the inclusion-preventing macro, which could be NULL
1246 meaning no controlling macro. */
1247 if (pfile
->mi_valid
&& file
->cmacro
== NULL
)
1248 file
->cmacro
= pfile
->mi_cmacro
;
1250 /* Invalidate control macros in the #including file. */
1251 pfile
->mi_valid
= false;
1255 free ((void *) file
->buffer
);
1256 file
->buffer
= NULL
;
1257 file
->buffer_valid
= false;
1261 /* Inteface to file statistics record in _cpp_file structure. */
1263 _cpp_get_file_stat (_cpp_file
*file
)
1268 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1269 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1270 directory of the including file.
1272 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1274 cpp_set_include_chains (cpp_reader
*pfile
, cpp_dir
*quote
, cpp_dir
*bracket
,
1275 int quote_ignores_source_dir
)
1277 pfile
->quote_include
= quote
;
1278 pfile
->bracket_include
= quote
;
1279 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1281 for (; quote
; quote
= quote
->next
)
1283 quote
->name_map
= NULL
;
1284 quote
->len
= strlen (quote
->name
);
1285 if (quote
== bracket
)
1286 pfile
->bracket_include
= bracket
;
1290 /* Append the file name to the directory to create the path, but don't
1291 turn / into // or // into ///; // may be a namespace escape. */
1293 append_file_to_dir (const char *fname
, cpp_dir
*dir
)
1299 flen
= strlen (fname
);
1300 path
= XNEWVEC (char, dlen
+ 1 + flen
+ 1);
1301 memcpy (path
, dir
->name
, dlen
);
1302 if (dlen
&& path
[dlen
- 1] != '/')
1304 memcpy (&path
[dlen
], fname
, flen
+ 1);
1309 /* Read a space delimited string of unlimited length from a stdio
1312 read_filename_string (int ch
, FILE *f
)
1318 set
= alloc
= XNEWVEC (char, len
+ 1);
1319 if (! is_space (ch
))
1322 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
1324 if (set
- alloc
== len
)
1327 alloc
= XRESIZEVEC (char, alloc
, len
+ 1);
1328 set
= alloc
+ len
/ 2;
1338 /* Read the file name map file for DIR. */
1340 read_name_map (cpp_dir
*dir
)
1342 static const char FILE_NAME_MAP_FILE
[] = "header.gcc";
1345 size_t len
, count
= 0, room
= 9;
1348 name
= (char *) alloca (len
+ sizeof (FILE_NAME_MAP_FILE
) + 1);
1349 memcpy (name
, dir
->name
, len
);
1350 if (len
&& name
[len
- 1] != '/')
1352 strcpy (name
+ len
, FILE_NAME_MAP_FILE
);
1353 f
= fopen (name
, "r");
1355 dir
->name_map
= XNEWVEC (const char *, room
);
1357 /* Silently return NULL if we cannot open. */
1362 while ((ch
= getc (f
)) != EOF
)
1369 if (count
+ 2 > room
)
1372 dir
->name_map
= XRESIZEVEC (const char *, dir
->name_map
, room
);
1375 dir
->name_map
[count
] = read_filename_string (ch
, f
);
1376 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1379 to
= read_filename_string (ch
, f
);
1380 if (IS_ABSOLUTE_PATH (to
))
1381 dir
->name_map
[count
+ 1] = to
;
1384 dir
->name_map
[count
+ 1] = append_file_to_dir (to
, dir
);
1389 while ((ch
= getc (f
)) != '\n')
1397 /* Terminate the list of maps. */
1398 dir
->name_map
[count
] = NULL
;
1401 /* Remap a FILE's name based on the file_name_map, if any, for
1402 FILE->dir. If the file name has any directory separators,
1403 recursively check those directories too. */
1405 remap_filename (cpp_reader
*pfile
, _cpp_file
*file
)
1407 const char *fname
, *p
;
1418 read_name_map (dir
);
1420 for (index
= 0; dir
->name_map
[index
]; index
+= 2)
1421 if (!strcmp (dir
->name_map
[index
], fname
))
1422 return xstrdup (dir
->name_map
[index
+ 1]);
1424 p
= strchr (fname
, '/');
1425 if (!p
|| p
== fname
)
1428 len
= dir
->len
+ (p
- fname
+ 1);
1429 new_dir
= XNEWVEC (char, len
+ 1);
1430 memcpy (new_dir
, dir
->name
, dir
->len
);
1431 memcpy (new_dir
+ dir
->len
, fname
, p
- fname
+ 1);
1432 new_dir
[len
] = '\0';
1434 dir
= make_cpp_dir (pfile
, new_dir
, dir
->sysp
);
1439 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1441 validate_pch (cpp_reader
*pfile
, _cpp_file
*file
, const char *pchname
)
1443 const char *saved_path
= file
->path
;
1446 file
->path
= pchname
;
1447 if (open_file (file
))
1449 valid
= 1 & pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
1457 if (CPP_OPTION (pfile
, print_include_names
))
1460 for (i
= 1; i
< pfile
->line_table
->depth
; i
++)
1462 fprintf (stderr
, "%c %s\n",
1463 valid
? '!' : 'x', pchname
);
1467 file
->path
= saved_path
;
1471 /* Get the path associated with the _cpp_file F. The path includes
1472 the base name from the include directive and the directory it was
1473 found in via the search path. */
1476 cpp_get_path (struct _cpp_file
*f
)
1481 /* Get the directory associated with the _cpp_file F. */
1484 cpp_get_dir (struct _cpp_file
*f
)
1489 /* Get the cpp_buffer currently associated with the cpp_reader
1493 cpp_get_buffer (cpp_reader
*pfile
)
1495 return pfile
->buffer
;
1498 /* Get the _cpp_file associated with the cpp_buffer B. */
1501 cpp_get_file (cpp_buffer
*b
)
1506 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1507 buffer is the buffer that included the given buffer. */
1510 cpp_get_prev (cpp_buffer
*b
)
1515 /* This data structure holds the list of header files that were seen
1516 while the PCH was being built. The 'entries' field is kept sorted
1517 in memcmp() order; yes, this means that on little-endian systems,
1518 it's sorted initially by the least-significant byte of 'size', but
1519 that's OK. The code does rely on having entries with the same size
1520 next to each other. */
1523 /* The size of this file. This is used to save running a MD5 checksum
1524 if the sizes don't match. */
1526 /* The MD5 checksum of this file. */
1527 unsigned char sum
[16];
1528 /* Is this file to be included only once? */
1533 /* Number of pchf_entry structures. */
1536 /* Are there any values with once_only set?
1537 This is used as an optimisation, it means we don't have to search
1538 the structure if we're processing a regular #include. */
1539 bool have_once_only
;
1541 struct pchf_entry entries
[1];
1544 static struct pchf_data
*pchf
;
1546 /* A qsort ordering function for pchf_entry structures. */
1549 pchf_save_compare (const void *e1
, const void *e2
)
1551 return memcmp (e1
, e2
, sizeof (struct pchf_entry
));
1554 /* Create and write to F a pchf_data structure. */
1557 _cpp_save_file_entries (cpp_reader
*pfile
, FILE *fp
)
1560 struct pchf_data
*result
;
1564 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1567 result_size
= (sizeof (struct pchf_data
)
1568 + sizeof (struct pchf_entry
) * (count
- 1));
1569 result
= XCNEWVAR (struct pchf_data
, result_size
);
1572 result
->have_once_only
= false;
1574 for (f
= pfile
->all_files
; f
; f
= f
->next_file
)
1578 /* This should probably never happen, since if a read error occurred
1579 the PCH file shouldn't be written... */
1580 if (f
->dont_read
|| f
->err_no
)
1583 if (f
->stack_count
== 0)
1586 count
= result
->count
++;
1588 result
->entries
[count
].once_only
= f
->once_only
;
1589 /* |= is avoided in the next line because of an HP C compiler bug */
1590 result
->have_once_only
= result
->have_once_only
| f
->once_only
;
1591 if (f
->buffer_valid
)
1592 md5_buffer ((const char *)f
->buffer
,
1593 f
->st
.st_size
, result
->entries
[count
].sum
);
1601 open_file_failed (pfile
, f
, 0);
1604 ff
= fdopen (f
->fd
, "rb");
1605 md5_stream (ff
, result
->entries
[count
].sum
);
1609 result
->entries
[count
].size
= f
->st
.st_size
;
1612 result_size
= (sizeof (struct pchf_data
)
1613 + sizeof (struct pchf_entry
) * (result
->count
- 1));
1615 qsort (result
->entries
, result
->count
, sizeof (struct pchf_entry
),
1618 return fwrite (result
, result_size
, 1, fp
) == 1;
1621 /* Read the pchf_data structure from F. */
1624 _cpp_read_file_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
, FILE *f
)
1628 if (fread (&d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
), 1, f
)
1632 pchf
= XNEWVAR (struct pchf_data
, sizeof (struct pchf_data
)
1633 + sizeof (struct pchf_entry
) * (d
.count
- 1));
1634 memcpy (pchf
, &d
, sizeof (struct pchf_data
) - sizeof (struct pchf_entry
));
1635 if (fread (pchf
->entries
, sizeof (struct pchf_entry
), d
.count
, f
)
1641 /* The parameters for pchf_compare. */
1643 struct pchf_compare_data
1645 /* The size of the file we're looking for. */
1648 /* The MD5 checksum of the file, if it's been computed. */
1649 unsigned char sum
[16];
1654 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1655 bool check_included
;
1657 /* The file that we're searching for. */
1661 /* bsearch comparison function; look for D_P in E_P. */
1664 pchf_compare (const void *d_p
, const void *e_p
)
1666 const struct pchf_entry
*e
= (const struct pchf_entry
*)e_p
;
1667 struct pchf_compare_data
*d
= (struct pchf_compare_data
*)d_p
;
1670 result
= memcmp (&d
->size
, &e
->size
, sizeof (off_t
));
1674 if (! d
->sum_computed
)
1676 _cpp_file
*const f
= d
->f
;
1678 md5_buffer ((const char *)f
->buffer
, f
->st
.st_size
, d
->sum
);
1679 d
->sum_computed
= true;
1682 result
= memcmp (d
->sum
, e
->sum
, 16);
1686 if (d
->check_included
|| e
->once_only
)
1692 /* Check that F is not in a list read from a PCH file (if any).
1693 Assumes that f->buffer_valid is true. Return TRUE if the file
1694 should not be read. */
1697 check_file_against_entries (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1699 bool check_included
)
1701 struct pchf_compare_data d
;
1704 || (! check_included
&& ! pchf
->have_once_only
))
1707 d
.size
= f
->st
.st_size
;
1708 d
.sum_computed
= false;
1710 d
.check_included
= check_included
;
1711 return bsearch (&d
, pchf
->entries
, pchf
->count
, sizeof (struct pchf_entry
),
1712 pchf_compare
) != NULL
;