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, 2008, 2009
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 3, 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; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
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 /* Pointer to the real start of BUFFER. read_file() might increment
78 BUFFER; when freeing, this this pointer must be used instead. */
79 const uchar *buffer_start;
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
89 /* As filled in by stat(2) for the file. */
92 /* File descriptor. Invalid if -1, otherwise open. */
95 /* Zero if this file was successfully opened and stat()-ed,
96 otherwise errno obtained from failure. */
99 /* Number of times the file has been stacked for preprocessing. */
100 unsigned short stack_count;
102 /* If opened with #import or contains #pragma once. */
105 /* If read() failed before. */
108 /* If this file is the main file. */
111 /* If BUFFER above contains the true contents of the file. */
115 /* A singly-linked list for all searches for a given file name, with
116 its head pointed to by a slot in FILE_HASH. The file name is what
117 appeared between the quotes in a #include directive; it can be
118 determined implicitly from the hash table location or explicitly
121 FILE is a structure containing details about the file that was
122 found with that search, or details of how the search failed.
124 START_DIR is the starting location of the search in the include
125 chain. The current directories for "" includes are also hashed in
126 the hash table and therefore unique. Files that are looked up
127 without using a search path, such as absolute filenames and file
128 names from the command line share a special starting directory so
129 they don't cause cache hits with normal include-chain lookups.
131 If START_DIR is NULL then the entry is for a directory, not a file,
132 and the directory is in DIR. Since the starting point in a file
133 lookup chain is never NULL, this means that simple pointer
134 comparisons against START_DIR can be made to determine cache hits
137 If a cache lookup fails because of e.g. an extra "./" in the path,
138 then nothing will break. It is just less efficient as CPP will
139 have to do more work re-preprocessing the file, and/or comparing
140 its contents against earlier once-only files.
142 struct file_hash_entry
144 struct file_hash_entry *next;
146 source_location location;
154 /* Number of entries to put in a file_hash_entry pool. */
155 #define FILE_HASH_POOL_SIZE 127
157 /* A file hash entry pool. We allocate file_hash_entry object from
159 struct file_hash_entry_pool
161 /* Number of entries used from this pool. */
162 unsigned int file_hash_entries_used;
163 /* Next pool in the chain; used when freeing. */
164 struct file_hash_entry_pool *next;
165 /* The memory pool. */
166 struct file_hash_entry pool[FILE_HASH_POOL_SIZE];
169 static bool open_file (_cpp_file *file);
170 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
172 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
174 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
175 static bool read_file (cpp_reader *pfile, _cpp_file *file);
176 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
177 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
178 int angle_brackets, enum include_type);
179 static const char *dir_name_of_file (_cpp_file *file);
180 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
181 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
182 const cpp_dir *start_dir);
183 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
184 static void destroy_cpp_file (_cpp_file *);
185 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
186 static void allocate_file_hash_entries (cpp_reader *pfile);
187 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
188 static int report_missing_guard (void **slot, void *b);
189 static hashval_t file_hash_hash (const void *p);
190 static int file_hash_eq (const void *p, const void *q);
191 static char *read_filename_string (int ch, FILE *f);
192 static void read_name_map (cpp_dir *dir);
193 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
194 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
195 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
196 static int pchf_save_compare (const void *e1, const void *e2);
197 static int pchf_compare (const void *d_p, const void *e_p);
198 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
200 /* Given a filename in FILE->PATH, with the empty string interpreted
203 On success FILE contains an open file descriptor and stat
204 information for the file. On failure the file descriptor is -1 and
205 the appropriate errno is also stored in FILE. Returns TRUE iff
208 We used to open files in nonblocking mode, but that caused more
209 problems than it solved. Do take care not to acquire a controlling
210 terminal by mistake (this can't happen on sane systems, but
211 paranoia is a virtue).
213 Use the three-argument form of open even though we aren't
214 specifying O_CREAT, to defend against broken system headers.
216 O_BINARY tells some runtime libraries (notably DJGPP) not to do
217 newline translation; we can handle DOS line breaks just fine
220 open_file (_cpp_file *file)
222 if (file->path[0] == '\0')
225 set_stdin_to_binary_mode ();
228 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
232 if (fstat (file->fd, &file->st) == 0)
234 if (!S_ISDIR (file->st.st_mode))
240 /* Ignore a directory and continue the search. The file we're
241 looking for may be elsewhere in the search path. */
248 #if defined(_WIN32) && !defined(__CYGWIN__)
249 else if (errno == EACCES)
251 /* On most UNIX systems, open succeeds on a directory. Above,
252 we check if we have opened a directory and if so, set errno
253 to ENOENT. However, on Windows, opening a directory
254 fails with EACCES. We want to return ENOENT in that
256 if (stat (file->path, &file->st) == 0
257 && S_ISDIR (file->st.st_mode))
260 /* The call to stat may have reset errno. */
264 else if (errno == ENOTDIR)
267 file->err_no = errno;
272 /* Temporary PCH intercept of opening a file. Try to find a PCH file
273 based on FILE->name and FILE->dir, and test those found for
274 validity using PFILE->cb.valid_pch. Return true iff a valid file is
275 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
278 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
280 static const char extension[] = ".gch";
281 const char *path = file->path;
287 /* No PCH on <stdin> or if not requested. */
288 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
291 flen = strlen (path);
292 len = flen + sizeof (extension);
293 pchname = XNEWVEC (char, len);
294 memcpy (pchname, path, flen);
295 memcpy (pchname + flen, extension, sizeof (extension));
297 if (stat (pchname, &st) == 0)
301 size_t dlen, plen = len;
303 if (!S_ISDIR (st.st_mode))
304 valid = validate_pch (pfile, file, pchname);
305 else if ((pchdir = opendir (pchname)) != NULL)
307 pchname[plen - 1] = '/';
308 while ((d = readdir (pchdir)) != NULL)
310 dlen = strlen (d->d_name) + 1;
311 if ((strcmp (d->d_name, ".") == 0)
312 || (strcmp (d->d_name, "..") == 0))
314 if (dlen + plen > len)
317 pchname = XRESIZEVEC (char, pchname, len);
319 memcpy (pchname + plen, d->d_name, dlen);
320 valid = validate_pch (pfile, file, pchname);
331 file->pchname = pchname;
338 /* Try to open the path FILE->name appended to FILE->dir. This is
339 where remap and PCH intercept the file lookup process. Return true
340 if the file was found, whether or not the open was successful.
341 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
344 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
348 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
351 if (file->dir->construct)
352 path = file->dir->construct (file->name, file->dir);
354 path = append_file_to_dir (file->name, file->dir);
358 hashval_t hv = htab_hash_string (path);
362 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
364 file->err_no = ENOENT;
369 if (pch_open_file (pfile, file, invalid_pch))
372 if (open_file (file))
375 if (file->err_no != ENOENT)
377 open_file_failed (pfile, file, 0);
381 /* We copy the path name onto an obstack partly so that we don't
382 leak the memory, but mostly so that we don't fragment the
384 copy = obstack_copy0 (&pfile->nonexistent_file_ob, path,
387 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
391 file->path = file->name;
395 file->err_no = ENOENT;
402 /* Return tue iff the missing_header callback found the given HEADER. */
404 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
406 missing_header_cb func = pfile->cb.missing_header;
408 /* When the regular search path doesn't work, try context dependent
409 headers search paths. */
411 && file->dir == NULL)
413 if ((file->path = func (pfile, header, &file->dir)) != NULL)
415 if (open_file (file))
417 free ((void *)file->path);
419 file->path = file->name;
426 _cpp_find_failed (_cpp_file *file)
428 return file->err_no != 0;
431 /* Given a filename FNAME search for such a file in the include path
432 starting from START_DIR. If FNAME is the empty string it is
433 interpreted as STDIN if START_DIR is PFILE->no_search_path.
435 If the file is not found in the file cache fall back to the O/S and
436 add the result to our cache.
438 If the file was not found in the filesystem, or there was an error
439 opening it, then ERR_NO is nonzero and FD is -1. If the file was
440 found, then ERR_NO is zero and FD could be -1 or an open file
441 descriptor. FD can be -1 if the file was found in the cache and
442 had previously been closed. To open it again pass the return value
446 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
448 struct file_hash_entry *entry, **hash_slot;
450 bool invalid_pch = false;
451 bool saw_bracket_include = false;
452 bool saw_quote_include = false;
453 struct cpp_dir *found_in_cache = NULL;
455 /* Ensure we get no confusion between cached files and directories. */
456 if (start_dir == NULL)
457 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
459 hash_slot = (struct file_hash_entry **)
460 htab_find_slot_with_hash (pfile->file_hash, fname,
461 htab_hash_string (fname),
464 /* First check the cache before we resort to memory allocation. */
465 entry = search_cache (*hash_slot, start_dir);
467 return entry->u.file;
469 file = make_cpp_file (pfile, start_dir, fname);
471 /* Try each path in the include chain. */
474 if (find_file_in_dir (pfile, file, &invalid_pch))
477 file->dir = file->dir->next;
478 if (file->dir == NULL)
480 if (search_path_exhausted (pfile, fname, file))
482 /* Although this file must not go in the cache, because
483 the file found might depend on things (like the current file)
484 that aren't represented in the cache, it still has to go in
485 the list of all files so that #import works. */
486 file->next_file = pfile->all_files;
487 pfile->all_files = file;
491 open_file_failed (pfile, file, angle_brackets);
494 cpp_error (pfile, CPP_DL_ERROR,
495 "one or more PCH files were found, but they were invalid");
496 if (!cpp_get_options (pfile)->warn_invalid_pch)
497 cpp_error (pfile, CPP_DL_ERROR,
498 "use -Winvalid-pch for more information");
503 /* Only check the cache for the starting location (done above)
504 and the quote and bracket chain heads because there are no
505 other possible starting points for searches. */
506 if (file->dir == pfile->bracket_include)
507 saw_bracket_include = true;
508 else if (file->dir == pfile->quote_include)
509 saw_quote_include = true;
513 entry = search_cache (*hash_slot, file->dir);
516 found_in_cache = file->dir;
523 /* Cache for START_DIR too, sharing the _cpp_file structure. */
524 free ((char *) file->name);
526 file = entry->u.file;
530 /* This is a new file; put it in the list. */
531 file->next_file = pfile->all_files;
532 pfile->all_files = file;
535 /* Store this new result in the hash table. */
536 entry = new_file_hash_entry (pfile);
537 entry->next = *hash_slot;
538 entry->start_dir = start_dir;
539 entry->location = pfile->line_table->highest_location;
540 entry->u.file = file;
543 /* If we passed the quote or bracket chain heads, cache them also.
544 This speeds up processing if there are lots of -I options. */
545 if (saw_bracket_include
546 && pfile->bracket_include != start_dir
547 && found_in_cache != pfile->bracket_include)
549 entry = new_file_hash_entry (pfile);
550 entry->next = *hash_slot;
551 entry->start_dir = pfile->bracket_include;
552 entry->location = pfile->line_table->highest_location;
553 entry->u.file = file;
556 if (saw_quote_include
557 && pfile->quote_include != start_dir
558 && found_in_cache != pfile->quote_include)
560 entry = new_file_hash_entry (pfile);
561 entry->next = *hash_slot;
562 entry->start_dir = pfile->quote_include;
563 entry->location = pfile->line_table->highest_location;
564 entry->u.file = file;
571 /* Read a file into FILE->buffer, returning true on success.
573 If FILE->fd is something weird, like a block device, we don't want
574 to read it at all. Don't even try to figure out what something is,
575 except for plain files and block devices, since there is no
576 reliable portable way of doing this.
578 FIXME: Flush file cache and try again if we run out of memory. */
580 read_file_guts (cpp_reader *pfile, _cpp_file *file)
582 ssize_t size, total, count;
586 if (S_ISBLK (file->st.st_mode))
588 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
592 regular = S_ISREG (file->st.st_mode);
595 /* off_t might have a wider range than ssize_t - in other words,
596 the max size of a file might be bigger than the address
597 space. We can't handle a file that large. (Anyone with
598 a single source file bigger than 2GB needs to rethink
599 their coding style.) Some systems (e.g. AIX 4.1) define
600 SSIZE_MAX to be much smaller than the actual range of the
601 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
604 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
606 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
611 size = file->st.st_size;
614 /* 8 kilobytes is a sensible starting size. It ought to be bigger
615 than the kernel pipe buffer, and it's definitely bigger than
616 the majority of C source files. */
619 buf = XNEWVEC (uchar, size + 1);
621 while ((count = read (file->fd, buf + total, size - total)) > 0)
630 buf = XRESIZEVEC (uchar, buf, size + 1);
636 cpp_errno (pfile, CPP_DL_ERROR, file->path);
641 /* For some reason, even though we opened with O_BINARY,
642 * Borland C++ seems to insist on doing CR/LF -> LF
643 * translations for us, which results in the file appearing
644 * shorter than stat told us it should be.
646 * This sucks, but don't bother throwing a warning.
648 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
649 cpp_error (pfile, CPP_DL_WARNING,
650 "%s is shorter than expected", file->path);
653 file->buffer = _cpp_convert_input (pfile,
654 CPP_OPTION (pfile, input_charset),
658 file->buffer_valid = true;
663 /* Convenience wrapper around read_file_guts that opens the file if
664 necessary and closes the file descriptor after reading. FILE must
665 have been passed through find_file() at some stage. */
667 read_file (cpp_reader *pfile, _cpp_file *file)
669 /* If we already have its contents in memory, succeed immediately. */
670 if (file->buffer_valid)
673 /* If an earlier read failed for some reason don't try again. */
674 if (file->dont_read || file->err_no)
677 if (file->fd == -1 && !open_file (file))
679 open_file_failed (pfile, file, 0);
683 file->dont_read = !read_file_guts (pfile, file);
687 return !file->dont_read;
690 /* Returns TRUE if FILE's contents have been successfully placed in
691 FILE->buffer and the file should be stacked, otherwise false. */
693 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
697 /* Skip once-only files. */
701 /* We must mark the file once-only if #import now, before header
702 guard checks. Otherwise, undefining the header guard might
703 cause the file to be re-stacked. */
706 _cpp_mark_file_once_only (pfile, file);
708 /* Don't stack files that have been stacked before. */
709 if (file->stack_count)
713 /* Skip if the file had a header guard and the macro is defined.
714 PCH relies on this appearing before the PCH handler below. */
715 if (file->cmacro && file->cmacro->type == NT_MACRO)
718 /* Handle PCH files immediately; don't stack them. */
721 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
723 free ((void *) file->pchname);
724 file->pchname = NULL;
728 if (!read_file (pfile, file))
731 /* Check the file against the PCH file. This is done before
732 checking against files we've already seen, since it may save on
734 if (check_file_against_entries (pfile, file, import))
736 /* If this isn't a #import, but yet we can't include the file,
737 that means that it was #import-ed in the PCH file,
738 so we can never include it again. */
740 _cpp_mark_file_once_only (pfile, file);
744 /* Now we've read the file's contents, we can stack it if there
745 are no once-only files. */
746 if (!pfile->seen_once_only)
749 /* We may have read the file under a different name. Look
750 for likely candidates and compare file contents to be sure. */
751 for (f = pfile->all_files; f; f = f->next_file)
756 if ((import || f->once_only)
758 && f->st.st_mtime == file->st.st_mtime
759 && f->st.st_size == file->st.st_size)
762 bool same_file_p = false;
764 if (f->buffer && !f->buffer_valid)
766 /* We already have a buffer but it is not valid, because
767 the file is still stacked. Make a new one. */
768 ref_file = make_cpp_file (pfile, f->dir, f->name);
769 ref_file->path = f->path;
772 /* The file is not stacked anymore. We can reuse it. */
775 same_file_p = read_file (pfile, ref_file)
776 /* Size might have changed in read_file(). */
777 && ref_file->st.st_size == file->st.st_size
778 && !memcmp (ref_file->buffer,
782 if (f->buffer && !f->buffer_valid)
785 destroy_cpp_file (ref_file);
796 /* Place the file referenced by FILE into a new buffer on the buffer
797 stack if possible. IMPORT is true if this stacking attempt is
798 because of a #import directive. Returns true if a buffer is
801 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
806 if (!should_stack_file (pfile, file, import))
809 if (pfile->buffer == NULL || file->dir == NULL)
812 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
814 /* Add the file to the dependencies on its first inclusion. */
815 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
817 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
818 deps_add_dep (pfile->deps, file->path);
821 /* Clear buffer_valid since _cpp_clean_line messes it up. */
822 file->buffer_valid = false;
825 /* Stack the buffer. */
826 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
827 CPP_OPTION (pfile, preprocessed)
828 && !CPP_OPTION (pfile, directives_only));
832 /* Initialize controlling macro state. */
833 pfile->mi_valid = true;
834 pfile->mi_cmacro = 0;
836 /* Generate the call back. */
837 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
842 /* Mark FILE to be included once only. */
844 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
846 pfile->seen_once_only = true;
847 file->once_only = true;
850 /* Return the directory from which searching for FNAME should start,
851 considering the directive TYPE and ANGLE_BRACKETS. If there is
852 nothing left in the path, returns NULL. */
853 static struct cpp_dir *
854 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
855 enum include_type type)
860 if (IS_ABSOLUTE_PATH (fname))
861 return &pfile->no_search_path;
863 /* pfile->buffer is NULL when processing an -include command-line flag. */
864 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
866 /* For #include_next, skip in the search path past the dir in which
867 the current file was found, but if it was found via an absolute
868 path use the normal search logic. */
869 if (type == IT_INCLUDE_NEXT && file->dir
870 && file->dir != &pfile->no_search_path)
871 dir = file->dir->next;
872 else if (angle_brackets)
873 dir = pfile->bracket_include;
874 else if (type == IT_CMDLINE)
875 /* -include and -imacros use the #include "" chain with the
876 preprocessor's cwd prepended. */
877 return make_cpp_dir (pfile, "./", false);
878 else if (pfile->quote_ignores_source_dir)
879 dir = pfile->quote_include;
881 return make_cpp_dir (pfile, dir_name_of_file (file),
882 pfile->buffer ? pfile->buffer->sysp : 0);
885 cpp_error (pfile, CPP_DL_ERROR,
886 "no include path in which to search for %s", fname);
891 /* Strip the basename from the file's path. It ends with a slash if
892 of nonzero length. Note that this procedure also works for
893 <stdin>, which is represented by the empty string. */
895 dir_name_of_file (_cpp_file *file)
899 size_t len = lbasename (file->path) - file->path;
900 char *dir_name = XNEWVEC (char, len + 1);
902 memcpy (dir_name, file->path, len);
903 dir_name[len] = '\0';
904 file->dir_name = dir_name;
907 return file->dir_name;
910 /* Handles #include-family directives (distinguished by TYPE),
911 including HEADER, and the command line -imacros and -include.
912 Returns true if a buffer was stacked. */
914 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
915 enum include_type type)
920 dir = search_path_head (pfile, fname, angle_brackets, type);
924 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
926 /* Compensate for the increment in linemap_add. In the case of a
927 normal #include, we're currently at the start of the line
928 *following* the #include. A separate source_location for this
929 location makes no sense (until we do the LC_LEAVE), and
930 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
931 found a PCH file (in which case linemap_add is not called) or we
932 were included from the command-line. */
933 if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
934 pfile->line_table->highest_location--;
936 return _cpp_stack_file (pfile, file, (bool)(type == IT_IMPORT));
939 /* Could not open FILE. The complication is dependency output. */
941 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
943 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
944 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
946 errno = file->err_no;
947 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
948 deps_add_dep (pfile->deps, file->name);
951 /* If we are outputting dependencies but not for this file then
952 don't error because we can still produce correct output. */
953 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
954 cpp_errno (pfile, CPP_DL_WARNING, file->path);
956 cpp_errno (pfile, CPP_DL_ERROR, file->path);
960 /* Search in the chain beginning at HEAD for a file whose search path
961 started at START_DIR != NULL. */
962 static struct file_hash_entry *
963 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
965 while (head && head->start_dir != start_dir)
971 /* Allocate a new _cpp_file structure. */
973 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
977 file = XCNEW (_cpp_file);
978 file->main_file = !pfile->buffer;
981 file->name = xstrdup (fname);
986 /* Release a _cpp_file structure. */
988 destroy_cpp_file (_cpp_file *file)
990 if (file->buffer_start)
991 free ((void *) file->buffer_start);
992 free ((void *) file->name);
996 /* Release all the files allocated by this reader. */
998 destroy_all_cpp_files (cpp_reader *pfile)
1000 _cpp_file *iter = pfile->all_files;
1003 _cpp_file *next = iter->next_file;
1004 destroy_cpp_file (iter);
1009 /* A hash of directory names. The directory names are the path names
1010 of files which contain a #include "", the included file name is
1011 appended to this directories.
1013 To avoid duplicate entries we follow the convention that all
1014 non-empty directory names should end in a '/'. DIR_NAME must be
1015 stored in permanently allocated memory. */
1017 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1019 struct file_hash_entry *entry, **hash_slot;
1022 hash_slot = (struct file_hash_entry **)
1023 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1024 htab_hash_string (dir_name),
1027 /* Have we already hashed this directory? */
1028 for (entry = *hash_slot; entry; entry = entry->next)
1029 if (entry->start_dir == NULL)
1030 return entry->u.dir;
1032 dir = XCNEW (cpp_dir);
1033 dir->next = pfile->quote_include;
1034 dir->name = (char *) dir_name;
1035 dir->len = strlen (dir_name);
1039 /* Store this new result in the hash table. */
1040 entry = new_file_hash_entry (pfile);
1041 entry->next = *hash_slot;
1042 entry->start_dir = NULL;
1043 entry->location = pfile->line_table->highest_location;
1050 /* Create a new block of memory for file hash entries. */
1052 allocate_file_hash_entries (cpp_reader *pfile)
1054 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1055 pool->file_hash_entries_used = 0;
1056 pool->next = pfile->file_hash_entries;
1057 pfile->file_hash_entries = pool;
1060 /* Return a new file hash entry. */
1061 static struct file_hash_entry *
1062 new_file_hash_entry (cpp_reader *pfile)
1065 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1066 allocate_file_hash_entries (pfile);
1068 idx = pfile->file_hash_entries->file_hash_entries_used++;
1069 return &pfile->file_hash_entries->pool[idx];
1072 /* Free the file hash entry pools. */
1074 free_file_hash_entries (cpp_reader *pfile)
1076 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1079 struct file_hash_entry_pool *next = iter->next;
1085 /* Returns TRUE if a file FNAME has ever been successfully opened.
1086 This routine is not intended to correctly handle filenames aliased
1087 by links or redundant . or .. traversals etc. */
1089 cpp_included (cpp_reader *pfile, const char *fname)
1091 struct file_hash_entry *entry;
1093 entry = (struct file_hash_entry *)
1094 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1096 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1097 entry = entry->next;
1099 return entry != NULL;
1102 /* Returns TRUE if a file FNAME has ever been successfully opened
1103 before LOCATION. This routine is not intended to correctly handle
1104 filenames aliased by links or redundant . or .. traversals etc. */
1106 cpp_included_before (cpp_reader *pfile, const char *fname,
1107 source_location location)
1109 struct file_hash_entry *entry;
1111 entry = (struct file_hash_entry *)
1112 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1114 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1115 || entry->location > location))
1116 entry = entry->next;
1118 return entry != NULL;
1121 /* Calculate the hash value of a file hash entry P. */
1124 file_hash_hash (const void *p)
1126 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1128 if (entry->start_dir)
1129 hname = entry->u.file->name;
1131 hname = entry->u.dir->name;
1133 return htab_hash_string (hname);
1136 /* Compare a string Q against a file hash entry P. */
1138 file_hash_eq (const void *p, const void *q)
1140 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1141 const char *fname = (const char *) q;
1144 if (entry->start_dir)
1145 hname = entry->u.file->name;
1147 hname = entry->u.dir->name;
1149 return strcmp (hname, fname) == 0;
1152 /* Compare entries in the nonexistent file hash table. These are just
1155 nonexistent_file_hash_eq (const void *p, const void *q)
1157 return strcmp (p, q) == 0;
1160 /* Initialize everything in this source file. */
1162 _cpp_init_files (cpp_reader *pfile)
1164 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1165 NULL, xcalloc, free);
1166 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1167 NULL, xcalloc, free);
1168 allocate_file_hash_entries (pfile);
1169 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1170 nonexistent_file_hash_eq,
1171 NULL, xcalloc, free);
1172 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1173 (void *(*) (long)) xmalloc,
1174 (void (*) (void *)) free);
1177 /* Finalize everything in this source file. */
1179 _cpp_cleanup_files (cpp_reader *pfile)
1181 htab_delete (pfile->file_hash);
1182 htab_delete (pfile->dir_hash);
1183 htab_delete (pfile->nonexistent_file_hash);
1184 obstack_free (&pfile->nonexistent_file_ob, 0);
1185 free_file_hash_entries (pfile);
1186 destroy_all_cpp_files (pfile);
1189 /* Make the parser forget about files it has seen. This can be useful
1190 for resetting the parser to start another run. */
1192 cpp_clear_file_cache (cpp_reader *pfile)
1194 _cpp_cleanup_files (pfile);
1195 pfile->file_hash_entries = NULL;
1196 pfile->all_files = NULL;
1197 _cpp_init_files (pfile);
1200 /* Enter a file name in the hash for the sake of cpp_included. */
1202 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1204 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1207 /* Not everyone who wants to set system-header-ness on a buffer can
1208 see the details of a buffer. This is an exported interface because
1209 fix-header needs it. */
1211 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1214 const struct line_maps *line_table = pfile->line_table;
1215 const struct line_map *map = &line_table->maps[line_table->used-1];
1217 /* 1 = system header, 2 = system header to be treated as C. */
1219 flags = 1 + (externc != 0);
1220 pfile->buffer->sysp = flags;
1221 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1222 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1225 /* Allow the client to change the current file. Used by the front end
1226 to achieve pseudo-file names like <built-in>.
1227 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1229 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1230 const char *new_name)
1232 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1235 struct report_missing_guard_data
1241 /* Callback function for htab_traverse. */
1243 report_missing_guard (void **slot, void *d)
1245 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1246 struct report_missing_guard_data *data
1247 = (struct report_missing_guard_data *) d;
1249 /* Skip directories. */
1250 if (entry->start_dir != NULL)
1252 _cpp_file *file = entry->u.file;
1254 /* We don't want MI guard advice for the main file. */
1255 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1257 if (data->paths == NULL)
1259 data->paths = XCNEWVEC (const char *, data->count);
1263 data->paths[data->count++] = file->path;
1267 /* Keep traversing the hash table. */
1271 /* Comparison function for qsort. */
1273 report_missing_guard_cmp (const void *p1, const void *p2)
1275 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1278 /* Report on all files that might benefit from a multiple include guard.
1281 _cpp_report_missing_guards (cpp_reader *pfile)
1283 struct report_missing_guard_data data;
1286 data.count = htab_elements (pfile->file_hash);
1287 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1289 if (data.paths != NULL)
1293 /* Sort the paths to avoid outputting them in hash table
1295 qsort (data.paths, data.count, sizeof (const char *),
1296 report_missing_guard_cmp);
1297 fputs (_("Multiple include guards may be useful for:\n"),
1299 for (i = 0; i < data.count; i++)
1301 fputs (data.paths[i], stderr);
1302 putc ('\n', stderr);
1308 /* Locate HEADER, and determine whether it is newer than the current
1309 file. If it cannot be located or dated, return -1, if it is
1310 newer, return 1, otherwise 0. */
1312 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1316 struct cpp_dir *dir;
1318 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1322 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1332 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1335 /* Pushes the given file onto the buffer stack. Returns nonzero if
1338 cpp_push_include (cpp_reader *pfile, const char *fname)
1340 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1343 /* Do appropriate cleanup when a file INC's buffer is popped off the
1346 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1348 /* Record the inclusion-preventing macro, which could be NULL
1349 meaning no controlling macro. */
1350 if (pfile->mi_valid && file->cmacro == NULL)
1351 file->cmacro = pfile->mi_cmacro;
1353 /* Invalidate control macros in the #including file. */
1354 pfile->mi_valid = false;
1356 if (file->buffer_start)
1358 free ((void *) file->buffer_start);
1359 file->buffer_start = NULL;
1360 file->buffer = NULL;
1361 file->buffer_valid = false;
1365 /* Inteface to file statistics record in _cpp_file structure. */
1367 _cpp_get_file_stat (_cpp_file *file)
1372 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1373 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1374 directory of the including file.
1376 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1378 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1379 int quote_ignores_source_dir)
1381 pfile->quote_include = quote;
1382 pfile->bracket_include = quote;
1383 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1385 for (; quote; quote = quote->next)
1387 quote->name_map = NULL;
1388 quote->len = strlen (quote->name);
1389 if (quote == bracket)
1390 pfile->bracket_include = bracket;
1394 /* Append the file name to the directory to create the path, but don't
1395 turn / into // or // into ///; // may be a namespace escape. */
1397 append_file_to_dir (const char *fname, cpp_dir *dir)
1403 flen = strlen (fname);
1404 path = XNEWVEC (char, dlen + 1 + flen + 1);
1405 memcpy (path, dir->name, dlen);
1406 if (dlen && path[dlen - 1] != '/')
1408 memcpy (&path[dlen], fname, flen + 1);
1413 /* Read a space delimited string of unlimited length from a stdio
1416 read_filename_string (int ch, FILE *f)
1422 set = alloc = XNEWVEC (char, len + 1);
1423 if (! is_space (ch))
1426 while ((ch = getc (f)) != EOF && ! is_space (ch))
1428 if (set - alloc == len)
1431 alloc = XRESIZEVEC (char, alloc, len + 1);
1432 set = alloc + len / 2;
1442 /* Read the file name map file for DIR. */
1444 read_name_map (cpp_dir *dir)
1446 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1449 size_t len, count = 0, room = 9;
1452 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1453 memcpy (name, dir->name, len);
1454 if (len && name[len - 1] != '/')
1456 strcpy (name + len, FILE_NAME_MAP_FILE);
1457 f = fopen (name, "r");
1459 dir->name_map = XNEWVEC (const char *, room);
1461 /* Silently return NULL if we cannot open. */
1466 while ((ch = getc (f)) != EOF)
1473 if (count + 2 > room)
1476 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1479 dir->name_map[count] = read_filename_string (ch, f);
1480 while ((ch = getc (f)) != EOF && is_hspace (ch))
1483 to = read_filename_string (ch, f);
1484 if (IS_ABSOLUTE_PATH (to))
1485 dir->name_map[count + 1] = to;
1488 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1493 while ((ch = getc (f)) != '\n')
1501 /* Terminate the list of maps. */
1502 dir->name_map[count] = NULL;
1505 /* Remap a FILE's name based on the file_name_map, if any, for
1506 FILE->dir. If the file name has any directory separators,
1507 recursively check those directories too. */
1509 remap_filename (cpp_reader *pfile, _cpp_file *file)
1511 const char *fname, *p;
1522 read_name_map (dir);
1524 for (index = 0; dir->name_map[index]; index += 2)
1525 if (!strcmp (dir->name_map[index], fname))
1526 return xstrdup (dir->name_map[index + 1]);
1528 p = strchr (fname, '/');
1529 if (!p || p == fname)
1532 len = dir->len + (p - fname + 1);
1533 new_dir = XNEWVEC (char, len + 1);
1534 memcpy (new_dir, dir->name, dir->len);
1535 memcpy (new_dir + dir->len, fname, p - fname + 1);
1536 new_dir[len] = '\0';
1538 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1543 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1545 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1547 const char *saved_path = file->path;
1550 file->path = pchname;
1551 if (open_file (file))
1553 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1561 if (CPP_OPTION (pfile, print_include_names))
1564 for (i = 1; i < pfile->line_table->depth; i++)
1566 fprintf (stderr, "%c %s\n",
1567 valid ? '!' : 'x', pchname);
1571 file->path = saved_path;
1575 /* Get the path associated with the _cpp_file F. The path includes
1576 the base name from the include directive and the directory it was
1577 found in via the search path. */
1580 cpp_get_path (struct _cpp_file *f)
1585 /* Get the directory associated with the _cpp_file F. */
1588 cpp_get_dir (struct _cpp_file *f)
1593 /* Get the cpp_buffer currently associated with the cpp_reader
1597 cpp_get_buffer (cpp_reader *pfile)
1599 return pfile->buffer;
1602 /* Get the _cpp_file associated with the cpp_buffer B. */
1605 cpp_get_file (cpp_buffer *b)
1610 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1611 buffer is the buffer that included the given buffer. */
1614 cpp_get_prev (cpp_buffer *b)
1619 /* This data structure holds the list of header files that were seen
1620 while the PCH was being built. The 'entries' field is kept sorted
1621 in memcmp() order; yes, this means that on little-endian systems,
1622 it's sorted initially by the least-significant byte of 'size', but
1623 that's OK. The code does rely on having entries with the same size
1624 next to each other. */
1627 /* The size of this file. This is used to save running a MD5 checksum
1628 if the sizes don't match. */
1630 /* The MD5 checksum of this file. */
1631 unsigned char sum[16];
1632 /* Is this file to be included only once? */
1637 /* Number of pchf_entry structures. */
1640 /* Are there any values with once_only set?
1641 This is used as an optimisation, it means we don't have to search
1642 the structure if we're processing a regular #include. */
1643 bool have_once_only;
1645 struct pchf_entry entries[1];
1648 static struct pchf_data *pchf;
1650 /* A qsort ordering function for pchf_entry structures. */
1653 pchf_save_compare (const void *e1, const void *e2)
1655 return memcmp (e1, e2, sizeof (struct pchf_entry));
1658 /* Create and write to F a pchf_data structure. */
1661 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1664 struct pchf_data *result;
1668 for (f = pfile->all_files; f; f = f->next_file)
1671 result_size = (sizeof (struct pchf_data)
1672 + sizeof (struct pchf_entry) * (count - 1));
1673 result = XCNEWVAR (struct pchf_data, result_size);
1676 result->have_once_only = false;
1678 for (f = pfile->all_files; f; f = f->next_file)
1682 /* This should probably never happen, since if a read error occurred
1683 the PCH file shouldn't be written... */
1684 if (f->dont_read || f->err_no)
1687 if (f->stack_count == 0)
1690 count = result->count++;
1692 result->entries[count].once_only = f->once_only;
1693 /* |= is avoided in the next line because of an HP C compiler bug */
1694 result->have_once_only = result->have_once_only | f->once_only;
1695 if (f->buffer_valid)
1696 md5_buffer ((const char *)f->buffer,
1697 f->st.st_size, result->entries[count].sum);
1705 open_file_failed (pfile, f, 0);
1708 ff = fdopen (f->fd, "rb");
1709 md5_stream (ff, result->entries[count].sum);
1713 result->entries[count].size = f->st.st_size;
1716 result_size = (sizeof (struct pchf_data)
1717 + sizeof (struct pchf_entry) * (result->count - 1));
1719 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1722 return fwrite (result, result_size, 1, fp) == 1;
1725 /* Read the pchf_data structure from F. */
1728 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1732 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1736 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1737 + sizeof (struct pchf_entry) * (d.count - 1));
1738 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1739 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1745 /* The parameters for pchf_compare. */
1747 struct pchf_compare_data
1749 /* The size of the file we're looking for. */
1752 /* The MD5 checksum of the file, if it's been computed. */
1753 unsigned char sum[16];
1758 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1759 bool check_included;
1761 /* The file that we're searching for. */
1765 /* bsearch comparison function; look for D_P in E_P. */
1768 pchf_compare (const void *d_p, const void *e_p)
1770 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1771 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1774 result = memcmp (&d->size, &e->size, sizeof (off_t));
1778 if (! d->sum_computed)
1780 _cpp_file *const f = d->f;
1782 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1783 d->sum_computed = true;
1786 result = memcmp (d->sum, e->sum, 16);
1790 if (d->check_included || e->once_only)
1796 /* Check that F is not in a list read from a PCH file (if any).
1797 Assumes that f->buffer_valid is true. Return TRUE if the file
1798 should not be read. */
1801 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1803 bool check_included)
1805 struct pchf_compare_data d;
1808 || (! check_included && ! pchf->have_once_only))
1811 d.size = f->st.st_size;
1812 d.sum_computed = false;
1814 d.check_included = check_included;
1815 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1816 pchf_compare) != NULL;