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 /* Number of entries to put in a file_hash_entry pool. */
154 #define FILE_HASH_POOL_SIZE 127
156 /* A file hash entry pool. We allocate file_hash_entry object from
158 struct file_hash_entry_pool
160 /* Number of entries used from this pool. */
161 unsigned int file_hash_entries_used;
162 /* Next pool in the chain; used when freeing. */
163 struct file_hash_entry_pool *next;
164 /* The memory pool. */
165 struct file_hash_entry pool[FILE_HASH_POOL_SIZE];
168 static bool open_file (_cpp_file *file);
169 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
171 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
173 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
174 static bool read_file (cpp_reader *pfile, _cpp_file *file);
175 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
176 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
177 int angle_brackets, enum include_type);
178 static const char *dir_name_of_file (_cpp_file *file);
179 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
180 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
181 const cpp_dir *start_dir);
182 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
183 static void destroy_cpp_file (_cpp_file *);
184 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
185 static void allocate_file_hash_entries (cpp_reader *pfile);
186 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
187 static int report_missing_guard (void **slot, void *b);
188 static hashval_t file_hash_hash (const void *p);
189 static int file_hash_eq (const void *p, const void *q);
190 static char *read_filename_string (int ch, FILE *f);
191 static void read_name_map (cpp_dir *dir);
192 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
193 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
194 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
195 static int pchf_save_compare (const void *e1, const void *e2);
196 static int pchf_compare (const void *d_p, const void *e_p);
197 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
199 /* Given a filename in FILE->PATH, with the empty string interpreted
202 On success FILE contains an open file descriptor and stat
203 information for the file. On failure the file descriptor is -1 and
204 the appropriate errno is also stored in FILE. Returns TRUE iff
207 We used to open files in nonblocking mode, but that caused more
208 problems than it solved. Do take care not to acquire a controlling
209 terminal by mistake (this can't happen on sane systems, but
210 paranoia is a virtue).
212 Use the three-argument form of open even though we aren't
213 specifying O_CREAT, to defend against broken system headers.
215 O_BINARY tells some runtime libraries (notably DJGPP) not to do
216 newline translation; we can handle DOS line breaks just fine
219 open_file (_cpp_file *file)
221 if (file->path[0] == '\0')
224 set_stdin_to_binary_mode ();
227 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
231 if (fstat (file->fd, &file->st) == 0)
233 if (!S_ISDIR (file->st.st_mode))
239 /* Ignore a directory and continue the search. The file we're
240 looking for may be elsewhere in the search path. */
247 #if defined(_WIN32) && !defined(__CYGWIN__)
248 else if (errno == EACCES)
250 /* On most UNIX systems, open succeeds on a directory. Above,
251 we check if we have opened a directory and if so, set errno
252 to ENOENT. However, on Windows, opening a directory
253 fails with EACCES. We want to return ENOENT in that
255 if (stat (file->path, &file->st) == 0
256 && S_ISDIR (file->st.st_mode))
259 /* The call to stat may have reset errno. */
263 else if (errno == ENOTDIR)
266 file->err_no = errno;
271 /* Temporary PCH intercept of opening a file. Try to find a PCH file
272 based on FILE->name and FILE->dir, and test those found for
273 validity using PFILE->cb.valid_pch. Return true iff a valid file is
274 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
277 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
279 static const char extension[] = ".gch";
280 const char *path = file->path;
286 /* No PCH on <stdin> or if not requested. */
287 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
290 flen = strlen (path);
291 len = flen + sizeof (extension);
292 pchname = XNEWVEC (char, len);
293 memcpy (pchname, path, flen);
294 memcpy (pchname + flen, extension, sizeof (extension));
296 if (stat (pchname, &st) == 0)
300 size_t dlen, plen = len;
302 if (!S_ISDIR (st.st_mode))
303 valid = validate_pch (pfile, file, pchname);
304 else if ((pchdir = opendir (pchname)) != NULL)
306 pchname[plen - 1] = '/';
307 while ((d = readdir (pchdir)) != NULL)
309 dlen = strlen (d->d_name) + 1;
310 if ((strcmp (d->d_name, ".") == 0)
311 || (strcmp (d->d_name, "..") == 0))
313 if (dlen + plen > len)
316 pchname = XRESIZEVEC (char, pchname, len);
318 memcpy (pchname + plen, d->d_name, dlen);
319 valid = validate_pch (pfile, file, pchname);
332 file->pchname = pchname;
339 /* Try to open the path FILE->name appended to FILE->dir. This is
340 where remap and PCH intercept the file lookup process. Return true
341 if the file was found, whether or not the open was successful.
342 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
345 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
349 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
352 if (file->dir->construct)
353 path = file->dir->construct (file->name, file->dir);
355 path = append_file_to_dir (file->name, file->dir);
359 hashval_t hv = htab_hash_string (path);
363 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
365 file->err_no = ENOENT;
370 if (pch_open_file (pfile, file, invalid_pch))
373 if (open_file (file))
376 if (file->err_no != ENOENT)
378 open_file_failed (pfile, file, 0);
382 /* We copy the path name onto an obstack partly so that we don't
383 leak the memory, but mostly so that we don't fragment the
385 copy = obstack_copy0 (&pfile->nonexistent_file_ob, path,
388 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
392 file->path = file->name;
396 file->err_no = ENOENT;
403 /* Return tue iff the missing_header callback found the given HEADER. */
405 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
407 missing_header_cb func = pfile->cb.missing_header;
409 /* When the regular search path doesn't work, try context dependent
410 headers search paths. */
412 && file->dir == NULL)
414 if ((file->path = func (pfile, header, &file->dir)) != NULL)
416 if (open_file (file))
418 free ((void *)file->path);
420 file->path = file->name;
427 _cpp_find_failed (_cpp_file *file)
429 return file->err_no != 0;
432 /* Given a filename FNAME search for such a file in the include path
433 starting from START_DIR. If FNAME is the empty string it is
434 interpreted as STDIN if START_DIR is PFILE->no_search_path.
436 If the file is not found in the file cache fall back to the O/S and
437 add the result to our cache.
439 If the file was not found in the filesystem, or there was an error
440 opening it, then ERR_NO is nonzero and FD is -1. If the file was
441 found, then ERR_NO is zero and FD could be -1 or an open file
442 descriptor. FD can be -1 if the file was found in the cache and
443 had previously been closed. To open it again pass the return value
447 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
449 struct file_hash_entry *entry, **hash_slot;
451 bool invalid_pch = false;
452 bool saw_bracket_include = false;
453 bool saw_quote_include = false;
454 struct cpp_dir *found_in_cache = NULL;
456 /* Ensure we get no confusion between cached files and directories. */
457 if (start_dir == NULL)
458 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
460 hash_slot = (struct file_hash_entry **)
461 htab_find_slot_with_hash (pfile->file_hash, fname,
462 htab_hash_string (fname),
465 /* First check the cache before we resort to memory allocation. */
466 entry = search_cache (*hash_slot, start_dir);
468 return entry->u.file;
470 file = make_cpp_file (pfile, start_dir, fname);
472 /* Try each path in the include chain. */
475 if (find_file_in_dir (pfile, file, &invalid_pch))
478 file->dir = file->dir->next;
479 if (file->dir == NULL)
481 if (search_path_exhausted (pfile, fname, file))
483 /* Although this file must not go in the cache, because
484 the file found might depend on things (like the current file)
485 that aren't represented in the cache, it still has to go in
486 the list of all files so that #import works. */
487 file->next_file = pfile->all_files;
488 pfile->all_files = file;
492 open_file_failed (pfile, file, angle_brackets);
495 cpp_error (pfile, CPP_DL_ERROR,
496 "one or more PCH files were found, but they were invalid");
497 if (!cpp_get_options (pfile)->warn_invalid_pch)
498 cpp_error (pfile, CPP_DL_ERROR,
499 "use -Winvalid-pch for more information");
504 /* Only check the cache for the starting location (done above)
505 and the quote and bracket chain heads because there are no
506 other possible starting points for searches. */
507 if (file->dir == pfile->bracket_include)
508 saw_bracket_include = true;
509 else if (file->dir == pfile->quote_include)
510 saw_quote_include = true;
514 entry = search_cache (*hash_slot, file->dir);
517 found_in_cache = file->dir;
524 /* Cache for START_DIR too, sharing the _cpp_file structure. */
525 free ((char *) file->name);
527 file = entry->u.file;
531 /* This is a new file; put it in the list. */
532 file->next_file = pfile->all_files;
533 pfile->all_files = file;
536 /* Store this new result in the hash table. */
537 entry = new_file_hash_entry (pfile);
538 entry->next = *hash_slot;
539 entry->start_dir = start_dir;
540 entry->location = pfile->line_table->highest_location;
541 entry->u.file = file;
544 /* If we passed the quote or bracket chain heads, cache them also.
545 This speeds up processing if there are lots of -I options. */
546 if (saw_bracket_include
547 && pfile->bracket_include != start_dir
548 && found_in_cache != pfile->bracket_include)
550 entry = new_file_hash_entry (pfile);
551 entry->next = *hash_slot;
552 entry->start_dir = pfile->bracket_include;
553 entry->location = pfile->line_table->highest_location;
554 entry->u.file = file;
557 if (saw_quote_include
558 && pfile->quote_include != start_dir
559 && found_in_cache != pfile->quote_include)
561 entry = new_file_hash_entry (pfile);
562 entry->next = *hash_slot;
563 entry->start_dir = pfile->quote_include;
564 entry->location = pfile->line_table->highest_location;
565 entry->u.file = file;
572 /* Read a file into FILE->buffer, returning true on success.
574 If FILE->fd is something weird, like a block device, we don't want
575 to read it at all. Don't even try to figure out what something is,
576 except for plain files and block devices, since there is no
577 reliable portable way of doing this.
579 FIXME: Flush file cache and try again if we run out of memory. */
581 read_file_guts (cpp_reader *pfile, _cpp_file *file)
583 ssize_t size, total, count;
587 if (S_ISBLK (file->st.st_mode))
589 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
593 regular = S_ISREG (file->st.st_mode);
596 /* off_t might have a wider range than ssize_t - in other words,
597 the max size of a file might be bigger than the address
598 space. We can't handle a file that large. (Anyone with
599 a single source file bigger than 2GB needs to rethink
600 their coding style.) Some systems (e.g. AIX 4.1) define
601 SSIZE_MAX to be much smaller than the actual range of the
602 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
605 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
607 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
612 size = file->st.st_size;
615 /* 8 kilobytes is a sensible starting size. It ought to be bigger
616 than the kernel pipe buffer, and it's definitely bigger than
617 the majority of C source files. */
620 buf = XNEWVEC (uchar, size + 1);
622 while ((count = read (file->fd, buf + total, size - total)) > 0)
631 buf = XRESIZEVEC (uchar, buf, size + 1);
637 cpp_errno (pfile, CPP_DL_ERROR, file->path);
642 /* For some reason, even though we opened with O_BINARY,
643 * Borland C++ seems to insist on doing CR/LF -> LF
644 * translations for us, which results in the file appearing
645 * shorter than stat told us it should be.
647 * This sucks, but don't bother throwing a warning.
649 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
650 cpp_error (pfile, CPP_DL_WARNING,
651 "%s is shorter than expected", file->path);
654 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
655 buf, size, total, &file->st.st_size);
656 file->buffer_valid = true;
661 /* Convenience wrapper around read_file_guts that opens the file if
662 necessary and closes the file descriptor after reading. FILE must
663 have been passed through find_file() at some stage. */
665 read_file (cpp_reader *pfile, _cpp_file *file)
667 /* If we already have its contents in memory, succeed immediately. */
668 if (file->buffer_valid)
671 /* If an earlier read failed for some reason don't try again. */
672 if (file->dont_read || file->err_no)
675 if (file->fd == -1 && !open_file (file))
677 open_file_failed (pfile, file, 0);
681 file->dont_read = !read_file_guts (pfile, file);
685 return !file->dont_read;
688 /* Returns TRUE if FILE's contents have been successfully placed in
689 FILE->buffer and the file should be stacked, otherwise false. */
691 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
695 /* Skip once-only files. */
699 /* We must mark the file once-only if #import now, before header
700 guard checks. Otherwise, undefining the header guard might
701 cause the file to be re-stacked. */
704 _cpp_mark_file_once_only (pfile, file);
706 /* Don't stack files that have been stacked before. */
707 if (file->stack_count)
711 /* Skip if the file had a header guard and the macro is defined.
712 PCH relies on this appearing before the PCH handler below. */
713 if (file->cmacro && file->cmacro->type == NT_MACRO)
716 /* Handle PCH files immediately; don't stack them. */
719 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
725 if (!read_file (pfile, file))
728 /* Check the file against the PCH file. This is done before
729 checking against files we've already seen, since it may save on
731 if (check_file_against_entries (pfile, file, import))
733 /* If this isn't a #import, but yet we can't include the file,
734 that means that it was #import-ed in the PCH file,
735 so we can never include it again. */
737 _cpp_mark_file_once_only (pfile, file);
741 /* Now we've read the file's contents, we can stack it if there
742 are no once-only files. */
743 if (!pfile->seen_once_only)
746 /* We may have read the file under a different name. Look
747 for likely candidates and compare file contents to be sure. */
748 for (f = pfile->all_files; f; f = f->next_file)
753 if ((import || f->once_only)
755 && f->st.st_mtime == file->st.st_mtime
756 && f->st.st_size == file->st.st_size)
759 bool same_file_p = false;
761 if (f->buffer && !f->buffer_valid)
763 /* We already have a buffer but it is not valid, because
764 the file is still stacked. Make a new one. */
765 ref_file = make_cpp_file (pfile, f->dir, f->name);
766 ref_file->path = f->path;
769 /* The file is not stacked anymore. We can reuse it. */
772 same_file_p = read_file (pfile, ref_file)
773 /* Size might have changed in read_file(). */
774 && ref_file->st.st_size == file->st.st_size
775 && !memcmp (ref_file->buffer,
779 if (f->buffer && !f->buffer_valid)
782 destroy_cpp_file (ref_file);
793 /* Place the file referenced by FILE into a new buffer on the buffer
794 stack if possible. IMPORT is true if this stacking attempt is
795 because of a #import directive. Returns true if a buffer is
798 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
803 if (!should_stack_file (pfile, file, import))
806 if (pfile->buffer == NULL || file->dir == NULL)
809 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
811 /* Add the file to the dependencies on its first inclusion. */
812 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
814 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
815 deps_add_dep (pfile->deps, file->path);
818 /* Clear buffer_valid since _cpp_clean_line messes it up. */
819 file->buffer_valid = false;
822 /* Stack the buffer. */
823 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
824 CPP_OPTION (pfile, preprocessed)
825 && !CPP_OPTION (pfile, directives_only));
829 /* Initialize controlling macro state. */
830 pfile->mi_valid = true;
831 pfile->mi_cmacro = 0;
833 /* Generate the call back. */
834 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
839 /* Mark FILE to be included once only. */
841 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
843 pfile->seen_once_only = true;
844 file->once_only = true;
847 /* Return the directory from which searching for FNAME should start,
848 considering the directive TYPE and ANGLE_BRACKETS. If there is
849 nothing left in the path, returns NULL. */
850 static struct cpp_dir *
851 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
852 enum include_type type)
857 if (IS_ABSOLUTE_PATH (fname))
858 return &pfile->no_search_path;
860 /* pfile->buffer is NULL when processing an -include command-line flag. */
861 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
863 /* For #include_next, skip in the search path past the dir in which
864 the current file was found, but if it was found via an absolute
865 path use the normal search logic. */
866 if (type == IT_INCLUDE_NEXT && file->dir
867 && file->dir != &pfile->no_search_path)
868 dir = file->dir->next;
869 else if (angle_brackets)
870 dir = pfile->bracket_include;
871 else if (type == IT_CMDLINE)
872 /* -include and -imacros use the #include "" chain with the
873 preprocessor's cwd prepended. */
874 return make_cpp_dir (pfile, "./", false);
875 else if (pfile->quote_ignores_source_dir)
876 dir = pfile->quote_include;
878 return make_cpp_dir (pfile, dir_name_of_file (file),
879 pfile->buffer ? pfile->buffer->sysp : 0);
882 cpp_error (pfile, CPP_DL_ERROR,
883 "no include path in which to search for %s", fname);
888 /* Strip the basename from the file's path. It ends with a slash if
889 of nonzero length. Note that this procedure also works for
890 <stdin>, which is represented by the empty string. */
892 dir_name_of_file (_cpp_file *file)
896 size_t len = lbasename (file->path) - file->path;
897 char *dir_name = XNEWVEC (char, len + 1);
899 memcpy (dir_name, file->path, len);
900 dir_name[len] = '\0';
901 file->dir_name = dir_name;
904 return file->dir_name;
907 /* Handles #include-family directives (distinguished by TYPE),
908 including HEADER, and the command line -imacros and -include.
909 Returns true if a buffer was stacked. */
911 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
912 enum include_type type)
917 dir = search_path_head (pfile, fname, angle_brackets, type);
921 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
923 /* Compensate for the increment in linemap_add. In the case of a
924 normal #include, we're currently at the start of the line
925 *following* the #include. A separate source_location for this
926 location makes no sense (until we do the LC_LEAVE), and
927 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
928 found a PCH file (in which case linemap_add is not called) or we
929 were included from the command-line. */
930 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
931 pfile->line_table->highest_location--;
933 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
936 /* Could not open FILE. The complication is dependency output. */
938 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
940 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
941 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
943 errno = file->err_no;
944 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
945 deps_add_dep (pfile->deps, file->name);
948 /* If we are outputting dependencies but not for this file then
949 don't error because we can still produce correct output. */
950 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
951 cpp_errno (pfile, CPP_DL_WARNING, file->path);
953 cpp_errno (pfile, CPP_DL_ERROR, file->path);
957 /* Search in the chain beginning at HEAD for a file whose search path
958 started at START_DIR != NULL. */
959 static struct file_hash_entry *
960 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
962 while (head && head->start_dir != start_dir)
968 /* Allocate a new _cpp_file structure. */
970 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
974 file = XCNEW (_cpp_file);
975 file->main_file = !pfile->buffer;
978 file->name = xstrdup (fname);
983 /* Release a _cpp_file structure. */
985 destroy_cpp_file (_cpp_file *file)
988 free ((void *) file->buffer);
989 free ((void *) file->name);
993 /* Release all the files allocated by this reader. */
995 destroy_all_cpp_files (cpp_reader *pfile)
997 _cpp_file *iter = pfile->all_files;
1000 _cpp_file *next = iter->next_file;
1001 destroy_cpp_file (iter);
1006 /* A hash of directory names. The directory names are the path names
1007 of files which contain a #include "", the included file name is
1008 appended to this directories.
1010 To avoid duplicate entries we follow the convention that all
1011 non-empty directory names should end in a '/'. DIR_NAME must be
1012 stored in permanently allocated memory. */
1014 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1016 struct file_hash_entry *entry, **hash_slot;
1019 hash_slot = (struct file_hash_entry **)
1020 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1021 htab_hash_string (dir_name),
1024 /* Have we already hashed this directory? */
1025 for (entry = *hash_slot; entry; entry = entry->next)
1026 if (entry->start_dir == NULL)
1027 return entry->u.dir;
1029 dir = XCNEW (cpp_dir);
1030 dir->next = pfile->quote_include;
1031 dir->name = (char *) dir_name;
1032 dir->len = strlen (dir_name);
1036 /* Store this new result in the hash table. */
1037 entry = new_file_hash_entry (pfile);
1038 entry->next = *hash_slot;
1039 entry->start_dir = NULL;
1040 entry->location = pfile->line_table->highest_location;
1047 /* Create a new block of memory for file hash entries. */
1049 allocate_file_hash_entries (cpp_reader *pfile)
1051 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1052 pool->file_hash_entries_used = 0;
1053 pool->next = pfile->file_hash_entries;
1054 pfile->file_hash_entries = pool;
1057 /* Return a new file hash entry. */
1058 static struct file_hash_entry *
1059 new_file_hash_entry (cpp_reader *pfile)
1062 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1063 allocate_file_hash_entries (pfile);
1065 idx = pfile->file_hash_entries->file_hash_entries_used++;
1066 return &pfile->file_hash_entries->pool[idx];
1069 /* Free the file hash entry pools. */
1071 free_file_hash_entries (cpp_reader *pfile)
1073 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1076 struct file_hash_entry_pool *next = iter->next;
1082 /* Returns TRUE if a file FNAME has ever been successfully opened.
1083 This routine is not intended to correctly handle filenames aliased
1084 by links or redundant . or .. traversals etc. */
1086 cpp_included (cpp_reader *pfile, const char *fname)
1088 struct file_hash_entry *entry;
1090 entry = (struct file_hash_entry *)
1091 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1093 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1094 entry = entry->next;
1096 return entry != NULL;
1099 /* Returns TRUE if a file FNAME has ever been successfully opened
1100 before LOCATION. This routine is not intended to correctly handle
1101 filenames aliased by links or redundant . or .. traversals etc. */
1103 cpp_included_before (cpp_reader *pfile, const char *fname,
1104 source_location location)
1106 struct file_hash_entry *entry;
1108 entry = (struct file_hash_entry *)
1109 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1111 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1112 || entry->location > location))
1113 entry = entry->next;
1115 return entry != NULL;
1118 /* Calculate the hash value of a file hash entry P. */
1121 file_hash_hash (const void *p)
1123 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1125 if (entry->start_dir)
1126 hname = entry->u.file->name;
1128 hname = entry->u.dir->name;
1130 return htab_hash_string (hname);
1133 /* Compare a string Q against a file hash entry P. */
1135 file_hash_eq (const void *p, const void *q)
1137 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1138 const char *fname = (const char *) q;
1141 if (entry->start_dir)
1142 hname = entry->u.file->name;
1144 hname = entry->u.dir->name;
1146 return strcmp (hname, fname) == 0;
1149 /* Compare entries in the nonexistent file hash table. These are just
1152 nonexistent_file_hash_eq (const void *p, const void *q)
1154 return strcmp (p, q) == 0;
1157 /* Initialize everything in this source file. */
1159 _cpp_init_files (cpp_reader *pfile)
1161 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1162 NULL, xcalloc, free);
1163 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1164 NULL, xcalloc, free);
1165 allocate_file_hash_entries (pfile);
1166 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1167 nonexistent_file_hash_eq,
1168 NULL, xcalloc, free);
1169 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1170 (void *(*) (long)) xmalloc,
1171 (void (*) (void *)) free);
1174 /* Finalize everything in this source file. */
1176 _cpp_cleanup_files (cpp_reader *pfile)
1178 htab_delete (pfile->file_hash);
1179 htab_delete (pfile->dir_hash);
1180 htab_delete (pfile->nonexistent_file_hash);
1181 obstack_free (&pfile->nonexistent_file_ob, 0);
1182 free_file_hash_entries (pfile);
1183 destroy_all_cpp_files (pfile);
1186 /* Make the parser forget about files it has seen. This can be useful
1187 for resetting the parser to start another run. */
1189 cpp_clear_file_cache (cpp_reader *pfile)
1191 _cpp_cleanup_files (pfile);
1192 pfile->file_hash_entries = NULL;
1193 pfile->all_files = NULL;
1194 _cpp_init_files (pfile);
1197 /* Enter a file name in the hash for the sake of cpp_included. */
1199 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1201 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1204 /* Not everyone who wants to set system-header-ness on a buffer can
1205 see the details of a buffer. This is an exported interface because
1206 fix-header needs it. */
1208 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1211 const struct line_maps *line_table = pfile->line_table;
1212 const struct line_map *map = &line_table->maps[line_table->used-1];
1214 /* 1 = system header, 2 = system header to be treated as C. */
1216 flags = 1 + (externc != 0);
1217 pfile->buffer->sysp = flags;
1218 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1219 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1222 /* Allow the client to change the current file. Used by the front end
1223 to achieve pseudo-file names like <built-in>.
1224 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1226 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1227 const char *new_name)
1229 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1232 struct report_missing_guard_data
1238 /* Callback function for htab_traverse. */
1240 report_missing_guard (void **slot, void *d)
1242 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1243 struct report_missing_guard_data *data
1244 = (struct report_missing_guard_data *) d;
1246 /* Skip directories. */
1247 if (entry->start_dir != NULL)
1249 _cpp_file *file = entry->u.file;
1251 /* We don't want MI guard advice for the main file. */
1252 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1254 if (data->paths == NULL)
1256 data->paths = XCNEWVEC (const char *, data->count);
1260 data->paths[data->count++] = file->path;
1264 /* Keep traversing the hash table. */
1268 /* Comparison function for qsort. */
1270 report_missing_guard_cmp (const void *p1, const void *p2)
1272 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1275 /* Report on all files that might benefit from a multiple include guard.
1278 _cpp_report_missing_guards (cpp_reader *pfile)
1280 struct report_missing_guard_data data;
1283 data.count = htab_elements (pfile->file_hash);
1284 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1286 if (data.paths != NULL)
1290 /* Sort the paths to avoid outputting them in hash table
1292 qsort (data.paths, data.count, sizeof (const char *),
1293 report_missing_guard_cmp);
1294 fputs (_("Multiple include guards may be useful for:\n"),
1296 for (i = 0; i < data.count; i++)
1298 fputs (data.paths[i], stderr);
1299 putc ('\n', stderr);
1305 /* Locate HEADER, and determine whether it is newer than the current
1306 file. If it cannot be located or dated, return -1, if it is
1307 newer, return 1, otherwise 0. */
1309 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1313 struct cpp_dir *dir;
1315 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1319 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1329 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1332 /* Pushes the given file onto the buffer stack. Returns nonzero if
1335 cpp_push_include (cpp_reader *pfile, const char *fname)
1337 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1340 /* Do appropriate cleanup when a file INC's buffer is popped off the
1343 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1345 /* Record the inclusion-preventing macro, which could be NULL
1346 meaning no controlling macro. */
1347 if (pfile->mi_valid && file->cmacro == NULL)
1348 file->cmacro = pfile->mi_cmacro;
1350 /* Invalidate control macros in the #including file. */
1351 pfile->mi_valid = false;
1355 free ((void *) file->buffer);
1356 file->buffer = NULL;
1357 file->buffer_valid = false;
1361 /* Inteface to file statistics record in _cpp_file structure. */
1363 _cpp_get_file_stat (_cpp_file *file)
1368 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1369 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1370 directory of the including file.
1372 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1374 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1375 int quote_ignores_source_dir)
1377 pfile->quote_include = quote;
1378 pfile->bracket_include = quote;
1379 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1381 for (; quote; quote = quote->next)
1383 quote->name_map = NULL;
1384 quote->len = strlen (quote->name);
1385 if (quote == bracket)
1386 pfile->bracket_include = bracket;
1390 /* Append the file name to the directory to create the path, but don't
1391 turn / into // or // into ///; // may be a namespace escape. */
1393 append_file_to_dir (const char *fname, cpp_dir *dir)
1399 flen = strlen (fname);
1400 path = XNEWVEC (char, dlen + 1 + flen + 1);
1401 memcpy (path, dir->name, dlen);
1402 if (dlen && path[dlen - 1] != '/')
1404 memcpy (&path[dlen], fname, flen + 1);
1409 /* Read a space delimited string of unlimited length from a stdio
1412 read_filename_string (int ch, FILE *f)
1418 set = alloc = XNEWVEC (char, len + 1);
1419 if (! is_space (ch))
1422 while ((ch = getc (f)) != EOF && ! is_space (ch))
1424 if (set - alloc == len)
1427 alloc = XRESIZEVEC (char, alloc, len + 1);
1428 set = alloc + len / 2;
1438 /* Read the file name map file for DIR. */
1440 read_name_map (cpp_dir *dir)
1442 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1445 size_t len, count = 0, room = 9;
1448 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1449 memcpy (name, dir->name, len);
1450 if (len && name[len - 1] != '/')
1452 strcpy (name + len, FILE_NAME_MAP_FILE);
1453 f = fopen (name, "r");
1455 dir->name_map = XNEWVEC (const char *, room);
1457 /* Silently return NULL if we cannot open. */
1462 while ((ch = getc (f)) != EOF)
1469 if (count + 2 > room)
1472 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1475 dir->name_map[count] = read_filename_string (ch, f);
1476 while ((ch = getc (f)) != EOF && is_hspace (ch))
1479 to = read_filename_string (ch, f);
1480 if (IS_ABSOLUTE_PATH (to))
1481 dir->name_map[count + 1] = to;
1484 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1489 while ((ch = getc (f)) != '\n')
1497 /* Terminate the list of maps. */
1498 dir->name_map[count] = NULL;
1501 /* Remap a FILE's name based on the file_name_map, if any, for
1502 FILE->dir. If the file name has any directory separators,
1503 recursively check those directories too. */
1505 remap_filename (cpp_reader *pfile, _cpp_file *file)
1507 const char *fname, *p;
1518 read_name_map (dir);
1520 for (index = 0; dir->name_map[index]; index += 2)
1521 if (!strcmp (dir->name_map[index], fname))
1522 return xstrdup (dir->name_map[index + 1]);
1524 p = strchr (fname, '/');
1525 if (!p || p == fname)
1528 len = dir->len + (p - fname + 1);
1529 new_dir = XNEWVEC (char, len + 1);
1530 memcpy (new_dir, dir->name, dir->len);
1531 memcpy (new_dir + dir->len, fname, p - fname + 1);
1532 new_dir[len] = '\0';
1534 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1539 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1541 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1543 const char *saved_path = file->path;
1546 file->path = pchname;
1547 if (open_file (file))
1549 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1557 if (CPP_OPTION (pfile, print_include_names))
1560 for (i = 1; i < pfile->line_table->depth; i++)
1562 fprintf (stderr, "%c %s\n",
1563 valid ? '!' : 'x', pchname);
1567 file->path = saved_path;
1571 /* Get the path associated with the _cpp_file F. The path includes
1572 the base name from the include directive and the directory it was
1573 found in via the search path. */
1576 cpp_get_path (struct _cpp_file *f)
1581 /* Get the directory associated with the _cpp_file F. */
1584 cpp_get_dir (struct _cpp_file *f)
1589 /* Get the cpp_buffer currently associated with the cpp_reader
1593 cpp_get_buffer (cpp_reader *pfile)
1595 return pfile->buffer;
1598 /* Get the _cpp_file associated with the cpp_buffer B. */
1601 cpp_get_file (cpp_buffer *b)
1606 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1607 buffer is the buffer that included the given buffer. */
1610 cpp_get_prev (cpp_buffer *b)
1615 /* This data structure holds the list of header files that were seen
1616 while the PCH was being built. The 'entries' field is kept sorted
1617 in memcmp() order; yes, this means that on little-endian systems,
1618 it's sorted initially by the least-significant byte of 'size', but
1619 that's OK. The code does rely on having entries with the same size
1620 next to each other. */
1623 /* The size of this file. This is used to save running a MD5 checksum
1624 if the sizes don't match. */
1626 /* The MD5 checksum of this file. */
1627 unsigned char sum[16];
1628 /* Is this file to be included only once? */
1633 /* Number of pchf_entry structures. */
1636 /* Are there any values with once_only set?
1637 This is used as an optimisation, it means we don't have to search
1638 the structure if we're processing a regular #include. */
1639 bool have_once_only;
1641 struct pchf_entry entries[1];
1644 static struct pchf_data *pchf;
1646 /* A qsort ordering function for pchf_entry structures. */
1649 pchf_save_compare (const void *e1, const void *e2)
1651 return memcmp (e1, e2, sizeof (struct pchf_entry));
1654 /* Create and write to F a pchf_data structure. */
1657 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1660 struct pchf_data *result;
1664 for (f = pfile->all_files; f; f = f->next_file)
1667 result_size = (sizeof (struct pchf_data)
1668 + sizeof (struct pchf_entry) * (count - 1));
1669 result = XCNEWVAR (struct pchf_data, result_size);
1672 result->have_once_only = false;
1674 for (f = pfile->all_files; f; f = f->next_file)
1678 /* This should probably never happen, since if a read error occurred
1679 the PCH file shouldn't be written... */
1680 if (f->dont_read || f->err_no)
1683 if (f->stack_count == 0)
1686 count = result->count++;
1688 result->entries[count].once_only = f->once_only;
1689 /* |= is avoided in the next line because of an HP C compiler bug */
1690 result->have_once_only = result->have_once_only | f->once_only;
1691 if (f->buffer_valid)
1692 md5_buffer ((const char *)f->buffer,
1693 f->st.st_size, result->entries[count].sum);
1701 open_file_failed (pfile, f, 0);
1704 ff = fdopen (f->fd, "rb");
1705 md5_stream (ff, result->entries[count].sum);
1709 result->entries[count].size = f->st.st_size;
1712 result_size = (sizeof (struct pchf_data)
1713 + sizeof (struct pchf_entry) * (result->count - 1));
1715 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1718 return fwrite (result, result_size, 1, fp) == 1;
1721 /* Read the pchf_data structure from F. */
1724 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1728 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1732 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1733 + sizeof (struct pchf_entry) * (d.count - 1));
1734 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1735 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1741 /* The parameters for pchf_compare. */
1743 struct pchf_compare_data
1745 /* The size of the file we're looking for. */
1748 /* The MD5 checksum of the file, if it's been computed. */
1749 unsigned char sum[16];
1754 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1755 bool check_included;
1757 /* The file that we're searching for. */
1761 /* bsearch comparison function; look for D_P in E_P. */
1764 pchf_compare (const void *d_p, const void *e_p)
1766 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1767 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1770 result = memcmp (&d->size, &e->size, sizeof (off_t));
1774 if (! d->sum_computed)
1776 _cpp_file *const f = d->f;
1778 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1779 d->sum_computed = true;
1782 result = memcmp (d->sum, e->sum, 16);
1786 if (d->check_included || e->once_only)
1792 /* Check that F is not in a list read from a PCH file (if any).
1793 Assumes that f->buffer_valid is true. Return TRUE if the file
1794 should not be read. */
1797 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1799 bool check_included)
1801 struct pchf_compare_data d;
1804 || (! check_included && ! pchf->have_once_only))
1807 d.size = f->st.st_size;
1808 d.sum_computed = false;
1810 d.check_included = check_included;
1811 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1812 pchf_compare) != NULL;