1 /* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003 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 */
54 /* This structure represents a file searched for by CPP, whether it
55 exists or not. An instance may be pointed to by more than one
56 file_hash_entry; at present no reference count is kept. */
59 /* Filename as given to #include or command line switch. */
62 /* The full path used to find the file. */
65 /* The full path of the pch file. */
68 /* The file's path with the basename stripped. NULL if it hasn't
69 been calculated yet. */
72 /* Chain through all files. */
73 struct _cpp_file *next_file;
75 /* The contents of NAME after calling read_file(). */
78 /* The macro, if any, preventing re-inclusion. */
79 const cpp_hashnode *cmacro;
81 /* The directory in the search path where FILE was found. Used for
82 #include_next and determining whether a header is a system
86 /* As filled in by stat(2) for the file. */
89 /* File descriptor. Invalid if -1, otherwise open. */
92 /* Zero if this file was successfully opened and stat()-ed,
93 otherwise errno obtained from failure. */
96 /* Number of times the file has been stacked for preprocessing. */
97 unsigned short stack_count;
99 /* If opened with #import or contains #pragma once. */
102 /* If read() failed before. */
105 /* If this file is the main file. */
108 /* If BUFFER above contains the true contents of the file. */
111 /* 0: file not known to be a PCH.
112 1: file is a PCH (on return from find_include_file).
113 2: file is not and never will be a valid precompiled header.
114 3: file is always a valid precompiled header. */
118 /* A singly-linked list for all searches for a given file name, with
119 its head pointed to by a slot in FILE_HASH. The file name is what
120 appeared between the quotes in a #include directive; it can be
121 determined implicitly from the hash table location or explicitly
124 FILE is a structure containing details about the file that was
125 found with that search, or details of how the search failed.
127 START_DIR is the starting location of the search in the include
128 chain. The current directories for "" includes are also hashed in
129 the hash table and therefore unique. Files that are looked up
130 without using a search path, such as absolute filenames and file
131 names from the command line share a special starting directory so
132 they don't cause cache hits with normal include-chain lookups.
134 If START_DIR is NULL then the entry is for a directory, not a file,
135 and the directory is in DIR. Since the starting point in a file
136 lookup chain is never NULL, this means that simple pointer
137 comparisons against START_DIR can be made to determine cache hits
140 If a cache lookup fails because of e.g. an extra "./" in the path,
141 then nothing will break. It is just less efficient as CPP will
142 have to do more work re-preprocessing the file, and/or comparing
143 its contents against earlier once-only files.
145 struct file_hash_entry
147 struct file_hash_entry *next;
156 static bool open_file (_cpp_file *file);
157 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
159 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
161 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
162 static bool read_file (cpp_reader *pfile, _cpp_file *file);
163 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
164 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
165 int angle_brackets, enum include_type);
166 static const char *dir_name_of_file (_cpp_file *file);
167 static void open_file_failed (cpp_reader *pfile, _cpp_file *file);
168 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
169 const cpp_dir *start_dir);
170 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
171 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
172 static void allocate_file_hash_entries (cpp_reader *pfile);
173 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
174 static int report_missing_guard (void **slot, void *b);
175 static int hash_string_eq (const void *p, const void *q);
176 static char *read_filename_string (int ch, FILE *f);
177 static void read_name_map (cpp_dir *dir);
178 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
179 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
180 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
181 static bool include_pch_p (_cpp_file *file);
183 /* Given a filename in FILE->PATH, with the empty string interpreted
186 On success FILE contains an open file descriptor and stat
187 information for the file. On failure the file descriptor is -1 and
188 the appropriate errno is also stored in FILE. Returns TRUE iff
191 We used to open files in nonblocking mode, but that caused more
192 problems than it solved. Do take care not to acquire a controlling
193 terminal by mistake (this can't happen on sane systems, but
194 paranoia is a virtue).
196 Use the three-argument form of open even though we aren't
197 specifying O_CREAT, to defend against broken system headers.
199 O_BINARY tells some runtime libraries (notably DJGPP) not to do
200 newline translation; we can handle DOS line breaks just fine
203 open_file (_cpp_file *file)
205 if (file->path[0] == '\0')
208 set_stdin_to_binary_mode ();
211 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
215 if (fstat (file->fd, &file->st) == 0)
217 if (!S_ISDIR (file->st.st_mode))
223 /* Ignore a directory and continue the search. The file we're
224 looking for may be elsewhere in the search path. */
231 else if (errno == ENOTDIR)
234 file->err_no = errno;
239 /* Temporary PCH intercept of opening a file. Try to find a PCH file
240 based on FILE->name and FILE->dir, and test those found for
241 validity using PFILE->cb.valid_pch. Return true iff a valid file is
242 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
245 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
247 static const char extension[] = ".gch";
248 const char *path = file->path;
254 /* No PCH on <stdin> or if not requested. */
255 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
258 flen = strlen (path);
259 len = flen + sizeof (extension);
260 pchname = xmalloc (len);
261 memcpy (pchname, path, flen);
262 memcpy (pchname + flen, extension, sizeof (extension));
264 if (stat (pchname, &st) == 0)
268 size_t dlen, plen = len;
270 if (!S_ISDIR (st.st_mode))
271 valid = validate_pch (pfile, file, pchname);
272 else if ((pchdir = opendir (pchname)) != NULL)
274 pchname[plen - 1] = '/';
275 while ((d = readdir (pchdir)) != NULL)
277 dlen = strlen (d->d_name) + 1;
278 if ((strcmp (d->d_name, ".") == 0)
279 || (strcmp (d->d_name, "..") == 0))
281 if (dlen + plen > len)
284 pchname = xrealloc (pchname, len);
286 memcpy (pchname + plen, d->d_name, dlen);
287 valid = validate_pch (pfile, file, pchname);
294 *invalid_pch |= ! valid;
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 path = append_file_to_dir (file->name, file->dir);
321 if (pch_open_file (pfile, file, invalid_pch))
324 if (open_file (file))
327 if (file->err_no != ENOENT)
329 open_file_failed (pfile, file);
334 file->path = file->name;
339 _cpp_find_failed (_cpp_file *file)
341 return file->err_no != 0;
344 /* Given a filename FNAME search for such a file in the include path
345 starting from START_DIR. If FNAME is the empty string it is
346 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
348 If the file is not found in the file cache fall back to the O/S and
349 add the result to our cache.
351 If the file was not found in the filesystem, or there was an error
352 opening it, then ERR_NO is nonzero and FD is -1. If the file was
353 found, then ERR_NO is zero and FD could be -1 or an open file
354 descriptor. FD can be -1 if the file was found in the cache and
355 had previously been closed. To open it again pass the return value
359 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake)
361 struct file_hash_entry *entry, **hash_slot;
363 bool invalid_pch = false;
365 /* Ensure we get no confusion between cached files and directories. */
366 if (start_dir == NULL)
367 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
369 hash_slot = (struct file_hash_entry **)
370 htab_find_slot (pfile->file_hash, fname, INSERT);
372 /* First check the cache before we resort to memory allocation. */
373 entry = search_cache (*hash_slot, start_dir);
375 return entry->u.file;
377 file = make_cpp_file (pfile, start_dir, fname);
379 /* Try each path in the include chain. */
382 if (find_file_in_dir (pfile, file, &invalid_pch))
385 file->dir = file->dir->next;
386 if (file->dir == NULL)
388 open_file_failed (pfile, file);
391 cpp_error (pfile, CPP_DL_ERROR,
392 "one or more PCH files were found, but they were invalid");
393 if (!cpp_get_options (pfile)->warn_invalid_pch)
394 cpp_error (pfile, CPP_DL_ERROR,
395 "use -Winvalid-pch for more information");
400 /* Only check the cache for the starting location (done above)
401 and the quote and bracket chain heads because there are no
402 other possible starting points for searches. */
403 if (file->dir != pfile->bracket_include
404 && file->dir != pfile->quote_include)
407 entry = search_cache (*hash_slot, file->dir);
414 /* Cache for START_DIR too, sharing the _cpp_file structure. */
415 free ((char *) file->name);
417 file = entry->u.file;
421 /* This is a new file; put it in the list. */
422 file->next_file = pfile->all_files;
423 pfile->all_files = file;
426 /* Store this new result in the hash table. */
427 entry = new_file_hash_entry (pfile);
428 entry->next = *hash_slot;
429 entry->start_dir = start_dir;
430 entry->u.file = file;
436 /* Read a file into FILE->buffer, returning true on success.
438 If FILE->fd is something weird, like a block device, we don't want
439 to read it at all. Don't even try to figure out what something is,
440 except for plain files and block devices, since there is no
441 reliable portable way of doing this.
443 FIXME: Flush file cache and try again if we run out of memory. */
445 read_file_guts (cpp_reader *pfile, _cpp_file *file)
447 ssize_t size, total, count;
451 if (S_ISBLK (file->st.st_mode))
453 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
457 regular = S_ISREG (file->st.st_mode);
460 /* off_t might have a wider range than ssize_t - in other words,
461 the max size of a file might be bigger than the address
462 space. We can't handle a file that large. (Anyone with
463 a single source file bigger than 2GB needs to rethink
464 their coding style.) Some systems (e.g. AIX 4.1) define
465 SSIZE_MAX to be much smaller than the actual range of the
466 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
468 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
470 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
474 size = file->st.st_size;
477 /* 8 kilobytes is a sensible starting size. It ought to be bigger
478 than the kernel pipe buffer, and it's definitely bigger than
479 the majority of C source files. */
482 buf = xmalloc (size + 1);
484 while ((count = read (file->fd, buf + total, size - total)) > 0)
493 buf = xrealloc (buf, size + 1);
499 cpp_errno (pfile, CPP_DL_ERROR, file->path);
503 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
504 cpp_error (pfile, CPP_DL_WARNING,
505 "%s is shorter than expected", file->path);
507 /* Shrink buffer if we allocated substantially too much. */
508 if (total + 4096 < size)
509 buf = xrealloc (buf, total + 1);
511 /* The lexer requires that the buffer be \n-terminated. */
515 file->st.st_size = total;
516 file->buffer_valid = true;
521 /* Convenience wrapper around read_file_guts that opens the file if
522 necessary and closes the file descriptor after reading. FILE must
523 have been passed through find_file() at some stage. */
525 read_file (cpp_reader *pfile, _cpp_file *file)
527 /* If we already have its contents in memory, succeed immediately. */
528 if (file->buffer_valid)
531 /* If an earlier read failed for some reason don't try again. */
532 if (file->dont_read || file->err_no)
535 if (file->fd == -1 && !open_file (file))
537 open_file_failed (pfile, file);
541 file->dont_read = !read_file_guts (pfile, file);
545 return !file->dont_read;
548 /* Returns TRUE if FILE's contents have been successfully placed in
549 FILE->buffer and the file should be stacked, otherwise false. */
551 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
555 /* Skip once-only files. */
559 /* We must mark the file once-only if #import now, before header
560 guard checks. Otherwise, undefining the header guard might
561 cause the file to be re-stacked. */
564 _cpp_mark_file_once_only (pfile, file);
566 /* Don't stack files that have been stacked before. */
567 if (file->stack_count)
571 /* Skip if the file had a header guard and the macro is defined.
572 PCH relies on this appearing before the PCH handler below. */
573 if (file->cmacro && file->cmacro->type == NT_MACRO)
576 /* Handle PCH files immediately; don't stack them. */
577 if (include_pch_p (file))
579 pfile->cb.read_pch (pfile, file->path, file->fd, file->pchname);
585 if (!read_file (pfile, file))
588 /* Now we've read the file's contents, we can stack it if there
589 are no once-only files. */
590 if (!pfile->seen_once_only)
593 /* We may have read the file under a different name. Look
594 for likely candidates and compare file contents to be sure. */
595 for (f = pfile->all_files; f; f = f->next_file)
600 if ((import || f->once_only)
602 && f->st.st_mtime == file->st.st_mtime
603 && f->st.st_size == file->st.st_size
604 && read_file (pfile, f)
605 /* Size might have changed in read_file(). */
606 && f->st.st_size == file->st.st_size
607 && !memcmp (f->buffer, file->buffer, f->st.st_size))
614 /* Place the file referenced by FILE into a new buffer on the buffer
615 stack if possible. IMPORT is true if this stacking attempt is
616 because of a #import directive. Returns true if a buffer is
619 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
624 if (!should_stack_file (pfile, file, import))
627 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
628 (file->dir ? file->dir->sysp : 0));
630 /* Add the file to the dependencies on its first inclusion. */
631 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
633 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
634 deps_add_dep (pfile->deps, file->path);
637 /* Clear buffer_valid since _cpp_clean_line messes it up. */
638 file->buffer_valid = false;
641 /* Stack the buffer. */
642 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
643 CPP_OPTION (pfile, preprocessed));
646 /* Initialize controlling macro state. */
647 pfile->mi_valid = true;
648 pfile->mi_cmacro = 0;
650 /* Generate the call back. */
651 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
656 /* Mark FILE to be included once only. */
658 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
660 pfile->seen_once_only = true;
661 file->once_only = true;
664 /* Return the directory from which searching for FNAME should start,
665 considering the directive TYPE and ANGLE_BRACKETS. If there is
666 nothing left in the path, returns NULL. */
667 static struct cpp_dir *
668 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
669 enum include_type type)
674 if (IS_ABSOLUTE_PATH (fname))
675 return &pfile->no_search_path;
677 /* pfile->buffer is NULL when processing an -include command-line flag. */
678 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
680 /* For #include_next, skip in the search path past the dir in which
681 the current file was found, but if it was found via an absolute
682 path use the normal search logic. */
683 if (type == IT_INCLUDE_NEXT && file->dir)
684 dir = file->dir->next;
685 else if (angle_brackets)
686 dir = pfile->bracket_include;
687 else if (type == IT_CMDLINE)
688 /* -include and -imacros use the #include "" chain with the
689 preprocessor's cwd prepended. */
690 return make_cpp_dir (pfile, "./", false);
691 else if (pfile->quote_ignores_source_dir)
692 dir = pfile->quote_include;
694 return make_cpp_dir (pfile, dir_name_of_file (file), pfile->map->sysp);
697 cpp_error (pfile, CPP_DL_ERROR,
698 "no include path in which to search for %s", fname);
703 /* Strip the basename from the file's path. It ends with a slash if
704 of nonzero length. Note that this procedure also works for
705 <stdin>, which is represented by the empty string. */
707 dir_name_of_file (_cpp_file *file)
711 size_t len = lbasename (file->path) - file->path;
712 char *dir_name = xmalloc (len + 1);
714 memcpy (dir_name, file->path, len);
715 dir_name[len] = '\0';
716 file->dir_name = dir_name;
719 return file->dir_name;
722 /* Handles #include-family directives (distinguished by TYPE),
723 including HEADER, and the command line -imacros and -include.
724 Returns true if a buffer was stacked. */
726 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
727 enum include_type type)
731 dir = search_path_head (pfile, fname, angle_brackets, type);
735 return _cpp_stack_file (pfile, _cpp_find_file (pfile, fname, dir, false),
739 /* Could not open FILE. The complication is dependency output. */
741 open_file_failed (cpp_reader *pfile, _cpp_file *file)
743 int sysp = pfile->map ? pfile->map->sysp: 0;
744 bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
746 errno = file->err_no;
747 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
748 deps_add_dep (pfile->deps, file->name);
751 /* If we are outputting dependencies but not for this file then
752 don't error because we can still produce correct output. */
753 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
754 cpp_errno (pfile, CPP_DL_WARNING, file->path);
756 cpp_errno (pfile, CPP_DL_ERROR, file->path);
760 /* Search in the chain beginning at HEAD for a file whose search path
761 started at START_DIR != NULL. */
762 static struct file_hash_entry *
763 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
765 while (head && head->start_dir != start_dir)
771 /* Allocate a new _cpp_file structure. */
773 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
777 file = xcalloc (1, sizeof (_cpp_file));
778 file->main_file = !pfile->buffer;
781 file->name = xstrdup (fname);
786 /* A hash of directory names. The directory names are the path names
787 of files which contain a #include "", the included file name is
788 appended to this directories.
790 To avoid duplicate entries we follow the convention that all
791 non-empty directory names should end in a '/'. DIR_NAME must be
792 stored in permanently allocated memory. */
794 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
796 struct file_hash_entry *entry, **hash_slot;
799 hash_slot = (struct file_hash_entry **)
800 htab_find_slot (pfile->file_hash, dir_name, INSERT);
802 /* Have we already hashed this directory? */
803 for (entry = *hash_slot; entry; entry = entry->next)
804 if (entry->start_dir == NULL)
807 dir = xcalloc (1, sizeof (cpp_dir));
808 dir->next = pfile->quote_include;
809 dir->name = (char *) dir_name;
810 dir->len = strlen (dir_name);
813 /* Store this new result in the hash table. */
814 entry = new_file_hash_entry (pfile);
815 entry->next = *hash_slot;
816 entry->start_dir = NULL;
823 /* Create a new block of memory for file hash entries. */
825 allocate_file_hash_entries (cpp_reader *pfile)
827 pfile->file_hash_entries_used = 0;
828 pfile->file_hash_entries_allocated = 127;
829 pfile->file_hash_entries = xmalloc
830 (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
833 /* Return a new file hash entry. */
834 static struct file_hash_entry *
835 new_file_hash_entry (cpp_reader *pfile)
837 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
838 allocate_file_hash_entries (pfile);
840 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
843 /* Returns TRUE if a file FNAME has ever been successfully opened.
844 This routine is not intended to correctly handle filenames aliased
845 by links or redundant . or .. traversals etc. */
847 cpp_included (cpp_reader *pfile, const char *fname)
849 struct file_hash_entry *entry;
851 entry = htab_find (pfile->file_hash, fname);
853 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
856 return entry != NULL;
859 /* Compare a string Q against a file hash entry P. */
861 hash_string_eq (const void *p, const void *q)
863 struct file_hash_entry *entry = (struct file_hash_entry *) p;
864 const char *fname = (const char *) q;
867 if (entry->start_dir)
868 hname = entry->u.file->name;
870 hname = entry->u.dir->name;
872 return strcmp (hname, fname) == 0;
875 /* Initialize everything in this source file. */
877 _cpp_init_files (cpp_reader *pfile)
879 pfile->file_hash = htab_create_alloc (127, htab_hash_string, hash_string_eq,
880 NULL, xcalloc, free);
881 allocate_file_hash_entries (pfile);
884 /* Finalize everything in this source file. */
886 _cpp_cleanup_files (cpp_reader *pfile)
888 htab_delete (pfile->file_hash);
891 /* Enter a file name in the hash for the sake of cpp_included. */
893 _cpp_fake_include (cpp_reader *pfile, const char *fname)
895 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
898 /* Not everyone who wants to set system-header-ness on a buffer can
899 see the details of a buffer. This is an exported interface because
900 fix-header needs it. */
902 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
906 /* 1 = system header, 2 = system header to be treated as C. */
908 flags = 1 + (externc != 0);
909 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
910 SOURCE_LINE (pfile->map, pfile->line), flags);
913 /* Allow the client to change the current file. Used by the front end
914 to achieve pseudo-file names like <built-in>.
915 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
917 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
918 const char *new_name)
920 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
923 /* Callback function for htab_traverse. */
925 report_missing_guard (void **slot, void *b)
927 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
928 int *bannerp = (int *) b;
930 /* Skip directories. */
931 if (entry->start_dir != NULL)
933 _cpp_file *file = entry->u.file;
935 /* We don't want MI guard advice for the main file. */
936 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
940 fputs (_("Multiple include guards may be useful for:\n"),
945 fputs (entry->u.file->path, stderr);
953 /* Report on all files that might benefit from a multiple include guard.
956 _cpp_report_missing_guards (cpp_reader *pfile)
960 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
963 /* Locate HEADER, and determine whether it is newer than the current
964 file. If it cannot be located or dated, return -1, if it is
965 newer, return 1, otherwise 0. */
967 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
973 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
977 file = _cpp_find_file (pfile, fname, dir, false);
987 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
990 /* Pushes the given file onto the buffer stack. Returns nonzero if
993 cpp_push_include (cpp_reader *pfile, const char *fname)
995 /* Make the command line directive take up a line. */
997 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1000 /* Do appropriate cleanup when a file INC's buffer is popped off the
1003 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1005 /* Record the inclusion-preventing macro, which could be NULL
1006 meaning no controlling macro. */
1007 if (pfile->mi_valid && file->cmacro == NULL)
1008 file->cmacro = pfile->mi_cmacro;
1010 /* Invalidate control macros in the #including file. */
1011 pfile->mi_valid = false;
1015 free ((void *) file->buffer);
1016 file->buffer = NULL;
1020 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1021 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1022 directory of the including file.
1024 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1026 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1027 int quote_ignores_source_dir)
1029 pfile->quote_include = quote;
1030 pfile->bracket_include = quote;
1031 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1033 for (; quote; quote = quote->next)
1035 quote->name_map = NULL;
1036 quote->len = strlen (quote->name);
1037 if (quote == bracket)
1038 pfile->bracket_include = bracket;
1042 /* Append the file name to the directory to create the path, but don't
1043 turn / into // or // into ///; // may be a namespace escape. */
1045 append_file_to_dir (const char *fname, cpp_dir *dir)
1051 flen = strlen (fname);
1052 path = xmalloc (dlen + 1 + flen + 1);
1053 memcpy (path, dir->name, dlen);
1054 if (dlen && path[dlen - 1] != '/')
1056 memcpy (&path[dlen], fname, flen + 1);
1061 /* Read a space delimited string of unlimited length from a stdio
1064 read_filename_string (int ch, FILE *f)
1070 set = alloc = xmalloc (len + 1);
1071 if (! is_space (ch))
1074 while ((ch = getc (f)) != EOF && ! is_space (ch))
1076 if (set - alloc == len)
1079 alloc = xrealloc (alloc, len + 1);
1080 set = alloc + len / 2;
1090 /* Read the file name map file for DIR. */
1092 read_name_map (cpp_dir *dir)
1094 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1097 size_t len, count = 0, room = 9;
1100 name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1101 memcpy (name, dir->name, len);
1102 if (len && name[len - 1] != '/')
1104 strcpy (name + len, FILE_NAME_MAP_FILE);
1105 f = fopen (name, "r");
1107 dir->name_map = xmalloc (room * sizeof (char *));
1109 /* Silently return NULL if we cannot open. */
1114 while ((ch = getc (f)) != EOF)
1121 if (count + 2 > room)
1124 dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1127 dir->name_map[count] = read_filename_string (ch, f);
1128 while ((ch = getc (f)) != EOF && is_hspace (ch))
1131 to = read_filename_string (ch, f);
1132 if (IS_ABSOLUTE_PATH (to))
1133 dir->name_map[count + 1] = to;
1136 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1141 while ((ch = getc (f)) != '\n')
1149 /* Terminate the list of maps. */
1150 dir->name_map[count] = NULL;
1153 /* Remap a FILE's name based on the file_name_map, if any, for
1154 FILE->dir. If the file name has any directory separators,
1155 recursively check those directories too. */
1157 remap_filename (cpp_reader *pfile, _cpp_file *file)
1159 const char *fname, *p;
1170 read_name_map (dir);
1172 for (index = 0; dir->name_map[index]; index += 2)
1173 if (!strcmp (dir->name_map[index], fname))
1174 return xstrdup (dir->name_map[index + 1]);
1176 p = strchr (fname, '/');
1177 if (!p || p == fname)
1180 len = dir->len + (p - fname + 1);
1181 new_dir = xmalloc (len + 1);
1182 memcpy (new_dir, dir->name, dir->len);
1183 memcpy (new_dir + dir->len, fname, p - fname + 1);
1184 new_dir[len] = '\0';
1186 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1191 /* Return true if FILE is usable by PCH. */
1193 include_pch_p (_cpp_file *file)
1195 return file->pch & 1;
1198 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1200 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1202 const char *saved_path = file->path;
1205 file->path = pchname;
1206 if (open_file (file))
1208 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1216 if (CPP_OPTION (pfile, print_include_names))
1219 for (i = 1; i < pfile->line_maps.depth; i++)
1221 fprintf (stderr, "%c %s\n",
1222 valid ? '!' : 'x', pchname);
1226 file->path = saved_path;