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 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
7 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 Reimplemented, Neil Booth, Jul 2003
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
39 # define STAT_SIZE_RELIABLE(ST) true
43 /* For DJGPP redirected input is opened in text mode. */
44 # define set_stdin_to_binary_mode() \
45 if (! isatty (0)) setmode (0, O_BINARY)
47 # define set_stdin_to_binary_mode() /* Nothing */
50 /* This structure represents a file searched for by CPP, whether it
51 exists or not. An instance may be pointed to by more than one
52 file_hash_entry; at present no reference count is kept. */
55 /* Filename as given to #include or command line switch. */
58 /* The full path used to find the file. */
61 /* The full path of the pch file. */
64 /* The file's path with the basename stripped. NULL if it hasn't
65 been calculated yet. */
68 /* Chain through all files. */
69 struct _cpp_file *next_file;
71 /* The contents of NAME after calling read_file(). */
74 /* The macro, if any, preventing re-inclusion. */
75 const cpp_hashnode *cmacro;
77 /* The directory in the search path where FILE was found. Used for
78 #include_next and determining whether a header is a system
82 /* As filled in by stat(2) for the file. */
85 /* File descriptor. Invalid if -1, otherwise open. */
88 /* Zero if this file was successfully opened and stat()-ed,
89 otherwise errno obtained from failure. */
92 /* Number of times the file has been stacked for preprocessing. */
93 unsigned short stack_count;
95 /* If opened with #import or contains #pragma once. */
98 /* If read() failed before. */
101 /* If this file is the main file. */
104 /* If BUFFER above contains the true contents of the file. */
107 /* File is a PCH (on return from find_include_file). */
111 /* A singly-linked list for all searches for a given file name, with
112 its head pointed to by a slot in FILE_HASH. The file name is what
113 appeared between the quotes in a #include directive; it can be
114 determined implicitly from the hash table location or explicitly
117 FILE is a structure containing details about the file that was
118 found with that search, or details of how the search failed.
120 START_DIR is the starting location of the search in the include
121 chain. The current directories for "" includes are also hashed in
122 the hash table and therefore unique. Files that are looked up
123 without using a search path, such as absolute filenames and file
124 names from the command line share a special starting directory so
125 they don't cause cache hits with normal include-chain lookups.
127 If START_DIR is NULL then the entry is for a directory, not a file,
128 and the directory is in DIR. Since the starting point in a file
129 lookup chain is never NULL, this means that simple pointer
130 comparisons against START_DIR can be made to determine cache hits
133 If a cache lookup fails because of e.g. an extra "./" in the path,
134 then nothing will break. It is just less efficient as CPP will
135 have to do more work re-preprocessing the file, and/or comparing
136 its contents against earlier once-only files.
138 struct file_hash_entry
140 struct file_hash_entry *next;
149 static bool open_file (_cpp_file *file);
150 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
152 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
154 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
155 static bool read_file (cpp_reader *pfile, _cpp_file *file);
156 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
157 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
158 int angle_brackets, enum include_type);
159 static const char *dir_name_of_file (_cpp_file *file);
160 static void open_file_failed (cpp_reader *pfile, _cpp_file *file);
161 static struct file_hash_entry *search_cache (cpp_reader *pfile,
162 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 cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
166 static void allocate_file_hash_entries (cpp_reader *pfile);
167 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
168 static int report_missing_guard (void **slot, void *b);
169 static hashval_t file_hash_hash (const void *p);
170 static int file_hash_eq (const void *p, const void *q);
171 static char *read_filename_string (int ch, FILE *f);
172 static void read_name_map (cpp_dir *dir);
173 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
174 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
175 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
176 static int pchf_adder (void **slot, void *data);
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 = xmalloc (len);
259 memcpy (pchname, path, flen);
260 memcpy (pchname + flen, extension, sizeof (extension));
262 if (stat (pchname, &st) == 0)
266 size_t dlen, plen = len;
268 if (!S_ISDIR (st.st_mode))
269 valid = validate_pch (pfile, file, pchname);
270 else if ((pchdir = opendir (pchname)) != NULL)
272 pchname[plen - 1] = '/';
273 while ((d = readdir (pchdir)) != NULL)
275 dlen = strlen (d->d_name) + 1;
276 if ((strcmp (d->d_name, ".") == 0)
277 || (strcmp (d->d_name, "..") == 0))
279 if (dlen + plen > len)
282 pchname = xrealloc (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);
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)
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 (pfile, *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))
428 open_file_failed (pfile, file);
431 cpp_error (pfile, CPP_DL_ERROR,
432 "one or more PCH files were found, but they were invalid");
433 if (!cpp_get_options (pfile)->warn_invalid_pch)
434 cpp_error (pfile, CPP_DL_ERROR,
435 "use -Winvalid-pch for more information");
443 /* Cache for START_DIR too, sharing the _cpp_file structure. */
444 free ((char *) file->name);
446 file = entry->u.file;
450 /* This is a new file; put it in the list. */
451 file->next_file = pfile->all_files;
452 pfile->all_files = file;
455 /* If this file was found in the directory-of-the-current-file,
456 check whether that directory is reachable via one of the normal
457 search paths. If so, we must record this entry as being
458 reachable that way, otherwise we will mistakenly reprocess this
459 file if it is included later from the normal search path. */
460 if (file->dir && start_dir->next == pfile->quote_include)
463 cpp_dir *proper_start_dir = pfile->quote_include;
465 for (d = proper_start_dir;; d = d->next)
467 if (d == pfile->bracket_include)
468 proper_start_dir = d;
471 proper_start_dir = 0;
474 /* file->dir->name will have a trailing slash. */
475 if (!strncmp (d->name, file->dir->name, file->dir->len - 1))
478 if (proper_start_dir)
479 start_dir = proper_start_dir;
482 /* Store this new result in the hash table. */
483 entry = new_file_hash_entry (pfile);
484 entry->next = *hash_slot;
485 entry->start_dir = start_dir;
486 entry->u.file = file;
492 /* Read a file into FILE->buffer, returning true on success.
494 If FILE->fd is something weird, like a block device, we don't want
495 to read it at all. Don't even try to figure out what something is,
496 except for plain files and block devices, since there is no
497 reliable portable way of doing this.
499 FIXME: Flush file cache and try again if we run out of memory. */
501 read_file_guts (cpp_reader *pfile, _cpp_file *file)
503 ssize_t size, total, count;
507 if (S_ISBLK (file->st.st_mode))
509 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
513 regular = S_ISREG (file->st.st_mode);
516 /* off_t might have a wider range than ssize_t - in other words,
517 the max size of a file might be bigger than the address
518 space. We can't handle a file that large. (Anyone with
519 a single source file bigger than 2GB needs to rethink
520 their coding style.) Some systems (e.g. AIX 4.1) define
521 SSIZE_MAX to be much smaller than the actual range of the
522 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
524 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
526 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
530 size = file->st.st_size;
533 /* 8 kilobytes is a sensible starting size. It ought to be bigger
534 than the kernel pipe buffer, and it's definitely bigger than
535 the majority of C source files. */
538 buf = xmalloc (size + 1);
540 while ((count = read (file->fd, buf + total, size - total)) > 0)
549 buf = xrealloc (buf, size + 1);
555 cpp_errno (pfile, CPP_DL_ERROR, file->path);
559 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
560 cpp_error (pfile, CPP_DL_WARNING,
561 "%s is shorter than expected", file->path);
563 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
564 buf, size, total, &file->st.st_size);
565 file->buffer_valid = true;
570 /* Convenience wrapper around read_file_guts that opens the file if
571 necessary and closes the file descriptor after reading. FILE must
572 have been passed through find_file() at some stage. */
574 read_file (cpp_reader *pfile, _cpp_file *file)
576 /* If we already have its contents in memory, succeed immediately. */
577 if (file->buffer_valid)
580 /* If an earlier read failed for some reason don't try again. */
581 if (file->dont_read || file->err_no)
584 if (file->fd == -1 && !open_file (file))
586 open_file_failed (pfile, file);
590 file->dont_read = !read_file_guts (pfile, file);
594 return !file->dont_read;
597 /* Returns TRUE if FILE's contents have been successfully placed in
598 FILE->buffer and the file should be stacked, otherwise false. */
600 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
604 /* Skip once-only files. */
608 /* We must mark the file once-only if #import now, before header
609 guard checks. Otherwise, undefining the header guard might
610 cause the file to be re-stacked. */
613 _cpp_mark_file_once_only (pfile, file);
615 /* Don't stack files that have been stacked before. */
616 if (file->stack_count)
620 /* Skip if the file had a header guard and the macro is defined.
621 PCH relies on this appearing before the PCH handler below. */
622 if (file->cmacro && file->cmacro->type == NT_MACRO)
625 /* Handle PCH files immediately; don't stack them. */
628 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
634 if (!read_file (pfile, file))
637 /* Check the file against the PCH file. This is done before
638 checking against files we've already seen, since it may save on
640 if (check_file_against_entries (pfile, file, import))
642 /* If this isn't a #import, but yet we can't include the file,
643 that means that it was #import-ed in the PCH file,
644 so we can never include it again. */
646 _cpp_mark_file_once_only (pfile, file);
650 /* Now we've read the file's contents, we can stack it if there
651 are no once-only files. */
652 if (!pfile->seen_once_only)
655 /* We may have read the file under a different name. Look
656 for likely candidates and compare file contents to be sure. */
657 for (f = pfile->all_files; f; f = f->next_file)
662 if ((import || f->once_only)
664 && f->st.st_mtime == file->st.st_mtime
665 && f->st.st_size == file->st.st_size
666 && read_file (pfile, f)
667 /* Size might have changed in read_file(). */
668 && f->st.st_size == file->st.st_size
669 && !memcmp (f->buffer, file->buffer, f->st.st_size))
676 /* Place the file referenced by FILE into a new buffer on the buffer
677 stack if possible. IMPORT is true if this stacking attempt is
678 because of a #import directive. Returns true if a buffer is
681 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
686 if (!should_stack_file (pfile, file, import))
689 if (pfile->buffer == NULL || file->dir == NULL)
692 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
694 /* Add the file to the dependencies on its first inclusion. */
695 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
697 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
698 deps_add_dep (pfile->deps, file->path);
701 /* Clear buffer_valid since _cpp_clean_line messes it up. */
702 file->buffer_valid = false;
705 /* Stack the buffer. */
706 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
707 CPP_OPTION (pfile, preprocessed));
711 /* Initialize controlling macro state. */
712 pfile->mi_valid = true;
713 pfile->mi_cmacro = 0;
715 /* Generate the call back. */
716 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
721 /* Mark FILE to be included once only. */
723 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
725 pfile->seen_once_only = true;
726 file->once_only = true;
729 /* Return the directory from which searching for FNAME should start,
730 considering the directive TYPE and ANGLE_BRACKETS. If there is
731 nothing left in the path, returns NULL. */
732 static struct cpp_dir *
733 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
734 enum include_type type)
739 if (IS_ABSOLUTE_PATH (fname))
740 return &pfile->no_search_path;
742 /* pfile->buffer is NULL when processing an -include command-line flag. */
743 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
745 /* For #include_next, skip in the search path past the dir in which
746 the current file was found, but if it was found via an absolute
747 path use the normal search logic. */
748 if (type == IT_INCLUDE_NEXT && file->dir)
749 dir = file->dir->next;
750 else if (angle_brackets)
751 dir = pfile->bracket_include;
752 else if (type == IT_CMDLINE)
753 /* -include and -imacros use the #include "" chain with the
754 preprocessor's cwd prepended. */
755 return make_cpp_dir (pfile, "./", false);
756 else if (pfile->quote_ignores_source_dir)
757 dir = pfile->quote_include;
759 return make_cpp_dir (pfile, dir_name_of_file (file),
760 pfile->buffer ? pfile->buffer->sysp : 0);
763 cpp_error (pfile, CPP_DL_ERROR,
764 "no include path in which to search for %s", fname);
769 /* Strip the basename from the file's path. It ends with a slash if
770 of nonzero length. Note that this procedure also works for
771 <stdin>, which is represented by the empty string. */
773 dir_name_of_file (_cpp_file *file)
777 size_t len = lbasename (file->path) - file->path;
778 char *dir_name = xmalloc (len + 1);
780 memcpy (dir_name, file->path, len);
781 dir_name[len] = '\0';
782 file->dir_name = dir_name;
785 return file->dir_name;
788 /* Handles #include-family directives (distinguished by TYPE),
789 including HEADER, and the command line -imacros and -include.
790 Returns true if a buffer was stacked. */
792 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
793 enum include_type type)
798 dir = search_path_head (pfile, fname, angle_brackets, type);
802 file = _cpp_find_file (pfile, fname, dir, false);
804 /* Compensate for the increment in linemap_add. In the case of a
805 normal #include, we're currently at the start of the line
806 *following* the #include. A separate source_location for this
807 location makes no sense (until we do the LC_LEAVE), and
808 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
809 found a PCH file (in which case linemap_add is not called) or we
810 were included from the command-line. */
811 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
812 pfile->line_table->highest_location--;
814 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
817 /* Could not open FILE. The complication is dependency output. */
819 open_file_failed (cpp_reader *pfile, _cpp_file *file)
821 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
822 bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
824 errno = file->err_no;
825 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
826 deps_add_dep (pfile->deps, file->name);
829 /* If we are outputting dependencies but not for this file then
830 don't error because we can still produce correct output. */
831 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
832 cpp_errno (pfile, CPP_DL_WARNING, file->path);
834 cpp_errno (pfile, CPP_DL_ERROR, file->path);
838 /* Search in the chain beginning at HEAD for a file whose search path
839 started at START_DIR != NULL. */
840 static struct file_hash_entry *
841 search_cache (cpp_reader *pfile, struct file_hash_entry *head,
842 const cpp_dir *start_dir)
844 struct file_hash_entry *p;
846 /* Look for a file that was found from a search starting at the
848 for (p = head; p; p = p->next)
849 if (p->start_dir == start_dir)
852 /* If the given location is for a search of the directory containing
853 the current file, check for a match starting at the base of the
854 quoted include chain. */
855 if (start_dir->next == pfile->quote_include)
857 start_dir = pfile->quote_include;
858 for (p = head; p; p = p->next)
859 if (p->start_dir == start_dir)
863 /* If the given location is for a search from the base of the quoted
864 include chain, check for a match starting at the base of the
865 bracket include chain. */
866 if (start_dir == pfile->quote_include)
868 start_dir = pfile->bracket_include;
869 for (p = head; p; p = p->next)
870 if (p->start_dir == start_dir)
877 /* Allocate a new _cpp_file structure. */
879 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
883 file = xcalloc (1, sizeof (_cpp_file));
884 file->main_file = !pfile->buffer;
887 file->name = xstrdup (fname);
892 /* A hash of directory names. The directory names are the path names
893 of files which contain a #include "", the included file name is
894 appended to this directories.
896 To avoid duplicate entries we follow the convention that all
897 non-empty directory names should end in a '/'. DIR_NAME must be
898 stored in permanently allocated memory. */
900 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
902 struct file_hash_entry *entry, **hash_slot;
905 hash_slot = (struct file_hash_entry **)
906 htab_find_slot_with_hash (pfile->file_hash, dir_name,
907 htab_hash_string (dir_name),
910 /* Have we already hashed this directory? */
911 for (entry = *hash_slot; entry; entry = entry->next)
912 if (entry->start_dir == NULL)
915 dir = xcalloc (1, sizeof (cpp_dir));
916 dir->next = pfile->quote_include;
917 dir->name = (char *) dir_name;
918 dir->len = strlen (dir_name);
922 /* Store this new result in the hash table. */
923 entry = new_file_hash_entry (pfile);
924 entry->next = *hash_slot;
925 entry->start_dir = NULL;
932 /* Create a new block of memory for file hash entries. */
934 allocate_file_hash_entries (cpp_reader *pfile)
936 pfile->file_hash_entries_used = 0;
937 pfile->file_hash_entries_allocated = 127;
938 pfile->file_hash_entries = xmalloc
939 (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
942 /* Return a new file hash entry. */
943 static struct file_hash_entry *
944 new_file_hash_entry (cpp_reader *pfile)
946 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
947 allocate_file_hash_entries (pfile);
949 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
952 /* Returns TRUE if a file FNAME has ever been successfully opened.
953 This routine is not intended to correctly handle filenames aliased
954 by links or redundant . or .. traversals etc. */
956 cpp_included (cpp_reader *pfile, const char *fname)
958 struct file_hash_entry *entry;
960 entry = htab_find_with_hash (pfile->file_hash, fname,
961 htab_hash_string (fname));
963 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
966 return entry != NULL;
969 /* Calculate the hash value of a file hash entry P. */
972 file_hash_hash (const void *p)
974 struct file_hash_entry *entry = (struct file_hash_entry *) p;
976 if (entry->start_dir)
977 hname = entry->u.file->name;
979 hname = entry->u.dir->name;
981 return htab_hash_string (hname);
984 /* Compare a string Q against a file hash entry P. */
986 file_hash_eq (const void *p, const void *q)
988 struct file_hash_entry *entry = (struct file_hash_entry *) p;
989 const char *fname = (const char *) q;
992 if (entry->start_dir)
993 hname = entry->u.file->name;
995 hname = entry->u.dir->name;
997 return strcmp (hname, fname) == 0;
1000 /* Initialize everything in this source file. */
1002 _cpp_init_files (cpp_reader *pfile)
1004 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1005 NULL, xcalloc, free);
1006 allocate_file_hash_entries (pfile);
1009 /* Finalize everything in this source file. */
1011 _cpp_cleanup_files (cpp_reader *pfile)
1013 htab_delete (pfile->file_hash);
1016 /* Enter a file name in the hash for the sake of cpp_included. */
1018 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1020 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
1023 /* Not everyone who wants to set system-header-ness on a buffer can
1024 see the details of a buffer. This is an exported interface because
1025 fix-header needs it. */
1027 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1030 const struct line_maps *line_table = pfile->line_table;
1031 const struct line_map *map = &line_table->maps[line_table->used-1];
1033 /* 1 = system header, 2 = system header to be treated as C. */
1035 flags = 1 + (externc != 0);
1036 pfile->buffer->sysp = flags;
1037 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1038 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1041 /* Allow the client to change the current file. Used by the front end
1042 to achieve pseudo-file names like <built-in>.
1043 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1045 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1046 const char *new_name)
1048 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1051 /* Callback function for htab_traverse. */
1053 report_missing_guard (void **slot, void *b)
1055 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1056 int *bannerp = (int *) b;
1058 /* Skip directories. */
1059 if (entry->start_dir != NULL)
1061 _cpp_file *file = entry->u.file;
1063 /* We don't want MI guard advice for the main file. */
1064 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1068 fputs (_("Multiple include guards may be useful for:\n"),
1073 fputs (entry->u.file->path, stderr);
1074 putc ('\n', stderr);
1081 /* Report on all files that might benefit from a multiple include guard.
1084 _cpp_report_missing_guards (cpp_reader *pfile)
1088 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1091 /* Locate HEADER, and determine whether it is newer than the current
1092 file. If it cannot be located or dated, return -1, if it is
1093 newer, return 1, otherwise 0. */
1095 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1099 struct cpp_dir *dir;
1101 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1105 file = _cpp_find_file (pfile, fname, dir, false);
1115 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1118 /* Pushes the given file onto the buffer stack. Returns nonzero if
1121 cpp_push_include (cpp_reader *pfile, const char *fname)
1123 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1126 /* Do appropriate cleanup when a file INC's buffer is popped off the
1129 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1131 /* Record the inclusion-preventing macro, which could be NULL
1132 meaning no controlling macro. */
1133 if (pfile->mi_valid && file->cmacro == NULL)
1134 file->cmacro = pfile->mi_cmacro;
1136 /* Invalidate control macros in the #including file. */
1137 pfile->mi_valid = false;
1141 free ((void *) file->buffer);
1142 file->buffer = NULL;
1146 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1147 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1148 directory of the including file.
1150 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1152 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1153 int quote_ignores_source_dir)
1155 pfile->quote_include = quote;
1156 pfile->bracket_include = quote;
1157 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1159 for (; quote; quote = quote->next)
1161 quote->name_map = NULL;
1162 quote->len = strlen (quote->name);
1163 if (quote == bracket)
1164 pfile->bracket_include = bracket;
1168 /* Append the file name to the directory to create the path, but don't
1169 turn / into // or // into ///; // may be a namespace escape. */
1171 append_file_to_dir (const char *fname, cpp_dir *dir)
1177 flen = strlen (fname);
1178 path = xmalloc (dlen + 1 + flen + 1);
1179 memcpy (path, dir->name, dlen);
1180 if (dlen && path[dlen - 1] != '/')
1182 memcpy (&path[dlen], fname, flen + 1);
1187 /* Read a space delimited string of unlimited length from a stdio
1190 read_filename_string (int ch, FILE *f)
1196 set = alloc = xmalloc (len + 1);
1197 if (! is_space (ch))
1200 while ((ch = getc (f)) != EOF && ! is_space (ch))
1202 if (set - alloc == len)
1205 alloc = xrealloc (alloc, len + 1);
1206 set = alloc + len / 2;
1216 /* Read the file name map file for DIR. */
1218 read_name_map (cpp_dir *dir)
1220 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1223 size_t len, count = 0, room = 9;
1226 name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1227 memcpy (name, dir->name, len);
1228 if (len && name[len - 1] != '/')
1230 strcpy (name + len, FILE_NAME_MAP_FILE);
1231 f = fopen (name, "r");
1233 dir->name_map = xmalloc (room * sizeof (char *));
1235 /* Silently return NULL if we cannot open. */
1240 while ((ch = getc (f)) != EOF)
1247 if (count + 2 > room)
1250 dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1253 dir->name_map[count] = read_filename_string (ch, f);
1254 while ((ch = getc (f)) != EOF && is_hspace (ch))
1257 to = read_filename_string (ch, f);
1258 if (IS_ABSOLUTE_PATH (to))
1259 dir->name_map[count + 1] = to;
1262 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1267 while ((ch = getc (f)) != '\n')
1275 /* Terminate the list of maps. */
1276 dir->name_map[count] = NULL;
1279 /* Remap a FILE's name based on the file_name_map, if any, for
1280 FILE->dir. If the file name has any directory separators,
1281 recursively check those directories too. */
1283 remap_filename (cpp_reader *pfile, _cpp_file *file)
1285 const char *fname, *p;
1296 read_name_map (dir);
1298 for (index = 0; dir->name_map[index]; index += 2)
1299 if (!strcmp (dir->name_map[index], fname))
1300 return xstrdup (dir->name_map[index + 1]);
1302 p = strchr (fname, '/');
1303 if (!p || p == fname)
1306 len = dir->len + (p - fname + 1);
1307 new_dir = xmalloc (len + 1);
1308 memcpy (new_dir, dir->name, dir->len);
1309 memcpy (new_dir + dir->len, fname, p - fname + 1);
1310 new_dir[len] = '\0';
1312 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1317 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1319 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1321 const char *saved_path = file->path;
1324 file->path = pchname;
1325 if (open_file (file))
1327 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1335 if (CPP_OPTION (pfile, print_include_names))
1338 for (i = 1; i < pfile->line_table->depth; i++)
1340 fprintf (stderr, "%c %s\n",
1341 valid ? '!' : 'x', pchname);
1345 file->path = saved_path;
1349 /* Get the path associated with the _cpp_file F. The path includes
1350 the base name from the include directive and the directory it was
1351 found in via the search path. */
1354 cpp_get_path (struct _cpp_file *f)
1359 /* Get the directory associated with the _cpp_file F. */
1362 cpp_get_dir (struct _cpp_file *f)
1367 /* Get the cpp_buffer currently associated with the cpp_reader
1371 cpp_get_buffer (cpp_reader *pfile)
1373 return pfile->buffer;
1376 /* Get the _cpp_file associated with the cpp_buffer B. */
1379 cpp_get_file (cpp_buffer *b)
1384 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1385 buffer is the buffer that included the given buffer. */
1388 cpp_get_prev (cpp_buffer *b)
1393 /* This data structure holds the list of header files that were seen
1394 while the PCH was being built. The 'entries' field is kept sorted
1395 in memcmp() order; yes, this means that on little-endian systems,
1396 it's sorted initially by the least-significant byte of 'size', but
1397 that's OK. The code does rely on having entries with the same size
1398 next to each other. */
1401 /* Number of pchf_entry structures. */
1404 /* Are there any values with once_only set?
1405 This is used as an optimisation, it means we don't have to search
1406 the structure if we're processing a regular #include. */
1407 bool have_once_only;
1410 /* The size of this file. This is used to save running a MD5 checksum
1411 if the sizes don't match. */
1413 /* The MD5 checksum of this file. */
1414 unsigned char sum[16];
1415 /* Is this file to be included only once? */
1420 static struct pchf_data *pchf;
1422 /* Data for pchf_addr. */
1423 struct pchf_adder_info
1426 struct pchf_data *d;
1429 /* A hash traversal function to add entries into DATA->D. */
1432 pchf_adder (void **slot, void *data)
1434 struct file_hash_entry *h = (struct file_hash_entry *) *slot;
1435 struct pchf_adder_info *i = (struct pchf_adder_info *) data;
1437 if (h->start_dir != NULL && h->u.file->stack_count != 0)
1439 struct pchf_data *d = i->d;
1440 _cpp_file *f = h->u.file;
1441 size_t count = d->count++;
1443 /* This should probably never happen, since if a read error occurred
1444 the PCH file shouldn't be written... */
1445 if (f->dont_read || f->err_no)
1448 d->entries[count].once_only = f->once_only;
1449 /* |= is avoided in the next line because of an HP C compiler bug */
1450 d->have_once_only = d->have_once_only | f->once_only;
1451 if (f->buffer_valid)
1452 md5_buffer ((const char *)f->buffer,
1453 f->st.st_size, d->entries[count].sum);
1461 open_file_failed (i->pfile, f);
1464 ff = fdopen (f->fd, "rb");
1465 md5_stream (ff, d->entries[count].sum);
1469 d->entries[count].size = f->st.st_size;
1474 /* A qsort ordering function for pchf_entry structures. */
1477 pchf_save_compare (const void *e1, const void *e2)
1479 return memcmp (e1, e2, sizeof (struct pchf_entry));
1482 /* Create and write to F a pchf_data structure. */
1485 _cpp_save_file_entries (cpp_reader *pfile, FILE *f)
1488 struct pchf_data *result;
1490 struct pchf_adder_info pai;
1492 count = htab_elements (pfile->file_hash);
1493 result_size = (sizeof (struct pchf_data)
1494 + sizeof (struct pchf_entry) * (count - 1));
1495 result = xcalloc (result_size, 1);
1498 result->have_once_only = false;
1502 htab_traverse (pfile->file_hash, pchf_adder, &pai);
1504 result_size = (sizeof (struct pchf_data)
1505 + sizeof (struct pchf_entry) * (result->count - 1));
1507 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1510 return fwrite (result, result_size, 1, f) == 1;
1513 /* Read the pchf_data structure from F. */
1516 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1520 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1524 pchf = xmalloc (sizeof (struct pchf_data)
1525 + sizeof (struct pchf_entry) * (d.count - 1));
1526 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1527 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1533 /* The parameters for pchf_compare. */
1535 struct pchf_compare_data
1537 /* The size of the file we're looking for. */
1540 /* The MD5 checksum of the file, if it's been computed. */
1541 unsigned char sum[16];
1546 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1547 bool check_included;
1549 /* The file that we're searching for. */
1553 /* bsearch comparison function; look for D_P in E_P. */
1556 pchf_compare (const void *d_p, const void *e_p)
1558 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1559 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1562 result = memcmp (&d->size, &e->size, sizeof (off_t));
1566 if (! d->sum_computed)
1568 _cpp_file *const f = d->f;
1570 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1571 d->sum_computed = true;
1574 result = memcmp (d->sum, e->sum, 16);
1578 if (d->check_included || e->once_only)
1584 /* Check that F is not in a list read from a PCH file (if any).
1585 Assumes that f->buffer_valid is true. Return TRUE if the file
1586 should not be read. */
1589 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1591 bool check_included)
1593 struct pchf_compare_data d;
1596 || (! check_included && ! pchf->have_once_only))
1599 d.size = f->st.st_size;
1600 d.sum_computed = false;
1602 d.check_included = check_included;
1603 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1604 pchf_compare) != NULL;