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. */
34 /* Variable length record files on VMS will have a stat size that includes
35 record control characters that won't be included in the read size. */
37 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
38 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
40 # 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 */
55 /* This structure represents a file searched for by CPP, whether it
56 exists or not. An instance may be pointed to by more than one
57 file_hash_entry; at present no reference count is kept. */
60 /* Filename as given to #include or command line switch. */
63 /* The full path used to find the file. */
66 /* The full path of the pch file. */
69 /* The file's path with the basename stripped. NULL if it hasn't
70 been calculated yet. */
73 /* Chain through all files. */
74 struct _cpp_file *next_file;
76 /* The contents of NAME after calling read_file(). */
79 /* The macro, if any, preventing re-inclusion. */
80 const cpp_hashnode *cmacro;
82 /* The directory in the search path where FILE was found. Used for
83 #include_next and determining whether a header is a system
87 /* As filled in by stat(2) for the file. */
90 /* File descriptor. Invalid if -1, otherwise open. */
93 /* Zero if this file was successfully opened and stat()-ed,
94 otherwise errno obtained from failure. */
97 /* Number of times the file has been stacked for preprocessing. */
98 unsigned short stack_count;
100 /* If opened with #import or contains #pragma once. */
103 /* If read() failed before. */
106 /* If this file is the main file. */
109 /* If BUFFER above contains the true contents of the file. */
112 /* 0: file not known to be a PCH.
113 1: file is a PCH (on return from find_include_file).
114 2: file is not and never will be a valid precompiled header.
115 3: file is always a valid precompiled header. */
119 /* A singly-linked list for all searches for a given file name, with
120 its head pointed to by a slot in FILE_HASH. The file name is what
121 appeared between the quotes in a #include directive; it can be
122 determined implicitly from the hash table location or explicitly
125 FILE is a structure containing details about the file that was
126 found with that search, or details of how the search failed.
128 START_DIR is the starting location of the search in the include
129 chain. The current directories for "" includes are also hashed in
130 the hash table and therefore unique. Files that are looked up
131 without using a search path, such as absolute filenames and file
132 names from the command line share a special starting directory so
133 they don't cause cache hits with normal include-chain lookups.
135 If START_DIR is NULL then the entry is for a directory, not a file,
136 and the directory is in DIR. Since the starting point in a file
137 lookup chain is never NULL, this means that simple pointer
138 comparisons against START_DIR can be made to determine cache hits
141 If a cache lookup fails because of e.g. an extra "./" in the path,
142 then nothing will break. It is just less efficient as CPP will
143 have to do more work re-preprocessing the file, and/or comparing
144 its contents against earlier once-only files.
146 struct file_hash_entry
148 struct file_hash_entry *next;
157 static bool open_file (_cpp_file *file);
158 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
160 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
162 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
163 static bool read_file (cpp_reader *pfile, _cpp_file *file);
164 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
165 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
166 int angle_brackets, enum include_type);
167 static const char *dir_name_of_file (_cpp_file *file);
168 static void open_file_failed (cpp_reader *pfile, _cpp_file *file);
169 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
170 const cpp_dir *start_dir);
171 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
172 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
173 static void allocate_file_hash_entries (cpp_reader *pfile);
174 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
175 static int report_missing_guard (void **slot, void *b);
176 static hashval_t file_hash_hash (const void *p);
177 static int file_hash_eq (const void *p, const void *q);
178 static char *read_filename_string (int ch, FILE *f);
179 static void read_name_map (cpp_dir *dir);
180 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
181 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
182 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
183 static bool include_pch_p (_cpp_file *file);
184 static int pchf_adder (void **slot, void *data);
185 static int pchf_save_compare (const void *e1, const void *e2);
186 static int pchf_compare (const void *d_p, const void *e_p);
187 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
189 /* Given a filename in FILE->PATH, with the empty string interpreted
192 On success FILE contains an open file descriptor and stat
193 information for the file. On failure the file descriptor is -1 and
194 the appropriate errno is also stored in FILE. Returns TRUE iff
197 We used to open files in nonblocking mode, but that caused more
198 problems than it solved. Do take care not to acquire a controlling
199 terminal by mistake (this can't happen on sane systems, but
200 paranoia is a virtue).
202 Use the three-argument form of open even though we aren't
203 specifying O_CREAT, to defend against broken system headers.
205 O_BINARY tells some runtime libraries (notably DJGPP) not to do
206 newline translation; we can handle DOS line breaks just fine
209 open_file (_cpp_file *file)
211 if (file->path[0] == '\0')
214 set_stdin_to_binary_mode ();
217 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
221 if (fstat (file->fd, &file->st) == 0)
223 if (!S_ISDIR (file->st.st_mode))
229 /* Ignore a directory and continue the search. The file we're
230 looking for may be elsewhere in the search path. */
237 else if (errno == ENOTDIR)
240 file->err_no = errno;
245 /* Temporary PCH intercept of opening a file. Try to find a PCH file
246 based on FILE->name and FILE->dir, and test those found for
247 validity using PFILE->cb.valid_pch. Return true iff a valid file is
248 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
251 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
253 static const char extension[] = ".gch";
254 const char *path = file->path;
260 /* No PCH on <stdin> or if not requested. */
261 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
264 flen = strlen (path);
265 len = flen + sizeof (extension);
266 pchname = xmalloc (len);
267 memcpy (pchname, path, flen);
268 memcpy (pchname + flen, extension, sizeof (extension));
270 if (stat (pchname, &st) == 0)
274 size_t dlen, plen = len;
276 if (!S_ISDIR (st.st_mode))
277 valid = validate_pch (pfile, file, pchname);
278 else if ((pchdir = opendir (pchname)) != NULL)
280 pchname[plen - 1] = '/';
281 while ((d = readdir (pchdir)) != NULL)
283 dlen = strlen (d->d_name) + 1;
284 if ((strcmp (d->d_name, ".") == 0)
285 || (strcmp (d->d_name, "..") == 0))
287 if (dlen + plen > len)
290 pchname = xrealloc (pchname, len);
292 memcpy (pchname + plen, d->d_name, dlen);
293 valid = validate_pch (pfile, file, pchname);
306 file->pchname = pchname;
313 /* Try to open the path FILE->name appended to FILE->dir. This is
314 where remap and PCH intercept the file lookup process. Return true
315 if the file was found, whether or not the open was successful.
316 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
319 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
323 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
326 path = append_file_to_dir (file->name, file->dir);
329 if (pch_open_file (pfile, file, invalid_pch))
332 if (open_file (file))
335 if (file->err_no != ENOENT)
337 open_file_failed (pfile, file);
342 file->path = file->name;
347 _cpp_find_failed (_cpp_file *file)
349 return file->err_no != 0;
352 /* Given a filename FNAME search for such a file in the include path
353 starting from START_DIR. If FNAME is the empty string it is
354 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
356 If the file is not found in the file cache fall back to the O/S and
357 add the result to our cache.
359 If the file was not found in the filesystem, or there was an error
360 opening it, then ERR_NO is nonzero and FD is -1. If the file was
361 found, then ERR_NO is zero and FD could be -1 or an open file
362 descriptor. FD can be -1 if the file was found in the cache and
363 had previously been closed. To open it again pass the return value
367 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake)
369 struct file_hash_entry *entry, **hash_slot;
371 bool invalid_pch = false;
373 /* Ensure we get no confusion between cached files and directories. */
374 if (start_dir == NULL)
375 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
377 hash_slot = (struct file_hash_entry **)
378 htab_find_slot_with_hash (pfile->file_hash, fname,
379 htab_hash_string (fname),
382 /* First check the cache before we resort to memory allocation. */
383 entry = search_cache (*hash_slot, start_dir);
385 return entry->u.file;
387 file = make_cpp_file (pfile, start_dir, fname);
389 /* Try each path in the include chain. */
392 if (find_file_in_dir (pfile, file, &invalid_pch))
395 file->dir = file->dir->next;
396 if (file->dir == NULL)
398 open_file_failed (pfile, file);
401 cpp_error (pfile, CPP_DL_ERROR,
402 "one or more PCH files were found, but they were invalid");
403 if (!cpp_get_options (pfile)->warn_invalid_pch)
404 cpp_error (pfile, CPP_DL_ERROR,
405 "use -Winvalid-pch for more information");
410 /* Only check the cache for the starting location (done above)
411 and the quote and bracket chain heads because there are no
412 other possible starting points for searches. */
413 if (file->dir != pfile->bracket_include
414 && file->dir != pfile->quote_include)
417 entry = search_cache (*hash_slot, file->dir);
424 /* Cache for START_DIR too, sharing the _cpp_file structure. */
425 free ((char *) file->name);
427 file = entry->u.file;
431 /* This is a new file; put it in the list. */
432 file->next_file = pfile->all_files;
433 pfile->all_files = file;
436 /* Store this new result in the hash table. */
437 entry = new_file_hash_entry (pfile);
438 entry->next = *hash_slot;
439 entry->start_dir = start_dir;
440 entry->u.file = file;
446 /* Read a file into FILE->buffer, returning true on success.
448 If FILE->fd is something weird, like a block device, we don't want
449 to read it at all. Don't even try to figure out what something is,
450 except for plain files and block devices, since there is no
451 reliable portable way of doing this.
453 FIXME: Flush file cache and try again if we run out of memory. */
455 read_file_guts (cpp_reader *pfile, _cpp_file *file)
457 ssize_t size, total, count;
461 if (S_ISBLK (file->st.st_mode))
463 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
467 regular = S_ISREG (file->st.st_mode);
470 /* off_t might have a wider range than ssize_t - in other words,
471 the max size of a file might be bigger than the address
472 space. We can't handle a file that large. (Anyone with
473 a single source file bigger than 2GB needs to rethink
474 their coding style.) Some systems (e.g. AIX 4.1) define
475 SSIZE_MAX to be much smaller than the actual range of the
476 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
478 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
480 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
484 size = file->st.st_size;
487 /* 8 kilobytes is a sensible starting size. It ought to be bigger
488 than the kernel pipe buffer, and it's definitely bigger than
489 the majority of C source files. */
492 buf = xmalloc (size + 1);
494 while ((count = read (file->fd, buf + total, size - total)) > 0)
503 buf = xrealloc (buf, size + 1);
509 cpp_errno (pfile, CPP_DL_ERROR, file->path);
513 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
514 cpp_error (pfile, CPP_DL_WARNING,
515 "%s is shorter than expected", file->path);
517 /* Shrink buffer if we allocated substantially too much. */
518 if (total + 4096 < size)
519 buf = xrealloc (buf, total + 1);
521 /* The lexer requires that the buffer be \n-terminated. */
525 file->st.st_size = total;
526 file->buffer_valid = true;
531 /* Convenience wrapper around read_file_guts that opens the file if
532 necessary and closes the file descriptor after reading. FILE must
533 have been passed through find_file() at some stage. */
535 read_file (cpp_reader *pfile, _cpp_file *file)
537 /* If we already have its contents in memory, succeed immediately. */
538 if (file->buffer_valid)
541 /* If an earlier read failed for some reason don't try again. */
542 if (file->dont_read || file->err_no)
545 if (file->fd == -1 && !open_file (file))
547 open_file_failed (pfile, file);
551 file->dont_read = !read_file_guts (pfile, file);
555 return !file->dont_read;
558 /* Returns TRUE if FILE's contents have been successfully placed in
559 FILE->buffer and the file should be stacked, otherwise false. */
561 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
565 /* Skip once-only files. */
569 /* We must mark the file once-only if #import now, before header
570 guard checks. Otherwise, undefining the header guard might
571 cause the file to be re-stacked. */
574 _cpp_mark_file_once_only (pfile, file);
576 /* Don't stack files that have been stacked before. */
577 if (file->stack_count)
581 /* Skip if the file had a header guard and the macro is defined.
582 PCH relies on this appearing before the PCH handler below. */
583 if (file->cmacro && file->cmacro->type == NT_MACRO)
586 /* Handle PCH files immediately; don't stack them. */
587 if (include_pch_p (file))
589 pfile->cb.read_pch (pfile, file->path, file->fd, file->pchname);
595 if (!read_file (pfile, file))
598 /* Check the file against the PCH file. This is done before
599 checking against files we've already seen, since it may save on
601 if (check_file_against_entries (pfile, file, import))
603 /* If this isn't a #import, but yet we can't include the file,
604 that means that it was #import-ed in the PCH file,
605 so we can never include it again. */
607 _cpp_mark_file_once_only (pfile, file);
611 /* Now we've read the file's contents, we can stack it if there
612 are no once-only files. */
613 if (!pfile->seen_once_only)
616 /* We may have read the file under a different name. Look
617 for likely candidates and compare file contents to be sure. */
618 for (f = pfile->all_files; f; f = f->next_file)
623 if ((import || f->once_only)
625 && f->st.st_mtime == file->st.st_mtime
626 && f->st.st_size == file->st.st_size
627 && read_file (pfile, f)
628 /* Size might have changed in read_file(). */
629 && f->st.st_size == file->st.st_size
630 && !memcmp (f->buffer, file->buffer, f->st.st_size))
637 /* Place the file referenced by FILE into a new buffer on the buffer
638 stack if possible. IMPORT is true if this stacking attempt is
639 because of a #import directive. Returns true if a buffer is
642 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
647 if (!should_stack_file (pfile, file, import))
650 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
651 (file->dir ? file->dir->sysp : 0));
653 /* Add the file to the dependencies on its first inclusion. */
654 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
656 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
657 deps_add_dep (pfile->deps, file->path);
660 /* Clear buffer_valid since _cpp_clean_line messes it up. */
661 file->buffer_valid = false;
664 /* Stack the buffer. */
665 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
666 CPP_OPTION (pfile, preprocessed));
669 /* Initialize controlling macro state. */
670 pfile->mi_valid = true;
671 pfile->mi_cmacro = 0;
673 /* Generate the call back. */
674 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
679 /* Mark FILE to be included once only. */
681 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
683 pfile->seen_once_only = true;
684 file->once_only = true;
687 /* Return the directory from which searching for FNAME should start,
688 considering the directive TYPE and ANGLE_BRACKETS. If there is
689 nothing left in the path, returns NULL. */
690 static struct cpp_dir *
691 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
692 enum include_type type)
697 if (IS_ABSOLUTE_PATH (fname))
698 return &pfile->no_search_path;
700 /* pfile->buffer is NULL when processing an -include command-line flag. */
701 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
703 /* For #include_next, skip in the search path past the dir in which
704 the current file was found, but if it was found via an absolute
705 path use the normal search logic. */
706 if (type == IT_INCLUDE_NEXT && file->dir)
707 dir = file->dir->next;
708 else if (angle_brackets)
709 dir = pfile->bracket_include;
710 else if (type == IT_CMDLINE)
711 /* -include and -imacros use the #include "" chain with the
712 preprocessor's cwd prepended. */
713 return make_cpp_dir (pfile, "./", false);
714 else if (pfile->quote_ignores_source_dir)
715 dir = pfile->quote_include;
717 return make_cpp_dir (pfile, dir_name_of_file (file), pfile->map->sysp);
720 cpp_error (pfile, CPP_DL_ERROR,
721 "no include path in which to search for %s", fname);
726 /* Strip the basename from the file's path. It ends with a slash if
727 of nonzero length. Note that this procedure also works for
728 <stdin>, which is represented by the empty string. */
730 dir_name_of_file (_cpp_file *file)
734 size_t len = lbasename (file->path) - file->path;
735 char *dir_name = xmalloc (len + 1);
737 memcpy (dir_name, file->path, len);
738 dir_name[len] = '\0';
739 file->dir_name = dir_name;
742 return file->dir_name;
745 /* Handles #include-family directives (distinguished by TYPE),
746 including HEADER, and the command line -imacros and -include.
747 Returns true if a buffer was stacked. */
749 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
750 enum include_type type)
754 dir = search_path_head (pfile, fname, angle_brackets, type);
758 return _cpp_stack_file (pfile, _cpp_find_file (pfile, fname, dir, false),
762 /* Could not open FILE. The complication is dependency output. */
764 open_file_failed (cpp_reader *pfile, _cpp_file *file)
766 int sysp = pfile->map ? pfile->map->sysp: 0;
767 bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
769 errno = file->err_no;
770 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
771 deps_add_dep (pfile->deps, file->name);
774 /* If we are outputting dependencies but not for this file then
775 don't error because we can still produce correct output. */
776 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
777 cpp_errno (pfile, CPP_DL_WARNING, file->path);
779 cpp_errno (pfile, CPP_DL_ERROR, file->path);
783 /* Search in the chain beginning at HEAD for a file whose search path
784 started at START_DIR != NULL. */
785 static struct file_hash_entry *
786 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
788 while (head && head->start_dir != start_dir)
794 /* Allocate a new _cpp_file structure. */
796 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
800 file = xcalloc (1, sizeof (_cpp_file));
801 file->main_file = !pfile->buffer;
804 file->name = xstrdup (fname);
809 /* A hash of directory names. The directory names are the path names
810 of files which contain a #include "", the included file name is
811 appended to this directories.
813 To avoid duplicate entries we follow the convention that all
814 non-empty directory names should end in a '/'. DIR_NAME must be
815 stored in permanently allocated memory. */
817 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
819 struct file_hash_entry *entry, **hash_slot;
822 hash_slot = (struct file_hash_entry **)
823 htab_find_slot_with_hash (pfile->file_hash, dir_name,
824 htab_hash_string (dir_name),
827 /* Have we already hashed this directory? */
828 for (entry = *hash_slot; entry; entry = entry->next)
829 if (entry->start_dir == NULL)
832 dir = xcalloc (1, sizeof (cpp_dir));
833 dir->next = pfile->quote_include;
834 dir->name = (char *) dir_name;
835 dir->len = strlen (dir_name);
838 /* Store this new result in the hash table. */
839 entry = new_file_hash_entry (pfile);
840 entry->next = *hash_slot;
841 entry->start_dir = NULL;
848 /* Create a new block of memory for file hash entries. */
850 allocate_file_hash_entries (cpp_reader *pfile)
852 pfile->file_hash_entries_used = 0;
853 pfile->file_hash_entries_allocated = 127;
854 pfile->file_hash_entries = xmalloc
855 (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
858 /* Return a new file hash entry. */
859 static struct file_hash_entry *
860 new_file_hash_entry (cpp_reader *pfile)
862 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
863 allocate_file_hash_entries (pfile);
865 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
868 /* Returns TRUE if a file FNAME has ever been successfully opened.
869 This routine is not intended to correctly handle filenames aliased
870 by links or redundant . or .. traversals etc. */
872 cpp_included (cpp_reader *pfile, const char *fname)
874 struct file_hash_entry *entry;
876 entry = htab_find_with_hash (pfile->file_hash, fname,
877 htab_hash_string (fname));
879 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
882 return entry != NULL;
885 /* Calculate the hash value of a file hash entry P. */
888 file_hash_hash (const void *p)
890 struct file_hash_entry *entry = (struct file_hash_entry *) p;
892 if (entry->start_dir)
893 hname = entry->u.file->name;
895 hname = entry->u.dir->name;
897 return htab_hash_string (hname);
900 /* Compare a string Q against a file hash entry P. */
902 file_hash_eq (const void *p, const void *q)
904 struct file_hash_entry *entry = (struct file_hash_entry *) p;
905 const char *fname = (const char *) q;
908 if (entry->start_dir)
909 hname = entry->u.file->name;
911 hname = entry->u.dir->name;
913 return strcmp (hname, fname) == 0;
916 /* Initialize everything in this source file. */
918 _cpp_init_files (cpp_reader *pfile)
920 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
921 NULL, xcalloc, free);
922 allocate_file_hash_entries (pfile);
925 /* Finalize everything in this source file. */
927 _cpp_cleanup_files (cpp_reader *pfile)
929 htab_delete (pfile->file_hash);
932 /* Enter a file name in the hash for the sake of cpp_included. */
934 _cpp_fake_include (cpp_reader *pfile, const char *fname)
936 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
939 /* Not everyone who wants to set system-header-ness on a buffer can
940 see the details of a buffer. This is an exported interface because
941 fix-header needs it. */
943 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
947 /* 1 = system header, 2 = system header to be treated as C. */
949 flags = 1 + (externc != 0);
950 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
951 SOURCE_LINE (pfile->map, pfile->line), flags);
954 /* Allow the client to change the current file. Used by the front end
955 to achieve pseudo-file names like <built-in>.
956 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
958 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
959 const char *new_name)
961 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
964 /* Callback function for htab_traverse. */
966 report_missing_guard (void **slot, void *b)
968 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
969 int *bannerp = (int *) b;
971 /* Skip directories. */
972 if (entry->start_dir != NULL)
974 _cpp_file *file = entry->u.file;
976 /* We don't want MI guard advice for the main file. */
977 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
981 fputs (_("Multiple include guards may be useful for:\n"),
986 fputs (entry->u.file->path, stderr);
994 /* Report on all files that might benefit from a multiple include guard.
997 _cpp_report_missing_guards (cpp_reader *pfile)
1001 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1004 /* Locate HEADER, and determine whether it is newer than the current
1005 file. If it cannot be located or dated, return -1, if it is
1006 newer, return 1, otherwise 0. */
1008 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1012 struct cpp_dir *dir;
1014 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1018 file = _cpp_find_file (pfile, fname, dir, false);
1028 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1031 /* Pushes the given file onto the buffer stack. Returns nonzero if
1034 cpp_push_include (cpp_reader *pfile, const char *fname)
1036 /* Make the command line directive take up a line. */
1038 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1041 /* Do appropriate cleanup when a file INC's buffer is popped off the
1044 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1046 /* Record the inclusion-preventing macro, which could be NULL
1047 meaning no controlling macro. */
1048 if (pfile->mi_valid && file->cmacro == NULL)
1049 file->cmacro = pfile->mi_cmacro;
1051 /* Invalidate control macros in the #including file. */
1052 pfile->mi_valid = false;
1056 free ((void *) file->buffer);
1057 file->buffer = NULL;
1061 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1062 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1063 directory of the including file.
1065 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1067 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1068 int quote_ignores_source_dir)
1070 pfile->quote_include = quote;
1071 pfile->bracket_include = quote;
1072 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1074 for (; quote; quote = quote->next)
1076 quote->name_map = NULL;
1077 quote->len = strlen (quote->name);
1078 if (quote == bracket)
1079 pfile->bracket_include = bracket;
1083 /* Append the file name to the directory to create the path, but don't
1084 turn / into // or // into ///; // may be a namespace escape. */
1086 append_file_to_dir (const char *fname, cpp_dir *dir)
1092 flen = strlen (fname);
1093 path = xmalloc (dlen + 1 + flen + 1);
1094 memcpy (path, dir->name, dlen);
1095 if (dlen && path[dlen - 1] != '/')
1097 memcpy (&path[dlen], fname, flen + 1);
1102 /* Read a space delimited string of unlimited length from a stdio
1105 read_filename_string (int ch, FILE *f)
1111 set = alloc = xmalloc (len + 1);
1112 if (! is_space (ch))
1115 while ((ch = getc (f)) != EOF && ! is_space (ch))
1117 if (set - alloc == len)
1120 alloc = xrealloc (alloc, len + 1);
1121 set = alloc + len / 2;
1131 /* Read the file name map file for DIR. */
1133 read_name_map (cpp_dir *dir)
1135 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1138 size_t len, count = 0, room = 9;
1141 name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1142 memcpy (name, dir->name, len);
1143 if (len && name[len - 1] != '/')
1145 strcpy (name + len, FILE_NAME_MAP_FILE);
1146 f = fopen (name, "r");
1148 dir->name_map = xmalloc (room * sizeof (char *));
1150 /* Silently return NULL if we cannot open. */
1155 while ((ch = getc (f)) != EOF)
1162 if (count + 2 > room)
1165 dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1168 dir->name_map[count] = read_filename_string (ch, f);
1169 while ((ch = getc (f)) != EOF && is_hspace (ch))
1172 to = read_filename_string (ch, f);
1173 if (IS_ABSOLUTE_PATH (to))
1174 dir->name_map[count + 1] = to;
1177 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1182 while ((ch = getc (f)) != '\n')
1190 /* Terminate the list of maps. */
1191 dir->name_map[count] = NULL;
1194 /* Remap a FILE's name based on the file_name_map, if any, for
1195 FILE->dir. If the file name has any directory separators,
1196 recursively check those directories too. */
1198 remap_filename (cpp_reader *pfile, _cpp_file *file)
1200 const char *fname, *p;
1211 read_name_map (dir);
1213 for (index = 0; dir->name_map[index]; index += 2)
1214 if (!strcmp (dir->name_map[index], fname))
1215 return xstrdup (dir->name_map[index + 1]);
1217 p = strchr (fname, '/');
1218 if (!p || p == fname)
1221 len = dir->len + (p - fname + 1);
1222 new_dir = xmalloc (len + 1);
1223 memcpy (new_dir, dir->name, dir->len);
1224 memcpy (new_dir + dir->len, fname, p - fname + 1);
1225 new_dir[len] = '\0';
1227 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1232 /* Return true if FILE is usable by PCH. */
1234 include_pch_p (_cpp_file *file)
1236 return file->pch & 1;
1239 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1241 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1243 const char *saved_path = file->path;
1246 file->path = pchname;
1247 if (open_file (file))
1249 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1257 if (CPP_OPTION (pfile, print_include_names))
1260 for (i = 1; i < pfile->line_maps.depth; i++)
1262 fprintf (stderr, "%c %s\n",
1263 valid ? '!' : 'x', pchname);
1267 file->path = saved_path;
1271 /* This datastructure holds the list of header files that were seen
1272 while the PCH was being built. The 'entries' field is kept sorted
1273 in memcmp() order; yes, this means that on little-endian systems,
1274 it's sorted initially by the least-significant byte of 'size', but
1275 that's OK. The code does rely on having entries with the same size
1276 next to each other. */
1279 /* Number of pchf_entry structures. */
1282 /* Are there any values with once_only set?
1283 This is used as an optimisation, it means we don't have to search
1284 the structure if we're processing a regular #include. */
1285 bool have_once_only;
1288 /* The size of this file. This is used to save running a MD5 checksum
1289 if the sizes don't match. */
1291 /* The MD5 checksum of this file. */
1292 unsigned char sum[16];
1293 /* Is this file to be included only once? */
1298 static struct pchf_data *pchf;
1300 /* Data for pchf_addr. */
1301 struct pchf_adder_info
1304 struct pchf_data *d;
1307 /* A hash traversal function to add entries into DATA->D. */
1310 pchf_adder (void **slot, void *data)
1312 struct file_hash_entry *h = (struct file_hash_entry *) *slot;
1313 struct pchf_adder_info *i = (struct pchf_adder_info *) data;
1315 if (h->start_dir != NULL && h->u.file->stack_count != 0)
1317 struct pchf_data *d = i->d;
1318 _cpp_file *f = h->u.file;
1319 size_t count = d->count++;
1321 /* This should probably never happen, since if a read error occurred
1322 the PCH file shouldn't be written... */
1323 if (f->dont_read || f->err_no)
1326 d->entries[count].once_only = f->once_only;
1327 d->have_once_only |= f->once_only;
1328 if (f->buffer_valid)
1329 md5_buffer ((const char *)f->buffer,
1330 f->st.st_size, d->entries[count].sum);
1338 open_file_failed (i->pfile, f);
1341 ff = fdopen (f->fd, "rb");
1342 md5_stream (ff, d->entries[count].sum);
1346 d->entries[count].size = f->st.st_size;
1351 /* A qsort ordering function for pchf_entry structures. */
1354 pchf_save_compare (const void *e1, const void *e2)
1356 return memcmp (e1, e2, sizeof (struct pchf_entry));
1359 /* Create and write to F a pchf_data structure. */
1362 _cpp_save_file_entries (cpp_reader *pfile, FILE *f)
1365 struct pchf_data *result;
1367 struct pchf_adder_info pai;
1369 count = htab_elements (pfile->file_hash);
1370 result_size = (sizeof (struct pchf_data)
1371 + sizeof (struct pchf_entry) * (count - 1));
1372 result = xcalloc (result_size, 1);
1375 result->have_once_only = false;
1379 htab_traverse (pfile->file_hash, pchf_adder, &pai);
1381 result_size = (sizeof (struct pchf_data)
1382 + sizeof (struct pchf_entry) * (result->count - 1));
1384 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1387 return fwrite (result, result_size, 1, f) == 1;
1390 /* Read the pchf_data structure from F. */
1393 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1397 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1401 pchf = xmalloc (sizeof (struct pchf_data)
1402 + sizeof (struct pchf_entry) * (d.count - 1));
1403 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1404 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1410 /* The parameters for pchf_compare. */
1412 struct pchf_compare_data
1414 /* The size of the file we're looking for. */
1417 /* The MD5 checksum of the file, if it's been computed. */
1418 unsigned char sum[16];
1423 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1424 bool check_included;
1426 /* The file that we're searching for. */
1430 /* bsearch comparison function; look for D_P in E_P. */
1433 pchf_compare (const void *d_p, const void *e_p)
1435 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1436 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1439 result = memcmp (&d->size, &e->size, sizeof (off_t));
1443 if (! d->sum_computed)
1445 _cpp_file *const f = d->f;
1447 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1448 d->sum_computed = true;
1451 result = memcmp (d->sum, e->sum, 16);
1455 if (d->check_included || e->once_only)
1461 /* Check that F is not in a list read from a PCH file (if any).
1462 Assumes that f->buffer_valid is true. Return TRUE if the file
1463 should not be read. */
1466 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1468 bool check_included)
1470 struct pchf_compare_data d;
1473 || (! check_included && ! pchf->have_once_only))
1476 d.size = f->st.st_size;
1477 d.sum_computed = false;
1479 d.check_included = check_included;
1480 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1481 pchf_compare) != NULL;