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 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
7 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 Reimplemented, Neil Booth, Jul 2003
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
39 # define STAT_SIZE_RELIABLE(ST) true
44 /* For DJGPP redirected input is opened in text mode. */
45 # define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY)
48 # define set_stdin_to_binary_mode() /* Nothing */
51 /* This structure represents a file searched for by CPP, whether it
52 exists or not. An instance may be pointed to by more than one
53 file_hash_entry; at present no reference count is kept. */
56 /* Filename as given to #include or command line switch. */
59 /* The full path used to find the file. */
62 /* The full path of the pch file. */
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
69 /* Chain through all files. */
70 struct _cpp_file *next_file;
72 /* The contents of NAME after calling read_file(). */
75 /* The macro, if any, preventing re-inclusion. */
76 const cpp_hashnode *cmacro;
78 /* The directory in the search path where FILE was found. Used for
79 #include_next and determining whether a header is a system
83 /* As filled in by stat(2) for the file. */
86 /* File descriptor. Invalid if -1, otherwise open. */
89 /* Zero if this file was successfully opened and stat()-ed,
90 otherwise errno obtained from failure. */
93 /* Number of times the file has been stacked for preprocessing. */
94 unsigned short stack_count;
96 /* If opened with #import or contains #pragma once. */
99 /* If read() failed before. */
102 /* If this file is the main file. */
105 /* If BUFFER above contains the true contents of the file. */
108 /* File is a PCH (on return from find_include_file). */
112 /* A singly-linked list for all searches for a given file name, with
113 its head pointed to by a slot in FILE_HASH. The file name is what
114 appeared between the quotes in a #include directive; it can be
115 determined implicitly from the hash table location or explicitly
118 FILE is a structure containing details about the file that was
119 found with that search, or details of how the search failed.
121 START_DIR is the starting location of the search in the include
122 chain. The current directories for "" includes are also hashed in
123 the hash table and therefore unique. Files that are looked up
124 without using a search path, such as absolute filenames and file
125 names from the command line share a special starting directory so
126 they don't cause cache hits with normal include-chain lookups.
128 If START_DIR is NULL then the entry is for a directory, not a file,
129 and the directory is in DIR. Since the starting point in a file
130 lookup chain is never NULL, this means that simple pointer
131 comparisons against START_DIR can be made to determine cache hits
134 If a cache lookup fails because of e.g. an extra "./" in the path,
135 then nothing will break. It is just less efficient as CPP will
136 have to do more work re-preprocessing the file, and/or comparing
137 its contents against earlier once-only files.
139 struct file_hash_entry
141 struct file_hash_entry *next;
150 static bool open_file (_cpp_file *file);
151 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
153 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
155 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
156 static bool read_file (cpp_reader *pfile, _cpp_file *file);
157 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
158 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
159 int angle_brackets, enum include_type);
160 static const char *dir_name_of_file (_cpp_file *file);
161 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
162 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
163 const cpp_dir *start_dir);
164 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
165 static void destroy_cpp_file (_cpp_file *);
166 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
167 static void allocate_file_hash_entries (cpp_reader *pfile);
168 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
169 static int report_missing_guard (void **slot, void *b);
170 static hashval_t file_hash_hash (const void *p);
171 static int file_hash_eq (const void *p, const void *q);
172 static char *read_filename_string (int ch, FILE *f);
173 static void read_name_map (cpp_dir *dir);
174 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
175 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
176 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
177 static int pchf_save_compare (const void *e1, const void *e2);
178 static int pchf_compare (const void *d_p, const void *e_p);
179 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
181 /* Given a filename in FILE->PATH, with the empty string interpreted
184 On success FILE contains an open file descriptor and stat
185 information for the file. On failure the file descriptor is -1 and
186 the appropriate errno is also stored in FILE. Returns TRUE iff
189 We used to open files in nonblocking mode, but that caused more
190 problems than it solved. Do take care not to acquire a controlling
191 terminal by mistake (this can't happen on sane systems, but
192 paranoia is a virtue).
194 Use the three-argument form of open even though we aren't
195 specifying O_CREAT, to defend against broken system headers.
197 O_BINARY tells some runtime libraries (notably DJGPP) not to do
198 newline translation; we can handle DOS line breaks just fine
201 open_file (_cpp_file *file)
203 if (file->path[0] == '\0')
206 set_stdin_to_binary_mode ();
209 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
213 if (fstat (file->fd, &file->st) == 0)
215 if (!S_ISDIR (file->st.st_mode))
221 /* Ignore a directory and continue the search. The file we're
222 looking for may be elsewhere in the search path. */
229 else if (errno == ENOTDIR)
232 file->err_no = errno;
237 /* Temporary PCH intercept of opening a file. Try to find a PCH file
238 based on FILE->name and FILE->dir, and test those found for
239 validity using PFILE->cb.valid_pch. Return true iff a valid file is
240 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
243 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
245 static const char extension[] = ".gch";
246 const char *path = file->path;
252 /* No PCH on <stdin> or if not requested. */
253 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
256 flen = strlen (path);
257 len = flen + sizeof (extension);
258 pchname = XNEWVEC (char, len);
259 memcpy (pchname, path, flen);
260 memcpy (pchname + flen, extension, sizeof (extension));
262 if (stat (pchname, &st) == 0)
266 size_t dlen, plen = len;
268 if (!S_ISDIR (st.st_mode))
269 valid = validate_pch (pfile, file, pchname);
270 else if ((pchdir = opendir (pchname)) != NULL)
272 pchname[plen - 1] = '/';
273 while ((d = readdir (pchdir)) != NULL)
275 dlen = strlen (d->d_name) + 1;
276 if ((strcmp (d->d_name, ".") == 0)
277 || (strcmp (d->d_name, "..") == 0))
279 if (dlen + plen > len)
282 pchname = XRESIZEVEC (char, pchname, len);
284 memcpy (pchname + plen, d->d_name, dlen);
285 valid = validate_pch (pfile, file, pchname);
298 file->pchname = pchname;
305 /* Try to open the path FILE->name appended to FILE->dir. This is
306 where remap and PCH intercept the file lookup process. Return true
307 if the file was found, whether or not the open was successful.
308 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
311 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
315 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
318 if (file->dir->construct)
319 path = file->dir->construct (file->name, file->dir);
321 path = append_file_to_dir (file->name, file->dir);
326 if (pch_open_file (pfile, file, invalid_pch))
329 if (open_file (file))
332 if (file->err_no != ENOENT)
334 open_file_failed (pfile, file, 0);
339 file->path = file->name;
343 file->err_no = ENOENT;
350 /* Return tue iff the missing_header callback found the given HEADER. */
352 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
354 missing_header_cb func = pfile->cb.missing_header;
356 /* When the regular search path doesn't work, try context dependent
357 headers search paths. */
359 && file->dir == NULL)
361 if ((file->path = func (pfile, header, &file->dir)) != NULL)
363 if (open_file (file))
365 free ((void *)file->path);
367 file->path = file->name;
374 _cpp_find_failed (_cpp_file *file)
376 return file->err_no != 0;
379 /* Given a filename FNAME search for such a file in the include path
380 starting from START_DIR. If FNAME is the empty string it is
381 interpreted as STDIN if START_DIR is PFILE->no_search_path.
383 If the file is not found in the file cache fall back to the O/S and
384 add the result to our cache.
386 If the file was not found in the filesystem, or there was an error
387 opening it, then ERR_NO is nonzero and FD is -1. If the file was
388 found, then ERR_NO is zero and FD could be -1 or an open file
389 descriptor. FD can be -1 if the file was found in the cache and
390 had previously been closed. To open it again pass the return value
394 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
396 struct file_hash_entry *entry, **hash_slot;
398 bool invalid_pch = false;
400 /* Ensure we get no confusion between cached files and directories. */
401 if (start_dir == NULL)
402 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
404 hash_slot = (struct file_hash_entry **)
405 htab_find_slot_with_hash (pfile->file_hash, fname,
406 htab_hash_string (fname),
409 /* First check the cache before we resort to memory allocation. */
410 entry = search_cache (*hash_slot, start_dir);
412 return entry->u.file;
414 file = make_cpp_file (pfile, start_dir, fname);
416 /* Try each path in the include chain. */
419 if (find_file_in_dir (pfile, file, &invalid_pch))
422 file->dir = file->dir->next;
423 if (file->dir == NULL)
425 if (search_path_exhausted (pfile, fname, file))
427 /* Although this file must not go in the cache, because
428 the file found might depend on things (like the current file)
429 that aren't represented in the cache, it still has to go in
430 the list of all files so that #import works. */
431 file->next_file = pfile->all_files;
432 pfile->all_files = file;
436 open_file_failed (pfile, file, angle_brackets);
439 cpp_error (pfile, CPP_DL_ERROR,
440 "one or more PCH files were found, but they were invalid");
441 if (!cpp_get_options (pfile)->warn_invalid_pch)
442 cpp_error (pfile, CPP_DL_ERROR,
443 "use -Winvalid-pch for more information");
448 /* Only check the cache for the starting location (done above)
449 and the quote and bracket chain heads because there are no
450 other possible starting points for searches. */
451 if (file->dir != pfile->bracket_include
452 && file->dir != pfile->quote_include)
455 entry = search_cache (*hash_slot, file->dir);
462 /* Cache for START_DIR too, sharing the _cpp_file structure. */
463 free ((char *) file->name);
465 file = entry->u.file;
469 /* This is a new file; put it in the list. */
470 file->next_file = pfile->all_files;
471 pfile->all_files = file;
474 /* Store this new result in the hash table. */
475 entry = new_file_hash_entry (pfile);
476 entry->next = *hash_slot;
477 entry->start_dir = start_dir;
478 entry->u.file = file;
484 /* Read a file into FILE->buffer, returning true on success.
486 If FILE->fd is something weird, like a block device, we don't want
487 to read it at all. Don't even try to figure out what something is,
488 except for plain files and block devices, since there is no
489 reliable portable way of doing this.
491 FIXME: Flush file cache and try again if we run out of memory. */
493 read_file_guts (cpp_reader *pfile, _cpp_file *file)
495 ssize_t size, total, count;
499 if (S_ISBLK (file->st.st_mode))
501 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
505 regular = S_ISREG (file->st.st_mode);
508 /* off_t might have a wider range than ssize_t - in other words,
509 the max size of a file might be bigger than the address
510 space. We can't handle a file that large. (Anyone with
511 a single source file bigger than 2GB needs to rethink
512 their coding style.) Some systems (e.g. AIX 4.1) define
513 SSIZE_MAX to be much smaller than the actual range of the
514 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
517 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
519 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
524 size = file->st.st_size;
527 /* 8 kilobytes is a sensible starting size. It ought to be bigger
528 than the kernel pipe buffer, and it's definitely bigger than
529 the majority of C source files. */
532 buf = XNEWVEC (uchar, size + 1);
534 while ((count = read (file->fd, buf + total, size - total)) > 0)
543 buf = XRESIZEVEC (uchar, buf, size + 1);
549 cpp_errno (pfile, CPP_DL_ERROR, file->path);
554 /* For some reason, even though we opened with O_BINARY,
555 * Borland C++ seems to insist on doing CR/LF -> LF
556 * translations for us, which results in the file appearing
557 * shorter than stat told us it should be.
559 * This sucks, but don't bother throwing a warning.
561 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
562 cpp_error (pfile, CPP_DL_WARNING,
563 "%s is shorter than expected", file->path);
566 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
567 buf, size, total, &file->st.st_size);
568 file->buffer_valid = true;
573 /* Convenience wrapper around read_file_guts that opens the file if
574 necessary and closes the file descriptor after reading. FILE must
575 have been passed through find_file() at some stage. */
577 read_file (cpp_reader *pfile, _cpp_file *file)
579 /* If we already have its contents in memory, succeed immediately. */
580 if (file->buffer_valid)
583 /* If an earlier read failed for some reason don't try again. */
584 if (file->dont_read || file->err_no)
587 if (file->fd == -1 && !open_file (file))
589 open_file_failed (pfile, file, 0);
593 file->dont_read = !read_file_guts (pfile, file);
597 return !file->dont_read;
600 /* Returns TRUE if FILE's contents have been successfully placed in
601 FILE->buffer and the file should be stacked, otherwise false. */
603 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
607 /* Skip once-only files. */
611 /* We must mark the file once-only if #import now, before header
612 guard checks. Otherwise, undefining the header guard might
613 cause the file to be re-stacked. */
616 _cpp_mark_file_once_only (pfile, file);
618 /* Don't stack files that have been stacked before. */
619 if (file->stack_count)
623 /* Skip if the file had a header guard and the macro is defined.
624 PCH relies on this appearing before the PCH handler below. */
625 if (file->cmacro && file->cmacro->type == NT_MACRO)
628 /* Handle PCH files immediately; don't stack them. */
631 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
637 if (!read_file (pfile, file))
640 /* Check the file against the PCH file. This is done before
641 checking against files we've already seen, since it may save on
643 if (check_file_against_entries (pfile, file, import))
645 /* If this isn't a #import, but yet we can't include the file,
646 that means that it was #import-ed in the PCH file,
647 so we can never include it again. */
649 _cpp_mark_file_once_only (pfile, file);
653 /* Now we've read the file's contents, we can stack it if there
654 are no once-only files. */
655 if (!pfile->seen_once_only)
658 /* We may have read the file under a different name. Look
659 for likely candidates and compare file contents to be sure. */
660 for (f = pfile->all_files; f; f = f->next_file)
665 if ((import || f->once_only)
667 && f->st.st_mtime == file->st.st_mtime
668 && f->st.st_size == file->st.st_size)
671 bool same_file_p = false;
673 if (f->buffer && !f->buffer_valid)
675 /* We already have a buffer but it is not valid, because
676 the file is still stacked. Make a new one. */
677 ref_file = make_cpp_file (pfile, f->dir, f->name);
678 ref_file->path = f->path;
681 /* The file is not stacked anymore. We can reuse it. */
684 same_file_p = read_file (pfile, ref_file)
685 /* Size might have changed in read_file(). */
686 && ref_file->st.st_size == file->st.st_size
687 && !memcmp (ref_file->buffer,
691 if (f->buffer && !f->buffer_valid)
694 destroy_cpp_file (ref_file);
705 /* Place the file referenced by FILE into a new buffer on the buffer
706 stack if possible. IMPORT is true if this stacking attempt is
707 because of a #import directive. Returns true if a buffer is
710 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
715 if (!should_stack_file (pfile, file, import))
718 if (pfile->buffer == NULL || file->dir == NULL)
721 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
723 /* Add the file to the dependencies on its first inclusion. */
724 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
726 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
727 deps_add_dep (pfile->deps, file->path);
730 /* Clear buffer_valid since _cpp_clean_line messes it up. */
731 file->buffer_valid = false;
734 /* Stack the buffer. */
735 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
736 CPP_OPTION (pfile, preprocessed));
740 /* Initialize controlling macro state. */
741 pfile->mi_valid = true;
742 pfile->mi_cmacro = 0;
744 /* Generate the call back. */
745 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
750 /* Mark FILE to be included once only. */
752 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
754 pfile->seen_once_only = true;
755 file->once_only = true;
758 /* Return the directory from which searching for FNAME should start,
759 considering the directive TYPE and ANGLE_BRACKETS. If there is
760 nothing left in the path, returns NULL. */
761 static struct cpp_dir *
762 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
763 enum include_type type)
768 if (IS_ABSOLUTE_PATH (fname))
769 return &pfile->no_search_path;
771 /* pfile->buffer is NULL when processing an -include command-line flag. */
772 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
774 /* For #include_next, skip in the search path past the dir in which
775 the current file was found, but if it was found via an absolute
776 path use the normal search logic. */
777 if (type == IT_INCLUDE_NEXT && file->dir)
778 dir = file->dir->next;
779 else if (angle_brackets)
780 dir = pfile->bracket_include;
781 else if (type == IT_CMDLINE)
782 /* -include and -imacros use the #include "" chain with the
783 preprocessor's cwd prepended. */
784 return make_cpp_dir (pfile, "./", false);
785 else if (pfile->quote_ignores_source_dir)
786 dir = pfile->quote_include;
788 return make_cpp_dir (pfile, dir_name_of_file (file),
789 pfile->buffer ? pfile->buffer->sysp : 0);
792 cpp_error (pfile, CPP_DL_ERROR,
793 "no include path in which to search for %s", fname);
798 /* Strip the basename from the file's path. It ends with a slash if
799 of nonzero length. Note that this procedure also works for
800 <stdin>, which is represented by the empty string. */
802 dir_name_of_file (_cpp_file *file)
806 size_t len = lbasename (file->path) - file->path;
807 char *dir_name = XNEWVEC (char, len + 1);
809 memcpy (dir_name, file->path, len);
810 dir_name[len] = '\0';
811 file->dir_name = dir_name;
814 return file->dir_name;
817 /* Handles #include-family directives (distinguished by TYPE),
818 including HEADER, and the command line -imacros and -include.
819 Returns true if a buffer was stacked. */
821 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
822 enum include_type type)
827 dir = search_path_head (pfile, fname, angle_brackets, type);
831 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
833 /* Compensate for the increment in linemap_add. In the case of a
834 normal #include, we're currently at the start of the line
835 *following* the #include. A separate source_location for this
836 location makes no sense (until we do the LC_LEAVE), and
837 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
838 found a PCH file (in which case linemap_add is not called) or we
839 were included from the command-line. */
840 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
841 pfile->line_table->highest_location--;
843 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
846 /* Could not open FILE. The complication is dependency output. */
848 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
850 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
851 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
853 errno = file->err_no;
854 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
855 deps_add_dep (pfile->deps, file->name);
858 /* If we are outputting dependencies but not for this file then
859 don't error because we can still produce correct output. */
860 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
861 cpp_errno (pfile, CPP_DL_WARNING, file->path);
863 cpp_errno (pfile, CPP_DL_ERROR, file->path);
867 /* Search in the chain beginning at HEAD for a file whose search path
868 started at START_DIR != NULL. */
869 static struct file_hash_entry *
870 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
872 while (head && head->start_dir != start_dir)
878 /* Allocate a new _cpp_file structure. */
880 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
884 file = XCNEW (_cpp_file);
885 file->main_file = !pfile->buffer;
888 file->name = xstrdup (fname);
893 /* Release a _cpp_file structure. */
895 destroy_cpp_file (_cpp_file *file)
898 free ((void *) file->buffer);
899 free ((void *) file->name);
903 /* A hash of directory names. The directory names are the path names
904 of files which contain a #include "", the included file name is
905 appended to this directories.
907 To avoid duplicate entries we follow the convention that all
908 non-empty directory names should end in a '/'. DIR_NAME must be
909 stored in permanently allocated memory. */
911 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
913 struct file_hash_entry *entry, **hash_slot;
916 hash_slot = (struct file_hash_entry **)
917 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
918 htab_hash_string (dir_name),
921 /* Have we already hashed this directory? */
922 for (entry = *hash_slot; entry; entry = entry->next)
923 if (entry->start_dir == NULL)
926 dir = XCNEW (cpp_dir);
927 dir->next = pfile->quote_include;
928 dir->name = (char *) dir_name;
929 dir->len = strlen (dir_name);
933 /* Store this new result in the hash table. */
934 entry = new_file_hash_entry (pfile);
935 entry->next = *hash_slot;
936 entry->start_dir = NULL;
943 /* Create a new block of memory for file hash entries. */
945 allocate_file_hash_entries (cpp_reader *pfile)
947 pfile->file_hash_entries_used = 0;
948 pfile->file_hash_entries_allocated = 127;
949 pfile->file_hash_entries = XNEWVEC (struct file_hash_entry,
950 pfile->file_hash_entries_allocated);
953 /* Return a new file hash entry. */
954 static struct file_hash_entry *
955 new_file_hash_entry (cpp_reader *pfile)
957 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
958 allocate_file_hash_entries (pfile);
960 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
963 /* Returns TRUE if a file FNAME has ever been successfully opened.
964 This routine is not intended to correctly handle filenames aliased
965 by links or redundant . or .. traversals etc. */
967 cpp_included (cpp_reader *pfile, const char *fname)
969 struct file_hash_entry *entry;
971 entry = (struct file_hash_entry *)
972 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
974 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
977 return entry != NULL;
980 /* Calculate the hash value of a file hash entry P. */
983 file_hash_hash (const void *p)
985 struct file_hash_entry *entry = (struct file_hash_entry *) p;
987 if (entry->start_dir)
988 hname = entry->u.file->name;
990 hname = entry->u.dir->name;
992 return htab_hash_string (hname);
995 /* Compare a string Q against a file hash entry P. */
997 file_hash_eq (const void *p, const void *q)
999 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1000 const char *fname = (const char *) q;
1003 if (entry->start_dir)
1004 hname = entry->u.file->name;
1006 hname = entry->u.dir->name;
1008 return strcmp (hname, fname) == 0;
1011 /* Initialize everything in this source file. */
1013 _cpp_init_files (cpp_reader *pfile)
1015 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1016 NULL, xcalloc, free);
1017 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1018 NULL, xcalloc, free);
1019 allocate_file_hash_entries (pfile);
1022 /* Finalize everything in this source file. */
1024 _cpp_cleanup_files (cpp_reader *pfile)
1026 htab_delete (pfile->file_hash);
1027 htab_delete (pfile->dir_hash);
1030 /* Enter a file name in the hash for the sake of cpp_included. */
1032 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1034 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1037 /* Not everyone who wants to set system-header-ness on a buffer can
1038 see the details of a buffer. This is an exported interface because
1039 fix-header needs it. */
1041 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1044 const struct line_maps *line_table = pfile->line_table;
1045 const struct line_map *map = &line_table->maps[line_table->used-1];
1047 /* 1 = system header, 2 = system header to be treated as C. */
1049 flags = 1 + (externc != 0);
1050 pfile->buffer->sysp = flags;
1051 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1052 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1055 /* Allow the client to change the current file. Used by the front end
1056 to achieve pseudo-file names like <built-in>.
1057 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1059 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1060 const char *new_name)
1062 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1065 /* Callback function for htab_traverse. */
1067 report_missing_guard (void **slot, void *b)
1069 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1070 int *bannerp = (int *) b;
1072 /* Skip directories. */
1073 if (entry->start_dir != NULL)
1075 _cpp_file *file = entry->u.file;
1077 /* We don't want MI guard advice for the main file. */
1078 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1082 fputs (_("Multiple include guards may be useful for:\n"),
1087 fputs (entry->u.file->path, stderr);
1088 putc ('\n', stderr);
1095 /* Report on all files that might benefit from a multiple include guard.
1098 _cpp_report_missing_guards (cpp_reader *pfile)
1102 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1105 /* Locate HEADER, and determine whether it is newer than the current
1106 file. If it cannot be located or dated, return -1, if it is
1107 newer, return 1, otherwise 0. */
1109 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1113 struct cpp_dir *dir;
1115 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1119 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1129 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1132 /* Pushes the given file onto the buffer stack. Returns nonzero if
1135 cpp_push_include (cpp_reader *pfile, const char *fname)
1137 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1140 /* Do appropriate cleanup when a file INC's buffer is popped off the
1143 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1145 /* Record the inclusion-preventing macro, which could be NULL
1146 meaning no controlling macro. */
1147 if (pfile->mi_valid && file->cmacro == NULL)
1148 file->cmacro = pfile->mi_cmacro;
1150 /* Invalidate control macros in the #including file. */
1151 pfile->mi_valid = false;
1155 free ((void *) file->buffer);
1156 file->buffer = NULL;
1157 file->buffer_valid = false;
1161 /* Inteface to file statistics record in _cpp_file structure. */
1163 _cpp_get_file_stat (_cpp_file *file)
1168 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1169 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1170 directory of the including file.
1172 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1174 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1175 int quote_ignores_source_dir)
1177 pfile->quote_include = quote;
1178 pfile->bracket_include = quote;
1179 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1181 for (; quote; quote = quote->next)
1183 quote->name_map = NULL;
1184 quote->len = strlen (quote->name);
1185 if (quote == bracket)
1186 pfile->bracket_include = bracket;
1190 /* Append the file name to the directory to create the path, but don't
1191 turn / into // or // into ///; // may be a namespace escape. */
1193 append_file_to_dir (const char *fname, cpp_dir *dir)
1199 flen = strlen (fname);
1200 path = XNEWVEC (char, dlen + 1 + flen + 1);
1201 memcpy (path, dir->name, dlen);
1202 if (dlen && path[dlen - 1] != '/')
1204 memcpy (&path[dlen], fname, flen + 1);
1209 /* Read a space delimited string of unlimited length from a stdio
1212 read_filename_string (int ch, FILE *f)
1218 set = alloc = XNEWVEC (char, len + 1);
1219 if (! is_space (ch))
1222 while ((ch = getc (f)) != EOF && ! is_space (ch))
1224 if (set - alloc == len)
1227 alloc = XRESIZEVEC (char, alloc, len + 1);
1228 set = alloc + len / 2;
1238 /* Read the file name map file for DIR. */
1240 read_name_map (cpp_dir *dir)
1242 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1245 size_t len, count = 0, room = 9;
1248 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1249 memcpy (name, dir->name, len);
1250 if (len && name[len - 1] != '/')
1252 strcpy (name + len, FILE_NAME_MAP_FILE);
1253 f = fopen (name, "r");
1255 dir->name_map = XNEWVEC (const char *, room);
1257 /* Silently return NULL if we cannot open. */
1262 while ((ch = getc (f)) != EOF)
1269 if (count + 2 > room)
1272 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1275 dir->name_map[count] = read_filename_string (ch, f);
1276 while ((ch = getc (f)) != EOF && is_hspace (ch))
1279 to = read_filename_string (ch, f);
1280 if (IS_ABSOLUTE_PATH (to))
1281 dir->name_map[count + 1] = to;
1284 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1289 while ((ch = getc (f)) != '\n')
1297 /* Terminate the list of maps. */
1298 dir->name_map[count] = NULL;
1301 /* Remap a FILE's name based on the file_name_map, if any, for
1302 FILE->dir. If the file name has any directory separators,
1303 recursively check those directories too. */
1305 remap_filename (cpp_reader *pfile, _cpp_file *file)
1307 const char *fname, *p;
1318 read_name_map (dir);
1320 for (index = 0; dir->name_map[index]; index += 2)
1321 if (!strcmp (dir->name_map[index], fname))
1322 return xstrdup (dir->name_map[index + 1]);
1324 p = strchr (fname, '/');
1325 if (!p || p == fname)
1328 len = dir->len + (p - fname + 1);
1329 new_dir = XNEWVEC (char, len + 1);
1330 memcpy (new_dir, dir->name, dir->len);
1331 memcpy (new_dir + dir->len, fname, p - fname + 1);
1332 new_dir[len] = '\0';
1334 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1339 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1341 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1343 const char *saved_path = file->path;
1346 file->path = pchname;
1347 if (open_file (file))
1349 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1357 if (CPP_OPTION (pfile, print_include_names))
1360 for (i = 1; i < pfile->line_table->depth; i++)
1362 fprintf (stderr, "%c %s\n",
1363 valid ? '!' : 'x', pchname);
1367 file->path = saved_path;
1371 /* Get the path associated with the _cpp_file F. The path includes
1372 the base name from the include directive and the directory it was
1373 found in via the search path. */
1376 cpp_get_path (struct _cpp_file *f)
1381 /* Get the directory associated with the _cpp_file F. */
1384 cpp_get_dir (struct _cpp_file *f)
1389 /* Get the cpp_buffer currently associated with the cpp_reader
1393 cpp_get_buffer (cpp_reader *pfile)
1395 return pfile->buffer;
1398 /* Get the _cpp_file associated with the cpp_buffer B. */
1401 cpp_get_file (cpp_buffer *b)
1406 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1407 buffer is the buffer that included the given buffer. */
1410 cpp_get_prev (cpp_buffer *b)
1415 /* This data structure holds the list of header files that were seen
1416 while the PCH was being built. The 'entries' field is kept sorted
1417 in memcmp() order; yes, this means that on little-endian systems,
1418 it's sorted initially by the least-significant byte of 'size', but
1419 that's OK. The code does rely on having entries with the same size
1420 next to each other. */
1423 /* The size of this file. This is used to save running a MD5 checksum
1424 if the sizes don't match. */
1426 /* The MD5 checksum of this file. */
1427 unsigned char sum[16];
1428 /* Is this file to be included only once? */
1433 /* Number of pchf_entry structures. */
1436 /* Are there any values with once_only set?
1437 This is used as an optimisation, it means we don't have to search
1438 the structure if we're processing a regular #include. */
1439 bool have_once_only;
1441 struct pchf_entry entries[1];
1444 static struct pchf_data *pchf;
1446 /* A qsort ordering function for pchf_entry structures. */
1449 pchf_save_compare (const void *e1, const void *e2)
1451 return memcmp (e1, e2, sizeof (struct pchf_entry));
1454 /* Create and write to F a pchf_data structure. */
1457 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1460 struct pchf_data *result;
1464 for (f = pfile->all_files; f; f = f->next_file)
1467 result_size = (sizeof (struct pchf_data)
1468 + sizeof (struct pchf_entry) * (count - 1));
1469 result = XCNEWVAR (struct pchf_data, result_size);
1472 result->have_once_only = false;
1474 for (f = pfile->all_files; f; f = f->next_file)
1478 /* This should probably never happen, since if a read error occurred
1479 the PCH file shouldn't be written... */
1480 if (f->dont_read || f->err_no)
1483 if (f->stack_count == 0)
1486 count = result->count++;
1488 result->entries[count].once_only = f->once_only;
1489 /* |= is avoided in the next line because of an HP C compiler bug */
1490 result->have_once_only = result->have_once_only | f->once_only;
1491 if (f->buffer_valid)
1492 md5_buffer ((const char *)f->buffer,
1493 f->st.st_size, result->entries[count].sum);
1501 open_file_failed (pfile, f, 0);
1504 ff = fdopen (f->fd, "rb");
1505 md5_stream (ff, result->entries[count].sum);
1509 result->entries[count].size = f->st.st_size;
1512 result_size = (sizeof (struct pchf_data)
1513 + sizeof (struct pchf_entry) * (result->count - 1));
1515 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1518 return fwrite (result, result_size, 1, fp) == 1;
1521 /* Read the pchf_data structure from F. */
1524 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1528 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1532 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1533 + sizeof (struct pchf_entry) * (d.count - 1));
1534 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1535 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1541 /* The parameters for pchf_compare. */
1543 struct pchf_compare_data
1545 /* The size of the file we're looking for. */
1548 /* The MD5 checksum of the file, if it's been computed. */
1549 unsigned char sum[16];
1554 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1555 bool check_included;
1557 /* The file that we're searching for. */
1561 /* bsearch comparison function; look for D_P in E_P. */
1564 pchf_compare (const void *d_p, const void *e_p)
1566 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1567 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1570 result = memcmp (&d->size, &e->size, sizeof (off_t));
1574 if (! d->sum_computed)
1576 _cpp_file *const f = d->f;
1578 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1579 d->sum_computed = true;
1582 result = memcmp (d->sum, e->sum, 16);
1586 if (d->check_included || e->once_only)
1592 /* Check that F is not in a list read from a PCH file (if any).
1593 Assumes that f->buffer_valid is true. Return TRUE if the file
1594 should not be read. */
1597 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1599 bool check_included)
1601 struct pchf_compare_data d;
1604 || (! check_included && ! pchf->have_once_only))
1607 d.size = f->st.st_size;
1608 d.sum_computed = false;
1610 d.check_included = check_included;
1611 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1612 pchf_compare) != NULL;